Tutorial ini melanjutkan seri Laravel di blog ini. Kita akan memakai contoh yang sama dengan tutorial sebelumnya, yaitu data produk dengan kolom name, description, price, dan stock. Bedanya, kali ini datanya tidak ditampilkan lewat Blade, melainkan disajikan sebagai data JSON yang bisa dikonsumsi aplikasi apa pun. Kalau kamu belum mengikuti tutorial CRUD sebelumnya, sangat disarankan menyelesaikannya dulu agar model dan tabel produknya sudah siap.

Apa Itu REST API dan Kenapa Laravel Cocok untuk Itu

REST API adalah cara standar dua aplikasi berkomunikasi lewat HTTP. Client mengirim request ke sebuah alamat (endpoint), lalu server membalas dengan data, biasanya dalam format JSON. Setiap operasi memakai method HTTP yang berbeda, dan pola ini berlaku konsisten di hampir semua API modern.

Laravel cocok untuk membuat REST API karena tiga alasan. Pertama, routing dan resource controller-nya memang dirancang mengikuti pola REST. Kedua, Eloquent membuat urusan database menjadi singkat. Ketiga, ekosistemnya lengkap: ada Sanctum untuk autentikasi token, API Resource untuk mengatur format JSON, dan validasi bawaan yang rapi. Kamu tidak perlu memasang banyak paket tambahan hanya untuk membuat API yang layak pakai.

Prasyarat Sebelum Mulai

Pastikan hal berikut sudah siap di komputermu:

1. Proyek Laravel 12 dari tutorial CRUD sebelumnya, dengan model Product dan tabel products yang sudah termigrasi.
2. Server lokal berjalan lewat perintah php artisan serve.
3. Aplikasi untuk menguji API, misalnya Postman, Insomnia, atau cukup terminal untuk perintah curl.

Kalau proyek CRUD belum ada, kamu tetap bisa mengikuti tutorial ini dari proyek Laravel baru. Cukup buat model dan migration produk seperti pada tutorial sebelumnya, lalu lanjutkan dari langkah pertama di bawah.

Langkah 1: Memasang Sanctum dengan Perintah install:api

Di Laravel versi modern, dukungan API tidak aktif secara bawaan agar proyek web biasa tetap ringan. Untuk mengaktifkannya, jalankan satu perintah berikut di terminal proyekmu:

php artisan install:api

Perintah ini melakukan beberapa hal sekaligus: memasang paket Laravel Sanctum, membuat file routes/api.php, dan menyiapkan migration untuk tabel personal_access_tokens yang nanti menyimpan token login pengguna. Setelah perintah selesai, jalankan migration:

php artisan migrate

Semua route yang kamu tulis di routes/api.php otomatis memakai awalan /api. Jadi route products di file itu akan diakses sebagai /api/products. Inilah yang membedakannya dari route web di routes/web.php.

Langkah 2: Membuat Controller Khusus API

Jangan mencampur controller web dan controller API dalam satu file. Controller web mengembalikan tampilan Blade, sedangkan controller API mengembalikan JSON. Buat controller baru di dalam folder Api:

php artisan make:controller Api/ProductController

Buka file app/Http/Controllers/Api/ProductController.php, lalu isi dengan kode berikut:

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Http\Resources\ProductResource;
use App\Models\Product;
use Illuminate\Http\Request;

class ProductController extends Controller
{
    public function index()
    {
        return ProductResource::collection(Product::latest()->paginate(10));
    }

    public function store(Request $request)
    {
        $validated = $request->validate([
            'name' => 'required|string|max:255',
            'description' => 'nullable|string',
            'price' => 'required|numeric|min:0',
            'stock' => 'required|integer|min:0',
        ]);

        $product = Product::create($validated);

        return (new ProductResource($product))
            ->response()
            ->setStatusCode(201);
    }

    public function show(Product $product)
    {
        return new ProductResource($product);
    }

