Laravel Sanctum en Passport bedienen verschillende API-authenticatiebehoeften. De verkeerde keuze leidt tot onnodige complexiteit of beveiligingslekken. Deze gids analyseert beide packages met praktische codevoorbeelden en echte sollicitatievragen.

Snelle Beslissing

Sanctum verzorgt SPA-authenticatie en eenvoudige API-tokens. Passport implementeert volledige OAuth2 met authorization codes, client credentials en refresh tokens. De meeste applicaties hebben alleen Sanctum nodig.

Laravel Sanctum vs Passport: Fundamentele Verschillen

Sanctum biedt lichtgewicht tokengebaseerde authenticatie, ontworpen voor first-party applicaties. Het package gebruikt cookie-gebaseerde sessieauthenticatie voor SPAs en Personal Access Tokens voor mobiele apps en eenvoudige APIs.

Passport implementeert de volledige OAuth2-specificatie, inclusief authorization servers, client credentials grants en machine-to-machine authenticatie. Deze complexiteit is zinvol voor applicaties die toegang van derden moeten autoriseren.

| Kenmerk | Sanctum | Passport | |---------|---------|----------| | Primair gebruik | SPAs, Mobiele Apps, Eenvoudige APIs | Third-Party OAuth2, Machine-to-Machine | | Token type | Eenvoudige gehashte tokens | JWT met OAuth2 scopes | | Sessie Auth | Ja (cookie-gebaseerd) | Nee | | OAuth2 Grants | Geen | Volledige specificatie | | Package grootte | Minimaal | Aanzienlijk | | Configuratie | Eenvoudig | Complex |

Sanctum Implementeren voor SPA-authenticatie

Sanctum SPA-authenticatie is gebaseerd op Laravel sessiecookies in plaats van API-tokens. Frontend en backend moeten hetzelfde top-level domein delen om dit te laten werken.

config/sanctum.phpphp

return [
    'stateful' => explode(',', env('SANCTUM_STATEFUL_DOMAINS', sprintf(
        '%s%s',
        'localhost,localhost:3000,127.0.0.1,127.0.0.1:8000,::1',
        env('APP_URL') ? ','.parse_url(env('APP_URL'), PHP_URL_HOST) : ''
    ))),

    'expiration' => null, // Tokens verlopen standaard nooit

    'middleware' => [
        'verify_csrf_token' => App\Http\Middleware\VerifyCsrfToken::class,
        'encrypt_cookies' => App\Http\Middleware\EncryptCookies::class,
    ],
];

De SPA moet het CSRF-cookie endpoint aanroepen voordat geauthenticeerde verzoeken worden gedaan. Dit stelt de sessie in en zet het XSRF-TOKEN cookie.

javascript

// Frontend: CSRF-bescherming initialiseren voor login
async function initializeAuth() {
    await fetch('/sanctum/csrf-cookie', {
        credentials: 'include'
    });
}

async function login(email, password) {
    await initializeAuth();
    
    const response = await fetch('/api/login', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'X-XSRF-TOKEN': getCookie('XSRF-TOKEN'),
            'Accept': 'application/json'
        },
        credentials: 'include',
        body: JSON.stringify({ email, password })
    });
    
    return response.json();
}

Sanctum API Token Authenticatie

Mobiele applicaties en integraties van derden gebruiken Personal Access Tokens in plaats van sessiecookies. Sanctum slaat deze tokens op als SHA-256 hashes in de database.

app/Http/Controllers/AuthController.phpphp

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;
use Illuminate\Validation\ValidationException;

class AuthController extends Controller
{
    public function createToken(Request $request)
    {
        $request->validate([
            'email' => 'required|email',
            'password' => 'required',
            'device_name' => 'required',
        ]);

        $user = User::where('email', $request->email)->first();

        if (! $user || ! Hash::check($request->password, $user->password)) {
            throw ValidationException::withMessages([
                'email' => ['De opgegeven inloggegevens zijn onjuist.'],
            ]);
        }

        // Token met abilities (scopes)
        $token = $user->createToken(
            $request->device_name,
            ['read', 'write'] // Optionele abilities
        );

        return response()->json([
            'token' => $token->plainTextToken,
            'expires_at' => null // Configureren in sanctum.php
        ]);
    }

    public function revokeToken(Request $request)
    {
        // Huidige token intrekken
        $request->user()->currentAccessToken()->delete();

        return response()->json(['message' => 'Token ingetrokken']);
    }
}

Routes worden beschermd met de auth:sanctum middleware. Token abilities worden gecontroleerd met de tokenCan methode.

routes/api.phpphp

