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

# Laravel Passport (OAuth2-Server-Implementierung)

> Wie Sie mit Laravel Passport einen OAuth2-Server implementieren. Wann Passport vs. Sanctum, Installation, Client-Verwaltung, Scopes und Token-Betrieb.

## Was ist Passport

Laravel Passport ist das offizielle Paket, um eine Laravel-Anwendung als OAuth2-Autorisierungsserver zu betreiben.
Es wird für die Integration mit Drittanbieter-Apps oder für APIs eingesetzt, die einen strengen OAuth2-Flow benötigen.

```mermaid theme={null}
sequenceDiagram
    participant User as Benutzer
    participant Client as OAuth-Client
    participant App as Laravel-App<br>(Passport)
    participant API as Geschützte API

    User->>Client: Verknüpfung starten
    Client->>App: Autorisierungs-Request
    App->>User: Zustimmungsseite anzeigen
    User->>App: Zustimmung
    App-->>Client: Authorization Code
    Client->>App: Authorization Code gegen Access Token tauschen
    App-->>Client: Access Token
    Client->>API: API-Aufruf mit Bearer-Token
    API-->>Client: Antwort
```

## Passport vs. Sanctum

Wenn OAuth2 zwingend erforderlich ist, wählen Sie Passport.
Für einfache API-Token-Authentifizierung oder SPA-/Mobile-Auth ist Sanctum die bessere Wahl.

| Aspekt       | Passport                                            | Sanctum                                      |
| ------------ | --------------------------------------------------- | -------------------------------------------- |
| Zweck        | OAuth2-Server-Implementierung                       | Einfache API-Authentifizierung               |
| Geeignet für | Externe App-Integration, OAuth2-Standardkonformität | Eigene SPAs, mobile Apps, persönliche Tokens |
| Komplexität  | Hoch                                                | Gering                                       |

## Installation

Ab Laravel 13 wird offiziell `install:api --passport` empfohlen.

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

Für die manuelle Einführung in bestehende Projekte:

```shell theme={null}
composer require laravel/passport
php artisan passport:install
```

Beim ersten Deployment möchten Sie eventuell nur die Schlüssel erzeugen.

```shell theme={null}
php artisan passport:keys
```

## Konfiguration

### User-Modell

Fügen Sie im `User`-Modell das Trait `HasApiTokens` und das Interface `OAuthenticatable` hinzu.

```php theme={null}
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Laravel\Passport\Contracts\OAuthenticatable;
use Laravel\Passport\HasApiTokens;

class User extends Authenticatable implements OAuthenticatable
{
    use HasApiTokens, HasFactory, Notifiable;
}
```

### auth-Guard

Konfigurieren Sie in `config/auth.php` für den `api`-Guard den `passport`-Treiber.

```php theme={null}
'guards' => [
    'api' => [
        'driver' => 'passport',
        'provider' => 'users',
    ],
],
```

### Service-Provider-Konfiguration

In `boot()` des `AppServiceProvider` legen Sie Scopes und Token-Gültigkeit fest.

```php theme={null}
use Carbon\CarbonInterval;
use Laravel\Passport\Passport;

public function boot(): void
{
    Passport::tokensCan([
        'orders:read' => 'Bestellungen lesen',
        'orders:create' => 'Bestellungen anlegen',
    ]);

    Passport::defaultScopes(['orders:read']);

    Passport::tokensExpireIn(CarbonInterval::days(15));
    Passport::refreshTokensExpireIn(CarbonInterval::days(30));
    Passport::personalAccessTokensExpireIn(CarbonInterval::months(6));
}
```

## Client-Verwaltung

### Client für Authorization Code Grant

```shell theme={null}
php artisan passport:client
```

Diesen Client verwenden Sie für den Standard-OAuth2-Flow mit Zustimmungsdialog.

### Client für Client Credentials Grant

```shell theme={null}
php artisan passport:client --client
```

Für Machine-to-Machine-Endpunkte verwenden Sie die Middleware `EnsureClientIsResourceOwner`.

```php theme={null}
use Laravel\Passport\Http\Middleware\EnsureClientIsResourceOwner;

Route::get('/orders', function () {
    // ...
})->middleware(EnsureClientIsResourceOwner::using('orders:read'));
```

## Token-Verwaltung

### Scopes vergeben

```php theme={null}
$accessToken = $user->createToken(
    'dashboard-token',
    ['orders:read', 'orders:create']
)->accessToken;
```

### Scopes prüfen

```php theme={null}
use Laravel\Passport\Http\Middleware\CheckToken;

Route::get('/orders', function () {
    // ...
})->middleware(['auth:api', CheckToken::using('orders:read')]);
```

### Widerrufen

```php theme={null}
use Laravel\Passport\Passport;

$token = Passport::token()->find($tokenId);
$token?->revoke();
```

## API-Routen schützen

Fügen Sie zu APIs, die mit einem User-Access-Token geschützt werden sollen, `auth:api` hinzu.

```php theme={null}
Route::middleware('auth:api')->group(function () {
    Route::get('/user', fn (Request $request) => $request->user());
    Route::get('/orders', [OrderController::class, 'index']);
});
```

<Warning>
  Für Routen mit Client Credentials Grant verwenden Sie nicht `auth:api`, sondern `EnsureClientIsResourceOwner`.
</Warning>

## Personal Access Token

Geeignet, wenn Benutzer selbst API-Tokens ausstellen, ohne den vollständigen OAuth2-Flow zu durchlaufen.

```shell theme={null}
php artisan passport:client --personal
```

```php theme={null}
$token = $request->user()->createToken('cli-token', ['orders:read'])->accessToken;
```

<Info>
  Wenn Personal Access Tokens Ihr Hauptanwendungsfall sind, empfiehlt auch die offizielle Laravel-Dokumentation, Sanctum in Betracht zu ziehen.
</Info>

## Weiterführende Links

* [Offizielle Laravel-Dokumentation: Passport](https://laravel.com/docs/13.x/passport)
* [Offizielle Laravel-Dokumentation: Sanctum](https://laravel.com/docs/13.x/sanctum)


## Related topics

- [Laravel Sanctum (API-Token-Authentifizierung)](/de/sanctum.md)
- [Socialite für Discord](/de/packages/socialite-discord.md)
- [Socialite (LINE Login) - LINE SDK für Laravel](/de/packages/laravel-line-sdk/socialite.md)
- [Einen MCP-Server mit Laravel bauen](/de/advanced/mcp-server.md)
- [LINE SDK für Laravel](/de/packages/laravel-line-sdk/index.md)