Routing is one of the most important concepts in Laravel. It determines how your application responds when a user visits a URL or when another application sends an HTTP request to your API.

If you’re learning Laravel, understanding how Laravel routing works will help you build web applications, REST APIs, authentication systems, admin panels, and other backend services more effectively.

Laravel provides a simple and expressive routing system that allows you to connect URLs to closures, controllers, middleware, and other application logic.

In this guide, we’ll explain Laravel routing from the basics to more advanced concepts, including route parameters, named routes, route groups, middleware, resource routes, API routes, route model binding, and routing best practices.

---

What Is Routing in Laravel?

Routing is the process of defining how an application responds to a specific URL and HTTP method.

For example, suppose your application has this URL:

/products

You might want Laravel to return a list of products whenever a user visits that URL.

You can define the route like this:

use Illuminate\Support\Facades\Route;

Route::get('/products', function () {
    return 'Product List';
});

When a user sends a GET request to /products, Laravel executes the code associated with that route.

Simple Laravel Routing Flow

User / Client
      │
      │ GET /products
      ▼
┌─────────────────┐
│ Laravel Router  │
└────────┬────────┘
         │
         │ Route Match
         ▼
┌─────────────────┐
│ Route Handler   │
│ / Controller    │
└────────┬────────┘
         │
         ▼
      Response
         │
         ▼
       Client

In simple terms:

URL + HTTP method → matching route → application logic → response

---

Where Are Laravel Routes Defined?

Laravel routes are generally stored inside the routes directory.

A typical Laravel application contains route files such as:

routes/
├── web.php
├── api.php
├── console.php
└── channels.php

The most commonly used route files are:

File	Purpose
web.php	Web application routes
api.php	API routes
console.php	Console commands and scheduled tasks
channels.php	Broadcast channel authorization

For traditional browser-based applications, web.php is commonly used.

---

Basic Laravel Route Syntax

The simplest Laravel route looks like this:

use Illuminate\Support\Facades\Route;

Route::get('/hello', function () {
    return 'Hello, Laravel!';
});

This route has three important parts:

Route::get(
      │
      ├── HTTP Method
      │
      ├── URI
      │
      └── Handler
)

The first argument is the URL.

The second argument is what Laravel should execute when the route matches.

---

Laravel HTTP Methods

Laravel supports the common HTTP methods used by modern web applications and APIs.

The most frequently used methods are:

Route::get('/users', ...);

Route::post('/users', ...);

Route::put('/users/{id}', ...);

Route::patch('/users/{id}', ...);

Route::delete('/users/{id}', ...);

These methods generally represent different operations.

HTTP Method	Common Purpose
GET	Retrieve data
POST	Create data
PUT	Replace/update data
PATCH	Partially update data
DELETE	Delete data

For example:

Route::get('/products', ...);

could retrieve products.

While:

Route::post('/products', ...);

could create a new product.

---

GET Routes in Laravel

A GET route is commonly used to retrieve a page or resource.

Route::get('/about', function () {
    return view('about');
});

When the user visits:

/about

Laravel returns the about Blade view.

Another example:

Route::get('/products', function () {
    return 'Products';
});

---

POST Routes in Laravel

POST requests are commonly used to submit or create data.

Route::post('/products', function () {
    return 'Product created';
});

For example, a form might send data to:

POST /products

Laravel can then process the submitted data.

In a real application, POST routes are usually connected to controllers rather than keeping business logic directly inside the route.

---

PUT and PATCH Routes

PUT and PATCH are commonly used to update existing resources.

Route::put('/products/{id}', function ($id) {
    return "Updating product {$id}";
});

PATCH can be used for partial updates:

Route::patch('/products/{id}', function ($id) {
    return "Partially updating product {$id}";
});

The distinction between PUT and PATCH is largely about the semantics of the update. PUT traditionally represents replacing a resource, while PATCH represents a partial modification.

---

DELETE Routes

DELETE routes are used to remove resources.

Route::delete('/products/{id}', function ($id) {
    return "Deleting product {$id}";
});