    public function update(Request $request, Product $product)
    {
        $validated = $request->validate([
            'name' => 'sometimes|string|max:255',
            'description' => 'nullable|string',
            'price' => 'sometimes|numeric|min:0',
            'stock' => 'sometimes|integer|min:0',
        ]);

        $product->update($validated);

        return new ProductResource($product);
    }

    public function destroy(Product $product)
    {
        $product->delete();

        return response()->json(['message' => 'Produk berhasil dihapus.']);
    }
}

Ada tiga hal yang perlu diperhatikan dari kode di atas. Pertama, validasi tetap dilakukan di setiap operasi tulis, sama seperti CRUD versi web. Kedua, pada method update kita memakai aturan sometimes agar client boleh mengubah sebagian kolom saja, sesuai sifat method PATCH. Ketiga, method show dan update memakai route model binding: Laravel otomatis mencari produk berdasarkan ID di URL, dan otomatis membalas 404 bila ID tidak ditemukan. Kamu tidak perlu menulis pencarian manual.

Sebagai pengembangan lanjutan, validasi di controller ini nantinya bisa dipisah ke Form Request agar controller lebih ramping. Untuk tahap dasar, validasi langsung seperti ini sudah cukup dan lebih mudah diikuti.

Langkah 3: Mengatur Format JSON dengan API Resource

Kalau model langsung dikembalikan sebagai JSON, semua kolom di tabel akan ikut tampil, termasuk yang seharusnya tidak perlu diketahui client. API Resource memberi kamu kendali penuh atas kolom apa saja yang dikirim. Buat resource-nya:

php artisan make:resource ProductResource

Lalu buka app/Http/Resources/ProductResource.php dan ubah method toArray menjadi:

public function toArray(Request $request): array
{
    return [
        'id' => $this->id,
        'name' => $this->name,
        'description' => $this->description,
        'price' => (int) $this->price,
        'stock' => (int) $this->stock,
        'created_at' => $this->created_at?->toDateTimeString(),
        'updated_at' => $this->updated_at?->toDateTimeString(),
    ];
}

Jangan lupa menambahkan use Illuminate\Http\Request; di bagian atas file bila belum ada. Dengan resource ini, format balasan akan konsisten di semua endpoint: data produk dibungkus dalam kunci data, dan untuk daftar produk Laravel otomatis menambahkan informasi pagination seperti total halaman. Konsistensi format seperti ini yang membuat API nyaman dipakai tim frontend.

Langkah 4: Mendaftarkan Route API

Sekarang daftarkan endpoint-nya di routes/api.php:

<?php

use App\Http\Controllers\Api\ProductController;
use Illuminate\Support\Facades\Route;

Route::apiResource('products', ProductController::class);

Satu baris apiResource itu menghasilkan lima endpoint sekaligus sesuai tabel di awal artikel. Untuk memastikan semuanya terdaftar dengan benar, jalankan:

php artisan route:list --path=api

Kamu akan melihat daftar route beserta method HTTP dan controller tujuannya. Bila daftar ini sudah muncul, API dasarmu sebenarnya sudah jadi dan siap diuji.

Langkah 5: Menguji API dengan curl

Pastikan server berjalan, lalu buka terminal baru dan coba beberapa perintah berikut.

Mengambil semua produk:

curl http://127.0.0.1:8000/api/products

Menambah produk baru:

curl -X POST http://127.0.0.1:8000/api/products -H "Content-Type: application/json" -H "Accept: application/json" -d '{"name":"Keyboard Mechanical","description":"Keyboard RGB hot swap","price":350000,"stock":12}'

Balasan yang benar untuk penambahan data adalah status 201 Created beserta data produk yang baru dibuat, lengkap dengan ID-nya. Kalau kamu mendapat status 422, berarti validasi gagal dan pesan errornya ada di dalam JSON balasan. Baca pesan itu baik baik, karena di situlah petunjuk kolom mana yang bermasalah.

Di Postman, langkahnya setara: pilih method POST, masukkan URL yang sama, buka tab Body, pilih raw dan JSON, lalu tempel isi data produknya. Jangan lupa selalu mengirim header Accept: application/json agar Laravel membalas error dalam format JSON, bukan halaman HTML.

