> ## 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 (implémentation d'un serveur OAuth2)

> Comment implémenter un serveur OAuth2 avec Laravel Passport. Choix entre Passport et Sanctum, installation, gestion des clients, portées et gestion des tokens.

## Qu'est-ce que Passport

Laravel Passport est le package officiel qui permet à une application Laravel de fonctionner comme un serveur d'autorisation OAuth2.
Il est utilisé pour l'intégration d'applications tierces ou pour les API qui nécessitent un flux OAuth2 strict.

```mermaid theme={null}
sequenceDiagram
    participant User as Utilisateur
    participant Client as Client OAuth
    participant App as Application Laravel<br>(Passport)
    participant API as API protégée

    User->>Client: Démarre l'intégration
    Client->>App: Requête d'autorisation
    App->>User: Affiche l'écran de consentement
    User->>App: Autorise
    App-->>Client: Code d'autorisation
    Client->>App: Échange le code contre un access token
    App-->>Client: Access token
    Client->>API: Appel API avec token Bearer
    API-->>Client: Réponse
```

## Passport vs Sanctum

Si OAuth2 est indispensable, choisissez Passport.
Si vous cherchez simplement une authentification par token d'API ou pour une SPA / mobile, choisissez Sanctum.

| Aspect      | Passport                                         | Sanctum                               |
| ----------- | ------------------------------------------------ | ------------------------------------- |
| Objectif    | Implémentation d'un serveur OAuth2               | Authentification API simple           |
| Cas d'usage | Intégration d'applis externes, conformité OAuth2 | SPA maison, mobile, tokens personnels |
| Complexité  | Élevée                                           | Faible                                |

## Installation

La recommandation officielle sous Laravel 13 est `install:api --passport`.

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

Pour une installation manuelle dans un projet existant, ces commandes fonctionnent aussi.

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

Lors du premier déploiement, il peut être utile de ne générer que les clés.

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

## Configuration

### Modèle User

Ajoutez le trait `HasApiTokens` et l'interface `OAuthenticatable` à votre modèle `User`.

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

### Garde d'authentification

Dans `config/auth.php`, utilisez le driver `passport` pour la garde `api`.

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

### Configuration du service provider

Dans la méthode `boot()` de `AppServiceProvider`, vous pouvez définir les portées et la durée de vie des tokens.

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

public function boot(): void
{
    Passport::tokensCan([
        'orders:read' => 'Consulter les commandes',
        'orders:create' => 'Créer des commandes',
    ]);

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

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

## Gestion des clients

### Client pour l'authorization code grant

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

Ce type de client s'utilise dans le flux OAuth2 standard avec écran de consentement utilisateur.

### Client pour le client credentials grant

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

Pour les endpoints de communication de machine à machine, utilisez le middleware `EnsureClientIsResourceOwner`.

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

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

## Gestion des tokens

### Attribution de portées

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

### Vérification des portées

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

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

### Révocation

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

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

## Protection des routes API

Pour protéger une API avec un access token d'utilisateur, ajoutez `auth:api`.

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

<Warning>
  Pour les routes utilisant le client credentials grant, utilisez `EnsureClientIsResourceOwner` et non `auth:api`.
</Warning>

## Personal Access Token

Adapté aux cas où l'utilisateur émet lui-même son token d'API, sans passer par le flux OAuth2 complet.

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

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

<Info>
  Si votre usage principal est le Personal Access Token, la documentation officielle Laravel recommande de considérer Sanctum.
</Info>

## Liens associés

* [Documentation officielle Laravel : Passport](https://laravel.com/docs/13.x/passport)
* [Documentation officielle Laravel : Sanctum](https://laravel.com/docs/13.x/sanctum)


## Related topics

- [Laravel Sanctum (authentification par token API)](/fr/sanctum.md)
- [Socialite for Discord](/fr/packages/socialite-discord.md)
- [Créer un serveur MCP avec Laravel](/fr/advanced/mcp-server.md)
- [Socialite (LINE Login) - LINE SDK for Laravel](/fr/packages/laravel-line-sdk/socialite.md)
- [Laravel MCP](/fr/mcp.md)