For example:

DELETE /products/15

could delete product 15.

In production applications, authorization and validation should be performed before destructive operations.

---

Routes Using Controllers

Although closures are useful for simple examples, real Laravel applications typically use controllers.

For example:

use App\Http\Controllers\ProductController;

Route::get(
    '/products',
    [ProductController::class, 'index']
);

Laravel sends requests for /products to the index() method of ProductController.

The controller might look like:

namespace App\Http\Controllers;

use App\Models\Product;

class ProductController extends Controller
{
    public function index()
    {
        $products = Product::all();

        return view('products.index', [
            'products' => $products
        ]);
    }
}

This approach keeps routing separate from application logic.

---

Why Use Controllers Instead of Closures?

Closures are convenient for simple routes:

Route::get('/hello', function () {
    return 'Hello';
});

But larger applications can become difficult to maintain if routes contain lots of business logic.

A better structure is:

Route
  │
  ▼
Controller
  │
  ▼
Service / Model
  │
  ▼
Database

This separation makes your application easier to test, maintain, and scale.

---

Laravel Route Parameters

Sometimes a URL needs to contain dynamic information.

For example:

/products/25

Here, 25 could represent a product ID.

Laravel allows dynamic route parameters using curly braces.

Route::get('/products/{id}', function ($id) {
    return "Product ID: {$id}";
});

If the user visits:

/products/25

Laravel passes 25 to the $id parameter.

---

Multiple Route Parameters

You can define multiple parameters.

Route::get('/users/{user}/posts/{post}', function ($user, $post) {
    return "User: {$user}, Post: {$post}";
});

A URL such as:

/users/10/posts/50

would provide:

user = 10
post = 50

---

Optional Route Parameters

Laravel also supports optional route parameters.

Use ? after the parameter name:

Route::get('/users/{name?}', function ($name = 'Guest') {
    return "Hello, {$name}";
});

Now both URLs can work:

/users/John

and:

/users

When no name is provided, Laravel uses the default value.

---

Route Parameter Constraints

You can restrict route parameters using regular expressions.

For example, if a route parameter should contain only numbers:

Route::get('/products/{id}', function ($id) {
    return "Product: {$id}";
})->where('id', '[0-9]+');

Now Laravel expects the id parameter to contain numbers.

Laravel also provides convenient methods for common patterns:

Route::get('/products/{id}', function ($id) {
    return $id;
})->whereNumber('id');

You can use similar constraints for alphabetic or alphanumeric values.

---

Named Routes in Laravel

Named routes allow you to give a route a unique name.

For example:

Route::get('/products', function () {
    return view('products.index');
})->name('products.index');

You can then generate its URL using:

$url = route('products.index');

This is better than hard-coding URLs throughout your application.

For example:

<a href="{{ route('products.index') }}">
    Products
</a>

If the URL later changes from:

/products

to:

/store/products

you can update the route definition without changing every link that references its name.

---

Route Redirects

Laravel allows you to redirect one URL to another.

Route::redirect('/old-page', '/new-page');

You can also specify the HTTP status code:

Route::redirect('/old-page', '/new-page', 301);

A 301 redirect is commonly used for permanent URL changes.

---

Route Groups

When multiple routes share the same configuration, route groups can reduce repetition.

For example:

Route::prefix('admin')->group(function () {

    Route::get('/dashboard', function () {
        return 'Admin Dashboard';
    });

    Route::get('/users', function () {
        return 'Admin Users';
    });

});

These routes become:

/admin/dashboard
/admin/users

Route groups are especially useful for:

• Admin routes
• API versions
• Middleware
• URL prefixes
• Route naming
• Shared controller configuration

---

Route Prefixes

You can apply a common URL prefix to a group.

Route::prefix('api')->group(function () {

    Route::get('/users', ...);

    Route::get('/products', ...);

});

The resulting URLs become:

/api/users
/api/products

You can combine prefixes with controllers and middleware for larger applications.

---

Route Name Prefixes

You can also give multiple routes a common name prefix.

