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-apiSetelah proses instalasi selesai, masuk ke direktori project:
cd laravel12-apiJalankan aplikasi Laravel:
php artisan serveJika berhasil, aplikasi dapat diakses melalui:
http://127.0.0.1:8000Sampai 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:apiPerintah tersebut akan menyiapkan kebutuhan API, termasuk file routes/api.php dan instalasi Sanctum.
Setelah selesai, jalankan migration:
php artisan migrateSekarang buka struktur project Laravel. Seharusnya kamu sudah menemukan file:
routes/
web.php
api.phpFile 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/productsJika 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_apiKemudian 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:clearDengan 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 -mPerintah 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:
| Kolom | Keterangan |
|---|---|
| id | Primary key produk |
| name | Nama produk |
| sku | Kode unik produk |
| description | Deskripsi produk |
| price | Harga produk |
| stock | Jumlah stok |
| timestamps | Waktu pembuatan dan perubahan |
Setelah migration selesai, jalankan:
php artisan migratePeriksa database MySQL. Seharusnya sekarang sudah terdapat tabel products.
7. Membuat Model Product
Selanjutnya buka file:
app/Models/Product.phpTambahkan 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 ProductResourceBuka file:
app/Http/Resources/ProductResource.phpKemudian 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 --apiLaravel akan membuat controller pada lokasi:
app/Http/Controllers/Api/ProductController.phpBuka 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:
index()untuk menampilkan daftar produk.store()untuk menambahkan produk.show()untuk menampilkan detail produk.update()untuk memperbarui produk.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.phpTambahkan 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:
| Method | Endpoint | Fungsi |
|---|---|---|
| GET | /api/products | Menampilkan produk |
| POST | /api/products | Menambah 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=apiSampai 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:apiMengaktifkan HasApiTokens pada User Model
Buka file:
app/Models/User.phpTambahkan 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 serveKemudian buka Postman.
A. Menguji Login
Buat request baru dengan konfigurasi berikut:
Method: POST
URL:
http://127.0.0.1:8000/api/loginBody: 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 Code | Keterangan |
|---|---|
| 200 OK | Request berhasil |
| 201 Created | Data berhasil dibuat |
| 204 No Content | Request berhasil tanpa respons body |
| 400 Bad Request | Request tidak sesuai |
| 401 Unauthorized | Belum terautentikasi |
| 403 Forbidden | Tidak memiliki izin |
| 404 Not Found | Data atau endpoint tidak ditemukan |
| 422 Unprocessable Content | Validasi gagal |
| 500 Internal Server Error | Terjadi 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.