Source code aplikasi, template web, dan ebook. Unduh dari akun setelah bayar. Lihat produk

Blog / REST API, Integrasi & Automation / Cara Mengirim Notifikasi Whats...
REST API, Integrasi & Automation

Cara Mengirim Notifikasi WhatsApp dari Laravel melalui Provider API

AD

Admin HijrahKreativa

Penulis

19 Oct 2026
15 min read
19 views

Mengirim pengingat iuran dan konfirmasi pembayaran lewat WhatsApp dengan cara yang bisa dirawat: channel notifikasi kustom di atas abstraksi provider, contoh Fonnte dan WhatsApp Cloud API resmi, normalisasi nomor, persetujuan penerima, jam tenang, pembatasan laju, log status pesan, dan test tanpa mengirim pesan sungguhan.

Overview

Di Indonesia, WhatsApp jauh lebih sering dibuka daripada email. Bagi aplikasi RW, pengingat iuran lewat WhatsApp jauh lebih efektif. Namun pengiriman WhatsApp punya risiko yang tidak dimiliki email:

Risiko Dampak
Mengirim ratusan pesan sekaligus dari satu nomor Nomor ditandai spam atau diblokir
Mengirim ke warga yang tidak setuju Keluhan, pelanggaran privasi
Pesan dikirim pukul 23.00 Warga terganggu
Format nomor tidak konsisten (0812, +62 812, 62812) Pesan gagal terkirim
Logika provider tersebar di banyak tempat Sulit berpindah provider
Kirim langsung di dalam request Halaman lambat; gagal bila provider bermasalah

Ada dua jenis provider yang umum dipakai:

Jenis Contoh Kelebihan Hal yang perlu diperhatikan
Resmi (WhatsApp Business Platform) WhatsApp Cloud API dari Meta, atau BSP (Business Solution Provider) Resmi, nomor terverifikasi, skala besar Pesan di luar jendela 24 jam wajib memakai template yang disetujui; biaya per percakapan
Berbasis perangkat Fonnte dan layanan sejenis yang menautkan WhatsApp di ponsel Cepat dimulai, murah, pesan bebas Tidak resmi; risiko pembatasan nomor oleh WhatsApp bila dipakai berlebihan; perhatikan ketentuan layanan WhatsApp

Hasil akhir:

  • antarmuka WhatsAppProvider dengan implementasi Fonnte dan WhatsApp Cloud API,
  • channel notifikasi whatsapp sehingga pesan dikirim dengan $user->notify(...),
  • normalisasi dan validasi nomor,
  • persetujuan (opt-in) dan opt-out penerima,
  • jam tenang dan pembatasan laju di queue,
  • tabel log pesan dan status,
  • test.

Prerequisites

Komponen Versi
PHP 8.3+ (disarankan 8.4)
Laravel 13.x
Queue Redis, worker berjalan
Provider Akun Fonnte (perangkat terhubung) atau WhatsApp Cloud API (nomor bisnis + template disetujui)
Testing Pest 4

Pola notifikasi Laravel mengikuti artikel Cara Membuat Sistem Notifikasi Laravel untuk Admin dan Pengguna.

Step-by-step Tutorial

Langkah 1: Konfigurasi Provider

// config/services.php
'whatsapp' => [
    'driver' => env('WHATSAPP_DRIVER', 'log'),            // fonnte | cloud | log

    'fonnte' => [
        'url'   => 'https://api.fonnte.com/send',
        'token' => env('FONNTE_TOKEN'),
    ],

    'cloud' => [
        'graph_version'   => env('WHATSAPP_GRAPH_VERSION', 'v23.0'),   // sesuaikan dengan versi Graph API yang aktif
        'phone_number_id' => env('WHATSAPP_PHONE_NUMBER_ID'),
        'token'           => env('WHATSAPP_CLOUD_TOKEN'),
    ],

    'jam_tenang'     => ['mulai' => '21:00', 'selesai' => '07:00'],
    'per_menit'      => (int) env('WHATSAPP_PER_MENIT', 20),
],

Driver log dipakai di lokal dan staging: pesan hanya ditulis ke log, tidak benar-benar dikirim.

Langkah 2: Normalisasi Nomor

// app/Support/NomorWhatsApp.php
namespace App\Support;

