Express.js Guide: Mastering Routers and GET Query Parameters

Rashmi Saini

September 29, 2025

9MIN READ

Learn how to use Express Router for modular APIs, access GET query params, apply middleware, and debug faster with Requestly.

Express.js makes building APIs in Node.js fast and efficient, and its Router feature helps keep route handling clean and modular. Whether you’re filtering data with query parameters or structuring large-scale applications, routes bring clarity and scalability to your codebase.

This guide explains how routers work, how to set them up effectively, and the best practices for building structured APIs.

Express Routes Explained

The Express Router is a built-in way to create modular and manageable route handlers in an Express.js application. Instead of defining all routes inside the main app.js or server.js file, the router allows developers to group related routes into separate modules.

This not only improves code readability but also makes it easier to scale applications as they grow.

At its core, the Express Routes works like a mini-application capable of handling its own routes, middleware, and parameters. Each router can be mounted onto a specific path, and all routes defined within it automatically inherit that base path.

For example, if a router is mounted at /users, all routes inside it (/profile, /settings, etc.) become accessible under that namespace. This makes it simple to divide responsibilities, such as having separate routers for users, products, or authentication within a larger API.

Key benefits of using Express Router include:

Modularizing routes for better project structure.
Applying middleware selectively to route groups.
Improving code maintainability and readability.
Simplifying collaboration in large teams by separating concerns.

Why Developers Use Express Router

As applications grow, managing all routes directly inside the main Express application can quickly become messy and difficult to maintain. This is where the Express Router proves invaluable. It provides a structured way to organize endpoints, apply middleware, and scale projects without losing clarity.

Some of the main reasons developers turn to Express Router include:

Improved Code Organization: Routes can be split into separate files or modules based on functionality (e.g., users.js, products.js), making the project easier to navigate.
Scalability: Large APIs often involve multiple resource domains; routers allow each domain to be managed independently.
Middleware Control: By attaching middleware to specific routers, developers can enforce authentication, logging, or validation only where necessary.
Reusability: Routers act as mini applications, making it possible to reuse them across multiple projects or microservices with minimal changes.
Team Collaboration: When working in larger teams, routers enable developers to work on different feature modules without interfering with each other’s code.

Setting Up an Express Router in a Project

Implementing the Express Router in a project is straightforward and follows a modular approach. Instead of placing all route definitions in the main application file (app.js or server.js), separate routers are created and mounted into the app. This results in cleaner code and easier maintenance.

Steps to set up an Express Router:

1. Create a Router File

Define a router in a separate module, for example, users.js:

				
					const express = require('express');
const router = express.Router();

// Example GET route
router.get('/profile', (req, res) => {
  res.send('User Profile');
});

module.exports = router;

2. Import and Mount the Router

In the main application file (app.js):

				
					const express = require('express');
const app = express();

// Import user routes
const userRouter = require('./routes/users');

// Mount the router on a base path
app.use('/users', userRouter);

app.listen(3000, () => console.log('Server running on port 3000'));

3. Access Routes Using the Mounted Path

With the above setup, the /profile route can be accessed at:

				
					http://localhost:3000/users/profile

This modular setup ensures each feature (such as users, products, or authentication) has its own dedicated router file. As the project expands, new routers can be added in the same structured way without cluttering the main server file.

Working with Routes Inside a Router

Once an Express Router is set up, defining routes inside it works the same way as with the main app instance. The router can handle various HTTP methods, route parameters, and query parameters, making it highly flexible for building modular endpoints.

For example, a typical router file might include multiple routes grouped by functionality:

				
					const express = require('express');
const router = express.Router();

// GET request with query parameters
// Example: /products/search?category=electronics&sort=price
router.get('/search', (req, res) => {
  const { category, sort } = req.query;  // Access query params
  res.send(`Filtering products in category: ${category}, sorted by: ${sort}`);
});

// GET request with route parameters
// Example: /products/123
router.get('/:id', (req, res) => {
  const productId = req.params.id;  // Access route parameter
  res.send(`Fetching details for product ID: ${productId}`);
});

// POST request
router.post('/', (req, res) => {
  res.send('Creating a new product');
});

module.exports = router;

Key Points When Working with Routes:

Query Parameters (req.query): Useful for filtering, searching, and customizing results without changing the URL structure.
Route Parameters (req.params): Ideal for identifying specific resources like users, products, or orders.
Request Body (req.body): Often used with POST or PUT requests to send data to the server.

By organizing these routes inside routers, each module (e.g., products, users, orders) can encapsulate its own behavior, making the codebase modular and easier to scale.

Leveraging Middleware in Routers

Middleware in Express acts as a layer of logic that executes before the final route handler. With the Express Router, middleware can be applied at the router level or for specific routes, making it easier to enforce consistent behavior such as authentication, input validation, or logging.

Applying Middleware to an Entire Router

When middleware is applied to a router, it automatically affects all routes within that router. For example, adding an authentication check to all user routes:

				
					const express = require('express');
const router = express.Router();

// Example authentication middleware
function checkAuth(req, res, next) {
  const token = req.headers['authorization'];
  if (token === 'valid-token') {
    next(); // allow access
  } else {
    res.status(401).send('Unauthorized');
  }
}

// Apply middleware to all user routes
router.use(checkAuth);

router.get('/profile', (req, res) => {
  res.send('User Profile - Access Granted');
});

router.get('/settings', (req, res) => {
  res.send('User Settings - Access Granted');
});

module.exports = router;

Applying Middleware to Specific Routes

Sometimes, middleware is only needed for certain endpoints, such as validating request data:

				
					// Middleware for validating product data
function validateProduct(req, res, next) {
  if (!req.body.name) {
    return res.status(400).send('Product name is required');
  }
  next();
}

