Beranda / Artikel / Laravel
Laravel

Tutorial Laravel 12 REST API: Cara Membuat API CRUD dengan Sanctum dan Postman

Dalam pengembangan aplikasi modern, REST API menjadi salah satu bagian penting yang hampir selalu dibutuhkan. Ketika sebuah aplikasi memiliki frontend menggunakan React, Next.js, Vue.js, atau bahkan Android, biasanya diperlukan backend yang bertugas mengelola data dan menyediakan layanan melalui API.

16 November 2026 19 kali dibaca Administrator
Tutorial Laravel 12 REST API: Cara Membuat API CRUD dengan Sanctum dan Postman

Dalam pengembangan aplikasi modern, REST API menjadi salah satu bagian penting yang hampir selalu dibutuhkan. Ketika sebuah aplikasi memiliki frontend menggunakan React, Next.js, Vue.js, atau bahkan Android, biasanya diperlukan backend yang bertugas mengelola data dan menyediakan layanan melalui API.

Salah satu framework PHP yang bisa digunakan untuk membangun backend tersebut adalah Laravel.

Laravel memiliki berbagai fitur yang memudahkan developer dalam membuat REST API, mulai dari routing, validasi data, Eloquent ORM, API Resource, hingga autentikasi menggunakan Laravel Sanctum.

Pada tutorial kali ini, kita akan belajar cara membuat REST API menggunakan Laravel 12 dari awal sampai bisa digunakan. Kita akan membuat API sederhana untuk mengelola data produk, lengkap dengan fitur CRUD (Create, Read, Update, Delete), autentikasi token, dan pengujian menggunakan Postman.

Tutorial ini cocok untuk kamu yang baru mulai belajar Laravel API maupun developer yang ingin memahami bagaimana Laravel digunakan sebagai backend untuk aplikasi frontend terpisah.

1. Apa Itu REST API?

REST API (Representational State Transfer Application Programming Interface) merupakan pendekatan komunikasi antara dua aplikasi melalui HTTP.

Sederhananya, REST API memungkinkan aplikasi frontend meminta atau mengirimkan data ke backend tanpa harus menggunakan halaman HTML.

Sebagai contoh, kita memiliki aplikasi toko online. Pengguna membuka halaman daftar produk melalui frontend React. Kemudian React mengirimkan request ke backend Laravel untuk mendapatkan data produk.

Laravel akan mengambil data dari database, mengolahnya, lalu mengirimkan respons dalam format JSON.

Contoh respons API:

{
    "success": true,
    "message": "Data produk berhasil ditampilkan",
    "data": [
        {
            "id": 1,
            "name": "Laptop Lenovo",
            "price": "8500000.00",
            "stock": 10
        },
        {
            "id": 2,
            "name": "Mouse Logitech",
            "price": "250000.00",
            "stock": 25
        }
    ]
}

Dengan cara ini, backend Laravel dapat digunakan oleh berbagai aplikasi sekaligus, seperti website, aplikasi Android, iOS, maupun frontend berbasis JavaScript.

2. Persiapan Sebelum Membuat REST API Laravel 12

Sebelum mulai coding, pastikan beberapa kebutuhan berikut sudah tersedia di komputer.

  • PHP versi 8.2 atau lebih baru.

  • Composer.

  • Laravel 12.

  • MySQL atau MariaDB.

  • Visual Studio Code atau editor lainnya.

  • Postman untuk melakukan pengujian API.

Jika belum memiliki Laravel, kamu bisa mempelajari instalasinya terlebih dahulu melalui dokumentasi resmi Laravel.

3. Membuat Project Laravel 12

Langkah pertama adalah membuat project Laravel baru.

Buka terminal atau Command Prompt, kemudian jalankan perintah berikut:

composer create-project laravel/laravel:^12.0 laravel12-api

Setelah proses instalasi selesai, masuk ke direktori project:

cd laravel12-api

Jalankan aplikasi Laravel:

php artisan serve

Jika berhasil, aplikasi dapat diakses melalui:

http://127.0.0.1:8000

Sampai tahap ini, project Laravel 12 sudah berhasil dibuat.

4. Mengaktifkan Fitur API Laravel 12

Berbeda dengan beberapa versi Laravel sebelumnya, pada instalasi Laravel 12 yang baru, file routes/api.php belum tentu tersedia secara default.

