> ## 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

> Erläutert die Grundlagen der Routendefinition in Laravel, Route-Parameter und benannte Routen.

## Grundlegendes Routing

Die einfachste Route in Laravel besteht aus einer URI und einer Closure.
Ohne komplizierte Konfigurationsdateien lassen sich Routen und Verhalten definieren.

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

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

### Standard-Routendateien

Alle Laravel-Routen definieren Sie in den Routendateien im Verzeichnis `routes/`.
Diese Dateien werden von Laravel gemäß der Konfiguration in `bootstrap/app.php` automatisch geladen.

```mermaid theme={null}
flowchart LR
    A["Eingehende Anfrage"] --> B{{"Art der Anfrage"}}
    B -->|"Für Browser<br>Session / CSRF"| C["routes/web.php<br>Middleware-Gruppe web"]
    B -->|"Für API<br>zustandslos"| D["routes/api.php<br>Middleware-Gruppe api"]
    B -->|"CLI-Befehl"| E["routes/console.php<br>Artisan-Befehle"]
    C --> F["Controller / Closure"]
    D --> F
    E --> G["Command-Handler"]
```

In `routes/web.php` definieren Sie Routen für den Browser.
Auf diese Routen wird die Middleware-Gruppe `web` angewendet, die Session, CSRF-Schutz und Cookie-Verschlüsselung bereitstellt.

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

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

### API-Routen

Wenn Ihre Anwendung eine zustandslose API bereitstellt, aktivieren Sie das API-Routing mit dem Artisan-Befehl `install:api`.

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

Der Befehl installiert [Laravel Sanctum](/de/sanctum) und legt die Datei `routes/api.php` an.
Sanctum bietet einen einfachen, robusten API-Token-Guard für externe API-Konsumenten, SPAs und Mobile-Apps.

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

Die Routen in `routes/api.php` sind zustandslos, es gilt die [Middleware-Gruppe](/de/middleware) `api`.
Zudem wird allen Routen automatisch der URI-Präfix `/api` vorangestellt, sodass Sie ihn nicht manuell setzen müssen.
Um den Präfix anzupassen, ändern Sie die Datei `bootstrap/app.php`.

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

### Verfügbare HTTP-Methoden

Der Router registriert Routen für 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);
```

Um auf mehrere HTTP-Methoden zu reagieren, verwenden Sie `match` oder `any`.

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

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

<Info>
  Für HTML-Formulare in `web`-Routen mit `POST`, `PUT`, `PATCH` oder `DELETE` müssen Sie unbedingt die Direktive `@csrf` einbinden.
  Andernfalls wird die Anfrage abgelehnt.
</Info>

## Routen, die eine View zurückgeben

Wenn eine Route lediglich eine View zurückgibt, verwenden Sie `Route::view`.

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

// Daten an die View übergeben
Route::view('/welcome', 'welcome', ['name' => 'Taylor']);
```

## Route-Parameter

### Pflichtparameter

Um Teile der URL dynamisch aufzunehmen, verwenden Sie Route-Parameter.
Sie kennzeichnen Parameter mit `{}` und erhalten sie als Argument in der Route-Callback.

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

Auch mehrere Parameter sind möglich.

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

<Warning>
  Route-Parameter dürfen kein `/` enthalten.
</Warning>

### Optionale Parameter

Um einen Parameter optional zu machen, hängen Sie `?` an den Namen und setzen dem Argument einen Standardwert.

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

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

### Parameter mit regulären Ausdrücken einschränken

Mit `where` schränken Sie das Format eines Parameters per Regex ein.

```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]+');
```

Häufig genutzte Muster stehen als Convenience-Methoden bereit.

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

## Benannte Routen

Benannte Routen erlauben es, beim Generieren von URLs oder Redirects auf den Namen zu verweisen.

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

### URL-Erzeugung für benannte Routen

Zur URL-Erzeugung verwenden Sie den `route`-Helper.

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

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

### Redirect

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

## Route-Gruppen

Zusammengehörige Routen lassen sich gruppieren, um Middleware, Controller oder Präfixe gemeinsam zu setzen.

```mermaid theme={null}
flowchart TD
    A["HTTP-Anfrage"] --> B["Router"]
    B --> C{{"Passende Route<br>gefunden?"}}
    C -->|"Nein"| D["404-Antwort"]
    C -->|"Ja"| E["Middleware der Route prüfen"]
    E --> F{{"Passiert die<br>Middleware?"}}
    F -->|"Abgelehnt"| G["Redirect /<br>Fehlerantwort"]
    F -->|"Ja"| H["Controller /<br>Closure ausführen"]
    H --> I["Antwort erzeugen"]
    I --> J["An Client senden"]
```

### Middleware

```php theme={null}
Route::middleware(['auth'])->group(function () {
    Route::get('/dashboard', function () {
        // Nur für angemeldete Benutzer erreichbar
    });

    Route::get('/account', function () {
        // Nur für angemeldete Benutzer erreichbar
    });
});
```

### Controller

Routen, die denselben Controller verwenden, lassen sich gruppieren.

```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');
});
```

### Präfix

Sie können den URIs einer Gruppe einen gemeinsamen Präfix voranstellen.

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

## Übersicht aller Routen

Um alle definierten Routen anzuzeigen, nutzen Sie den Artisan-Befehl:

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

Um zusätzlich Middleware-Informationen anzuzeigen:

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

Um nur Routen mit einer bestimmten URI anzuzeigen:

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

## Nächste Schritte

<Card title="Views" icon="eye" href="/de/views">
  Erfahren Sie, wie Sie Views erstellen und Daten aus Controllern übergeben.
</Card>


## Related topics

- [Laravel Socialite (Social Authentication)](/de/socialite.md)
- [Request-Lebenszyklus](/de/lifecycle.md)
- [FAQ zur neuen App-Struktur ab Laravel 11](/de/advanced/app-structure-faq.md)
- [Laravel-Updates März 2026](/de/blog/changelog/202603.md)
- [Übersicht der neuen Features in Laravel 13](/de/blog/laravel-13-new-features.md)