Routing

Learn the basics of defining routes, route parameters, and named routes in Laravel.

Basic routing

The most basic Laravel routes accept a URI and a closure. They let you easily define routes and their behavior without complex configuration files.

use Illuminate\Support\Facades\Route;

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

The default route files

All Laravel routes are defined in route files in the routes/ directory. These files are automatically loaded by Laravel based on the configuration in bootstrap/app.php.

Define browser-facing routes in routes/web.php. Routes in this file are wrapped in the web middleware group, which provides session, CSRF protection, and cookie encryption.

use App\Http\Controllers\UserController;

Route::get('/user', [UserController::class, 'index']);

API routes

If your application will offer a stateless API, you can enable API routing with the install:api Artisan command.

php artisan install:api

The install:api command installs Laravel Sanctum and creates a routes/api.php file. Sanctum provides a simple, robust API token authentication guard for third-party API consumers, SPAs, and mobile applications.

Route::get('/user', function (Request $request) {
    return $request->user();
})->middleware('auth:sanctum');

Routes in routes/api.php are stateless and the api middleware group is applied. The /api URI prefix is also automatically applied to every route, so you don’t need to add it manually. To change the prefix, edit your application’s bootstrap/app.php file.

->withRouting(
    api: __DIR__.'/../routes/api.php',
    apiPrefix: 'api/admin',
    // ...
)

Available HTTP methods

The router allows you to register routes for any HTTP verb.

Route::get($uri, $callback);
Route::post($uri, $callback);
Route::put($uri, $callback);
Route::patch($uri, $callback);
Route::delete($uri, $callback);
Route::options($uri, $callback);

Use match or any for a route that responds to multiple HTTP verbs.

Route::match(['get', 'post'], '/', function () {
    // ...
});

Route::any('/', function () {
    // ...
});

Any HTML form that accepts POST, PUT, PATCH, or DELETE in a web route file must include the @csrf directive. Otherwise, the request will be rejected.

Routes that return views

If a route only needs to return a view, you can write it concisely with Route::view.

Route::view('/welcome', 'welcome');

// Passing data to the view
Route::view('/welcome', 'welcome', ['name' => 'Taylor']);

Route parameters

Required parameters

To capture a dynamic part of the URL, use route parameters. Wrap the parameter in {} and receive it as an argument on the route callback.

Route::get('/user/{id}', function (string $id) {
    return 'User ID: ' . $id;
});

You can also define multiple parameters.

Route::get('/posts/{post}/comments/{comment}', function (string $postId, string $commentId) {
    return "Comment {$commentId} on post {$postId}";
});

Route parameters cannot contain the / character.

Optional parameters

To make a parameter optional, append ? to the parameter name and give the corresponding argument a default value.

Route::get('/user/{name?}', function (?string $name = null) {
    return $name ?? 'Guest';
});

Route::get('/user/{name?}', function (?string $name = 'Guest') {
    return $name;
});

Regular expression constraints

You can constrain the format of parameters with regular expressions using the where method.

Route::get('/user/{id}', function (string $id) {
    // ...
})->where('id', '[0-9]+');

Route::get('/user/{name}', function (string $name) {
    // ...
})->where('name', '[a-zA-Z]+');

For common patterns, there are convenience methods you can use instead.

Route::get('/user/{id}/{name}', function (string $id, string $name) {
    // ...
})->whereNumber('id')->whereAlpha('name');

Named routes

Named routes let you refer to a route by name when generating URLs or redirects.

Route::get('/user/profile', function () {
    // ...
})->name('profile');

Generating URLs to named routes

To generate a URL from a route name, use the route helper.

// Generate URL
$url = route('profile');

// Generate URL with parameters
$url = route('user.show', ['id' => 1]);

Redirecting

return redirect()->route('profile');

Route groups

You can group related routes to share middleware, controllers, prefixes, and more.

Middleware

Route::middleware(['auth'])->group(function () {
    Route::get('/dashboard', function () {
        // Only accessible to authenticated users
    });

    Route::get('/account', function () {
        // Only accessible to authenticated users
    });
});

Controllers

You can group routes that use the same controller.

use App\Http\Controllers\OrderController;

Route::controller(OrderController::class)->group(function () {
    Route::get('/orders', 'index');
    Route::post('/orders', 'store');
    Route::get('/orders/{id}', 'show');
});

Prefixes

You can apply a common prefix to a set of route URIs.

Route::prefix('admin')->group(function () {
    Route::get('/users', function () {
        // Accessible at /admin/users
    });
    Route::get('/posts', function () {
        // Accessible at /admin/posts
    });
});

Listing routes

To list every route that has been defined, use the Artisan command.

php artisan route:list

Include middleware information as follows:

php artisan route:list -v

To display only routes that start with a specific URI:

php artisan route:list --path=user

Next steps

Views

Learn how to create views and pass data to them from controllers.