Skip to main content

Documentation Index

Fetch the complete documentation index at: https://kawax.biz/llms.txt

Use this file to discover all available pages before exploring further.

​
Basic routing

The most basic Laravel route accepts a URI and a closure, letting you define a route and its behavior without complex configuration files: 
use Illuminate\Support\Facades\Route;

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

​
Default route files

All Laravel routes are defined in the files inside the routes/ directory. Laravel automatically loads these files based on the configuration in bootstrap/app.php. Define browser-facing routes in routes/web.php. Routes in this file have the web middleware group applied, which provides session handling, CSRF protection, and cookie encryption: 
use App\Http\Controllers\UserController;

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

​
Available HTTP methods

The router can register routes that respond to 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);
To respond to multiple HTTP verbs, use match or any: 
Route::match(['get', 'post'], '/', function () {
    // ...
});

Route::any('/', function () {
    // ...
});
HTML forms in the web routes file that send POST, PUT, PATCH, or DELETE requests must include the @csrf Blade directive. Requests without it will be rejected.

​
Returning a view

When a route only needs to return a view, use Route::view for a concise definition: 
Route::view('/welcome', 'welcome');

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

​
Route parameters

​
Required parameters

Capture segments of the URI by defining route parameters wrapped in {}. The captured values are passed as arguments to the route callback: 
Route::get('/user/{id}', function (string $id) {
    return 'User ID: ' . $id;
});
You can define multiple parameters: 
Route::get('/posts/{post}/comments/{comment}', function (string $postId, string $commentId) {
    return "Post {$postId}, comment {$commentId}";
});
Route parameters cannot contain the / character.

​
Optional parameters

Make a parameter optional by adding ? after its name and providing a default value for the corresponding argument: 
Route::get('/user/{name?}', function (?string $name = null) {
    return $name ?? 'Guest';
});

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

​
Regular expression constraints

Constrain the format of a route parameter 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]+');
Commonly used patterns have convenience methods: 
Route::get('/user/{id}/{name}', function (string $id, string $name) {
    // ...
})->whereNumber('id')->whereAlpha('name');

​
Named routes

Named routes let you reference a route by name when generating URLs or redirects, so you don’t need to hard-code URLs: 
Route::get('/user/profile', function () {
    // ...
})->name('profile');

​
Generating URLs to named routes

Use the route helper to generate a URL from a route name: 
// Generate a URL
$url = route('profile');

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

​
Redirecting to named routes

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

​
Route groups

Group related routes to share middleware, controllers, prefixes, and other attributes without repeating them on each route.

​
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

Group routes that share 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

Add a common URI prefix to a group of routes: 
Route::prefix('admin')->group(function () {
    Route::get('/users', function () {
        // Accessible at /admin/users
    });
    Route::get('/posts', function () {
        // Accessible at /admin/posts
    });
});

​
Name prefixes

Prefix the name of every route in a group: 
Route::name('admin.')->group(function () {
    Route::get('/users', function () {
        // Route named "admin.users"
    })->name('users');
});

​
Resource routes

For controllers that handle CRUD operations on a resource, Route::resource registers all the standard routes in one line: 
use App\Http\Controllers\PhotoController;

Route::resource('photos', PhotoController::class);
This single declaration creates the following routes:
VerbURIActionRoute name
GET/photosindexphotos.index
GET/photos/createcreatephotos.create
POST/photosstorephotos.store
GET/photos/{photo}showphotos.show
GET/photos/{photo}/editeditphotos.edit
PUT/PATCH/photos/{photo}updatephotos.update
DELETE/photos/{photo}destroyphotos.destroy
To register only a subset of these routes, use only or except: 
Route::resource('photos', PhotoController::class)->only(['index', 'show']);

Route::resource('photos', PhotoController::class)->except(['create', 'store', 'update', 'destroy']);

​
Listing defined routes

Display all registered routes with the Artisan command: 
php artisan route:list
Include middleware information: 
php artisan route:list -v
Filter routes by URI prefix: 
php artisan route:list --path=user

​
Next steps

Blade templates

Learn how to use Laravel’s Blade templating engine to build dynamic views.
Last modified on April 7, 2026