use Illuminate\Support\Facades\Route;

Route::middleware('auth:sanctum')->group(function () {
    Route::get('/user', function (Request $request) {
        return $request->user();
    });

    Route::post('/posts', function (Request $request) {
        // Controleren of token schrijfrechten heeft
        if (! $request->user()->tokenCan('write')) {
            abort(403, 'Token heeft geen schrijfrechten');
        }

        return Post::create($request->validated());
    });
});

Laravel Passport Configureren voor OAuth2

Passport vereist een uitgebreidere setup maar biedt volledige OAuth2-functionaliteit. De installatie maakt databasetabellen aan voor clients, tokens en refresh tokens.

bash

composer require laravel/passport
php artisan passport:install

Het passport:install commando genereert encryptiesleutels en maakt Personal Access en Password Grant clients aan.

app/Models/User.phpphp

namespace App\Models;

use Laravel\Passport\HasApiTokens;
use Illuminate\Foundation\Auth\User as Authenticatable;

class User extends Authenticatable
{
    use HasApiTokens;

    // ...
}

De Passport routes worden geregistreerd in de AuthServiceProvider:

app/Providers/AuthServiceProvider.phpphp

namespace App\Providers;

use Laravel\Passport\Passport;
use Illuminate\Support\ServiceProvider;

class AuthServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        Passport::tokensExpireIn(now()->addDays(15));
        Passport::refreshTokensExpireIn(now()->addDays(30));
        Passport::personalAccessTokensExpireIn(now()->addMonths(6));
    }
}

OAuth2 Password Grant met Passport

De Password Grant stelt first-party applicaties in staat om tokens te verkrijgen met gebruikersnaam en wachtwoord. Dit wordt vaak gebruikt voor mobiele apps.

app/Http/Controllers/OAuth/TokenController.phpphp

namespace App\Http\Controllers\OAuth;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Http;
use App\Http\Controllers\Controller;

class TokenController extends Controller
{
    public function issueToken(Request $request)
    {
        $request->validate([
            'email' => 'required|email',
            'password' => 'required',
        ]);

        $response = Http::asForm()->post(config('app.url') . '/oauth/token', [
            'grant_type' => 'password',
            'client_id' => config('passport.password_client_id'),
            'client_secret' => config('passport.password_client_secret'),
            'username' => $request->email,
            'password' => $request->password,
            'scope' => '*',
        ]);

        if ($response->failed()) {
            return response()->json([
                'error' => 'Ongeldige inloggegevens'
            ], 401);
        }

        return $response->json();
    }
}

Client Credentials Grant voor Machine-to-Machine

De Client Credentials Grant is ideaal voor server-naar-server communicatie waar geen gebruikersinteractie vereist is.

php

// Middleware voor Client Credentials
Route::middleware(['client'])->group(function () {
    Route::get('/api/external/data', function () {
        return response()->json([
            'data' => ExternalData::all()
        ]);
    });
});

De clientapplicatie authenticeert met Client ID en Secret:

php

// Externe service: token aanvragen
$response = Http::asForm()->post('https://api.example.com/oauth/token', [
    'grant_type' => 'client_credentials',
    'client_id' => 'client-id',
    'client_secret' => 'client-secret',
    'scope' => 'read-data',
]);

$token = $response->json()['access_token'];

// API aanroepen met token
$data = Http::withToken($token)
    ->get('https://api.example.com/api/external/data')
    ->json();

Token Scopes voor Granulaire Rechten

Zowel Sanctum als Passport ondersteunen scopes om tokenrechten te beperken. Passport definieert scopes in de AuthServiceProvider:

app/Providers/AuthServiceProvider.phpphp

use Laravel\Passport\Passport;

public function boot(): void
{
    Passport::tokensCan([
        'read-posts' => 'Posts lezen',
        'write-posts' => 'Posts aanmaken en bewerken',
        'delete-posts' => 'Posts verwijderen',
        'admin' => 'Volledige beheerderstoegang',
    ]);

    Passport::setDefaultScope([
        'read-posts',
    ]);
}

Routes kunnen dan specifieke scopes vereisen:

routes/api.phpphp

Route::middleware(['auth:api', 'scope:write-posts'])->group(function () {
    Route::post('/posts', [PostController::class, 'store']);
    Route::put('/posts/{post}', [PostController::class, 'update']);
});

Route::middleware(['auth:api', 'scopes:read-posts,write-posts'])->group(function () {
    // Vereist BEIDE scopes
    Route::get('/posts/drafts', [PostController::class, 'drafts']);
});

Klaar om je Laravel gesprekken te halen?