Langkah 6: Menambahkan Autentikasi Token dengan Sanctum

API yang terbuka untuk siapa pun cocok untuk data publik, tetapi operasi tambah, ubah, dan hapus data sebaiknya hanya boleh dilakukan pengguna yang sudah login. Sanctum menyelesaikan ini dengan token: pengguna login sekali, menerima token, lalu mengirim token itu di setiap request berikutnya.

Pertama, aktifkan trait HasApiTokens pada model User. Buka app/Models/User.php dan sesuaikan bagian atas class:

use Laravel\Sanctum\HasApiTokens;

class User extends Authenticatable
{
    use HasApiTokens, HasFactory, Notifiable;
    // ...
}

Kedua, buat controller autentikasi:

php artisan make:controller Api/AuthController

Isi file app/Http/Controllers/Api/AuthController.php dengan kode berikut:

<?php

namespace App\Http\Controllers\Api;

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

class AuthController extends Controller
{
    public function register(Request $request)
    {
        $validated = $request->validate([
            'name' => 'required|string|max:255',
            'email' => 'required|string|email|unique:users',
            'password' => 'required|string|min:8|confirmed',
        ]);

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

        return response()->json([
            'user' => $user,
            'token' => $user->createToken('api-token')->plainTextToken,
        ], 201);
    }

    public function login(Request $request)
    {
        $request->validate([
            'email' => 'required|string|email',
            'password' => 'required|string',
        ]);

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

        if (! $user || ! Hash::check($request->password, $user->password)) {
            throw ValidationException::withMessages([
                'email' => ['Email atau password salah.'],
            ]);
        }

        return response()->json([
            'user' => $user,
            'token' => $user->createToken('api-token')->plainTextToken,
        ]);
    }

    public function logout(Request $request)
    {
        $request->user()->currentAccessToken()->delete();

        return response()->json(['message' => 'Berhasil logout.']);
    }
}

Ketiga, perbarui routes/api.php agar endpoint produk terlindungi, sedangkan register dan login tetap terbuka:

<?php

use App\Http\Controllers\Api\AuthController;
use App\Http\Controllers\Api\ProductController;
use Illuminate\Support\Facades\Route;

Route::post('/register', [AuthController::class, 'register']);
Route::post('/login', [AuthController::class, 'login']);

Route::middleware('auth:sanctum')->group(function () {
    Route::apiResource('products', ProductController::class);
    Route::post('/logout', [AuthController::class, 'logout']);
});

Pola ini umum dipakai: membaca data pun bisa kamu longgarkan bila memang datanya publik, misalnya memindahkan method index dan show ke luar grup middleware. Untuk latihan ini, semua endpoint produk kita lindungi agar perilaku tokennya terlihat jelas.

Langkah 7: Menguji Endpoint yang Terlindungi

Coba akses /api/products tanpa token. Laravel akan membalas status 401 Unauthorized. Itu tanda perlindungannya bekerja.

Selanjutnya login untuk mendapatkan token:

curl -X POST http://127.0.0.1:8000/api/login -H "Content-Type: application/json" -H "Accept: application/json" -d '{"email":"contoh@mail.com","password":"password123"}'

Salin nilai token dari balasan, lalu pakai pada request berikutnya lewat header Authorization:

curl http://127.0.0.1:8000/api/products -H "Accept: application/json" -H "Authorization: Bearer TOKEN_KAMU"

Kali ini data produk akan tampil. Di Postman, token yang sama bisa diisi pada tab Authorization dengan tipe Bearer Token. Simpan token ini baik baik dan jangan pernah menaruhnya di kode frontend yang dipublikasikan, karena siapa pun yang memiliki token itu bisa bertindak atas nama pengguna pemiliknya.

Troubleshooting yang Sering Terjadi

Route /api tidak ditemukan (404). Biasanya karena install:api belum dijalankan atau file routes/api.php belum terdaftar. Jalankan php artisan route:list –path=api untuk memastikan, dan bersihkan cache route dengan php artisan route:clear bila perlu.

