Gratis update & dukungan instalasi

Tutorial Website 14 Nov 2026

Cara Membuat Sistem Membership & Langganan Berbayar di Laravel: Paket, Pembayaran & Middleware (Panduan 2026)

R Oleh renz mobellgnd
Cara Membuat Sistem Membership & Langganan Berbayar di Laravel: Paket, Pembayaran & Middleware (Panduan 2026)

Cara membuat sistem membership di Laravel adalah dengan menyiapkan tiga tabel utama — plans, subscriptions, dan transactions — lalu menambahkan middleware untuk membatasi akses konten premium, checkout lewat payment gateway seperti Midtrans, dan perintah terjadwal untuk menonaktifkan langganan yang kedaluwarsa. Panduan ini membangun semuanya dari nol tanpa paket admin, supaya kamu memahami setiap bagiannya dan bisa menyesuaikannya dengan produk apa pun, dari kursus online sampai aplikasi kasir berlangganan.

Apa itu sistem membership di Laravel?

Sistem membership adalah mekanisme yang membedakan pengguna gratis dan berbayar, lalu membuka atau menutup fitur berdasarkan status langganan mereka. Di Laravel, sistem ini biasanya terdiri dari tiga lapisan: data (paket dan langganan di database), akses (middleware yang memeriksa status langganan di setiap request), dan uang (payment gateway yang mengaktifkan langganan setelah pembayaran terkonfirmasi).

Pendekatan ini berbeda dengan sekadar menambahkan kolom is_premium di tabel users. Kolom boolean memang cukup untuk satu paket seumur hidup, tetapi begitu kamu punya beberapa paket, masa berlaku, perpanjangan, dan riwayat pembayaran, kamu butuh struktur yang rapi. Tiga tabel adalah titik awal yang paling awet.

Bagaimana cara kerja sistem membership?

Alur lengkapnya hanya enam langkah, dan setiap langkah bisa diuji secara terpisah:

  1. Pengguna memilih paket di halaman pricing (plans).
  2. Sistem membuat transaksi berstatus pending dan meminta token pembayaran ke Midtrans Snap.
  3. Pengguna membayar lewat QRIS, transfer bank, atau e-wallet.
  4. Midtrans mengirim notifikasi (webhook) ke server kamu.
  5. Server memverifikasi notifikasi, mengubah transaksi jadi paid, dan membuat atau memperpanjang baris di subscriptions.
  6. Middleware memeriksa subscriptions di setiap request ke konten premium; kalau sudah kedaluwarsa, pengguna diarahkan ke halaman perpanjang.

Satu hal yang wajib dipegang: status langganan tidak pernah diubah dari sisi frontend. Semua perubahan status hanya terjadi lewat webhook yang terverifikasi atau perintah terjadwal di server. Kalau status bisa diubah lewat JavaScript, siapa pun bisa mengaktifkan paket Pro untuk dirinya sendiri.

Pilih dulu: bangun manual, Laravel Cashier, atau paket siap pakai?

Pendekatan Cocok untuk Kekurangan
Manual (panduan ini)Produk Indonesia, pembayaran Midtrans/Xendit, kontrol penuhKamu yang menulis semua logika
Laravel CashierLangganan kartu kredit via Stripe/PaddleStripe tidak umum dipakai pembeli Indonesia; butuh kartu
Paket admin (Filament dsb.)Butuh panel admin cepatLogika langganan tetap harus ditulis sendiri

Untuk pasar Indonesia, jalur manual dengan Midtrans biasanya paling masuk akal: pembeli bisa bayar pakai QRIS, VA bank lokal, atau e-wallet tanpa kartu kredit. Laravel Cashier memang elegan, tetapi ia terikat ke Stripe dan Paddle — dua gateway yang jarang dipakai pelanggan Indonesia. Sementara itu, paket admin seperti Filament mempercepat CRUD paket, tetapi tidak menyelesaikan inti masalahnya: kapan langganan aktif, kapan kedaluwarsa, dan apa yang terjadi saat pembayaran gagal.

Langkah 1: Buat tiga tabel utama

Buat migration untuk plans, subscriptions, dan transactions:

php artisan make:model Plan -m
php artisan make:model Subscription -m
php artisan make:model Transaction -m

Isi migration plans dengan kolom yang menentukan isi paket:

Schema::create('plans', function (Blueprint $table) {
$table->id();
$table->string('name'); // Basic, Pro, Lifetime
$table->string('slug')->unique();
$table->unsignedInteger('price'); // dalam rupiah, tanpa desimal
$table->unsignedInteger('duration_days'); // 30, 365, atau 36500
$table->json('features')->nullable(); // daftar fitur paket
$table->boolean('is_active')->default(true);
$table->timestamps();
});