Oefen met onze interactieve simulatoren, flashcards en technische tests.

Ontdek Laravel

Beveiligingsoverwegingen bij Token Authenticatie

Veilige tokenverwerking vereist meerdere beveiligingsmaatregelen. Tokenrotatie voorkomt langdurig gebruik van gecompromitteerde credentials.

app/Http/Controllers/TokenController.phpphp

public function refreshToken(Request $request)
{
    $user = $request->user();
    $currentToken = $user->currentAccessToken();
    
    // Oude token intrekken
    $currentToken->delete();
    
    // Nieuwe token aanmaken met dezelfde abilities
    $newToken = $user->createToken(
        $currentToken->name,
        $currentToken->abilities
    );
    
    return response()->json([
        'token' => $newToken->plainTextToken,
        'message' => 'Token succesvol vernieuwd'
    ]);
}

Voor verbeterde beveiliging moeten tokenverlooptijden worden geconfigureerd:

config/sanctum.phpphp

return [
    'expiration' => 60 * 24, // 24 uur in minuten
    
    // Verlopen tokens automatisch verwijderen
    'prune_after' => 7, // dagen
];

De scheduler kan verlopen tokens automatisch opruimen:

app/Console/Kernel.phpphp

protected function schedule(Schedule $schedule): void
{
    $schedule->command('sanctum:prune-expired --hours=24')->daily();
}

Sollicitatievragen over Laravel API-authenticatie

Technische sollicitaties voor Laravel-ontwikkelaars testen vaak het begrip van authenticatieconcepten. De volgende vragen en antwoorden behandelen de belangrijkste onderwerpen.

Vraag: Wanneer moet Sanctum boven Passport worden gekozen?

Sanctum is de juiste keuze voor first-party applicaties: SPAs die op hetzelfde domein draaien als de API, mobiele apps ontwikkeld door hetzelfde team en eenvoudige API-tokenvereisten. Passport is nodig wanneer OAuth2-functionaliteit vereist is: applicaties van derden die toegang nodig hebben, Authorization Code Flow voor externe diensten, Client Credentials voor server-naar-server communicatie of Refresh Token rotatie.

Vraag: Hoe werkt het CSRF-beschermingsmechanisme bij Sanctum SPA-authenticatie?

Bij SPA-authenticatie gebruikt Sanctum Laravel-sessies en cookies. Het proces begint met een verzoek aan /sanctum/csrf-cookie, dat een XSRF-TOKEN cookie instelt. De SPA leest dit cookie en stuurt de waarde mee in de X-XSRF-TOKEN header bij elk geauthenticeerd verzoek. Laravel valideert dit token tegen de in de sessie opgeslagen waarde. Dit beschermt tegen Cross-Site Request Forgery, omdat andere domeinen het cookie niet kunnen lezen.

Vraag: Wat zijn de beveiligingsimplicaties van Personal Access Tokens?

Personal Access Tokens werken als wachtwoorden met onbeperkte geldigheid. Beveiligingsmaatregelen omvatten: beperkte scopes voor elk token, tokenverlooptijden, veilige opslag aan clientzijde, mogelijkheid tot directe intrekking, logging van al het tokengebruik en regelmatige tokenrotatie.

Vraag: Hoe implementeer je Rate Limiting voor API-authenticatie?

Rate Limiting beschermt tegen brute-force aanvallen en API-misbruik:

app/Providers/RouteServiceProvider.phpphp

use Illuminate\Cache\RateLimiting\Limit;
use Illuminate\Support\Facades\RateLimiter;

public function boot(): void
{
    RateLimiter::for('api', function (Request $request) {
        return Limit::perMinute(60)->by(
            $request->user()?->id ?: $request->ip()
        );
    });

    RateLimiter::for('auth', function (Request $request) {
        return Limit::perMinute(5)->by(
            $request->ip()
        );
    });
}

Vraag: Hoe test je geauthenticeerde API-endpoints?

Laravel biedt de actingAs methode voor tests met Sanctum en Passport:

tests/Feature/ApiTest.phpphp

use App\Models\User;
use Laravel\Sanctum\Sanctum;

public function test_authenticated_user_can_access_profile(): void
{
    $user = User::factory()->create();
    
    Sanctum::actingAs($user, ['read']);
    
    $response = $this->getJson('/api/user');
    
    $response->assertOk()
        ->assertJson(['email' => $user->email]);
}

public function test_token_without_scope_cannot_write(): void
{
    $user = User::factory()->create();
    
    Sanctum::actingAs($user, ['read']); // Geen 'write' scope
    
    $response = $this->postJson('/api/posts', [
        'title' => 'Test Post'
    ]);
    
    $response->assertForbidden();
}