Untuk mengaktifkan routing API sekaligus memasang Laravel Sanctum, jalankan perintah:

php artisan install:api

Perintah tersebut akan menyiapkan kebutuhan API, termasuk file routes/api.php dan instalasi Sanctum.

Setelah selesai, jalankan migration:

php artisan migrate

Sekarang buka struktur project Laravel. Seharusnya kamu sudah menemukan file:

routes/
    web.php
    api.php

File api.php inilah yang akan kita gunakan untuk mendefinisikan endpoint REST API.

Secara default, route yang didefinisikan di dalam file tersebut akan memiliki prefix /api.

Contohnya:

Route::get('/products', function () {
    return response()->json([
        'message' => 'API Laravel 12 berhasil dijalankan'
    ]);
});

Endpoint tersebut dapat diakses melalui:

GET http://127.0.0.1:8000/api/products

Jika berhasil, Laravel akan mengembalikan respons JSON.

5. Konfigurasi Database MySQL

Selanjutnya kita akan menghubungkan Laravel dengan database MySQL.

Buat database baru menggunakan phpMyAdmin atau MySQL client.

Misalnya, gunakan nama database:

db_laravel12_api

Kemudian buka file .env pada root project Laravel.

Sesuaikan konfigurasi database berikut:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=db_laravel12_api
DB_USERNAME=root
DB_PASSWORD=

Jika database MySQL kamu menggunakan password, isi bagian DB_PASSWORD sesuai konfigurasi masing-masing.

Setelah mengubah konfigurasi, jalankan:

php artisan config:clear

Dengan demikian, Laravel sudah diarahkan untuk menggunakan database MySQL yang telah dibuat.

6. Membuat Model dan Migration Product

Sekarang kita mulai membuat fitur utama, yaitu pengelolaan data produk.

Jalankan perintah berikut:

php artisan make:model Product -m

Perintah tersebut akan membuat dua file:

  • Model Product.php.

  • Migration untuk tabel products.

Buka file migration yang baru dibuat di direktori:

database/migrations/

Sesuaikan isinya menjadi:

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up(): void
    {
        Schema::create('products', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('sku')->unique();
            $table->text('description')->nullable();
            $table->decimal('price', 12, 2)->default(0);
            $table->unsignedInteger('stock')->default(0);
            $table->timestamps();
        });
    }

    public function down(): void
    {
        Schema::dropIfExists('products');
    }
};

Penjelasan beberapa kolom:

KolomKeterangan
idPrimary key produk
nameNama produk
skuKode unik produk
descriptionDeskripsi produk
priceHarga produk
stockJumlah stok
timestampsWaktu pembuatan dan perubahan

Setelah migration selesai, jalankan:

php artisan migrate

Periksa database MySQL. Seharusnya sekarang sudah terdapat tabel products.

7. Membuat Model Product

Selanjutnya buka file:

app/Models/Product.php

Tambahkan konfigurasi $fillable agar kolom produk dapat diisi melalui mass assignment.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    protected $fillable = [
        'name',
        'sku',
        'description',
        'price',
        'stock'
    ];
}

Dengan konfigurasi tersebut, kita dapat menggunakan Product::create() untuk menyimpan data produk dengan lebih praktis.

8. Membuat API Resource

Salah satu fitur Laravel yang berguna ketika membangun REST API adalah API Resource.

API Resource digunakan untuk mengatur bagaimana data model ditampilkan dalam respons JSON.

Jalankan perintah:

php artisan make:resource ProductResource

Buka file:

app/Http/Resources/ProductResource.php

Kemudian ubah menjadi:

<?php

namespace App\Http\Resources;

use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\JsonResource;

class ProductResource extends JsonResource
{
    public function toArray(Request $request): array
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'sku' => $this->sku,
            'description' => $this->description,
            'price' => $this->price,
            'stock' => $this->stock,
            'created_at' => $this->created_at,
            'updated_at' => $this->updated_at,
        ];
    }
}

Mengapa menggunakan API Resource?

Karena kita bisa mengontrol data apa saja yang boleh dikirimkan kepada pengguna API.

Selain itu, struktur respons menjadi lebih konsisten dan mudah dikelola ketika aplikasi berkembang.

9. Membuat Product Controller

Berikutnya kita akan membuat controller untuk mengelola seluruh proses CRUD produk.

Jalankan perintah:

php artisan make:controller Api/ProductController --api

Laravel akan membuat controller pada lokasi:

app/Http/Controllers/Api/ProductController.php

Buka file tersebut dan masukkan 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;
use Illuminate\Validation\Rule;

class ProductController extends Controller
{
    // GET: Menampilkan seluruh produk
    public function index()
    {
        $products = Product::latest()->paginate(10);

        return ProductResource::collection($products);
    }

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

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

        return (new ProductResource($product))
            ->additional([
                'message' => 'Produk berhasil ditambahkan'
            ])
            ->response()
            ->setStatusCode(201);
    }

    // GET: Menampilkan detail produk
    public function show(string $id)
    {
        $product = Product::findOrFail($id);

        return new ProductResource($product);
    }

    // PUT/PATCH: Mengubah produk
    public function update(Request $request, string $id)
    {
        $product = Product::findOrFail($id);

        $validated = $request->validate([
            'name' => 'required|string|max:255',
            'sku' => [
                'required',
                'string',
                'max:100',
                Rule::unique('products', 'sku')->ignore($product->id),
            ],
            'description' => 'nullable|string',
            'price' => 'required|numeric|min:0',
            'stock' => 'required|integer|min:0',
        ]);

        $product->update($validated);

        return (new ProductResource($product))
            ->additional([
                'message' => 'Produk berhasil diperbarui'
            ]);
    }

    // DELETE: Menghapus produk
    public function destroy(string $id)
    {
        $product = Product::findOrFail($id);

        $product->delete();

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

Sekarang controller sudah memiliki lima fungsi utama:

  1. index() untuk menampilkan daftar produk.

  2. store() untuk menambahkan produk.

  3. show() untuk menampilkan detail produk.

  4. update() untuk memperbarui produk.

  5. destroy() untuk menghapus produk.

Kita juga menggunakan validasi Laravel agar data yang masuk ke database sesuai dengan aturan yang sudah ditentukan.

10. Membuat Route REST API

Setelah controller selesai, sekarang kita perlu mendaftarkan endpoint API.

Buka file:

routes/api.php

Tambahkan kode berikut:

<?php

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

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

Dengan menggunakan Route::apiResource(), Laravel akan otomatis membuat beberapa endpoint CRUD.

Berikut daftar endpoint yang tersedia:

MethodEndpointFungsi
GET/api/productsMenampilkan produk
POST/api/productsMenambah produk
GET/api/products/{id}Detail produk
PUT/api/products/{id}Mengubah produk
PATCH/api/products/{id}Mengubah produk
DELETE/api/products/{id}Menghapus produk

Untuk memeriksa route yang sudah dibuat, jalankan:

php artisan route:list --path=api

Sampai tahap ini, REST API CRUD produk sudah terbentuk.

Namun, API kita masih belum memiliki autentikasi. Artinya, siapa pun yang mengetahui endpoint dapat mengakses fitur CRUD tersebut.

Pada aplikasi yang digunakan secara nyata, kondisi ini tentu perlu diperbaiki.

11. Menambahkan Autentikasi API Menggunakan Laravel Sanctum

Laravel Sanctum merupakan salah satu pilihan autentikasi yang disediakan dalam ekosistem Laravel.

Sanctum mendukung penggunaan API token untuk aplikasi mobile maupun API yang diakses oleh pihak ketiga.

Pada tutorial ini kita akan menggunakan sistem Bearer Token.

Sebelum melanjutkan, pastikan kamu sudah menjalankan:

php artisan install:api

Mengaktifkan HasApiTokens pada User Model

Buka file:

app/Models/User.php

Tambahkan trait HasApiTokens.

Contoh kode:

<?php

namespace App\Models;

use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Laravel\Sanctum\HasApiTokens;

class User extends Authenticatable
{
    use HasApiTokens, Notifiable;

    // Properti model lainnya tetap gunakan konfigurasi project.
}

Jika file User.php milikmu sudah memiliki properti $fillable, $hidden, atau konfigurasi lainnya, jangan menghapusnya. Cukup tambahkan import dan trait tersebut.

Membuat Endpoint Login API

Sekarang buka routes/api.php.

Tambahkan endpoint login berikut sebelum route produk:

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

Route::post('/login', function (Request $request) {

    $request->validate([
        'email' => 'required|email',
        'password' => 'required|string',
        'device_name' => 'required|string|max:255'
    ]);

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

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

    $token = $user->createToken(
        $request->device_name
    )->plainTextToken;

    return response()->json([
        'success' => true,
        'message' => 'Login berhasil',
        'data' => [
            'user' => $user,
            'token' => $token
        ]
    ]);
});

Endpoint login akan menerima email, password, dan nama perangkat.

Jika kredensial benar, Laravel akan menghasilkan token yang nantinya digunakan untuk mengakses endpoint yang dilindungi.

Token tersebut hanya ditampilkan dalam bentuk aslinya ketika dibuat. Sanctum menyimpan representasi hash token di database.

Melindungi Route Product dengan Sanctum

Sekarang kita ubah route produk agar hanya dapat diakses oleh pengguna yang sudah login.

Ubah bagian route produk di routes/api.php menjadi:

Route::middleware('auth:sanctum')->group(function () {

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

    Route::post('/logout', function (Request $request) {

        $request->user()->currentAccessToken()->delete();

        return response()->json([
            'success' => true,
            'message' => 'Logout berhasil'
        ]);
    });

});

Sekarang seluruh endpoint CRUD produk membutuhkan autentikasi.

Endpoint login tetap bisa diakses tanpa token, karena pengguna perlu melakukan login terlebih dahulu untuk mendapatkan token.

12. Menguji REST API Laravel 12 Menggunakan Postman

Setelah seluruh proses coding selesai, kita masuk ke tahap pengujian.

Pastikan aplikasi Laravel masih berjalan:

php artisan serve

Kemudian buka Postman.

A. Menguji Login

Buat request baru dengan konfigurasi berikut:

  • Method: POST

  • URL: http://127.0.0.1:8000/api/login

  • Body: raw JSON

Masukkan data:

{
    "email": "admin@example.com",
    "password": "password",
    "device_name": "Postman"
}

Pastikan akun tersebut memang sudah tersedia di tabel users dan password-nya sesuai.

Jika berhasil, respons akan berisi token:

{
    "success": true,
    "message": "Login berhasil",
    "data": {
        "user": {
            "id": 1,
            "name": "Admin",
            "email": "admin@example.com"
        },
        "token": "1|xxxxxxxxxxxxxxxx"
    }
}

Simpan token tersebut untuk pengujian berikutnya.

B. Menguji GET Products

Buat request baru:

  • Method: GET

  • URL: http://127.0.0.1:8000/api/products

Pada bagian Authorization:

  • Type: Bearer Token

  • Token: masukkan token hasil login.

Klik Send.

Jika berhasil, Laravel akan mengembalikan daftar produk dalam format JSON.

C. Menguji POST Products

Buat request:

  • Method: POST

  • URL: http://127.0.0.1:8000/api/products

Pada bagian Authorization, gunakan Bearer Token.

Kemudian pilih Body, raw, JSON.

Masukkan data:

{
    "name": "Laptop ASUS VivoBook",
    "sku": "LPT-001",
    "description": "Laptop untuk kebutuhan pekerjaan dan programming",
    "price": 8500000,
    "stock": 15
}

Klik Send.

Jika berhasil, Laravel akan menyimpan produk baru dan mengembalikan HTTP status 201 Created.

D. Menguji GET Product Detail

Untuk melihat detail produk berdasarkan ID:

  • Method: GET

  • URL: http://127.0.0.1:8000/api/products/1

Ganti angka 1 dengan ID produk yang ingin ditampilkan.

E. Menguji PUT Products

Untuk mengubah data produk:

  • Method: PUT

  • URL: http://127.0.0.1:8000/api/products/1

Contoh Body JSON:

{
    "name": "Laptop ASUS VivoBook Updated",
    "sku": "LPT-001",
    "description": "Laptop untuk programmer",
    "price": 9000000,
    "stock": 20
}

Klik Send.

Jika berhasil, data produk akan diperbarui.

F. Menguji DELETE Products

Untuk menghapus produk:

  • Method: DELETE

  • URL: http://127.0.0.1:8000/api/products/1

Gunakan Bearer Token yang sama.

Jika berhasil, Laravel akan memberikan respons:

{
    "success": true,
    "message": "Produk berhasil dihapus"
}

G. Menguji Logout

Terakhir, coba endpoint logout:

  • Method: POST

  • URL: http://127.0.0.1:8000/api/logout

Gunakan Bearer Token yang masih aktif.

Jika berhasil, token yang sedang digunakan akan dihapus sehingga tidak dapat digunakan kembali untuk mengakses endpoint yang dilindungi.

13. Memahami HTTP Status Code pada REST API

Saat membangun API, kita perlu memahami HTTP status code agar aplikasi frontend dapat mengetahui hasil dari setiap request.

Berikut beberapa status code yang sering digunakan:

Status CodeKeterangan
200 OKRequest berhasil
201 CreatedData berhasil dibuat
204 No ContentRequest berhasil tanpa respons body
400 Bad RequestRequest tidak sesuai
401 UnauthorizedBelum terautentikasi
403 ForbiddenTidak memiliki izin
404 Not FoundData atau endpoint tidak ditemukan
422 Unprocessable ContentValidasi gagal
500 Internal Server ErrorTerjadi kesalahan server

Memahami status code akan membantu ketika kita mengintegrasikan API Laravel dengan aplikasi frontend.

14. Tips Membuat REST API Laravel yang Lebih Aman dan Terstruktur

Membuat API yang bisa berjalan memang merupakan langkah awal. Namun, untuk aplikasi yang akan digunakan secara nyata, ada beberapa hal yang perlu diperhatikan.

Gunakan validasi request.

Jangan langsung menyimpan data yang dikirimkan pengguna. Pastikan setiap input sudah melalui proses validasi.

Gunakan autentikasi.

Endpoint yang berisi data penting sebaiknya dilindungi menggunakan autentikasi seperti Laravel Sanctum.

Jangan menyimpan token secara sembarangan.

Hindari menampilkan token ke log atau menyimpannya di tempat yang dapat diakses pengguna lain.

Gunakan API Resource.

API Resource membantu menjaga struktur respons JSON agar tetap konsisten.

Gunakan pagination.

Ketika jumlah data semakin banyak, hindari mengirimkan seluruh data sekaligus. Gunakan pagination seperti contoh pada tutorial ini.

Terapkan authorization.

Autentikasi saja tidak cukup. Pastikan pengguna hanya dapat mengakses dan mengubah data yang memang menjadi haknya.

Gunakan HTTPS pada production.

Komunikasi antara aplikasi frontend dan backend sebaiknya dilindungi menggunakan HTTPS.

15. Kesimpulan

Laravel 12 menyediakan berbagai fitur yang memudahkan developer dalam membangun REST API. Dengan memanfaatkan routing, Eloquent ORM, API Resource, validasi, dan Laravel Sanctum, kita dapat membuat backend API yang terstruktur tanpa harus membangun seluruh mekanisme dari awal.

Pada tutorial ini kita sudah mempelajari cara membuat REST API Laravel 12 mulai dari instalasi project, konfigurasi database, pembuatan model dan migration, CRUD produk, autentikasi menggunakan Sanctum, hingga pengujian menggunakan Postman.

Setelah memahami dasar ini, kamu bisa mengembangkan API menjadi aplikasi yang lebih kompleks, misalnya API untuk sistem HRIS, CRM, POS, inventory, maupun aplikasi mobile.

Jika kamu sedang belajar backend development, memahami REST API merupakan salah satu kemampuan yang sangat berguna karena banyak aplikasi modern membutuhkan komunikasi antara frontend dan backend.

Teruslah mencoba, bereksperimen, dan membangun project sendiri.

Pendekar Koding – Belajar Teknologi, Membangun Solusi.


Bermanfaat?

Jelajahi artikel lainnya di Pendekar Koding.

Artikel Lainnya
LANJUTKAN MEMBACA

Artikel Terkait

Temukan artikel lainnya yang mungkin menarik untuk kamu pelajari.

Mengenal Laravel Sanctum dan Cara Menggunakannya di Laravel 12
Laravel

Mengenal Laravel Sanctum dan Cara Menggunakannya di Laravel 12

Laravel Sanctum merupakan package autentikasi yang disediakan oleh Laravel untuk menangani autentikasi aplikasi SPA (Single Page Application), mobile application, serta API yang menggunakan token. Dibandingkan implementasi OAuth2 yang lebih kompleks, Sanctum menawarkan mekanisme autentikasi yang relatif sederhana dan praktis untuk banyak kebutuhan aplikasi.

19 November 2026