Laravel Sanctum e Passport atendem a diferentes necessidades de autenticação de API, e escolher o pacote errado leva a complexidade desnecessária ou falhas de segurança. Este guia detalha ambos os pacotes com exemplos de código práticos e perguntas reais de entrevistas.

Decisão Rápida

Sanctum gerencia autenticação de SPAs e tokens de API simples. Passport implementa OAuth2 completo com códigos de autorização, credenciais de cliente e tokens de atualização. A maioria das aplicações precisa do Sanctum.

Laravel Sanctum vs Passport: Diferenças Fundamentais

Sanctum fornece autenticação leve baseada em tokens projetada para aplicações first-party. O pacote utiliza autenticação baseada em cookies de sessão para SPAs e tokens de acesso pessoal para aplicativos móveis e APIs simples.

Passport implementa a especificação OAuth2 completa, incluindo servidores de autorização, grants de credenciais de cliente e autenticação machine-to-machine. Essa complexidade faz sentido para aplicações que precisam autorizar acesso de terceiros.

| Característica | Sanctum | Passport | |----------------|---------|----------| | Caso de Uso Principal | SPAs, Apps Móveis, APIs Simples | OAuth2 Terceiros, Machine-to-Machine | | Tipo de Token | Tokens com hash simples | JWT com scopes OAuth2 | | Auth de Sessão | Sim (baseado em cookies) | Não | | Grants OAuth2 | Nenhum | Especificação completa | | Tamanho do Pacote | Mínimo | Significativo | | Configuração | Simples | Complexa |

Implementando Sanctum para Autenticação SPA

A autenticação SPA do Sanctum depende de cookies de sessão do Laravel em vez de tokens de API. O frontend e o backend devem compartilhar o mesmo domínio de nível superior para que isso funcione.

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 never expire by default

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

O SPA deve chamar o endpoint de cookie CSRF antes de fazer requisições autenticadas. Isso estabelece a sessão e define o cookie XSRF-TOKEN.

javascript

// Frontend: Initialize CSRF protection before 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();
}

Autenticação com Token de API no Sanctum

Aplicativos móveis e integrações de terceiros utilizam tokens de acesso pessoal em vez de cookies de sessão. O Sanctum armazena esses tokens como hashes SHA-256 no banco de dados.

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' => ['The provided credentials are incorrect.'],
            ]);
        }

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

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

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

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

A proteção de rotas é feita com o middleware auth:sanctum. A verificação das abilities do token utiliza o método tokenCan.

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) {
        // Check if token has write ability
        if (! $request->user()->tokenCan('write')) {
            abort(403, 'Token does not have write permissions');
        }

        // Create post logic
    });
});

Pronto para mandar bem nas entrevistas de Laravel?

Pratique com nossos simuladores interativos, flashcards e testes tecnicos.

Explorar Laravel

Quando Usar o Laravel Passport

O Passport torna-se necessário quando a aplicação atua como servidor de autorização OAuth2. Os cenários comuns incluem:

Desenvolvedores terceiros construindo integrações com a API
Autenticação machine-to-machine entre microsserviços
Aplicações que requerem conformidade OAuth2 para clientes empresariais
Sistemas que precisam de rotação de tokens de atualização e validação 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);
        }

        // Create OAuth2 token with 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
        ]);
    }
}

O Passport também suporta o grant de credenciais de cliente para autenticação servidor-para-servidor sem contexto de usuário.

php

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

// routes/api.php - Client credentials protected route
Route::middleware('client')->group(function () {
    Route::get('/machine-data', function () {
        return response()->json(['data' => 'Machine accessible']);
    });
});

Melhores Práticas de Segurança para Autenticação de API no Laravel

Ambos os pacotes requerem medidas de segurança adicionais além da configuração básica. A expiração de tokens, o rate limiting e a validação adequada de scopes previnem vulnerabilidades comuns.

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 token expiration (Sanctum)
        Sanctum::authenticateAccessTokensUsing(function ($token, $isValid) {
            // Expire tokens after 24 hours
            $expiration = config('sanctum.expiration');
            
            if ($expiration === null) {
                return $isValid;
            }

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

A implementação de rate limiting em endpoints de autenticação previne ataques de força bruta. O Laravel 12 fornece configuração flexível do rate limiter através da facade RateLimiting.

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());
    });
}

Perguntas de Entrevista sobre Autenticação no Laravel

As entrevistas técnicas frequentemente avaliam a compreensão dos padrões de autenticação de API. Essas perguntas aparecem em entrevistas de desenvolvedores Laravel de todos os níveis.

P: Qual é a diferença entre a autenticação SPA e a autenticação por token do Sanctum?

A autenticação SPA utiliza cookies de sessão do Laravel com proteção CSRF. O frontend chama /sanctum/csrf-cookie para estabelecer uma sessão, então as requisições subsequentes incluem automaticamente o cookie de sessão. A autenticação por token utiliza tokens Bearer no cabeçalho Authorization, adequada para aplicativos móveis e integrações de terceiros onde cookies são impraticáveis.

P: Quando escolher Passport em vez de Sanctum?

Passport implementa OAuth2 completo, necessário quando desenvolvedores terceiros precisam integrar-se à API usando o fluxo de código de autorização, ou quando a autenticação machine-to-machine requer grants de credenciais de cliente. Sanctum gerencia aplicações first-party de forma mais simples.

P: Como o Sanctum armazena tokens de API?

O Sanctum armazena o hash SHA-256 de cada token na tabela personal_access_tokens. O token em texto plano é retornado apenas uma vez durante a criação. Essa abordagem significa que dados de banco de dados comprometidos não podem revelar tokens válidos.

P: Como implementar abilities/scopes de token no Sanctum?

php

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

// Checking abilities in controller
if ($request->user()->tokenCan('posts:write')) {
    // Authorized for write operations
}

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

P: Como revogar todos os tokens de um usuário no Sanctum?

php

// Revoke all tokens
$user->tokens()->delete();

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

// Revoke current token only
$request->user()->currentAccessToken()->delete();

Migração de Passport para Sanctum

Aplicações que começaram com Passport mas usam apenas autenticação por token simples podem migrar para Sanctum para reduzir a complexidade. A migração requer atualizar a criação de tokens, a configuração do middleware e quaisquer verificações de scopes.

php

// Migration helper: Convert Passport tokens to Sanctum
use App\Models\User;
use Laravel\Passport\Token;

// This is a one-way migration - run once then remove 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 ?? []
            );
        }
    }
});

A atualização do middleware das rotas de auth:api para auth:sanctum e a substituição de $request->user()->token()->scopes por $request->user()->currentAccessToken()->abilities são necessárias.

Conclusão

Sanctum é ideal para SPAs, aplicativos móveis e APIs first-party com configuração mínima
Passport gerencia servidores de autorização OAuth2 e integrações de terceiros
A autenticação SPA usa cookies de sessão; a autenticação de API usa tokens Bearer
As abilities de token fornecem controle de permissões granular no Sanctum
O rate limiting e a expiração de tokens são medidas de segurança essenciais independentemente do pacote escolhido
A maioria das aplicações Laravel deveria começar com Sanctum e adicionar Passport apenas quando a conformidade OAuth2 se tornar um requisito

Comece a praticar!

Teste seus conhecimentos com nossos simuladores de entrevista e testes tecnicos.

Criar minha conta gratis

Laravel Sanctum vs Passport em 2026: Autenticação de API e Perguntas de Entrevista