final class NomorWhatsApp
{
    /** Mengembalikan format internasional tanpa '+', misalnya 6281234567890, atau null bila tidak valid */
    public static function normalisasi(?string $nomor): ?string
    {
        $digit = preg_replace('/\D/', '', (string) $nomor);

        $digit = match (true) {
            str_starts_with($digit, '62') => $digit,
            str_starts_with($digit, '0')  => '62'.substr($digit, 1),
            str_starts_with($digit, '8')  => '62'.$digit,
            default                       => $digit,
        };

        // Nomor seluler Indonesia: 62 8xx, total 10–13 digit setelah 62
        return preg_match('/^628\d{8,11}$/', $digit) ? $digit : null;
    }

    public static function samarkan(string $nomor): string
    {
        return substr($nomor, 0, 5).str_repeat('•', max(0, strlen($nomor) - 8)).substr($nomor, -3);
    }
}

Simpan nomor yang sudah dinormalisasi di database (misalnya kolom users.no_whatsapp), dan validasi di Form Request saat warga mengisi profil.

Langkah 3: Persetujuan Penerima

Kirim WhatsApp hanya kepada warga yang menyetujuinya, dan simpan buktinya:

Schema::table('users', function (Blueprint $table) {
    $table->string('no_whatsapp', 20)->nullable()->index();
    $table->timestamp('whatsapp_disetujui_pada')->nullable();
    $table->timestamp('whatsapp_berhenti_pada')->nullable();
});
// app/Models/User.php
public function bolehDikirimWhatsApp(): bool
{
    return $this->no_whatsapp
        && $this->whatsapp_disetujui_pada
        && ! $this->whatsapp_berhenti_pada;
}

/** Dipakai channel notifikasi untuk mengetahui nomor tujuan */
public function routeNotificationForWhatsapp(): ?string
{
    return $this->bolehDikirimWhatsApp() ? $this->no_whatsapp : null;
}

Sediakan cara berhenti yang mudah: tautan di profil, dan untuk provider yang mendukung pesan masuk, balasan kata "BERHENTI" yang diproses lewat webhook.

Langkah 4: Antarmuka Provider dan Implementasinya

// app/Integrations/WhatsApp/WhatsAppProvider.php
namespace App\Integrations\WhatsApp;

interface WhatsAppProvider
{
    /** @return string|null ID pesan dari provider */
    public function kirim(PesanWhatsApp $pesan): ?string;
}
// app/Integrations/WhatsApp/PesanWhatsApp.php
namespace App\Integrations\WhatsApp;

final readonly class PesanWhatsApp
{
    public function __construct(
        public string $tujuan,                 // 6281234567890
        public string $teks,                   // isi untuk provider pesan bebas
        public ?string $template = null,       // nama template untuk Cloud API
        public array $parameter = [],          // parameter template, berurutan
        public string $bahasa = 'id',
    ) {}
}

Fonnte. Endpoint POST https://api.fonnte.com/send, token di header Authorization (tanpa awalan Bearer), parameter target dan message. Parameter countryCode berisi string; karena nomor sudah dinormalisasi ke format 62..., nonaktifkan dengan "0".

// app/Integrations/WhatsApp/FonnteProvider.php
namespace App\Integrations\WhatsApp;

use App\Integrations\WhatsApp\Exceptions\{PengirimanGagal, PengirimanSementaraGagal};
use Illuminate\Http\Client\ConnectionException;
use Illuminate\Support\Facades\Http;

final class FonnteProvider implements WhatsAppProvider
{
    public function __construct(#[\SensitiveParameter] private readonly string $token, private readonly string $url) {}

    public function kirim(PesanWhatsApp $pesan): ?string
    {
        try {
            $res = Http::withHeaders(['Authorization' => $this->token])
                ->asForm()
                ->timeout(15)
                ->connectTimeout(5)
                ->post($this->url, [
                    'target'      => $pesan->tujuan,
                    'message'     => $pesan->teks,
                    'countryCode' => '0',             // nomor sudah berformat 62...
                    'connectOnly' => 'true',          // gagal bila perangkat tidak terhubung
                ]);
        } catch (ConnectionException $e) {
            throw new PengirimanSementaraGagal('Tidak dapat terhubung ke Fonnte.', previous: $e);
        }

        $data = $res->json() ?? [];
        $sukses = ($data['status'] ?? $data['Status'] ?? false) === true;

        if (! $res->successful() || ! $sukses) {
            $alasan = $data['reason'] ?? $data['detail'] ?? 'tidak diketahui';

            // Kuota habis atau perangkat terputus: bisa dicoba lagi nanti
            if (str_contains($alasan, 'quota') || str_contains($alasan, 'disconnected')) {
                throw new PengirimanSementaraGagal("Fonnte: {$alasan}");
            }

            throw new PengirimanGagal("Fonnte: {$alasan}");     // token salah, target tidak valid, dsb.
        }

        return isset($data['id'][0]) ? (string) $data['id'][0] : null;
    }
}

WhatsApp Cloud API (resmi). Pesan yang dimulai oleh bisnis di luar jendela layanan 24 jam wajib memakai template yang sudah disetujui. Daftarkan template seperti berikut di WhatsApp Manager:

Nama     : pengingat_iuran
Bahasa   : id
Kategori : Utility
Isi      : Halo {{1}}, iuran RW periode {{2}} sebesar Rp {{3}} belum tercatat lunas.
           Bayar melalui aplikasi: {{4}}
// app/Integrations/WhatsApp/CloudApiProvider.php
namespace App\Integrations\WhatsApp;

use App\Integrations\WhatsApp\Exceptions\{PengirimanGagal, PengirimanSementaraGagal};
use Illuminate\Support\Facades\Http;

final class CloudApiProvider implements WhatsAppProvider
{
    public function __construct(
        private readonly string $graphVersion,
        private readonly string $phoneNumberId,
        #[\SensitiveParameter] private readonly string $token,
    ) {}