Route::name('admin.')->group(function () {

    Route::get('/dashboard', ...)
        ->name('dashboard');

    Route::get('/users', ...)
        ->name('users');

});

The route names become:

admin.dashboard
admin.users

This is useful for organizing named routes in large applications.

---

Laravel Middleware and Routing

Middleware is another important part of Laravel routing.

Middleware can inspect an incoming request before it reaches your application logic.

For example:

Route::middleware('auth')->group(function () {

    Route::get('/dashboard', function () {
        return view('dashboard');
    });

});

The auth middleware ensures that the user is authenticated before accessing the dashboard.

Middleware Flow

HTTP Request
     │
     ▼
   Route
     │
     ▼
 Middleware
     │
     ├── Not Authorized ──► Response
     │
     ▼
 Controller
     │
     ▼
 Response

Middleware is commonly used for:

• Authentication
• Authorization
• Rate limiting
• Logging
• Request filtering
• CORS
• Custom application rules

---

Route Model Binding

Laravel provides a convenient feature called route model binding.

Instead of manually retrieving a model from an ID, Laravel can automatically resolve it.

For example:

use App\Models\Product;

Route::get('/products/{product}', function (Product $product) {
    return $product;
});

If the URL is:

/products/25

Laravel can automatically retrieve the corresponding Product model.

This reduces repetitive code.

Without model binding, you might write:

$product = Product::findOrFail($id);

With route model binding, Laravel can resolve the model for you.

---

Implicit Route Model Binding

Implicit binding is commonly used with type-hinted model parameters.

Route::get('/users/{user}', function (User $user) {
    return $user;
});

Laravel uses the route parameter and model type to determine which model should be retrieved.

If the model doesn’t exist, Laravel can automatically return a 404 response.

---

Explicit Route Model Binding

You can also explicitly define how a route parameter should resolve.

This is useful for custom binding behavior and more advanced applications.

For example, an application may want to resolve a product using a SKU instead of a numeric ID.

This provides greater flexibility when designing URLs.

---

Resource Routes

Laravel provides resource routing for common CRUD operations.

Instead of defining every route manually:

Route::get('/products', ...);
Route::post('/products', ...);
Route::get('/products/{product}', ...);
Route::put('/products/{product}', ...);
Route::delete('/products/{product}', ...);

you can use:

Route::resource('products', ProductController::class);

Laravel generates the standard resource routes for you.

Resource Route Table

HTTP Method	URI	Controller Method	Typical Purpose
GET	/products	index	List products
GET	/products/create	create	Show create form
POST	/products	store	Create product
GET	/products/{product}	show	Show product
GET	/products/{product}/edit	edit	Show edit form
PUT/PATCH	/products/{product}	update	Update product
DELETE	/products/{product}	destroy	Delete product

This is one of Laravel’s most useful features when building CRUD applications.

---

Laravel API Resource Routes

For APIs, you can use:

Route::apiResource(
    'products',
    ProductController::class
);

This generates API-oriented resource routes without the routes intended for HTML create and edit forms.

For example:

GET     /products
POST    /products
GET     /products/{product}
PUT     /products/{product}
PATCH   /products/{product}
DELETE  /products/{product}

This is useful when building REST APIs for mobile apps, frontend applications, or third-party integrations.

---

Laravel API Routing

Laravel can be used to build RESTful APIs.

For example:

Route::get('/products', [ProductController::class, 'index']);
Route::post('/products', [ProductController::class, 'store']);
Route::get('/products/{product}', [ProductController::class, 'show']);
Route::put('/products/{product}', [ProductController::class, 'update']);
Route::delete('/products/{product}', [ProductController::class, 'destroy']);

A frontend application could communicate with these endpoints using HTTP requests.

React / Vue / Mobile App
          │
          │ HTTP
          ▼
     Laravel API
          │
          ▼
     Controller
          │
          ▼
       Eloquent
          │
          ▼
       Database

---

API Versioning With Routes

When building APIs, versioning can help maintain backward compatibility.

For example:

Route::prefix('v1')->group(function () {

    Route::get('/products', [ProductController::class, 'index']);

});

The API endpoint becomes:

/api/v1/products

Later, you can introduce:

/api/v2/products

without necessarily breaking clients using version 1.

---

Route Caching

Laravel can cache routes to improve application performance in production.

You can cache routes with:

php artisan route:cache

To clear the route cache:

php artisan route:clear

Route caching should be considered part of production deployment rather than something you need during normal development.

---

How to View All Laravel Routes

One of the most useful Artisan commands for debugging routing is:

php artisan route:list

It displays your application’s registered routes.

You may see output similar to:

GET|HEAD   /products
POST       /products
GET|HEAD   /products/{product}
PUT        /products/{product}
DELETE     /products/{product}

This is extremely useful when debugging:

• Wrong URLs
• Missing routes
• Middleware
• Route names
• Controllers
• HTTP methods

---

Route Naming Best Practices

Good route naming makes applications easier to maintain.

For example:

Route::get('/products', ...)
    ->name('products.index');

Route::get('/products/{product}', ...)
    ->name('products.show');

A common naming convention is:

resource.action

Examples:

products.index
products.create
products.store
products.show
products.edit
products.update
products.destroy

This convention works particularly well with Laravel resource controllers.

---

Laravel Route Model Binding vs Manual Queries

Approach	Example	Benefit
Manual Query	Product::findOrFail($id)	Explicit control
Route Model Binding	Product $product	Less repetitive code
Custom Binding	Resolve using custom field	Flexible URLs

For straightforward CRUD applications, route model binding can significantly reduce boilerplate.

---

Common Laravel Routing Mistakes

1. Using the Wrong HTTP Method

A route defined as:

Route::post('/products', ...);

will not match a GET request to:

/products

Always verify the HTTP method.

---

2. Defining Routes in the Wrong File

Web routes and API routes can have different middleware and behavior.

Make sure your route is registered in the appropriate route file for your application’s architecture.

---

3. Hard-Coding URLs Everywhere

Instead of:

<a href="/products">Products</a>

prefer named routes:

<a href="{{ route('products.index') }}">
    Products
</a>

This makes URL changes easier to manage.

---

4. Putting Too Much Logic Inside Routes

Avoid:

Route::get('/products', function () {

    // Hundreds of lines of business logic...

});

Use controllers and appropriate application layers instead.

---

5. Forgetting Route Parameters

If your route is:

Route::get('/products/{product}', ...);

the URL must include a product parameter:

/products/10

---

6. Route Conflicts

Consider these routes:

Route::get('/products/{product}', ...);

Route::get('/products/special', ...);

A static route such as /products/special should be designed carefully alongside dynamic routes so that route matching behaves as intended.

Use specific routes and constraints where appropriate.

---

7. Forgetting to Clear Cached Routes

If routes appear outdated in a production environment, cached routes may be involved.

Useful commands include:

php artisan route:clear

and:

php artisan optimize:clear

---

Laravel Routing Best Practices

For clean and maintainable applications, follow these practices.

Keep Routes Simple

Routes should primarily define URL-to-handler relationships.

Use Controllers

Move application logic into controllers or appropriate service layers.

Use Named Routes

Named routes make URLs easier to maintain.

Use Route Groups

Group routes that share middleware, prefixes, or naming conventions.

Use Resource Controllers for CRUD

Resource routes reduce repetitive route definitions.

Use Route Model Binding

Use model binding where it makes the code simpler and clearer.

Protect Sensitive Routes

Use authentication and authorization middleware for private functionality.

Validate Parameters

Use route constraints when a parameter has a specific format.

Avoid Duplicate Routes

Keep route definitions organized to prevent conflicts.

Inspect Routes During Debugging

Use:

php artisan route:list

to understand exactly what Laravel has registered.

---

Laravel Routing Example: Complete CRUD Application

Suppose you’re building a product management system.

Your routes might look like:

use App\Http\Controllers\ProductController;

Route::middleware('auth')->group(function () {

    Route::resource(
        'products',
        ProductController::class
    );

});

