> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Routing

> Uitleg over de basis van routedefinities, routeparameters en named routes in Laravel.

## Basisrouting

De meest basale Laravel-route neemt een URI en een closure.
Zonder ingewikkelde configuratiebestanden definieer je zo eenvoudig routes en hun gedrag.

```php theme={null}
use Illuminate\Support\Facades\Route;

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

### Standaard routebestanden

Alle Laravel-routes definieer je in de routebestanden in de map `routes/`.
Laravel laadt deze bestanden automatisch op basis van de configuratie in `bootstrap/app.php`.

```mermaid theme={null}
flowchart LR
    A["Binnenkomend request"] --> B{{"Type request"}}
    B -->|"Voor de browser<br>sessie / CSRF"| C["routes/web.php<br>web-middlewaregroep"]
    B -->|"Voor API's<br>stateless"| D["routes/api.php<br>api-middlewaregroep"]
    B -->|"CLI-commando"| E["routes/console.php<br>Artisan-commandodefinities"]
    C --> F["Controller / closure"]
    D --> F
    E --> G["Commandohandler"]
```

In `routes/web.php` definieer je de routes voor de browser.
Op de routes in dit bestand wordt de `web`-middlewaregroep toegepast, die sessies, CSRF-bescherming en cookie-encryptie biedt.

```php theme={null}
use App\Http\Controllers\UserController;

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

### API-routes

Biedt je applicatie een stateless API aan, dan kun je API-routing inschakelen met het Artisan-commando `install:api`.

```shell theme={null}
php artisan install:api
```

Het commando `install:api` installeert [Laravel Sanctum](/nl/sanctum) en maakt het bestand `routes/api.php` aan.
Sanctum biedt een eenvoudige en robuuste API-token-authenticatieguard voor externe API-consumers, SPA's en mobiele applicaties.

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

De routes in `routes/api.php` zijn stateless en krijgen de `api`-[middlewaregroep](/nl/middleware).
Bovendien krijgen alle routes automatisch de URI-prefix `/api`, dus die hoef je niet zelf toe te voegen.
Wil je de prefix wijzigen, pas dan het bestand `bootstrap/app.php` van je applicatie aan.

```php theme={null}
->withRouting(
    api: __DIR__.'/../routes/api.php',
    apiPrefix: 'api/admin',
    // ...
)
```

### Beschikbare HTTP-methoden

De router kan routes registreren voor alle HTTP-methoden.

```php theme={null}
Route::get($uri, $callback);
Route::post($uri, $callback);
Route::put($uri, $callback);
Route::patch($uri, $callback);
Route::delete($uri, $callback);
Route::options($uri, $callback);
```

Voor routes die op meerdere HTTP-methoden reageren gebruik je `match` of `any`.

```php theme={null}
Route::match(['get', 'post'], '/', function () {
    // ...
});

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

<Info>
  Neem in HTML-formulieren die `POST`, `PUT`, `PATCH` of `DELETE` versturen naar routes in het `web`-routebestand altijd de `@csrf`-directive op.
  Doe je dat niet, dan wordt het request geweigerd.
</Info>

## Routes die een view teruggeven

Als een route alleen een view hoeft terug te geven, kun je dat beknopt schrijven met `Route::view`.

```php theme={null}
Route::view('/welcome', 'welcome');

// Data doorgeven aan de view
Route::view('/welcome', 'welcome', ['name' => 'Taylor']);
```

## Routeparameters

### Verplichte parameters

Om een deel van de URL dynamisch op te vangen gebruik je routeparameters.
Parameters omsluit je met `{}` en ontvang je als argument van de routecallback.

```php theme={null}
Route::get('/user/{id}', function (string $id) {
    return 'Gebruikers-ID: ' . $id;
});
```

Je kunt ook meerdere parameters definiëren.

```php theme={null}
Route::get('/posts/{post}/comments/{comment}', function (string $postId, string $commentId) {
    return "Reactie {$commentId} van post {$postId}";
});
```

<Warning>
  Routeparameters mogen geen `/`-teken bevatten.
</Warning>

### Optionele parameters

Om een parameter optioneel te maken zet je een `?` achter de parameternaam en geef je het bijbehorende argument een standaardwaarde.

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

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

### Parameterbeperkingen met reguliere expressies

Met de `where`-methode leg je het formaat van een parameter vast via een reguliere expressie.

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

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

Veelgebruikte patronen kun je ook met handige hulpmethoden schrijven.

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

## Named routes

Met named routes kun je bij het genereren van URL's of redirects verwijzen naar de routenaam.

```php theme={null}
Route::get('/user/profile', function () {
    // ...
})->name('profile');
```

### URL's genereren voor named routes

Om een URL te genereren op basis van een routenaam gebruik je de `route`-helper.

```php theme={null}
// URL genereren
$url = route('profile');

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

### Redirects

```php theme={null}
return redirect()->route('profile');
```

## Routegroepen

Je kunt gerelateerde routes groeperen en gedeelde instellingen zoals middleware, controllers en prefixes toepassen.

```mermaid theme={null}
flowchart TD
    A["HTTP-request"] --> B["Router"]
    B --> C{{"Is er een<br>passende route?"}}
    C -->|"Nee"| D["404-response"]
    C -->|"Ja"| E["Middleware van de route controleren"]
    E --> F{{"Komt het request door<br>de middleware?"}}
    F -->|"Geweigerd"| G["Redirect /<br>foutresponse"]
    F -->|"Doorgelaten"| H["Controller /<br>closure uitvoeren"]
    H --> I["Response genereren"]
    I --> J["Naar de client versturen"]
```

### Middleware

```php theme={null}
Route::middleware(['auth'])->group(function () {
    Route::get('/dashboard', function () {
        // Alleen toegankelijk voor ingelogde gebruikers
    });

    Route::get('/account', function () {
        // Alleen toegankelijk voor ingelogde gebruikers
    });
});
```

### Controllers

Routes die dezelfde controller gebruiken kun je groeperen.

```php theme={null}
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

Je kunt de URI's van routes een gedeelde prefix geven.

```php theme={null}
Route::prefix('admin')->group(function () {
    Route::get('/users', function () {
        // Bereikbaar via /admin/users
    });
    Route::get('/posts', function () {
        // Bereikbaar via /admin/posts
    });
});
```

## Routelijst bekijken

Om alle gedefinieerde routes op te sommen gebruik je een Artisan-commando.

```shell theme={null}
php artisan route:list
```

Wil je ook de middleware-informatie zien, doe dan het volgende:

```shell theme={null}
php artisan route:list -v
```

Wil je alleen routes tonen die met een bepaalde URI beginnen, doe dan het volgende:

```shell theme={null}
php artisan route:list --path=user
```

## Volgende stap

<Card title="Views" icon="eye" href="/nl/views">
  Leer hoe je views maakt en data doorgeeft vanuit een controller.
</Card>


## Related topics

- [Laravel Socialite (sociale authenticatie)](/nl/socialite.md)
- [FAQ over de nieuwe appstructuur van Laravel 11+](/nl/advanced/app-structure-faq.md)
- [Queues en jobs](/nl/queues.md)
- [Laravel-updates van maart 2026](/nl/blog/changelog/202603.md)
- [Laravel Folio](/nl/folio.md)