Tabel subscriptions mencatat langganan aktif setiap pengguna:

Schema::create('subscriptions', function (Blueprint $table) {
$table->id();
$table->foreignId('user_id')->constrained()->cascadeOnDelete();
$table->foreignId('plan_id')->constrained();
$table->timestamp('starts_at');
$table->timestamp('ends_at')->nullable(); // null = seumur hidup
$table->string('status'); // active, expired, cancelled
$table->timestamps();
});

Dan transactions mencatat setiap percobaan bayar — termasuk yang gagal — supaya riwayat keuanganmu bisa diaudit:

Schema::create('transactions', function (Blueprint $table) {
$table->id();
$table->foreignId('user_id')->constrained();
$table->foreignId('plan_id')->constrained();
$table->string('order_id')->unique(); // ORDER-20261105-XXXX
$table->unsignedInteger('amount');
$table->string('status'); // pending, paid, failed, expired
$table->string('payment_type')->nullable(); // qris, bank_transfer
$table->timestamps();
});

Satu detail yang sering dilupakan: order_id harus unik dan tidak bisa ditebak urutannya. Midtrans menolak order_id yang dipakai dua kali, jadi gabungkan tanggal dengan string acak, misalnya ORDER-20261105- ditambah 8 karakter acak.

Langkah 2: Relasi model dan helper status langganan

Di model User, tambahkan relasi dan satu helper yang akan dipakai di seluruh aplikasi:

public function subscriptions()
{
return $this->hasMany(Subscription::class);
}

public function activeSubscription()
{
return $this->hasOne(Subscription::class)
->where('status', 'active')
->where(function ($query) {
$query->whereNull('ends_at')
->orWhere('ends_at', '>', now());
})
->latestOfMany();
}

public function hasActiveSubscription(): bool
{
return $this->activeSubscription()->exists();
}

Perhatikan kondisi ends_at > now() di dalam query: status active saja tidak cukup, karena langganan yang sudah lewat tanggalnya tetap berstatus active di database sampai ada proses yang menandainya kedaluwarsa. Helper ini membuat aplikasi tetap benar meski proses kedaluwarsa belum jalan — pertahanan berlapis yang murah.

Untuk menentukan paket mana yang dimiliki pengguna, tambahkan relasi plan di model Subscription dan belongsTo di Transaction. Kalau aplikasimu memakai role dan permission terpisah, pola ini melengkapi — bukan menggantikan — sistem role yang sudah kamu punya; peran menjawab "siapa dia", sedangkan langganan menjawab "apa yang boleh dia akses". Baca panduan Cara Membuat Multi Role & Permission di Laravel kalau kamu belum memisahkan keduanya.

Langkah 3: Middleware untuk membatasi konten premium

Middleware adalah penjaga gerbangnya. Buat dengan Artisan, lalu daftarkan di bootstrap/app.php:

php artisan make:middleware EnsureSubscribed
namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;

class EnsureSubscribed
{
public function handle(Request $request, Closure $next)
{
$user = $request->user();

if (! $user || ! $user->hasActiveSubscription()) {
return redirect()->route('pricing')
->with('error', 'Fitur ini khusus member berbayar. Pilih paket untuk melanjutkan.');
}

return $next($request);
}
}

Pasang middleware ini pada route yang memang butuh langganan, bukan pada seluruh aplikasi:

Route::middleware(['auth', 'subscribed'])->group(function () {
Route::get('/materi-premium', [CourseController::class, 'premium']);
Route::get('/laporan-lengkap', [ReportController::class, 'index']);
});

Dua jebakan umum di langkah ini. Pertama, jangan menaruh pengecekan langganan hanya di Blade (@if(auth()->user()->hasActiveSubscription())) tanpa middleware: Blade hanya menyembunyikan tombol, sedangkan URL-nya tetap bisa dibuka langsung. Kedua, kalau paketmu bertingkat (Basic vs Pro), middleware perlu menerima parameter nama paket — Laravel mendukung subscribed:pro lewat sintaks Route::middleware('subscribed:pro') dan $planSlug di method handle.

Langkah 4: Checkout dengan Midtrans Snap

Instal package resmi Midtrans, lalu buat endpoint checkout yang membuat transaksi pending sebelum meminta token Snap:

composer require midtrans/midtrans-php
public function checkout(Plan $plan)
{
$orderId = 'ORDER-'.now()->format('Ymd').'-'.Str::upper(Str::random(8));

$transaction = Transaction::create([
'user_id' => auth()->id(),
'plan_id' => $plan->id,
'order_id' => $orderId,
'amount' => $plan->price,
'status' => 'pending',
]);

Config::$serverKey = config('services.midtrans.server_key');
Config::$isProduction = config('services.midtrans.is_production');
Config::$isSanitized = true;

$snapToken = Snap::getSnapToken([
'transaction_details' => [
'order_id' => $orderId,
'gross_amount' => $plan->price,
],
'customer_details' => [
'first_name' => auth()->user()->name,
'email' => auth()->user()->email,
],
]);

return view('checkout', compact('transaction', 'snapToken'));
}

Kenapa transaksi dibuat dulu sebelum memanggil Snap? Karena order_id harus ada di database sebelum Midtrans mengenalnya — kalau proses gagal di tengah jalan, kamu tetap punya jejak transaksi pending yang bisa dicek, bukan pembayaran hantu yang tidak bisa dilacak. Pola ini sama dengan yang dipakai di keranjang belanja: simpan dulu, bayar kemudian. Lihat Cara Membuat Keranjang Belanja & Checkout di Laravel untuk fondasi checkout yang anti double order.

Langkah 5: Webhook Midtrans dan aktivasi yang idempoten

Webhook adalah satu-satunya sumber kebenaran soal pembayaran. Jangan mengaktifkan langganan dari callback JavaScript onSuccess di Snap — callback itu berjalan di browser pengguna dan bisa dipalsukan. Buat route webhook tanpa middleware auth, tapi verifikasi signature key-nya:

public function handleWebhook(Request $request)
{
$notification = new Notification();

$signature = hash('sha512',
$notification->order_id
.$notification->status_code
.$notification->gross_amount
.config('services.midtrans.server_key')
);

if ($signature !== $notification->signature_key) {
return response()->json(['message' => 'Invalid signature'], 403);
}

$transaction = Transaction::where('order_id', $notification->order_id)->firstOrFail();

// Idempotency: Midtrans bisa mengirim notifikasi yang sama berkali-kali.
if ($transaction->status === 'paid') {
return response()->json(['message' => 'Already processed']);
}

if (in_array($notification->transaction_status, ['capture', 'settlement'])) {
DB::transaction(function () use ($transaction, $notification) {
$transaction->update([
'status' => 'paid',
'payment_type' => $notification->payment_type,
]);

$plan = $transaction->plan;
$current = $transaction->user->activeSubscription;

$startsAt = $current ? max($current->ends_at, now()) : now();

Subscription::create([
'user_id' => $transaction->user_id,
'plan_id' => $plan->id,
'starts_at' => $startsAt,
'ends_at' => $startsAt->copy()->addDays($plan->duration_days),
'status' => 'active',
]);
});
}

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

Tiga detail di sini menyelamatkanmu dari bug yang mahal. Pertama, verifikasi signature mencegah orang mengirim webhook palsu. Kedua, pengecekan status === 'paid' membuat notifikasi ganda tidak menggandakan masa langganan. Ketiga, max($current->ends_at, now()) memastikan pengguna yang memperpanjang sebelum habis tidak kehilangan sisa harinya — perpanjangan menumpuk, bukan menimpa.

Jangan lupa daftarkan URL webhook di dashboard Midtrans dan kecualikan route ini dari proteksi CSRF di bootstrap/app.php, karena request datang dari server Midtrans, bukan dari form aplikasimu.

Langkah 6: Tandai langganan kedaluwarsa secara terjadwal

Buat Artisan command yang berjalan tiap jam lewat scheduler Laravel:

php artisan make:command ExpireSubscriptions
public function handle(): void
{
$expired = Subscription::where('status', 'active')
->whereNotNull('ends_at')
->where('ends_at', '<=', now())
->update(['status' => 'expired']);

$this->info("{$expired} langganan ditandai kedaluwarsa.");
}

Daftarkan di routes/console.php:

Schedule::command('subscriptions:expire')->hourly();

Dan pastikan cron server memanggil php artisan schedule:run setiap menit — kalau cron ini tidak jalan, tidak ada satu pun perintah terjadwal yang dieksekusi, termasuk pengingat perpanjangan yang mungkin kamu tambahkan nanti. Panduan Cara Setting Cron Job Laravel di Shared Hosting menjelaskan cara memasangnya di cPanel. Untuk pengalaman pengguna yang lebih baik, tambahkan pengingat H-3 sebelum kedaluwarsa lewat notifikasi email atau WhatsApp — pengguna yang diingatkan jauh lebih mungkin memperpanjang daripada yang tiba-tiba terkunci.

Kapan cara ini tidak cocok?

Pendekatan manual ini bukan untuk semua kasus. Jujur saja soal batasannya:

  1. Kalau kamu butuh recurring billing otomatis (tagihan bulanan tanpa aksi pengguna), Midtrans punya fitur recurring, tetapi alurnya berbeda: kamu menyimpan token kartu, bukan menunggu pengguna checkout tiap bulan. Itu topik tersendiri dan butuh persetujuan eksplisit dari pengguna.
  2. Kalau produkmu dijual ke luar negeri dan butuh pajak otomatis per negara, Laravel Cashier dengan Stripe atau Paddle menangani tax ID dan invoice pajak jauh lebih rapi.
  3. Kalau kamu hanya punya satu paket seumur hidup, tiga tabel di atas berlebihan — cukup kolom is_premium dan purchased_at di tabel users.
  4. Kalau trafikmu besar, pengecekan hasActiveSubscription() di setiap request sebaiknya di-cache per pengguna selama beberapa menit, supaya tidak menambah satu query di setiap halaman premium.

Satu lagi: simpan server key Midtrans hanya di .env dan jangan pernah menaruhnya di JavaScript atau repository. Server key yang bocor memungkinkan orang membatalkan transaksi dan membaca data pembayaranmu.

Penutup: dari langganan ke produk yang menghasilkan

Sistem membership yang sehat punya empat ciri: paketnya jelas, pembayarannya terlacak, aksesnya dijaga middleware, dan kedaluwarsanya otomatis. Panduan ini membangun keempatnya dengan komponen Laravel standar — migration, model, middleware, scheduler, dan satu package payment gateway — tanpa bergantung pada paket admin apa pun.

Setelah fondasinya jalan, pengembangan berikutnya yang paling berdampak biasanya bukan fitur baru, melainkan hal-hal kecil yang menaikkan konversi: halaman pricing yang jujur, pengingat perpanjangan H-3, dan paket tahunan dengan diskon. Kalau kamu menjual paket lewat voucher atau kode promo, sistem diskon yang rapi bisa dipasang di atas checkout yang sama — lihat Cara Membuat Sistem Voucher Diskon di Laravel untuk pola anti-abuse-nya.

FAQ

Apakah sistem membership Laravel harus memakai Laravel Cashier?

Tidak. Laravel Cashier hanya diperlukan kalau kamu memakai Stripe atau Paddle sebagai gateway. Untuk pasar Indonesia dengan Midtrans, Xendit, atau Tripay, membangun manual dengan tiga tabel (plans, subscriptions, transactions) justru lebih cocok karena mendukung QRIS, VA bank lokal, dan e-wallet.

Berapa tabel minimal untuk sistem langganan berbayar?

Tiga tabel: plans untuk paket dan harga, subscriptions untuk masa aktif tiap pengguna, dan transactions untuk riwayat pembayaran. Satu kolom is_premium di tabel users hanya cukup kalau kamu punya satu paket seumur hidup tanpa masa berlaku.

Bagaimana cara membatasi konten hanya untuk member berbayar?

Buat middleware (misalnya EnsureSubscribed) yang memeriksa hasActiveSubscription() milik pengguna, lalu pasang middleware itu pada route konten premium. Jangan hanya menyembunyikan tombol di Blade, karena URL-nya tetap bisa dibuka langsung tanpa middleware.

Apakah aman mengaktifkan langganan dari callback JavaScript Midtrans Snap?

Tidak aman. Callback onSuccess berjalan di browser dan bisa dipalsukan. Langganan hanya boleh diaktifkan dari webhook server-to-server Midtrans setelah signature key diverifikasi, dengan pengecekan idempotency supaya notifikasi ganda tidak menggandakan masa langganan.

Bagaimana kalau pengguna memperpanjang sebelum langganan lama habis?

Hitung tanggal mulai baru sebagai nilai terbesar antara ends_at langganan lama dan waktu sekarang (max($current->ends_at, now())), lalu tambahkan durasi paket. Dengan begitu sisa hari langganan lama tidak hangus dan perpanjangan menumpuk dengan benar.

Apakah langganan yang kedaluwarsa harus dihapus dari database?

Tidak. Ubah saja statusnya menjadi expired dan biarkan barisnya tersimpan sebagai riwayat. Data itu berguna untuk laporan, analisis churn, dan penawaran win-back ke mantan pelanggan. Yang dihapus permanen — kalau memang perlu — hanya data yang sudah melewati masa retensi yang kamu tetapkan.