    public function kirim(PesanWhatsApp $pesan): ?string
    {
        $payload = $pesan->template
            ? [
                'messaging_product' => 'whatsapp',
                'to'   => $pesan->tujuan,
                'type' => 'template',
                'template' => [
                    'name'     => $pesan->template,
                    'language' => ['code' => $pesan->bahasa],
                    'components' => [[
                        'type'       => 'body',
                        'parameters' => array_map(fn ($v) => ['type' => 'text', 'text' => (string) $v], $pesan->parameter),
                    ]],
                ],
            ]
            : ['messaging_product' => 'whatsapp', 'to' => $pesan->tujuan, 'type' => 'text', 'text' => ['body' => $pesan->teks]];

        $res = Http::withToken($this->token)
            ->timeout(15)
            ->post("https://graph.facebook.com/{$this->graphVersion}/{$this->phoneNumberId}/messages", $payload);

        if ($res->status() === 429 || $res->serverError()) {
            throw new PengirimanSementaraGagal('WhatsApp Cloud API: '.$res->json('error.message', 'error sementara'));
        }

        if ($res->failed()) {
            throw new PengirimanGagal('WhatsApp Cloud API: '.$res->json('error.message', 'permintaan ditolak'));
        }

        return $res->json('messages.0.id');
    }
}

Driver log untuk lokal:

// app/Integrations/WhatsApp/LogProvider.php
final class LogProvider implements WhatsAppProvider
{
    public function kirim(PesanWhatsApp $pesan): ?string
    {
        Log::info('whatsapp.simulasi', ['tujuan' => NomorWhatsApp::samarkan($pesan->tujuan), 'teks' => $pesan->teks]);
        return 'log-'.Str::uuid();
    }
}

Daftarkan di container:

// app/Providers/AppServiceProvider.php
$this->app->singleton(WhatsAppProvider::class, fn () => match (config('services.whatsapp.driver')) {
    'fonnte' => new FonnteProvider(config('services.whatsapp.fonnte.token'), config('services.whatsapp.fonnte.url')),
    'cloud'  => new CloudApiProvider(
        config('services.whatsapp.cloud.graph_version'),
        config('services.whatsapp.cloud.phone_number_id'),
        config('services.whatsapp.cloud.token'),
    ),
    default  => new LogProvider(),
});

Mengganti provider cukup dengan mengubah WHATSAPP_DRIVER; kode notifikasi tidak berubah.

Langkah 5: Tabel Log Pesan

Schema::create('pesan_whatsapp', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->nullable()->constrained()->nullOnDelete();
    $table->string('tujuan', 20);
    $table->string('jenis', 50);                    // iuran.pengingat, pembayaran.diterima
    $table->text('isi');
    $table->string('provider', 20);
    $table->string('provider_message_id', 100)->nullable()->index();
    $table->string('status', 20)->default('antre');   // antre | terkirim | gagal | dilewati
    $table->string('alasan', 255)->nullable();
    $table->timestamp('terkirim_pada')->nullable();
    $table->timestamps();

    $table->index(['user_id', 'jenis', 'created_at']);
});

Log ini menjawab pertanyaan pengurus seperti "apakah Pak Budi sudah diingatkan?" dan memudahkan investigasi bila ada keluhan.

