Versa Soft - Proses 85% - Dokumentasi API

Pengenalan

WhatsApp Gateway API memungkinkan Anda mengirim dan menerima pesan WhatsApp melalui aplikasi Anda. API kami menggunakan protokol REST dengan format JSON untuk integrasi yang mudah.

Base URL

https://your-domain.com

URL terdeteksi berdasarkan domain website saat ini

Format Response

Semua response API menggunakan format JSON dengan struktur berikut:

{
  "success": true,
  "message": "Pesan berhasil dikirim",
  "data": {
    // Data response
  }
}

Autentikasi

API menggunakan Bearer Token untuk autentikasi. Anda dapat memperoleh token melalui endpoint login.

Login

POST /auth/login

Parameter	Tipe	Wajib	Deskripsi
email	string	Ya	Alamat email pengguna
password	string	Ya	Password pengguna

curl -X POST https://your-domain.com/auth/login \
  -H "Content-Type: application/json" \
  -d '{
    "email": "user@example.com",
    "password": "password123"
  }'

Menggunakan Token

Sertakan token di header Authorization untuk setiap request:

Authorization: Bearer YOUR_TOKEN_HERE

Manajemen Koneksi

Endpoint untuk mengelola koneksi WhatsApp Anda.

Buat Koneksi

POST /connection/create

Parameter	Tipe	Wajib	Deskripsi
name	string	Ya	Nama koneksi
description	string	Tidak	Deskripsi koneksi
webhook	string	Tidak	URL webhook untuk menerima pesan

Status Koneksi

GET /connection/status/:connectionId

curl -X GET https://your-domain.com/connection/status/CONNECTION_ID \
  -H "Authorization: Bearer YOUR_TOKEN"

Kirim Pesan

Endpoint untuk mengirim berbagai jenis pesan WhatsApp.

Kirim Pesan Teks

POST /message/send

Parameter	Tipe	Wajib	Deskripsi
connectionId	string	Ya	ID koneksi WhatsApp
to	string	Ya	Nomor tujuan (format: 628123456789)
message	string	Ya	Isi pesan

curl -X POST https://your-domain.com/message/send \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d '{
    "connectionId": "CONNECTION_ID",
    "to": "628123456789",
    "message": "Halo dari WhatsApp Gateway!"
  }'

Riwayat Pesan

GET /message/history

Parameter query yang tersedia:

connectionId - Filter berdasarkan koneksi
status - Filter berdasarkan status (success/failed)
page - Nomor halaman (default: 1)
limit - Item per halaman (default: 20)

Integrasi Platform

WhatsApp Gateway dapat diintegrasikan dengan berbagai platform dan sistem untuk otomatisasi bisnis yang lebih baik.

WHMCS Integration

Integrasikan dengan WHMCS untuk mengirim notifikasi otomatis kepada klien hosting Anda.

Paket WHMCS WhatsApp Gateway

Paket lengkap berisi modul WHMCS, file hook, dan dokumentasi instalasi.

Notifikasi Invoice: Invoice baru, jatuh tempo, dan pembayaran
Notifikasi Layanan: Suspend, unsuspend, dan aktivasi layanan
Notifikasi Klien: Pesan selamat datang untuk klien baru
Notifikasi Support: Tiket support baru dan balasan

WordPress Integration

Integrasikan dengan WordPress untuk notifikasi otomatis dari website Anda.

// WordPress Plugin Hook Example
add_action('wp_insert_post', 'send_whatsapp_notification');

function send_whatsapp_notification($post_id) {
    $post = get_post($post_id);
    
    if ($post->post_status == 'publish') {
        $data = array(
            'connectionId' => 'YOUR_CONNECTION_ID',
            'to' => '628123456789',
            'message' => 'Post baru: ' . $post->post_title
        );
        
        wp_remote_post('https://your-domain.com/message/send', array(
            'headers' => array(
                'Authorization' => 'Bearer YOUR_TOKEN',
                'Content-Type' => 'application/json'
            ),
            'body' => json_encode($data)
        ));
    }
}

