---
id: 69a9184b42ae3947e4925016
title: How Does express.Router Work?
challengeType: 19
dashedName: how-does-expressrouter-work
---

# --description--

In Express, `express.Router()` is a powerful feature that helps you organize your routes into smaller, modular pieces. This is especially useful as your application grows.

Instead of defining all your routes in one large file, you can split them into separate files using routers. This keeps your code easier to read, maintain, and scale.

The `express.Router()` method creates a new router object.

A router works like a mini Express application. It can handle its own routes and middleware, but it is not a full-fledged Express application. Once you define routes on a router, you can mount it in your main app using `app.use()`.

In other words, a router lets you group related routes together and then later integrate them into your main application.

Using routers has several advantages:

**Separation of concerns**

You can define routes in separate files, which improves the organization and readability of your application.

**Code reusability**  
Routers can be reused in different parts of an application or even across projects.

**Cleaner main file**  
Instead of filling your main `app.js` or `server.js` file with many route definitions, you can move them into routers and keep your main file focused on configuration and setup.

Let’s look at a simple example where we use `express.Router()` to define routes for the `/users` path.

First, here's the `app.js` file:

```javascript
const express = require("express");
const app = express();
const port = 3000;

// Importing the user routes
const userRoutes = require("./userRoutes");

// Using the userRoutes router for /users path
app.use("/users", userRoutes);

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});
```

And here's `userRoutes.js`:

```javascript
const express = require("express");
const router = express.Router();

// GET request for /users
router.get("/", (req, res) => {
  res.send("List of users");
});

// POST request for /users
router.post("/", (req, res) => {
  res.send("Creating a new user");
});

// GET request for /users/:id
router.get("/:id", (req, res) => {
  const userId = req.params.id;
  res.send(`User details for user with id: ${userId}`);
});

module.exports = router;
```

Now let's take a closer look at how everything works.

In `app.js`, we import `express` and create an instance of the Express application and assign it to a variable named `app`.

Next, we import the `userRoutes` router from `userRoutes.js` and use `app.use("/users", userRoutes)` to mount the router. This tells Express that, if a request starts with `/users`, pass it to the `userRoutes` router.

Then in `userRoutes.js`, we create a new router using `express.Router()` and define routes using `router.get()`, `router.post()`, and `router.get("/:id")`.

Note that the routes defined here are relative to `/users` because that's where the router is mounted. So:

*   `router.get("/")` → `GET /users`: Responds with a list of users
    
*   `router.post("/")` → `POST /users`: Responds with a message about creating a new user
    
*   `router.get("/:id")` → `GET /users/:id`: Responds with user details for a given user ID
    

Using `express.Router()` keeps your main file clean and focused on configuration. All user-related routes are grouped together in `userRoutes.js`.

As your application grows, you can create additional routers for other sections, such as `/products`, `/orders`, or `/auth`.

Each section stays organized in its own file, making the application easier to maintain and scale.

# --questions--

## --text--

What does `express.Router()` do?

## --answers--

Creates a new instance of the Express application.

### --feedback--

Think about modularizing routes in your app.

---

Defines middleware for a specific route.

### --feedback--

Think about modularizing routes in your app.

---

Creates a router object for handling routes.

---

Starts the server.

### --feedback--

Think about modularizing routes in your app.

## --video-solution--

3

## --text--

How do you integrate a router into the main app?

## --answers--

By calling `app.use()` and passing the router.

---

By calling `app.get()` directly inside the router.

### --feedback--

Consider how the `app.js` uses the router to handle `/users` requests.

---

By using `router.listen()`.

### --feedback--

Consider how the `app.js` uses the router to handle `/users` requests.

---

By importing the router and calling `router.start()`.

### --feedback--

Consider how the `app.js` uses the router to handle `/users` requests.

## --video-solution--

1

## --text--

What is the benefit of using `express.Router()`?

## --answers--

It helps you handle static files.

### --feedback--

Think about how routers help organize code for large applications.

---

It allows you to group route handlers and apply middleware to specific paths.

---

It enables you to handle the database connection.

### --feedback--

Think about how routers help organize code for large applications.

---

It automatically starts the Express server.

### --feedback--

Think about how routers help organize code for large applications.

## --video-solution--

2
