# Cara Menggunakan Laravel Sanctum untuk Otentikasi API: Amankan Aplikasi Anda

Otentikasi API merupakan aspek krusial dalam pengembangan aplikasi web modern. Tanpa otentikasi yang kuat, aplikasi Anda rentan terhadap serangan dan kebocoran data. Nah, bagi para developer Laravel, **Laravel Sanctum** hadir sebagai solusi elegan dan mudah untuk mengamankan API Anda. Dalam artikel ini, kita akan membahas secara mendalam **cara menggunakan Laravel Sanctum untuk otentikasi API**, memastikan aplikasi Anda aman dan terlindungi.

## 1. Apa Itu Laravel Sanctum dan Mengapa Anda Harus Menggunakannya?

Laravel Sanctum, sebelumnya dikenal sebagai Laravel Airlock, adalah paket otentikasi ringan untuk aplikasi web, API, dan aplikasi seluler single-page (SPA).  Ia menyediakan mekanisme otentikasi berbasis token yang aman dan mudah dikonfigurasi.

**Mengapa memilih Laravel Sanctum?**

*   **Ringan dan Mudah Digunakan:** Sanctum sangat mudah dipahami dan diimplementasikan, bahkan untuk pemula.
*   **Keamanan:** Menyediakan keamanan yang kuat melalui token API yang dienkripsi dan diverifikasi.
*   **SPA & Mobile App Support:** Dirancang khusus untuk mendukung autentikasi untuk SPA dan aplikasi seluler.
*   **Tanpa Cookies Berlebihan:**  Mengurangi ketergantungan pada cookie yang kompleks, terutama berguna untuk API.
*   **Token Granular:** Anda dapat memberikan kemampuan (abilities) spesifik pada setiap token, membatasi akses ke endpoint API tertentu.
*   **Laravel Friendly:** Integrasi mulus dengan ekosistem Laravel.

Singkatnya, Laravel Sanctum menyederhanakan proses otentikasi API, meningkatkan keamanan, dan memberikan fleksibilitas yang dibutuhkan dalam pengembangan aplikasi modern. Ini adalah pilihan yang sangat baik jika Anda sedang membangun API yang perlu diamankan dengan otentikasi berbasis token.

## 2. Persiapan Awal: Instalasi dan Konfigurasi Laravel Sanctum

Sebelum kita mulai **menggunakan Laravel Sanctum untuk otentikasi API**, mari persiapkan lingkungan kita terlebih dahulu.  Langkah ini mencakup instalasi paket Sanctum dan melakukan konfigurasi dasar.