Langkah 6: Channel Notifikasi Kustom

// app/Notifications/Channels/WhatsAppChannel.php
namespace App\Notifications\Channels;

use App\Integrations\WhatsApp\{PesanWhatsApp, WhatsAppProvider};
use App\Models\PesanWhatsappLog;
use Illuminate\Notifications\Notification;

final class WhatsAppChannel
{
    public function __construct(private readonly WhatsAppProvider $provider) {}

    public function send(object $notifiable, Notification $notification): void
    {
        $tujuan = $notifiable->routeNotificationFor('whatsapp', $notification);

        if (! $tujuan) {
            return;                                          // tidak punya nomor / belum setuju / sudah berhenti
        }

        /** @var PesanWhatsApp $pesan */
        $pesan = $notification->toWhatsApp($notifiable);
        $pesan = new PesanWhatsApp($tujuan, $pesan->teks, $pesan->template, $pesan->parameter, $pesan->bahasa);

        $log = PesanWhatsappLog::create([
            'user_id'  => $notifiable->id ?? null,
            'tujuan'   => $tujuan,
            'jenis'    => defined($notification::class.'::JENIS') ? $notification::JENIS : class_basename($notification),
            'isi'      => $pesan->teks,
            'provider' => config('services.whatsapp.driver'),
        ]);

        try {
            $id = $this->provider->kirim($pesan);
            $log->update(['status' => 'terkirim', 'provider_message_id' => $id, 'terkirim_pada' => now()]);
        } catch (\Throwable $e) {
            $log->update(['status' => 'gagal', 'alasan' => mb_substr($e->getMessage(), 0, 255)]);
            throw $e;                                         // biarkan job notifikasi mengulang bila sementara
        }
    }
}

PesanWhatsappLog adalah model untuk tabel pesan_whatsapp. Daftarkan alias channel agar bisa dipakai sebagai string 'whatsapp':

// app/Providers/AppServiceProvider.php
use Illuminate\Notifications\ChannelManager;
use Illuminate\Support\Facades\Notification;

public function boot(): void
{
    Notification::resolved(fn (ChannelManager $service) =>
        $service->extend('whatsapp', fn ($app) => $app->make(\App\Notifications\Channels\WhatsAppChannel::class)));
}

Langkah 7: Notifikasi dengan Jam Tenang dan Pembatasan Laju

// app/Notifications/PengingatIuran.php
namespace App\Notifications;

use App\Integrations\WhatsApp\Exceptions\PengirimanGagal;
use App\Integrations\WhatsApp\PesanWhatsApp;
use App\Models\Iuran;
use Carbon\CarbonImmutable;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Notifications\Notification;
use Illuminate\Queue\Middleware\RateLimited;

class PengingatIuran extends Notification implements ShouldQueue
{
    use Queueable;

    public const JENIS = 'iuran.pengingat';

    public int $tries = 5;
    public array $backoff = [60, 300, 900];

    public function __construct(public Iuran $iuran)
    {
        $this->afterCommit();
        $this->onQueue('whatsapp');
        $this->delay(self::luarJamTenang());
    }

    public function via(object $notifiable): array
    {
        return $notifiable->saluranUntuk(self::JENIS, ['whatsapp', 'database']);
    }

    public function shouldSend(object $notifiable, string $channel): bool
    {
        return ! $this->iuran->fresh()->sudahLunas();          // jangan ingatkan yang sudah bayar
    }

    /** Batasi laju khusus untuk channel whatsapp */
    public function middleware(object $notifiable, string $channel): array
    {
        return $channel === 'whatsapp' ? [new RateLimited('whatsapp')] : [];
    }

    public function retryUntil(): \DateTime
    {
        return now()->addHours(12);
    }

    public function toWhatsApp(object $notifiable): PesanWhatsApp
    {
        $nominal = number_format($this->iuran->sisaTagihan(), 0, ',', '.');
        $tautan  = route('iuran.show', $this->iuran);

        return new PesanWhatsApp(
            tujuan: '',                                          // diisi oleh channel
            teks: "Halo {$notifiable->name}, iuran RW periode {$this->iuran->periode} sebesar Rp {$nominal} belum tercatat lunas.\n\nBayar melalui aplikasi: {$tautan}\n\nBalas BERHENTI bila tidak ingin menerima pengingat.",
            template: 'pengingat_iuran',                         // dipakai oleh Cloud API
            parameter: [$notifiable->name, $this->iuran->periode, $nominal, $tautan],
        );
    }

