Cara Mengirim Pesan WhatsApp dari Node.js Menggunakan API

Oleh /

Cara Mengirim Pesan WhatsApp dari Node.js Menggunakan API

Node.js dapat digunakan untuk mengirim pesan WhatsApp secara otomatis melalui REST API. Dengan pendekatan ini, aplikasi Node.js dapat terhubung dengan WhatsApp untuk mengirim notifikasi, konfirmasi transaksi, pengingat, dan berbagai pesan berdasarkan proses yang terjadi di dalam sistem.

Artikel ini membahas cara mengirim pesan WhatsApp dari Node.js menggunakan API Whapi, mulai dari menyiapkan API key, membuat request HTTP, mengirim pesan, hingga menangani respons dari API.

Yang Dibutuhkan

Sebelum membuat integrasi, siapkan:

  • Node.js yang sudah terpasang
  • Project Node.js
  • Device Whapi dengan status CONNECTED
  • API key Whapi
  • Nomor WhatsApp tujuan

Whapi menyediakan REST API yang dapat diakses dari aplikasi Node.js menggunakan HTTP request.

1. Siapkan API Key dan Device WhatsApp

Pengiriman pesan membutuhkan API key dan device WhatsApp yang sudah terhubung.

Pastikan device memiliki status:

CONNECTED

API key digunakan untuk mengautentikasi request yang dikirim dari aplikasi Node.js.

Endpoint untuk mengirim pesan adalah:

POST /api/sendMessage

Dokumentasi lengkap parameter endpoint tersedia di dokumentasi Send Message Whapi.

2. Membuat Project Node.js

Jika belum memiliki project, buat folder baru kemudian jalankan:

mkdir whatsapp-nodejs
cd whatsapp-nodejs
npm init -y
`

Untuk mengirim HTTP request, salah satu pilihan yang dapat digunakan adalah library Axios.

Install Axios dengan:

npm install axios

Setelah instalasi selesai, buat file:

index.js

File tersebut akan digunakan untuk menjalankan contoh pengiriman pesan.

3. Menyimpan API Key dalam Environment Variable

API key sebaiknya tidak ditulis langsung di dalam source code.

Simpan konfigurasi pada environment variable, misalnya:

WHAPI_ENDPOINT=https://alamat-server-whapi
WHAPI_API_KEY=your_api_key

Jika menggunakan file .env, install package dotenv:

npm install dotenv

Kemudian panggil konfigurasi tersebut dari aplikasi Node.js.

4. Membuat Request POST dari Node.js

Gunakan Axios untuk mengirim request ke endpoint Whapi.

Contoh:

require('dotenv').config();

const axios = require('axios');

async function sendWhatsAppMessage() {
    try {
        const response = await axios.post(
            `${process.env.WHAPI_ENDPOINT}/api/sendMessage`,
            new URLSearchParams({
                apiKey: process.env.WHAPI_API_KEY,
                phone: '6281234567890',
                message: 'Pesan otomatis dari aplikasi Node.js.',
            }),
            {
                headers: {
                    'Content-Type': 'application/x-www-form-urlencoded',
                },
            }
        );

        console.log(response.data);
    } catch (error) {
        console.error(error.response?.data || error.message);
    }
}

sendWhatsAppMessage();

Pada request tersebut terdapat beberapa parameter utama:

  • apiKey digunakan untuk autentikasi.
  • phone menentukan nomor WhatsApp tujuan.
  • message berisi pesan yang akan dikirim.

Nomor WhatsApp dapat ditulis menggunakan format internasional tanpa tanda +.

Contohnya:

6281234567890

5. Menjalankan Program

Setelah kode disimpan sebagai index.js, jalankan:

node index.js

Jika request berhasil diproses, aplikasi akan menerima respons dari API.

Respons tersebut dapat digunakan untuk mengetahui informasi hasil pengiriman, termasuk ID pesan yang diberikan oleh API.

6. Menangani Respons API

Respons API sebaiknya diproses agar aplikasi dapat mengetahui apakah request berhasil atau gagal.

Contoh:

require('dotenv').config();

const axios = require('axios');

async function sendWhatsAppMessage(phone, message) {
    try {
        const response = await axios.post(
            `${process.env.WHAPI_ENDPOINT}/api/sendMessage`,
            new URLSearchParams({
                apiKey: process.env.WHAPI_API_KEY,
                phone,
                message,
            }),
            {
                headers: {
                    'Content-Type': 'application/x-www-form-urlencoded',
                },
            }
        );

        return {
            success: true,
            data: response.data,
        };
    } catch (error) {
        return {
            success: false,
            status: error.response?.status,
            data: error.response?.data,
            message: error.message,
        };
    }
}

Fungsi tersebut dapat digunakan kembali dari bagian lain dalam aplikasi.

Contohnya:

const result = await sendWhatsAppMessage(
    '6281234567890',
    'Pesanan #INV-001 telah berhasil diproses.'
);

console.log(result);

Dengan cara ini, proses request dan penanganan error tidak perlu ditulis berulang kali.

7. Mengirim Pesan Berdasarkan Proses Aplikasi

Pengiriman WhatsApp akan lebih berguna jika dipanggil berdasarkan event atau proses tertentu dalam aplikasi.

Misalnya ketika pembayaran berhasil:

const result = await sendWhatsAppMessage(
    '6281234567890',
    'Pembayaran untuk pesanan #INV-001 telah diterima.'
);

Contoh penggunaan lainnya:

  • Konfirmasi pesanan
  • Notifikasi pembayaran
  • Perubahan status pesanan
  • Pengingat pembayaran
  • Informasi pengiriman
  • Notifikasi aktivitas akun

Dengan pola tersebut, aplikasi Node.js dapat mengirim pesan secara otomatis berdasarkan kondisi atau aktivitas yang terjadi di dalam sistem.

8. Membuat Endpoint Internal untuk Pengiriman Pesan

Jika Node.js digunakan sebagai backend aplikasi, fungsi pengiriman WhatsApp dapat dipanggil melalui endpoint internal.

Contohnya menggunakan Express:

npm install express

Kemudian:

require('dotenv').config();

const express = require('express');
const axios = require('axios');

const app = express();

app.use(express.json());

app.post('/send-whatsapp', async (req, res) => {
    const { phone, message } = req.body;

    try {
        const response = await axios.post(
            `${process.env.WHAPI_ENDPOINT}/api/sendMessage`,
            new URLSearchParams({
                apiKey: process.env.WHAPI_API_KEY,
                phone,
                message,
            }),
            {
                headers: {
                    'Content-Type': 'application/x-www-form-urlencoded',
                },
            }
        );

        res.json({
            success: true,
            data: response.data,
        });
    } catch (error) {
        res.status(500).json({
            success: false,
            error: error.response?.data || error.message,
        });
    }
});

app.listen(3000, () => {
    console.log('Server berjalan pada port 3000');
});

Dengan struktur tersebut, aplikasi lain dapat mengirim data ke endpoint internal Node.js, kemudian Node.js meneruskan request ke Whapi.

Alurnya menjadi:

Aplikasi
   ↓
Node.js
   ↓
Whapi API
   ↓
Device WhatsApp
   ↓
Nomor Tujuan

9. Menangani Error Pengiriman

Request ke API dapat gagal karena beberapa kondisi.

Contohnya:

  • API key tidak valid
  • Device belum CONNECTED
  • Nomor tujuan tidak sesuai
  • Parameter request tidak lengkap
  • Endpoint tidak sesuai
  • API mengembalikan HTTP error

Gunakan try...catch untuk menangani error dari request.

Contoh:

try {
    const response = await axios.post(
        `${process.env.WHAPI_ENDPOINT}/api/sendMessage`,
        new URLSearchParams({
            apiKey: process.env.WHAPI_API_KEY,
            phone: '6281234567890',
            message: 'Pesan otomatis dari Node.js.',
        }),
        {
            headers: {
                'Content-Type': 'application/x-www-form-urlencoded',
            },
        }
    );

    console.log(response.data);
} catch (error) {
    console.error('Status:', error.response?.status);
    console.error('Response:', error.response?.data);
}

Logging seperti ini membantu proses debugging ketika request tidak berhasil.

10. Gunakan Queue untuk Pengiriman dalam Jumlah Besar

Jika aplikasi harus memproses banyak pengiriman, proses pengiriman sebaiknya tidak selalu dilakukan langsung di dalam request utama.

Node.js dapat menggunakan sistem queue untuk memisahkan pekerjaan pengiriman dari proses utama aplikasi.

Contohnya:

Request masuk
      ↓
Data disimpan ke queue
      ↓
Worker mengambil pekerjaan
      ↓
Node.js mengirim request ke Whapi
      ↓
Pesan diproses

Pendekatan ini membantu aplikasi menangani pekerjaan asynchronous tanpa membuat request utama harus menunggu seluruh proses pengiriman.

Implementasi queue dapat disesuaikan dengan arsitektur aplikasi dan kebutuhan volume pesan.

Alur Lengkap Integrasi Node.js dengan WhatsApp API

Secara keseluruhan, prosesnya dapat digambarkan sebagai berikut:

Node.js Application
        ↓
  Event / API Request
        ↓
  Function Pengiriman
        ↓
   HTTP POST Request
        ↓
     Whapi API
        ↓
 Device WhatsApp
        ↓
 Nomor WhatsApp Tujuan

Contohnya pada sistem e-commerce:

Pesanan dibuat
      ↓
Pembayaran berhasil
      ↓
Node.js menerima event
      ↓
Node.js membuat pesan
      ↓
Request dikirim ke Whapi
      ↓
WhatsApp mengirim pesan
      ↓
Pelanggan menerima notifikasi

Kesimpulan

Mengirim pesan WhatsApp dari Node.js dapat dilakukan dengan membuat HTTP request ke endpoint Whapi. Implementasi dasarnya terdiri dari menyiapkan API key, memastikan device terhubung, membuat request POST, lalu memproses respons dari API.

Node.js juga dapat mengintegrasikan proses pengiriman tersebut dengan event aplikasi, endpoint internal, maupun queue untuk kebutuhan asynchronous.

Untuk implementasi parameter dan format request yang lebih lengkap, gunakan dokumentasi Send Message Whapi.

Artikel Populer

Scroll to Top