This gives you a complete CRUD structure.

                  /products
                      │
       ┌──────────────┼──────────────┐
       │              │              │
      GET            POST           GET
       │              │              │
     index           store          show
       │                             │
       └────────── Product ──────────┘
                     │
                update/delete

The authentication middleware protects all product management routes.

This is a common pattern for Laravel admin applications.

---

Laravel Routing in a Real-World Application

Imagine an e-commerce application.

You might have:

/products
/products/{product}

/cart
/checkout

/orders
/orders/{order}

/admin/dashboard
/admin/products
/admin/orders

These can be organized into route groups:

Route::get('/products', [ProductController::class, 'index']);
Route::get('/products/{product}', [ProductController::class, 'show']);

Route::middleware('auth')->group(function () {

    Route::get('/orders', [OrderController::class, 'index']);
    Route::get('/orders/{order}', [OrderController::class, 'show']);

});

Route::prefix('admin')
    ->middleware(['auth', 'admin'])
    ->group(function () {

        Route::get('/dashboard', [AdminController::class, 'dashboard']);

        Route::resource(
            'products',
            AdminProductController::class
        );

    });

This structure separates public routes, authenticated routes, and administrator routes.

---

Key Takeaways

The most important things to remember about Laravel routing are:

• Routing determines how Laravel responds to URLs and HTTP requests.
• Routes are commonly defined in the routes directory.
• Route::get(), Route::post(), Route::put(), Route::patch(), and Route::delete() define HTTP-specific routes.
• Routes can point to closures or controller methods.
• Dynamic URL values can be defined using route parameters.
• Named routes make URL generation easier.
• Route groups help organize routes with shared configuration.
• Middleware can protect and process routes.
• Route model binding automatically resolves models from route parameters.
• Resource routes simplify CRUD applications.
• API resource routes are useful for REST APIs.
• php artisan route:list is an essential debugging command.
• Good route organization makes Laravel applications easier to maintain and scale.

---

Frequently Asked Questions

1. What is routing in Laravel?

Laravel routing defines how your application responds to specific URLs and HTTP methods. A route connects an incoming request to a closure, controller, or other handler.

2. Where are Laravel routes stored?

Laravel routes are generally stored in the routes directory. Common files include web.php, api.php, console.php, and channels.php.

3. How do I create a route in Laravel?

You can create a basic route using the Route facade:

Route::get('/hello', function () {
    return 'Hello, Laravel!';
});

4. What is the difference between web.php and api.php in Laravel?

web.php is commonly used for browser-based web routes and typically uses web middleware such as sessions and CSRF protection. API routes are designed for stateless API requests and use the API routing configuration of the Laravel application.

5. What is route model binding in Laravel?

Route model binding allows Laravel to automatically retrieve a model based on a route parameter.

Route::get('/products/{product}', function (Product $product) {
    return $product;
});

6. What are named routes in Laravel?

Named routes allow you to assign a name to a route and generate its URL using the route name.

Route::get('/products', ...)
    ->name('products.index');

You can then use:

route('products.index');

7. What are Laravel resource routes?

Resource routes automatically create the standard CRUD routes for a resource.

Route::resource('products', ProductController::class);

This can generate routes for listing, creating, viewing, updating, and deleting products.

8. How can I see all routes in Laravel?

Run:

php artisan route:list

This displays the routes registered by your Laravel application.

---

Conclusion

Understanding how Laravel routing works is essential for anyone building Laravel applications.

Laravel’s routing system provides a clean way to connect URLs and HTTP methods to controllers and application logic. As your project grows, features such as named routes, route groups, middleware, route model binding, and resource controllers help keep your application organized.

For beginners, start with basic GET and POST routes. Then learn route parameters, controllers, named routes, middleware, and resource routing. Once those concepts are comfortable, move into API routing, route model binding, versioning, and route optimization.

Good routing isn’t just about making URLs work. It is about creating a clear, predictable, secure, and maintainable structure for your application’s HTTP layer.

---