Laravel Integration

Integrasikan dengan aplikasi Laravel menggunakan HTTP Client atau package khusus.

// Laravel Service Class
baseUrl = config('whatsapp.base_url');
        $this->token = config('whatsapp.token');
    }
    
    public function sendMessage($connectionId, $to, $message)
    {
        return Http::withToken($this->token)
            ->post($this->baseUrl . '/message/send', [
                'connectionId' => $connectionId,
                'to' => $to,
                'message' => $message
            ]);
    }
    
    public function getConnections()
    {
        return Http::withToken($this->token)
            ->get($this->baseUrl . '/connection/list');
    }
}

Node.js Integration

Integrasikan dengan aplikasi Node.js menggunakan axios atau fetch API.

// Node.js Integration Example
const axios = require('axios');

class WhatsAppGateway {
    constructor(baseUrl, token) {
        this.baseUrl = baseUrl;
        this.token = token;
        this.client = axios.create({
            baseURL: baseUrl,
            headers: {
                'Authorization': `Bearer ${token}`,
                'Content-Type': 'application/json'
            }
        });
    }
    
    async sendMessage(connectionId, to, message) {
        try {
            const response = await this.client.post('/message/send', {
                connectionId,
                to,
                message
            });
            return response.data;
        } catch (error) {
            throw new Error(`Failed to send message: ${error.message}`);
        }
    }
    
    async getConnections() {
        try {
            const response = await this.client.get('/connection/list');
            return response.data;
        } catch (error) {
            throw new Error(`Failed to get connections: ${error.message}`);
        }
    }
}

// Usage
const whatsapp = new WhatsAppGateway('https://your-domain.com', 'YOUR_TOKEN');
whatsapp.sendMessage('CONNECTION_ID', '628123456789', 'Hello from Node.js!');

Python Integration

Integrasikan dengan aplikasi Python menggunakan requests library.

# Python Integration Example
import requests
import json

class WhatsAppGateway:
    def __init__(self, base_url, token):
        self.base_url = base_url
        self.headers = {
            'Authorization': f'Bearer {token}',
            'Content-Type': 'application/json'
        }
    
    def send_message(self, connection_id, to, message):
        url = f"{self.base_url}/message/send"
        data = {
            'connectionId': connection_id,
            'to': to,
            'message': message
        }
        
        response = requests.post(url, headers=self.headers, json=data)
        return response.json()
    
    def get_connections(self):
        url = f"{self.base_url}/connection/list"
        response = requests.get(url, headers=self.headers)
        return response.json()

# Usage
whatsapp = WhatsAppGateway('https://your-domain.com', 'YOUR_TOKEN')
result = whatsapp.send_message('CONNECTION_ID', '628123456789', 'Hello from Python!')

PHP Integration

Integrasikan dengan aplikasi PHP menggunakan cURL atau Guzzle HTTP.

baseUrl = $baseUrl;
        $this->token = $token;
    }
    
    public function sendMessage($connectionId, $to, $message) {
        $url = $this->baseUrl . '/message/send';
        $data = json_encode([
            'connectionId' => $connectionId,
            'to' => $to,
            'message' => $message
        ]);
        
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $url);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'Authorization: Bearer ' . $this->token,
            'Content-Type: application/json'
        ]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        
        $response = curl_exec($ch);
        curl_close($ch);
        
        return json_decode($response, true);
    }
    
    public function getConnections() {
        $url = $this->baseUrl . '/connection/list';
        
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $url);
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'Authorization: Bearer ' . $this->token
        ]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        
        $response = curl_exec($ch);
        curl_close($ch);
        
        return json_decode($response, true);
    }
}

// Usage
$whatsapp = new WhatsAppGateway('https://your-domain.com', 'YOUR_TOKEN');
$result = $whatsapp->sendMessage('CONNECTION_ID', '628123456789', 'Hello from PHP!');
?>

Zapier Integration

Integrasikan dengan Zapier untuk menghubungkan dengan 5000+ aplikasi lainnya.