1.  **Instalasi melalui Composer:** Buka terminal Anda dan arahkan ke direktori proyek Laravel Anda. Kemudian, jalankan perintah berikut:

    ```bash
    composer require laravel/sanctum

Perintah ini akan mengunduh dan menginstal paket Laravel Sanctum ke dalam proyek Anda.

2. Publish Konfigurasi dan Migrasi: Setelah instalasi selesai, publikasikan file konfigurasi dan migrasi Sanctum dengan perintah:

   php artisan vendor:publish --provider="LaravelSanctumSanctumServiceProvider"

   Perintah ini akan membuat file konfigurasi config/sanctum.php dan migrasi di direktori database/migrations.

3. Jalankan Migrasi: Jalankan migrasi untuk membuat tabel yang dibutuhkan oleh Sanctum.

   php artisan migrate

   Migrasi ini akan membuat tabel personal_access_tokens yang digunakan untuk menyimpan token API yang dihasilkan.

4. Konfigurasi Model User: Pastikan model User Anda menggunakan trait HasApiTokens. Buka file app/Models/User.php dan tambahkan baris berikut:

   <?php
   
   namespace AppModels;
   
   use IlluminateContractsAuthMustVerifyEmail;
   use IlluminateDatabaseEloquentFactoriesHasFactory;
   use IlluminateFoundationAuthUser as Authenticatable;
   use IlluminateNotificationsNotifiable;
   use LaravelSanctumHasApiTokens; // Tambahkan baris ini
   
   class User extends Authenticatable
   {
       use HasApiTokens, HasFactory, Notifiable;
   
       // ... kode lainnya ...
   }

5. Konfigurasi Middleware api: Pastikan middleware api di file routes/api.php menggunakan EnsureFrontendRequestsAreStateful middleware. Ini penting jika Anda menggunakan Sanctum dengan SPA yang berjalan di domain berbeda. Jika Anda tidak menggunakan SPA, Anda bisa melewati langkah ini.

   Buka file app/Http/Kernel.php dan cari $middlewareGroups. Pastikan middleware EnsureFrontendRequestsAreStateful (Sanctum) ada di grup api. Jika belum ada, tambahkan.

   protected $middlewareGroups = [
       'web' => [
           AppHttpMiddlewareEncryptCookies::class,
           IlluminateCookieMiddlewareAddQueuedCookiesToResponse::class,
           IlluminateSessionMiddlewareStartSession::class,
           // IlluminateSessionMiddlewareAuthenticateSession::class,
           IlluminateViewMiddlewareShareErrorsFromSession::class,
           AppHttpMiddlewareVerifyCsrfToken::class,
           IlluminateRoutingMiddlewareSubstituteBindings::class,
       ],
   
       'api' => [
           AppHttpMiddlewareEncryptCookies::class, // Tambahkan ini
           IlluminateSessionMiddlewareStartSession::class, // Tambahkan ini
           IlluminateCookieMiddlewareAddQueuedCookiesToResponse::class, // Tambahkan ini
           LaravelSanctumHttpMiddlewareEnsureFrontendRequestsAreStateful::class, // Tambahkan ini
           'throttle:api',
           IlluminateRoutingMiddlewareSubstituteBindings::class,
       ],
   ];

Dengan langkah-langkah ini, Anda telah berhasil menginstal dan mengkonfigurasi Laravel Sanctum di proyek Anda. Sekarang, kita siap untuk mulai membuat dan menggunakan token API.

3. Membuat Token API: Proses Registrasi dan Login Pengguna

Setelah instalasi dan konfigurasi selesai, langkah selanjutnya adalah membuat endpoint untuk registrasi dan login pengguna, serta menghasilkan token API. Endpoint ini akan memungkinkan pengguna untuk mendaftar atau masuk ke aplikasi Anda dan mendapatkan token yang akan mereka gunakan untuk mengakses API yang dilindungi.

Contoh Endpoint Registrasi (Register):

use AppModelsUser;
use IlluminateSupportFacadesHash;
use IlluminateSupportFacadesValidator;
use IlluminateHttpRequest;

Route::post('/register', function (Request $request) {
    $validator = Validator::make($request->all(), [
        'name' => 'required|string|max:255',
        'email' => 'required|string|email|max:255|unique:users',
        'password' => 'required|string|min:8',
    ]);

    if ($validator->fails()) {
        return response()->json(['errors' => $validator->errors()], 422);
    }

    $user = User::create([
        'name' => $request->name,
        'email' => $request->email,
        'password' => Hash::make($request->password),
    ]);

    $token = $user->createToken('auth_token')->plainTextToken;

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

Penjelasan:

Related Post

Laravel Sanctum Tutorial: Implementasi Authentication API dengan Laravel Sanctum

September 7, 2025

Laravel Sanctum untuk Authentication API: Solusi Authentication Modern untuk Laravel

September 7, 2025

Laravel Authentication Package: Pilihan Terbaik untuk Keamanan Aplikasi Laravel Anda

September 6, 2025

Belajar Authentication dan Authorization di Laravel Indonesia: Keamanan Website Terjamin

August 23, 2025

• Validasi data input menggunakan Validator.
• Membuat pengguna baru menggunakan model User dan mengenkripsi password dengan Hash::make().
• Menghasilkan token API menggunakan createToken('auth_token') dan mengambil plainTextToken. Parameter 'auth_token' adalah nama token yang bisa Anda ganti sesuai kebutuhan.
• Mengembalikan token dan tipe token dalam format JSON.

Contoh Endpoint Login:

use IlluminateSupportFacadesAuth;
use IlluminateHttpRequest;

Route::post('/login', function (Request $request) {
    if (!Auth::attempt($request->only('email', 'password'))) {
        return response()->json(['message' => 'Invalid login credentials'], 401);
    }

    $user = User::where('email', $request['email'])->firstOrFail();

    $token = $user->createToken('auth_token')->plainTextToken;

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

Penjelasan:

• Mencoba melakukan otentikasi menggunakan Auth::attempt().
• Jika otentikasi gagal, mengembalikan response error 401.
• Jika berhasil, mengambil data pengguna dari database.
• Menghasilkan token API menggunakan createToken('auth_token') dan mengambil plainTextToken.
• Mengembalikan token dan tipe token dalam format JSON.

Pastikan Anda menambahkan route ini ke file routes/api.php. Sekarang, pengguna dapat mendaftar dan login, dan mendapatkan token API untuk mengakses endpoint yang dilindungi.

4. Mengamankan Endpoint API: Menggunakan Middleware Sanctum

Setelah kita memiliki token API, langkah selanjutnya adalah mengamankan endpoint API kita. Ini dilakukan dengan menggunakan middleware Sanctum yang akan memverifikasi token yang dikirimkan oleh klien dan memastikan bahwa hanya pengguna yang terotentikasi yang dapat mengakses endpoint tersebut.

Cara Menggunakan Middleware Sanctum:

Buka file routes/api.php Anda dan tambahkan middleware auth:sanctum ke route yang ingin Anda lindungi.

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

// Contoh lain: melindungi grup route
Route::middleware('auth:sanctum')->group(function () {
    Route::get('/posts', 'PostController@index');
    Route::post('/posts', 'PostController@store');
});

Penjelasan:

• middleware('auth:sanctum') mengaplikasikan middleware Sanctum ke route /user.
• Middleware ini akan memverifikasi token yang dikirimkan dalam header Authorization: Bearer <token>.
• Jika token valid, request akan diteruskan dan Anda dapat mengakses informasi pengguna yang terotentikasi melalui $request->user().
• Jika token tidak valid atau tidak ada, request akan ditolak dengan response error 401.
• Contoh kedua menunjukkan cara melindungi sekelompok route menggunakan group().

Mengirimkan Token dalam Request:

Untuk mengakses endpoint yang dilindungi, klien harus mengirimkan token API di header Authorization dengan format Bearer <token>. Contoh:

Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...

Pastikan klien Anda (misalnya, aplikasi frontend atau aplikasi seluler) mengirimkan header ini dengan benar setiap kali mereka melakukan request ke endpoint API yang dilindungi.

5. Menggunakan Abilities (Kemampuan) Token: Kontrol Akses Lebih Detail

Salah satu fitur unggulan Laravel Sanctum adalah kemampuan untuk memberikan kemampuan (abilities) spesifik pada setiap token. Ini memungkinkan Anda untuk mengontrol akses ke endpoint API secara lebih detail. Misalnya, Anda dapat memberikan token yang hanya memiliki izin untuk membaca data, tetapi tidak untuk mengubahnya.

Contoh Penggunaan Abilities:

Saat membuat token, Anda dapat menentukan daftar kemampuan yang akan diberikan ke token tersebut:

$token = $user->createToken('auth_token', ['post:read'])->plainTextToken; // Hanya izin membaca postingan

Dalam contoh ini, token yang dihasilkan hanya memiliki kemampuan post:read.

Memverifikasi Abilities di Endpoint:

Di endpoint API Anda, Anda dapat memverifikasi apakah token yang digunakan memiliki kemampuan yang dibutuhkan:

Route::middleware(['auth:sanctum', 'ability:post:read'])->get('/posts', function () {
    // Kode untuk menampilkan daftar postingan
});

Route::middleware(['auth:sanctum', 'ability:post:create,post:update'])->post('/posts', function () {
    // Kode untuk membuat atau memperbarui postingan
});

Penjelasan:

• ability:post:read memastikan token yang digunakan memiliki kemampuan post:read.
• ability:post:create,post:update memastikan token yang digunakan memiliki kemampuan post:create atau post:update.
• Jika token tidak memiliki kemampuan yang dibutuhkan, request akan ditolak dengan response error 403 (Forbidden).

Dengan menggunakan abilities, Anda dapat mengimplementasikan kontrol akses yang lebih granular dan fleksibel di API Anda.

6. Revoking (Mencabut) Token: Keamanan Lebih Lanjut

Laravel Sanctum menyediakan cara untuk mencabut token API, yang berguna jika Anda ingin membatalkan akses pengguna ke API Anda. Ini penting untuk keamanan, terutama jika token pengguna telah disusupi atau jika pengguna telah keluar dari aplikasi Anda.

Cara Mencabut Token:

• Mencabut Token Saat Ini (Token yang Digunakan):

  Route::middleware('auth:sanctum')->post('/logout', function (Request $request) {
      $request->user()->currentAccessToken()->delete();
  
      return response()->json(['message' => 'Logged out successfully']);
  });

  Kode ini mencabut token yang saat ini digunakan untuk melakukan request.

• Mencabut Semua Token Pengguna:

  $user->tokens()->delete(); // Mencabut semua token milik pengguna $user

  Kode ini mencabut semua token yang terkait dengan pengguna tertentu.

Kapan Mencabut Token:

• Logout Pengguna: Saat pengguna keluar dari aplikasi, Anda harus mencabut token mereka untuk mencegah akses yang tidak sah.
• Perubahan Password: Setelah pengguna mengubah password mereka, Anda sebaiknya mencabut semua token mereka sebagai tindakan pencegahan.
• Keamanan: Jika Anda mencurigai bahwa token pengguna telah disusupi, segera cabut token tersebut.
• Pencabutan Manual: Admin aplikasi mungkin perlu mencabut token pengguna secara manual dalam situasi tertentu.

Dengan menyediakan mekanisme pencabutan token, Laravel Sanctum membantu Anda menjaga keamanan API Anda dan memberikan kontrol lebih besar atas akses pengguna.

7. Menangani Statefull dan Stateless Authentication: Memilih Pendekatan yang Tepat

Laravel Sanctum mendukung baik autentikasi statefull (dengan sesi dan cookie) dan stateless (tanpa sesi, menggunakan token). Memilih pendekatan yang tepat tergantung pada jenis aplikasi yang Anda bangun.

Statefull Authentication (SPA pada Domain yang Sama):

Pendekatan ini cocok untuk aplikasi Single-Page Application (SPA) yang berjalan di domain yang sama dengan backend Laravel Anda. Sanctum menggunakan cookie untuk menyimpan informasi sesi otentikasi.

• Keuntungan:

  • Lebih mudah diimplementasikan.
  • Tidak perlu mengirimkan token di setiap request (cookie dikelola oleh browser).

• Konfigurasi: Pastikan middleware EnsureFrontendRequestsAreStateful sudah terkonfigurasi dengan benar di app/Http/Kernel.php (seperti yang dijelaskan di bagian instalasi).

Stateless Authentication (API, Mobile App, SPA pada Domain Berbeda):

Pendekatan ini ideal untuk API, aplikasi seluler, atau SPA yang berjalan di domain yang berbeda dari backend Laravel Anda (CORS). Dalam pendekatan ini, token dikirimkan dalam header Authorization di setiap request.

• Keuntungan:

  • Cocok untuk API dan aplikasi yang tidak bergantung pada cookie.
  • Lebih fleksibel untuk integrasi dengan berbagai platform.

• Konfigurasi:

  • Pastikan klien Anda mengirimkan header Authorization: Bearer <token> di setiap request.
  • Konfigurasi CORS (Cross-Origin Resource Sharing) mungkin diperlukan jika SPA Anda berada di domain yang berbeda.

Memilih Pendekatan yang Tepat:

• SPA pada Domain yang Sama: Gunakan statefull authentication untuk kemudahan implementasi.
• API, Mobile App, SPA pada Domain Berbeda: Gunakan stateless authentication untuk fleksibilitas dan kompatibilitas.

Pahami perbedaan antara kedua pendekatan ini untuk memilih konfigurasi Laravel Sanctum yang paling sesuai dengan kebutuhan proyek Anda.

8. Kustomisasi Konfigurasi Sanctum: Mengubah Masa Berlaku Token dan Lainnya

Laravel Sanctum menawarkan beberapa opsi konfigurasi yang dapat Anda sesuaikan sesuai kebutuhan aplikasi Anda. File konfigurasi config/sanctum.php adalah tempat Anda dapat mengubah pengaturan-pengaturan ini.

Beberapa Opsi Konfigurasi Penting:

• expiration: Menentukan masa berlaku token dalam menit. Secara default, token tidak memiliki masa berlaku (berlaku selamanya). Anda dapat mengubahnya untuk meningkatkan keamanan. Misalnya, expiration => 60 akan membuat token hanya berlaku selama 60 menit.

• stateful: Daftar domain yang dianggap “stateful” (menggunakan cookie). Ini digunakan oleh middleware EnsureFrontendRequestsAreStateful. Anda dapat menambahkan domain aplikasi frontend Anda ke daftar ini jika diperlukan.

• guard: Guard autentikasi yang digunakan oleh Sanctum. Biasanya, Anda tidak perlu mengubah ini.

• middleware: Middleware yang digunakan oleh Sanctum. Anda dapat menambahkan middleware kustom Anda sendiri jika diperlukan.

Contoh Kustomisasi:

Untuk mengubah masa berlaku token menjadi 2 jam (120 menit), buka config/sanctum.php dan ubah expiration menjadi:

    'expiration' => 120,

Setelah melakukan perubahan pada file konfigurasi, pastikan untuk membersihkan cache konfigurasi dengan perintah:

php artisan config:cache

Dengan menyesuaikan konfigurasi Sanctum, Anda dapat mengoptimalkan keamanan dan kinerja API Anda.

9. Troubleshooting Umum dan Solusinya

Meskipun Laravel Sanctum relatif mudah digunakan, Anda mungkin menghadapi beberapa masalah umum saat mengimplementasikannya. Berikut adalah beberapa masalah umum dan solusinya:

• Error 401 Unauthorized: Ini biasanya terjadi jika token tidak valid, tidak ada, atau sudah kedaluwarsa. Pastikan klien mengirimkan token dengan benar di header Authorization dan bahwa token belum dicabut. Periksa juga konfigurasi masa berlaku token.

• Error 403 Forbidden: Ini terjadi jika token tidak memiliki kemampuan yang dibutuhkan untuk mengakses endpoint tersebut. Periksa konfigurasi abilities token dan pastikan token yang digunakan memiliki izin yang sesuai.

• CORS Issues (SPA di Domain Berbeda): Jika Anda menggunakan SPA di domain yang berbeda, Anda mungkin perlu mengkonfigurasi CORS dengan benar. Pastikan server Anda mengizinkan permintaan dari domain SPA Anda. Anda dapat menggunakan paket fruitcake/laravel-cors untuk mengelola CORS.

• Token Tidak Disimpan dengan Benar: Pastikan tabel personal_access_tokens telah dibuat dengan benar melalui migrasi.

• EnsureFrontendRequestsAreStateful Middleware Issues: Pastikan middleware ini dikonfigurasi dengan benar di app/Http/Kernel.php dan bahwa domain frontend Anda ditambahkan ke daftar stateful di config/sanctum.php jika diperlukan.

• Cache Konfigurasi: Setelah melakukan perubahan pada file konfigurasi, pastikan untuk membersihkan cache konfigurasi dengan php artisan config:cache.

Dengan memahami masalah-masalah umum ini dan solusinya, Anda dapat dengan cepat mengatasi masalah dan memastikan implementasi Laravel Sanctum Anda berjalan dengan lancar.

10. Praktik Terbaik untuk Keamanan Otentikasi API dengan Sanctum

Berikut adalah beberapa praktik terbaik untuk meningkatkan keamanan otentikasi API Anda dengan Laravel Sanctum:

• Gunakan HTTPS: Selalu gunakan HTTPS untuk mengenkripsi komunikasi antara klien dan server Anda. Ini mencegah penyerang mencuri token API Anda.

• Validasi Input: Validasi semua input dari pengguna untuk mencegah serangan injeksi SQL dan serangan lainnya.

• Batasi Masa Berlaku Token: Konfigurasi masa berlaku token yang wajar untuk mengurangi risiko jika token disusupi.

• Gunakan Abilities: Terapkan kontrol akses yang granular menggunakan abilities untuk membatasi akses ke endpoint API.

• Implementasikan Rate Limiting: Batasi jumlah request yang dapat dilakukan oleh pengguna dalam jangka waktu tertentu untuk mencegah serangan brute-force.

• Pantau Log: Pantau log aplikasi Anda untuk mendeteksi aktivitas yang mencurigakan.

• Rutin Perbarui Laravel dan Paket: Pastikan Anda selalu menggunakan versi terbaru Laravel dan paket Sanctum untuk mendapatkan perbaikan keamanan terbaru.

• Simpan Token dengan Aman di Klien: Di sisi klien (aplikasi frontend atau aplikasi seluler), simpan token dengan aman menggunakan mekanisme penyimpanan yang aman (misalnya, Keychain untuk iOS atau Keystore untuk Android). Hindari menyimpan token di local storage browser jika memungkinkan, karena lebih rentan terhadap serangan XSS.

Dengan mengikuti praktik terbaik ini, Anda dapat secara signifikan meningkatkan keamanan otentikasi API Anda dan melindungi aplikasi Anda dari berbagai ancaman keamanan.

11. Alternatif untuk Laravel Sanctum

Meskipun Laravel Sanctum adalah pilihan yang sangat baik untuk otentikasi API, ada beberapa alternatif lain yang perlu dipertimbangkan, tergantung pada kebutuhan spesifik proyek Anda:

• Laravel Passport: Laravel Passport adalah server otorisasi OAuth2 lengkap. Ini lebih kompleks daripada Sanctum, tetapi menawarkan lebih banyak fitur, seperti dukungan untuk berbagai jenis grant (misalnya, password grant, client credentials grant, authorization code grant). Passport cocok untuk aplikasi yang membutuhkan OAuth2 standard compliant authorization server.

• JWT (JSON Web Tokens): Anda dapat menggunakan paket JWT seperti tymon/jwt-auth untuk mengimplementasikan otentikasi berbasis token. JWT menyediakan cara yang ringkas dan aman untuk merepresentasikan klaim untuk ditransmisikan antar pihak sebagai objek JSON yang ditandatangani secara digital.

• Session-Based Authentication (Laravel Default): Untuk aplikasi web tradisional (bukan API atau SPA), Anda dapat menggunakan sistem autentikasi berbasis sesi bawaan Laravel. Ini lebih sederhana daripada Sanctum atau Passport, tetapi kurang fleksibel untuk API dan aplikasi seluler.

Kapan Memilih Alternatif:

• OAuth2 Standard Compliance: Jika Anda membutuhkan server otorisasi yang sepenuhnya sesuai dengan standar OAuth2, Laravel Passport adalah pilihan yang tepat.
• JWT Standard: Jika Anda memerlukan fleksibilitas dan kompatibilitas yang ditawarkan oleh standar JWT, paket tymon/jwt-auth bisa menjadi pilihan.
• Aplikasi Web Tradisional: Untuk aplikasi web tradisional yang tidak memerlukan API, sistem autentikasi berbasis sesi bawaan Laravel mungkin sudah cukup.

Pertimbangkan kebutuhan proyek Anda dengan cermat sebelum memilih solusi otentikasi.

12. Kesimpulan: Mengamankan Aplikasi Anda dengan Laravel Sanctum

Dalam artikel ini, kita telah membahas secara mendalam cara menggunakan Laravel Sanctum untuk otentikasi API. Kita telah membahas instalasi, konfigurasi, pembuatan token, pengamanan endpoint, penggunaan abilities, pencabutan token, dan praktik terbaik untuk keamanan.

Laravel Sanctum adalah alat yang ampuh dan mudah digunakan untuk mengamankan API Laravel Anda. Dengan mengikuti panduan dalam artikel ini, Anda dapat mengimplementasikan otentikasi yang kuat dan melindungi aplikasi Anda dari berbagai ancaman keamanan. Jangan ragu untuk bereksperimen dengan berbagai fitur Sanctum dan menyesuaikannya dengan kebutuhan proyek Anda. Ingatlah, keamanan adalah proses berkelanjutan, jadi teruslah belajar dan meningkatkan praktik keamanan Anda.