Balasan error berupa halaman HTML, bukan JSON. Client tidak mengirim header Accept: application/json. Tambahkan header itu di curl atau Postman, terutama saat menguji validasi dan autentikasi.

Status 401 padahal sudah login. Periksa tiga hal: token disalin utuh tanpa spasi tambahan, header diawali kata Bearer diikuti satu spasi, dan route memang berada di dalam grup auth:sanctum. Kesalahan paling sering adalah token tertukar dengan token dari sesi login lama yang sudah dihapus.

Class HasApiTokens tidak ditemukan. Artinya Sanctum belum terpasang. Jalankan kembali php artisan install:api, atau pasang manual dengan composer require laravel/sanctum lalu php artisan vendor:publish untuk konfigurasinya.

Error kolom tidak boleh diisi (mass assignment). Sama seperti tutorial CRUD: pastikan semua kolom produk sudah terdaftar di properti fillable pada model Product.

FAQ REST API Laravel

1. Apa bedanya Route::apiResource dan Route::resource?
apiResource hanya membuat lima route untuk operasi data (index, store, show, update, destroy), sedangkan resource menambahkan route create dan edit yang dipakai untuk menampilkan form HTML. Karena API tidak punya form, apiResource adalah pilihan yang tepat.

2. Apakah REST API Laravel harus selalu memakai Sanctum?
Tidak selalu. API publik yang hanya menampilkan data terbuka bisa dibuat tanpa autentikasi. Sanctum dipakai bila ada data milik pengguna atau operasi tulis yang perlu dibatasi. Untuk komunikasi antar server yang lebih kompleks, ada juga Laravel Passport berbasis OAuth2, tetapi untuk kebanyakan aplikasi pemula Sanctum jauh lebih sederhana.

3. Bagaimana cara membatasi jumlah data per halaman?
Pada contoh ini kita memakai paginate(10), dan client bisa berpindah halaman dengan menambahkan ?page=2 pada URL. Jumlah per halaman boleh diubah sesuai kebutuhan, dan lazimnya disertakan juga pilihan per_page dari query string bila API dipakai banyak client.

4. Bisakah API ini dipakai aplikasi Flutter atau React Native?
Bisa, dan memang untuk itulah API ini dibuat. Aplikasi mobile cukup mengirim request HTTP ke endpoint yang sama dan membaca balasan JSON-nya. Yang perlu diperhatikan, alamat 127.0.0.1 hanya berlaku di komputer pengembang. Untuk pengujian dari HP, gunakan alamat IP lokal komputer atau layanan tunnel selama pengembangan.

5. Bagaimana cara membuat versi API, misalnya v1 dan v2?
Kelompokkan route ke dalam awalan versi, contohnya Route::prefix(‘v1’) pada grup route, sehingga URL menjadi /api/v1/products. Dengan cara ini, perubahan besar di masa depan bisa diterbitkan sebagai v2 tanpa merusak aplikasi lama yang masih memakai v1.

Kesimpulan

Kamu baru saja mengubah aplikasi CRUD Laravel menjadi REST API yang utuh: endpoint produk dengan format JSON yang konsisten lewat API Resource, validasi di setiap operasi tulis, pagination, dan autentikasi token memakai Sanctum. Pola ini adalah fondasi hampir semua backend modern, baik untuk aplikasi mobile, frontend JavaScript, maupun integrasi antar layanan.

Langkah alami berikutnya adalah menerapkan pola yang sama ke data lain di aplikasimu, lalu mempelajari cara men-deploy API ini ke server agar bisa diakses dari mana saja. Sebagai penguat dasar, baca kembali seri awalnya di Tutorial Laravel 12: Membuat CRUD Sederhana dari Nol untuk Pemula dan padukan dengan bantuan AI secara etis lewat panduan 5 Tools AI Gratis untuk Mahasiswa yang juga sudah terbit di blog ini.

Sudah berhasil membuat endpoint pertamamu? Ceritakan di kolom komentar method mana yang paling membingungkan, nanti kita bahas bersama.