Buat Webhook di Zapier: Pilih "Webhooks by Zapier" sebagai trigger
Konfigurasi URL: Gunakan endpoint API WhatsApp Gateway sebagai action
Setup Authentication: Tambahkan Bearer token di header
Test Integration: Kirim test message untuk memastikan koneksi

Make.com (Integromat) Integration

Integrasikan dengan Make.com untuk otomatisasi workflow yang kompleks.

HTTP Module: Gunakan HTTP module untuk memanggil API
JSON Parser: Parse response dari API untuk data processing
Error Handling: Setup error handling untuk retry mechanism
Scheduling: Jadwalkan pengiriman pesan otomatis

Google Sheets Integration

Integrasikan dengan Google Sheets menggunakan Google Apps Script.

// Google Apps Script Integration
function sendWhatsAppFromSheet() {
  const sheet = SpreadsheetApp.getActiveSheet();
  const data = sheet.getDataRange().getValues();
  
  // Skip header row
  for (let i = 1; i < data.length; i++) {
    const [name, phone, message] = data[i];
    
    if (phone && message) {
      sendWhatsAppMessage(phone, message);
      Utilities.sleep(1000); // Delay 1 second between messages
    }
  }
}

function sendWhatsAppMessage(phone, message) {
  const url = 'https://your-domain.com/message/send';
  const token = 'YOUR_TOKEN';
  
  const payload = {
    'connectionId': 'YOUR_CONNECTION_ID',
    'to': phone,
    'message': message
  };
  
  const options = {
    'method': 'POST',
    'headers': {
      'Authorization': 'Bearer ' + token,
      'Content-Type': 'application/json'
    },
    'payload': JSON.stringify(payload)
  };
  
  try {
    const response = UrlFetchApp.fetch(url, options);
    console.log('Message sent to ' + phone + ': ' + response.getContentText());
  } catch (error) {
    console.error('Error sending message to ' + phone + ': ' + error.toString());
  }
}

E-commerce Integration

Integrasikan dengan platform e-commerce untuk notifikasi order dan customer service.

WooCommerce Integration

// WooCommerce Hook Example
add_action('woocommerce_order_status_completed', 'send_order_completion_whatsapp');

function send_order_completion_whatsapp($order_id) {
    $order = wc_get_order($order_id);
    $phone = $order->get_billing_phone();
    $customer_name = $order->get_billing_first_name();
    
    $message = "Halo {$customer_name}, pesanan #{$order_id} Anda telah selesai diproses. Terima kasih!";
    
    // Send WhatsApp message
    wp_remote_post('https://your-domain.com/message/send', array(
        'headers' => array(
            'Authorization' => 'Bearer YOUR_TOKEN',
            'Content-Type' => 'application/json'
        ),
        'body' => json_encode(array(
            'connectionId' => 'YOUR_CONNECTION_ID',
            'to' => $phone,
            'message' => $message
        ))
    ));
}

Shopify Integration

// Shopify Webhook Handler (Node.js)
app.post('/shopify/webhook/order/paid', (req, res) => {
    const order = req.body;
    
    const message = `Terima kasih ${order.customer.first_name}! Pembayaran order #${order.order_number} telah diterima. Pesanan Anda sedang diproses.`;
    
    // Send WhatsApp notification
    sendWhatsAppMessage(order.customer.phone, message);
    
    res.status(200).send('OK');
});

CRM Integration

Integrasikan dengan sistem CRM untuk komunikasi customer yang lebih baik.

Lead Notifications: Notifikasi WhatsApp untuk lead baru
Follow-up Reminders: Pengingat follow-up otomatis
Deal Updates: Update status deal kepada tim sales
Customer Support: Integrasi dengan sistem ticketing

Database Integration

Integrasikan dengan database untuk trigger otomatis berdasarkan perubahan data.

-- MySQL Trigger Example
DELIMITER $$

