Laravel Sanctum dan Passport memiliki tujuan berbeda dalam autentikasi API. Memilih paket yang salah dapat mengakibatkan kompleksitas berlebihan atau celah keamanan. Panduan ini menguraikan kedua paket dengan contoh kode praktis dan pertanyaan interview yang relevan.

Keputusan Cepat

Sanctum menangani autentikasi SPA dan token API sederhana. Passport mengimplementasikan OAuth2 lengkap dengan authorization codes, client credentials, dan refresh tokens. Sebagian besar aplikasi membutuhkan Sanctum.

Laravel Sanctum vs Passport: Perbedaan Utama

Sanctum menyediakan autentikasi berbasis token yang ringan, dirancang untuk aplikasi first-party. Paket ini menggunakan autentikasi session berbasis cookie untuk SPA dan personal access tokens untuk aplikasi mobile dan API sederhana.

Passport mengimplementasikan spesifikasi OAuth2 secara lengkap, termasuk authorization servers, client credentials grants, dan autentikasi machine-to-machine. Kompleksitas ini diperlukan untuk aplikasi yang membutuhkan otorisasi akses pihak ketiga.

| Fitur | Sanctum | Passport | |-------|---------|----------| | Use Case Utama | SPA, Aplikasi Mobile, API Sederhana | OAuth2 Pihak Ketiga, Machine-to-Machine | | Tipe Token | Token hash sederhana | JWT dengan OAuth2 scopes | | Autentikasi Session | Ya (berbasis cookie) | Tidak | | OAuth2 Grants | Tidak ada | Spesifikasi lengkap | | Ukuran Paket | Minimal | Signifikan | | Konfigurasi | Sederhana | Kompleks |

Implementasi Sanctum untuk Autentikasi SPA

Autentikasi SPA Sanctum mengandalkan cookie session Laravel daripada token API. Frontend dan backend harus berbagi domain top-level yang sama agar sistem ini berfungsi.

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, // Token tidak expire secara default

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

SPA harus memanggil endpoint CSRF cookie sebelum melakukan request yang memerlukan autentikasi. Langkah ini membuat session dan mengatur cookie XSRF-TOKEN.

javascript

// Frontend: Inisialisasi proteksi CSRF sebelum 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();
}

Autentikasi Token API dengan Sanctum

Aplikasi mobile dan integrasi pihak ketiga menggunakan personal access tokens daripada session cookies. Sanctum menyimpan token ini sebagai hash SHA-256 di 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' => ['Kredensial yang diberikan tidak valid.'],
            ]);
        }

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

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

    public function revokeToken(Request $request)
    {
        // Revoke token saat ini
        $request->user()->currentAccessToken()->delete();

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

Proteksi route dengan middleware auth:sanctum. Gunakan method tokenCan untuk memeriksa abilities token.

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) {
        // Cek apakah token memiliki ability write
        if (! $request->user()->tokenCan('write')) {
            abort(403, 'Token tidak memiliki izin write');
        }

        // Logika pembuatan post
    });
});

Siap menguasai wawancara Laravel Anda?

Berlatih dengan simulator interaktif, flashcards, dan tes teknis kami.

Jelajahi Laravel

Kapan Menggunakan Laravel Passport

Passport diperlukan ketika aplikasi bertindak sebagai authorization server OAuth2. Skenario umum meliputi:

Developer pihak ketiga yang membangun integrasi dengan API
Autentikasi machine-to-machine antar microservices
Aplikasi yang memerlukan kepatuhan OAuth2 untuk pelanggan enterprise
Sistem yang membutuhkan rotasi refresh token dan validasi JWT

app/Http/Controllers/Api/PassportController.phpphp

namespace App\Http\Controllers\Api;

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

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

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

        if (! $user || ! Hash::check($request->password, $user->password)) {
            return response()->json([
                'error' => 'invalid_credentials'
            ], 401);
        }

        // Membuat token OAuth2 dengan scopes
        $token = $user->createToken('API Token', ['read-posts', 'write-posts']);

        return response()->json([
            'access_token' => $token->accessToken,
            'token_type' => 'Bearer',
            'expires_at' => $token->token->expires_at
        ]);
    }
}

Passport juga mendukung client credentials grant untuk autentikasi server-to-server tanpa konteks user.

php

// Autentikasi machine-to-machine
// config/auth.php
'guards' => [
    'api' => [
        'driver' => 'passport',
        'provider' => 'users',
    ],
],

// routes/api.php - Route yang diproteksi client credentials
Route::middleware('client')->group(function () {
    Route::get('/machine-data', function () {
        return response()->json(['data' => 'Dapat diakses oleh mesin']);
    });
});

Praktik Terbaik Keamanan untuk Autentikasi API Laravel

Kedua paket memerlukan langkah keamanan tambahan di luar setup dasar. Expiration token, rate limiting, dan validasi scope yang tepat mencegah kerentanan umum.

app/Providers/AuthServiceProvider.phpphp

namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use Laravel\Sanctum\Sanctum;
use Laravel\Sanctum\PersonalAccessToken;

class AuthServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        // Set expiration token (Sanctum)
        Sanctum::authenticateAccessTokensUsing(function ($token, $isValid) {
            // Expire token setelah 24 jam
            $expiration = config('sanctum.expiration');
            
            if ($expiration === null) {
                return $isValid;
            }

            return $isValid && $token->created_at->gt(now()->subMinutes($expiration));
        });
    }
}

Implementasikan rate limiting pada endpoint autentikasi untuk mencegah serangan brute force. Laravel 12 menyediakan konfigurasi rate limiter yang fleksibel melalui RateLimiting facade.

app/Providers/AppServiceProvider.phpphp

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

public function boot(): void
{
    RateLimiting::for('login', function ($request) {
        return Limit::perMinute(5)->by($request->ip());
    });

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

Pertanyaan Interview Autentikasi Laravel

Interview teknis sering menguji pemahaman tentang pola autentikasi API. Pertanyaan-pertanyaan ini muncul dalam interview developer Laravel di semua tingkat.

T: Apa perbedaan antara autentikasi SPA Sanctum dan autentikasi token?

Autentikasi SPA menggunakan session cookies Laravel dengan proteksi CSRF. Frontend memanggil /sanctum/csrf-cookie untuk membuat session, kemudian request berikutnya menyertakan session cookie secara otomatis. Autentikasi token menggunakan Bearer tokens di header Authorization, cocok untuk aplikasi mobile dan integrasi pihak ketiga di mana cookies tidak praktis.

T: Kapan memilih Passport daripada Sanctum?

Passport mengimplementasikan OAuth2 lengkap, diperlukan ketika developer pihak ketiga perlu berintegrasi dengan API menggunakan authorization code flow, atau ketika autentikasi machine-to-machine memerlukan client credentials grants. Sanctum menangani aplikasi first-party dengan lebih sederhana.

T: Bagaimana Sanctum menyimpan token API?

Sanctum menyimpan hash SHA-256 dari setiap token di tabel personal_access_tokens. Teks plain token hanya dikembalikan sekali saat pembuatan. Pendekatan ini memastikan data database yang dikompromikan tidak dapat mengungkapkan token yang valid.

T: Bagaimana mengimplementasikan abilities/scopes token di Sanctum?

php

// Membuat token dengan abilities
$token = $user->createToken('api-token', ['posts:read', 'posts:write']);

// Memeriksa abilities di controller
if ($request->user()->tokenCan('posts:write')) {
    // Diotorisasi untuk operasi write
}

// Pemeriksaan ability berbasis middleware
Route::middleware(['auth:sanctum', 'ability:posts:write'])
    ->post('/posts', [PostController::class, 'store']);

T: Bagaimana cara mencabut semua token untuk user di Sanctum?

php

// Revoke semua token
$user->tokens()->delete();

// Revoke token spesifik berdasarkan ID
$user->tokens()->where('id', $tokenId)->delete();

// Revoke hanya token saat ini
$request->user()->currentAccessToken()->delete();

Migrasi dari Passport ke Sanctum

Aplikasi yang memulai dengan Passport tetapi hanya menggunakan autentikasi token sederhana dapat bermigrasi ke Sanctum untuk mengurangi kompleksitas. Migrasi memerlukan pembaruan pembuatan token, konfigurasi middleware, dan pemeriksaan scope.

php

// Helper migrasi: Konversi token Passport ke Sanctum
use App\Models\User;
use Laravel\Passport\Token;

// Ini adalah migrasi satu arah - jalankan sekali lalu hapus Passport
User::chunk(100, function ($users) {
    foreach ($users as $user) {
        $passportTokens = Token::where('user_id', $user->id)
            ->where('revoked', false)
            ->get();

        foreach ($passportTokens as $token) {
            $user->createToken(
                $token->name ?? 'migrated-token',
                $token->scopes ?? []
            );
        }
    }
});

Perbarui middleware route dari auth:api ke auth:sanctum dan ganti $request->user()->token()->scopes dengan $request->user()->currentAccessToken()->abilities.

Kesimpulan

Sanctum cocok untuk SPA, aplikasi mobile, dan API first-party dengan konfigurasi minimal
Passport menangani authorization server OAuth2 dan integrasi pihak ketiga
Autentikasi SPA menggunakan session cookies; autentikasi API menggunakan Bearer tokens
Token abilities menyediakan kontrol izin yang granular di Sanctum
Rate limiting dan token expiration adalah langkah keamanan penting terlepas dari pilihan paket
Sebagian besar aplikasi Laravel sebaiknya memulai dengan Sanctum dan hanya menambahkan Passport ketika kepatuhan OAuth2 menjadi kebutuhan

Mulai berlatih!

Uji pengetahuan Anda dengan simulator wawancara dan tes teknis kami.

Buat akun gratis saya

Laravel Sanctum vs Passport 2026: Autentikasi API dan Pertanyaan Interview