    public function toArray(object $notifiable): array
    {
        return ['jenis' => self::JENIS, 'judul' => 'Pengingat iuran', 'pesan' => "Iuran {$this->iuran->periode} belum lunas."];
    }

    /** Bila sekarang jam tenang, tunda sampai pukul 07.00 WIB berikutnya */
    public static function luarJamTenang(): ?CarbonImmutable
    {
        $sekarang = CarbonImmutable::now('Asia/Jakarta');
        [$mulai, $selesai] = array_values(config('services.whatsapp.jam_tenang'));

        $batasMulai   = $sekarang->setTimeFromTimeString($mulai);
        $batasSelesai = $sekarang->setTimeFromTimeString($selesai);

        if ($sekarang->greaterThanOrEqualTo($batasMulai)) {
            return $batasSelesai->addDay();                       // malam ini → besok pagi
        }
        if ($sekarang->lessThan($batasSelesai)) {
            return $batasSelesai;                                 // dini hari → pagi ini
        }

        return null;
    }
}
// app/Providers/AppServiceProvider.php
use Illuminate\Cache\RateLimiting\Limit;

RateLimiter::for('whatsapp', fn () => Limit::perMinute(config('services.whatsapp.per_menit')));

Pembatas RateLimited pada job membuat pesan yang melebihi kuota per menit dikembalikan ke antrean untuk dicoba sebentar lagi, bukan gagal. Pengiriman massal ke 300 keluarga akan berjalan bertahap, misalnya 20 pesan per menit. Untuk provider berbasis perangkat, laju yang rendah dan isi pesan yang personal mengurangi risiko nomor dibatasi.

PengirimanGagal (kesalahan permanen seperti nomor tidak valid) sebaiknya tidak diulang. Tangani dengan memanggil $this->fail($e) di dalam channel atau periksa jenis exception di method failed(); PengirimanSementaraGagal dibiarkan diulang oleh queue.

Langkah 8: Kirim dan Pantau

// Satu warga
$warga->notify(new PengingatIuran($iuran));

// Massal (lihat artikel Scheduler untuk penjadwalan)
Iuran::belumLunas()->periode(now()->format('Y-m'))->with('keluarga.anggotaPenerimaNotifikasi')
    ->lazyById(200)
    ->each(fn ($iuran) => Notification::send($iuran->keluarga->anggotaPenerimaNotifikasi, new PengingatIuran($iuran)));

Jalankan worker khusus antrean WhatsApp agar pesan tidak menghambat antrean lain:

php artisan queue:work redis --queue=whatsapp --tries=5 --sleep=3

Halaman log untuk pengurus, dengan nomor yang disamarkan:

PesanWhatsappLog::with('user:id,name')->latest()->paginate(50)
    ->through(fn ($p) => [...$p->only('jenis', 'status', 'alasan', 'created_at'), 'tujuan' => NomorWhatsApp::samarkan($p->tujuan)]);

Langkah 9: Webhook Status dan Pesan Masuk

Kedua jenis provider dapat mengirim webhook untuk status pesan (terkirim, dibaca, gagal) dan pesan masuk. Terima dengan pola dari artikel Webhook Laravel: verifikasi sesuai mekanisme provider (token verifikasi dan tanda tangan untuk Cloud API; konfigurasi webhook di dasbor untuk Fonnte), simpan, lalu proses di queue.

Contoh pemrosesan balasan "BERHENTI":

public function prosesPesanMasuk(string $pengirim, string $teks): void
{
    if (preg_match('/^\s*(berhenti|stop)\s*$/i', $teks)) {
        User::where('no_whatsapp', NomorWhatsApp::normalisasi($pengirim))
            ->update(['whatsapp_berhenti_pada' => now()]);
    }
}

Format payload webhook berbeda antar provider dan bisa berubah; ikuti dokumentasi provider yang Anda pakai.

Langkah 10: Test

// tests/Feature/WhatsApp/PengingatIuranTest.php
use Illuminate\Support\Facades\{Http, Notification};

it('menormalisasi nomor', function (string $input, ?string $hasil) {
    expect(NomorWhatsApp::normalisasi($input))->toBe($hasil);
})->with([
    ['0812-3456-7890', '6281234567890'],
    ['+62 812 3456 7890', '6281234567890'],
    ['812345678901', '62812345678901'],
    ['021-5551234', null],                 // telepon rumah, bukan seluler
    ['abc', null],
]);