Multi-Guard Authenticatie Configureren

Complexe applicaties kunnen meerdere authenticatiemechanismen tegelijk nodig hebben. Laravel staat toe om meerdere guards te definiëren:

config/auth.phpphp

return [
    'guards' => [
        'web' => [
            'driver' => 'session',
            'provider' => 'users',
        ],
        'api' => [
            'driver' => 'sanctum',
            'provider' => 'users',
        ],
        'admin-api' => [
            'driver' => 'passport',
            'provider' => 'admins',
        ],
    ],
    
    'providers' => [
        'users' => [
            'driver' => 'eloquent',
            'model' => App\Models\User::class,
        ],
        'admins' => [
            'driver' => 'eloquent',
            'model' => App\Models\Admin::class,
        ],
    ],
];

Routes kunnen dan specifieke guards gebruiken:

routes/api.phpphp

Route::middleware('auth:api')->group(function () {
    // Sanctum-beschermde routes voor normale gebruikers
});

Route::prefix('admin')->middleware('auth:admin-api')->group(function () {
    // Passport-beschermde routes voor beheerders
});

Best Practices voor Productieomgevingen

Het deployen van API-authenticatie in productieomgevingen vereist extra overwegingen. HTTPS is verplicht voor alle verzoeken die tokens verzenden. Omgevingsvariabelen moeten gevoelige configuraties opslaan.

.envphp

SANCTUM_STATEFUL_DOMAINS=app.example.com,api.example.com
SESSION_DOMAIN=.example.com

# Passport
PASSPORT_PRIVATE_KEY="..."
PASSPORT_PUBLIC_KEY="..."

Monitoring en logging van authenticatiegerelateerde events helpt bij het detecteren van aanvallen:

app/Listeners/LogAuthenticationEvent.phpphp

namespace App\Listeners;

use Illuminate\Auth\Events\Login;
use Illuminate\Support\Facades\Log;

class LogAuthenticationEvent
{
    public function handle(Login $event): void
    {
        Log::info('Gebruiker ingelogd', [
            'user_id' => $event->user->id,
            'ip' => request()->ip(),
            'user_agent' => request()->userAgent(),
        ]);
    }
}

Laravel-ontwikkelaars die API-authenticatie implementeren zouden de officiële documentatie van Sanctum en Passport grondig moeten bestuderen. De keuze tussen beide packages hangt af van de specifieke vereisten van de applicatie.

Passez à la pratique !

Conclusie

Laravel Sanctum en Passport bedienen verschillende authenticatiebehoeften. Sanctum biedt een eenvoudige maar veilige oplossing voor SPAs en mobiele apps met first-party tokenauthenticatie. Passport implementeert volledige OAuth2 voor scenario's die autorisatie van derden of machine-to-machine communicatie vereisen.

De keuze moet gebaseerd zijn op de daadwerkelijke vereisten: Sanctum voor de meeste applicaties, Passport alleen wanneer OAuth2-functionaliteit onmisbaar is. Beide packages vereisen zorgvuldige configuratie van tokenverlooptijden, scopes en rate limiting voor productierijpe implementaties.

Ontwikkelaars moeten de CSRF-beschermingsmechanismen bij SPA-authenticatie begrijpen, tokenrotatie implementeren en uitgebreide tests schrijven voor alle authenticatiepaden. Deze kennis is niet alleen relevant voor het dagelijks werk maar ook een belangrijk onderdeel van technische sollicitaties voor Laravel-posities.

Laravel Sanctum vs Passport in 2026: API-authenticatie en Sollicitatievragen

Laravel Sanctum vs Passport: Fundamentele Verschillen

Sanctum Implementeren voor SPA-authenticatie

Sanctum API Token Authenticatie

Laravel Passport Configureren voor OAuth2

OAuth2 Password Grant met Passport

Client Credentials Grant voor Machine-to-Machine

Token Scopes voor Granulaire Rechten

Klaar om je Laravel gesprekken te halen?

Beveiligingsoverwegingen bij Token Authenticatie

Sollicitatievragen over Laravel API-authenticatie

Multi-Guard Authenticatie Configureren

Best Practices voor Productieomgevingen

Passez à la pratique !

Conclusie

Gerelateerde artikelen

Laravel Livewire 3 in 2026: Reactieve Applicaties en Sollicitatievragen

Laravel Testing in 2026: Pest, Mocking en Vragen voor Technische Interviews

Laravel 12 in 2026: Nieuwe Features, Starter Kits en Sollicitatievragen