CREATE TRIGGER send_whatsapp_on_order_insert
AFTER INSERT ON orders
FOR EACH ROW
BEGIN
    -- Call external API using UDF or stored procedure
    -- This requires MySQL UDF for HTTP requests
    SELECT send_whatsapp_message(
        NEW.customer_phone,
        CONCAT('Order baru #', NEW.id, ' telah diterima. Total: Rp', NEW.total)
    );
END$$

DELIMITER ;

Monitoring & Analytics Integration

Integrasikan dengan sistem monitoring untuk alert dan notifikasi sistem.

Server Monitoring: Alert WhatsApp untuk downtime server
Application Errors: Notifikasi error aplikasi real-time
Performance Alerts: Alert untuk performance degradation
Security Alerts: Notifikasi untuk aktivitas mencurigakan

Webhooks

Webhooks memungkinkan Anda menerima notifikasi real-time ketika pesan masuk diterima. Konfigurasikan URL webhook Anda di pengaturan koneksi untuk menerima notifikasi otomatis.

Konfigurasi Webhook

Atur URL webhook Anda saat membuat atau memperbarui koneksi. Sistem akan otomatis mengirim POST request ke URL Anda ketika pesan diterima.

Format Webhook

Ketika pesan masuk diterima, sistem akan mengirim POST request ke URL webhook Anda dengan payload berikut:

{
  "connectionId": "CONNECTION_ID",
  "from": "628123456789",
  "message": "Pesan dari pengguna",
  "messageType": "text",
  "timestamp": "2024-01-01T12:00:00Z",
  "messageId": "MESSAGE_ID",
  "isGroup": false,
  "fromMe": false
}

Tipe Pesan

Field messageType dapat memiliki nilai berikut:

text - Pesan teks
image - Pesan gambar
video - Pesan video
audio - Pesan audio
document - Pesan dokumen
sticker - Pesan stiker

Test Webhook

POST /webhook/test/:connectionId

Test konfigurasi webhook Anda dengan mengirim pesan test:

curl -X POST https://your-domain.com/webhook/test/CONNECTION_ID \
  -H "Authorization: Bearer YOUR_TOKEN"

Ambil Pesan Masuk

GET /webhook/messages/:connectionId

Ambil pesan masuk untuk koneksi tertentu:

curl -X GET https://your-domain.com/webhook/messages/CONNECTION_ID \
  -H "Authorization: Bearer YOUR_TOKEN"

Parameter query:

page - Nomor halaman (default: 1)
limit - Pesan per halaman (default: 20)
since - Ambil pesan sejak timestamp

Statistik Webhook

GET /webhook/stats/:connectionId

Dapatkan statistik webhook untuk koneksi:

curl -X GET https://your-domain.com/webhook/stats/CONNECTION_ID \
  -H "Authorization: Bearer YOUR_TOKEN"

Verifikasi Webhook

Pastikan endpoint webhook Anda:

Mengembalikan status code 200 untuk konfirmasi penerimaan
Merespons dalam 10 detik (batas timeout)
Menerima POST request dengan JSON payload
Menangani pesan duplikat dengan baik

Contoh Webhook Handler

Berikut contoh webhook handler dalam Node.js:

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

app.use(express.json());

app.post('/webhook', (req, res) => {
  const { connectionId, from, message, messageType } = req.body;
  
  console.log(`Pesan baru dari ${from}: ${message}`);
  
  // Proses pesan di sini
  // Logika bisnis Anda di sini
  
  // Selalu respons dengan 200 OK
  res.status(200).json({ success: true });
});

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

Penanganan Error

API menggunakan kode status HTTP standar untuk menunjukkan keberhasilan atau kegagalan request.

Kode Status

Kode	Status	Deskripsi
200	OK	Request berhasil
400	Bad Request	Parameter tidak valid
401	Unauthorized	Token tidak valid atau hilang
404	Not Found	Resource tidak ditemukan
500	Internal Server Error	Error server

Format Response Error

{
  "success": false,
  "message": "Deskripsi error",
  "error": "Error detail (jika tersedia)"
}

Dokumentasi API