it('tidak mengirim ke warga yang belum menyetujui', function () {
    Notification::fake();
    $warga = User::factory()->create(['no_whatsapp' => '6281234567890', 'whatsapp_disetujui_pada' => null]);

    expect($warga->routeNotificationFor('whatsapp'))->toBeNull();
});

it('mengirim lewat Fonnte dengan parameter yang benar', function () {
    config(['services.whatsapp.driver' => 'fonnte', 'services.whatsapp.fonnte.token' => 'tok-uji']);
    $this->app->forgetInstance(WhatsAppProvider::class);
    Http::fake(['api.fonnte.com/send' => Http::response(['status' => true, 'id' => ['80367170'], 'detail' => 'success! message in queue'])]);

    $warga = User::factory()->setujuWhatsApp()->create(['no_whatsapp' => '6281234567890']);
    $iuran = Iuran::factory()->belumLunas()->create();

    $warga->notifyNow(new PengingatIuran($iuran), ['whatsapp']);

    Http::assertSent(fn ($r) => $r->hasHeader('Authorization', 'tok-uji')
        && $r['target'] === '6281234567890'
        && $r['countryCode'] === '0');

    expect(PesanWhatsappLog::first())->status->toBe('terkirim')->provider_message_id->toBe('80367170');
});

it('menunda pengiriman saat jam tenang', function () {
    $this->travelTo(CarbonImmutable::parse('2026-10-19 22:30', 'Asia/Jakarta'));

    expect(PengingatIuran::luarJamTenang()->format('Y-m-d H:i'))->toBe('2026-10-20 07:00');
});

it('tidak mengirim pengingat untuk iuran yang sudah lunas', function () {
    $iuran = Iuran::factory()->lunas()->create();
    $notif = new PengingatIuran($iuran);

    expect($notif->shouldSend(User::factory()->make(), 'whatsapp'))->toBeFalse();
});

Troubleshooting

Error / Gejala Penyebab Solusi
Fonnte token invalid Token salah, atau memakai awalan Bearer Kirim token apa adanya di header Authorization
Fonnte status: false walau parameter benar countryCode/delay dikirim sebagai integer Kirim sebagai string ('0', '5')
Fonnte insufficient quota Kuota paket habis Tambah kuota; job akan mengulang nanti
Pesan tidak terkirim, perangkat terputus WhatsApp di ponsel logout/terputus Hubungkan ulang perangkat di dasbor provider
Cloud API menolak pesan teks bebas Di luar jendela 24 jam layanan pelanggan Gunakan template yang disetujui
Cloud API template name does not exist Nama/bahasa template tidak cocok atau belum disetujui Samakan nama dan kode bahasa; tunggu persetujuan
Pesan menumpuk tidak terkirim Worker antrean whatsapp tidak berjalan queue:work --queue=whatsapp
Nomor dibatasi WhatsApp Volume tinggi dari nomor berbasis perangkat Turunkan laju, personalisasi isi, pertimbangkan API resmi
Warga menerima pesan tengah malam Jam tenang tidak diterapkan atau zona waktu salah delay() dengan zona Asia/Jakarta

Best Practices

Keamanan dan privasi

  • Kirim hanya ke penerima yang menyetujui; sediakan cara berhenti yang mudah dan hormati segera.
  • Token provider di .env, tidak pernah dicatat.
  • Jangan sertakan data sensitif (NIK, saldo lengkap keluarga) di isi pesan; arahkan ke aplikasi untuk detail.
  • Samarkan nomor di log dan tampilan admin.

Performa dan keandalan

  • Semua pengiriman lewat queue khusus dengan pembatasan laju.
  • Bedakan kesalahan sementara (ulang) dan permanen (hentikan).
  • Jam tenang dengan penundaan otomatis.
  • shouldSend() memeriksa ulang kondisi saat pesan benar-benar akan dikirim.

Maintainability

  • Abstraksi WhatsAppProvider sehingga provider bisa diganti lewat konfigurasi.
  • Channel notifikasi kustom agar WhatsApp dipakai seperti channel Laravel lain.
  • Log pesan per penerima untuk dukungan dan audit.
  • Driver log untuk lokal dan staging, dan Http::fake() di test.

Related Articles

Last Tested

Komponen Versi
Laravel 13.x
PHP 8.4
Fonnte API POST /send
WhatsApp Cloud API Graph API (versi sesuai konfigurasi)
Redis 7.x
Pest 4.x
Tanggal 19 Oktober 2026

Bagikan artikel:

Artikel lainnya

Cari Artikel