Next.js Middleware Get Query Params For Effective Routing

When building powerful, user-centric applications, mastering how to retrieve and manipulate query params in Next.js middleware is crucial for effective routing. Whether you're working on client components, leveraging server-side rendering, or managing a combination of pages router and app router, understanding query parameters empowers you to create dynamic and efficient applications.

This comprehensive blog will teach you how to extract query params, handle query string parameters, and implement best practices for Next.js middleware get query params.

Let’s dive in!

What are Query Parameters and Why They Matter?

In web development, query parameters (also called query string parameters) are key-value pairs appended to a URL after the question mark (?). They help customize requests, manage state, and handle filters dynamically. For instance, a URL like:

Copy
https://example.com/products?category=electronics&price=100

contains query string values for "category" and "price," which can adjust what data a user sees.

Understanding how to retrieve these params effectively is key to creating robust routes, dynamic filtering, and powerful APIs.

Next.js Middleware and Query Params

Next.js middleware enables you to execute code during request handling before rendering the final page. Combining middleware with query params allows dynamic manipulation of requests and responses, enhancing routing flexibility.

Here’s how you can implement Next.js middleware get query params in your application:

Using Middleware for Query Parameters

Middleware operates on the server, giving access to incoming URL requests. By parsing the query string, you can access params and make routing decisions dynamically.

Example: Extracting Query Params in Middleware

Copy
import { NextResponse } from 'next/server';

export function middleware(request) {
    const { searchParams } = new URL(request.url);
    const category = searchParams.get('category');
    const price = searchParams.get('price');

    if (category && price) {
        console.log(`Category: ${category}, Price: ${price}`);
    }

    return NextResponse.next();
}

This middleware retrieves search params and processes them dynamically. The searchParams.get() method ensures easy access to individual values.

Accessing Query Parameters in the App Router

The app router in Next.js 13 introduces an advanced way to manage routes with searchparams prop and the usesearchparams hook.

Using useSearchParams for Query Strings

The usesearchparams hook provides an easy way to access query params in a client component:

Copy
'use client';

import { useSearchParams } from 'next/navigation';

export default function ProductPage() {
    const searchParams = useSearchParams();
    const category = searchParams.get('category');
    const price = searchParams.get('price');

    return (
        <div>
            <h1>Products</h1>
            <p>Category: {category}</p>
            <p>Price: {price}</p>
        </div>
    );
}

By using searchParams.get(), you retrieve values seamlessly in a client component, enhancing the user experience with real-time updates.

Query Parameters in the Pages Router

For applications using the traditional pages router, you can access query params via Next.js' getServerSideProps or getStaticProps methods.

Example: Fetching Query Params Server-Side

Here, the context.query object contains all query string values passed to the URL. Using getServerSideProps, you can fetch and process these values during server side rendering.

Other Methods for Query Handling

Parsing Query Strings Manually

While Next.js provides native tools, you can use other read only methods like URLSearchParams to manually parse a query string.

This is useful when working with APIs or external URL structures.

Combining Query and Path Params

Sometimes, you need to handle both query params and path params. For instance, . Here’s how:

Tips for Effective Query Param Management

1. Leverage Dynamic Middleware: Use middleware to intercept and redirect based on query params for better route control.

2. Client and Server Harmony: Balance client components and server methods to ensure smooth rendering and performance.

3. Avoid Overuse: Not every state needs to be in a query string. Reserve it for dynamic filtering and routing.

4. Security First: Always sanitize input received through query params to prevent vulnerabilities.

The Bottom Line!

Understanding Next.js middleware get query params is a vital skill for building scalable, dynamic web applications. By combining query parameters, client components, and server-side rendering, you can create seamless user experiences tailored to individual preferences.

Start implementing these techniques today to make your routes smarter and your applications more dynamic. Remember, a small tweak in how you handle query params can make a big difference in performance and usability.

export async function getServerSideProps(context) {
    const { query } = context;
    const { category, price } = query;

    return {
        props: { category, price },
    };
}

const queryString = '?category=books&price=200';
const searchParams = new URLSearchParams(queryString);
console.log(searchParams.get('category')); // Output: books

export async function getServerSideProps({ params, query }) {
    const { id } = params;
    const { category } = query;

    return {
        props: { id, category },
    };
}