router.post('/add', validateProduct, (req, res) => {
  res.send('Product added successfully');
});

Benefits of Router-Level Middleware

Cleaner Code: Shared logic is placed in one layer instead of repeated in each route.
Security: Authentication/authorization can be consistently enforced.
Flexibility: Middleware can target an entire router, specific routes, or even a single route chain.

By strategically integrating middleware within routers, applications remain modular while preserving reusability, scalability, and maintainability.

Structuring Routers for Large APIs

As an API grows, the number of routes quickly expands, and placing all of them in a single file can lead to clutter and difficulties in maintenance. To keep large applications organized, Express routers should be structured in a way that groups related endpoints together and follows a clear, scalable convention.

Recommended Project Structure

A common folder layout for large APIs might look like this:

				
					project-root/
│
├── app.js
├── routes/
│   ├── users.js
│   ├── products.js
│   ├── orders.js
│   └── index.js
├── controllers/
│   ├── userController.js
│   ├── productController.js
│   └── orderController.js
└── middleware/
    ├── authMiddleware.js
    └── loggerMiddleware.js

Explanation of the Structure

routes/: Contains modular route files where each file handles a specific resource (e.g., users.js, products.js).
controllers/: Handles the business logic, keeping route files focused only on defining endpoints.
middleware/: Stores reusable middleware functions such as authentication or request logging.
index.js inside routes/: Acts as a central router that combines all resource routers and exports them for use in app.js.

Example of routes/index.js:

				
					const express = require('express');
const router = express.Router();

// Import individual routers
const userRoutes = require('./users');
const productRoutes = require('./products');
const orderRoutes = require('./orders');

// Use modular routers
router.use('/users', userRoutes);
router.use('/products', productRoutes);
router.use('/orders', orderRoutes);

module.exports = router;

Using the Central Router in app.js:

				
					const express = require('express');
const app = express();

// Import central router
const apiRoutes = require('./routes');

// Use it under the /api prefix
app.use('/api', apiRoutes);

app.listen(3000, () => {
  console.log('API running on port 3000');
});

Benefits of This Structure

Separation of Concerns: Business logic (controllers) stays separate from route definitions.
Scalability: New features can be added simply by creating new route and controller files.
Maintainability: Developers can quickly locate and manage related routes and functionalities.
Collaboration-Friendly: Teams can work on different modules independently without conflicts.

By following a structured approach, even large-scale projects can remain organized, modular, and easy to maintain over time.

Best Practices when Using Express Routers

To make Express applications scalable and maintainable, routers should be used with proper structure and conventions. Below are best practices that ensure efficiency and consistency.

Keep Routes Modular: Group related routes into separate files so the project remains organized, avoiding a single bloated route file.
Leverage Controllers: Move business logic to controllers, keeping routers focused only on defining endpoints for cleaner and testable code.
Use Middleware Wisely: Apply middleware at the router or route level where needed, instead of globally, to avoid unnecessary overhead.
Maintain a Consistent URL Structure: Use RESTful naming conventions so endpoints stay predictable, clear, and easier to consume.
Centralize Error Handling: Handle errors through a dedicated middleware to ensure consistent responses across the entire application.
Validate and Secure Input: Always validate data and use authentication or authorization middleware to safeguard the API.
Organize with an Index Route: Combine all routers in a central index.js and mount it under a base path like /api for better scalability.
Document Routes and APIs: Sync route definitions with updated API documentation, keeping collaboration and maintenance smooth.

By consistently applying these practices, Express routers remain modular, secure, and scalable, making them suitable for both small and enterprise-level applications.

Accelerate Debugging with Requestly HTTP Interceptor

Debugging APIs often requires inspecting requests and responses in real-time, and this is where Requestly HTTP Interceptor by BrowserStack proves valuable. It allows developers to capture, modify, and test API calls without constantly changing backend code.

Simplify Network Debugging: Requestly enables easy inspection of headers, query parameters, and payloads, helping quickly identify issues in request formatting or missing data.
Test Scenarios Without Code Changes: By intercepting requests, developers can mock responses or redirect APIs, making it possible to test edge cases without altering the server code.
Accelerate Frontend–Backend Collaboration: Frontend teams can simulate backend responses even before APIs are fully available, reducing development bottlenecks and ensuring faster integration.
Consistent Debugging Across Teams: Requestly rules can be shared within teams, ensuring everyone tests with the same configurations and scenarios, improving collaboration and consistency.

By integrating Requestly into the development workflow, debugging becomes faster, testing edge cases becomes easier, and overall API development turns more efficient.

Conclusion

Express Router is a powerful tool for organizing APIs, making route management clean, modular, and scalable. By structuring routes around specific features, applying middleware strategically, and following best practices like input validation and centralized error handling, developers can build robust backend applications with ease.

Combined with effective debugging tools such as Requestly HTTP Interceptor, the development process becomes smoother, allowing teams to test faster, collaborate better, and deliver reliable APIs. Adopting these practices ensures that both small applications and large-scale APIs remain maintainable, secure, and future-ready.

Written by

Rashmi Saini

How to convert OpenAPI spec to an API collection

Instantly convert your OpenAPI (Swagger) spec into a ready-to-test API collection in Requestly. Import, organize, and explore your APIs with zero manual setup.

Dinesh Thakur

October 29, 2025

Serving API Mocks from Local Files in Requestly

Serve mock APIs directly from local files using Requestly’s Map Local feature—develop, test, and debug without depending on backend servers.

Dinesh Thakur

October 24, 2025

Requestly helps a global learning & talent technology provider deliver brand-personalized demos in minutes

Global learning tech provider uses Requestly to deliver brand-personalized demos in minutes by swapping logos, images, and data—no code or backend changes.

Akanksha Bhadauria

October 23, 2025