Contoh Implementasi Webhook

Pengenalan

Contoh implementasi webhook lengkap dalam berbagai bahasa pemrograman dan framework.

Pilih contoh yang sesuai dengan technology stack Anda.

Daftar Isi

Node.js/Express
Python/Flask
PHP
Go
Ruby

Node.js/Express

Implementasi Lengkap

const express = require('express');
const bodyParser = require('body-parser');
const app = express();

// Konfigurasi
const SECRET_KEY = process.env.WEBHOOK_SECRET_KEY || 'your_secret_key';
const PORT = process.env.PORT || 3000;

// Middleware
app.use(bodyParser.json());

// Simpan event yang sudah diproses (di produksi, gunakan database)
const processedEvents = new Set();

// Bersihkan event yang diproses secara berkala (simpan 10,000 terakhir)
setInterval(() => {
  if (processedEvents.size > 10000) {
    const events = Array.from(processedEvents);
    processedEvents.clear();
    events.slice(5000).forEach(id => processedEvents.add(id));
  }
}, 3600000); // Setiap jam

// Endpoint webhook
app.post('/webhook', async (req, res) => {
  try {
    // Validasi autentikasi
    const authHeader = req.headers.authorization;
    if (authHeader !== SECRET_KEY) {
      console.error('Secret webhook tidak valid');
      return res.status(401).json({ error: 'Unauthorized' });
    }
    
    const { event, timestamp, conversation_id, message } = req.body;
    
    // Deduplikasi event
    const eventId = `${event}_${message.id}`;
    if (processedEvents.has(eventId)) {
      console.log('Event duplikat, melewati');
      return res.status(200).send('OK');
    }
    
    // Proses berdasarkan jenis event
    switch (event) {
      case 'channel.message_in':
        await handleIncomingMessage(message, conversation_id);
        break;
      case 'agent.message_out':
        await handleAgentMessage(message, conversation_id);
        break;
      case 'ai.message_generated':
        await handleAIMessage(message, conversation_id);
        break;
      case 'device.connected':
        await handleDeviceConnected(req.body.device);
        break;
      case 'device.disconnected':
        await handleDeviceDisconnected(req.body.device);
        break;
      default:
        console.log('Jenis event tidak dikenal:', event);
    }
    
    // Tandai sebagai sudah diproses
    processedEvents.add(eventId);
    
    // Respons segera
    res.status(200).send('OK');
  } catch (error) {
    console.error('Error webhook:', error);
    res.status(500).send('Error');
  }
});

// Handler event
async function handleIncomingMessage(message, conversationId) {
  console.log('Pesan baru dari:', message.sender_name);
  console.log('Konten:', message.content.text);
  console.log('Channel:', message.channel.name);
  
  // Logika bisnis Anda di sini
  // Contoh: Simpan ke database
  // await db.messages.create({ ...message, conversationId });
}

async function handleAgentMessage(message, conversationId) {
  console.log('Agen', message.agent.name, 'mengirim pesan');
  
  // Logika bisnis Anda di sini
}

async function handleAIMessage(message, conversationId) {
  console.log('AI', message.ai.name, 'menghasilkan respons');
  
  // Logika bisnis Anda di sini
}

async function handleDeviceConnected(device) {
  console.log('Perangkat', device.name, 'sekarang terhubung');
  
  // Logika bisnis Anda di sini
}

async function handleDeviceDisconnected(device) {
  console.log('Perangkat', device.name, 'sekarang terputus');
  
  // Logika bisnis Anda di sini
}

// Health check
app.get('/health', (req, res) => {
  res.status(200).json({ status: 'healthy', processedEvents: processedEvents.size });
});

// Jalankan server
app.listen(PORT, () => {
  console.log(`Server webhook berjalan di port ${PORT}`);
});

Python/Flask

Implementasi Lengkap

from flask import Flask, request, jsonify
from collections import deque
import os
from datetime import datetime
import threading
import time

# Konfigurasi
app = Flask(__name__)
SECRET_KEY = os.getenv('WEBHOOK_SECRET_KEY', 'your_secret_key')
PORT = os.getenv('PORT', 3000)

# Simpan event yang sudah diproses (di produksi, gunakan database)
processed_events = deque(maxlen=10000)

def cleanup_processed_events():
    """Pembersihan berkala (tidak diperlukan dengan deque maxlen)"""
    pass

# Jalankan thread pembersihan
cleanup_thread = threading.Thread(target=cleanup_processed_events, daemon=True)
cleanup_thread.start()

@app.route('/webhook', methods=['POST'])
def webhook():
    try:
        # Validasi autentikasi
        auth_header = request.headers.get('Authorization')
        if auth_header != SECRET_KEY:
            print('Secret webhook tidak valid')
            return jsonify({'error': 'Unauthorized'}), 401
        
        data = request.get_json()
        event = data.get('event')
        timestamp = data.get('timestamp')
        conversation_id = data.get('conversation_id')
        message = data.get('message')
        
        # Deduplikasi event
        event_id = f"{event}_{message['id']}"
        if event_id in processed_events:
            print(f'Event duplikat: {event_id}')
            return 'OK', 200
        
        # Proses berdasarkan jenis event
        if event == 'channel.message_in':
            handle_incoming_message(message, conversation_id)
        elif event == 'agent.message_out':
            handle_agent_message(message, conversation_id)
        elif event == 'ai.message_generated':
            handle_ai_message(message, conversation_id)
        elif event == 'device.connected':
            handle_device_connected(data['device'])
        elif event == 'device.disconnected':
            handle_device_disconnected(data['device'])
        else:
            print(f'Jenis event tidak dikenal: {event}')
        
        # Tandai sebagai sudah diproses
        processed_events.append(event_id)
        
        return 'OK', 200
    except Exception as e:
        print(f'Error webhook: {str(e)}')
        return 'Error', 500

def handle_incoming_message(message, conversation_id):
    print(f"Pesan baru dari: {message['sender_name']}")
    print(f"Konten: {message['content']['text']}")
    print(f"Channel: {message['channel']['name']}")
    # Logika bisnis Anda di sini

def handle_agent_message(message, conversation_id):
    print(f"Agen {message['agent']['name']} mengirim pesan")
    # Logika bisnis Anda di sini

def handle_ai_message(message, conversation_id):
    print(f"AI {message['ai']['name']} menghasilkan respons")
    # Logika bisnis Anda di sini

def handle_device_connected(device):
    print(f"Perangkat {device['name']} sekarang terhubung")
    # Logika bisnis Anda di sini

def handle_device_disconnected(device):
    print(f"Perangkat {device['name']} sekarang terputus")
    # Logika bisnis Anda di sini

@app.route('/health', methods=['GET'])
def health():
    return jsonify({
        'status': 'healthy',
        'processed_events': len(processed_events)
    })

if __name__ == '__main__':
    app.run(port=PORT, debug=True)

PHP

Implementasi Lengkap

<?php
$SECRET_KEY = getenv('WEBHOOK_SECRET_KEY') ?: 'your_secret_key';
$processedEvents = [];

function webhookHandler() {
    global $SECRET_KEY, $processedEvents;
    
    // Validasi autentikasi
    $authHeader = $_SERVER['HTTP_AUTHORIZATION'] ?? '';
    if ($authHeader !== $SECRET_KEY) {
        error_log('Secret webhook tidak valid');
        http_response_code(401);
        echo json_encode(['error' => 'Unauthorized']);
        return;
    }
    
    // Dapatkan data POST
    $data = json_decode(file_get_contents('php://input'), true);
    
    if (!isset($data['event'], $data['message'])) {
        error_log('Struktur payload tidak valid');
        http_response_code(400);
        echo json_encode(['error' => 'Invalid payload']);
        return;
    }
    
    $event = $data['event'];
    $message = $data['message'];
    $conversationId = $data['conversation_id'] ?? '';
    
    // Deduplikasi event
    $eventId = $event . '_' . ($message['id'] ?? '');
    if (in_array($eventId, $processedEvents)) {
        error_log("Event duplikat: $eventId");
        http_response_code(200);
        echo 'OK';
        return;
    }
    
    // Proses berdasarkan jenis event
    switch ($event) {
        case 'channel.message_in':
            handleIncomingMessage($message, $conversationId);
            break;
        case 'agent.message_out':
            handleAgentMessage($message, $conversationId);
            break;
        case 'ai.message_generated':
            handleAIMessage($message, $conversationId);
            break;
        case 'device.connected':
            handleDeviceConnected($data['device']);
            break;
        case 'device.disconnected':
            handleDeviceDisconnected($data['device']);
            break;
        default:
            error_log("Jenis event tidak dikenal: $event");
    }
    
    // Tandai sebagai sudah diproses
    $processedEvents[] = $eventId;
    
    // Batasi array event yang diproses
    if (count($processedEvents) > 10000) {
        array_shift($processedEvents);
    }
    
    http_response_code(200);
    echo 'OK';
}

function handleIncomingMessage($message, $conversationId) {
    error_log("Pesan baru dari: {$message['sender_name']}");
    error_log("Konten: {$message['content']['text']}");
    error_log("Channel: {$message['channel']['name']}");
    // Logika bisnis Anda di sini
}

function handleAgentMessage($message, $conversationId) {
    error_log("Agen {$message['agent']['name']} mengirim pesan");
    // Logika bisnis Anda di sini
}

function handleAIMessage($message, $conversationId) {
    error_log("AI {$message['ai']['name']} menghasilkan respons");
    // Logika bisnis Anda di sini
}

function handleDeviceConnected($device) {
    error_log("Perangkat {$device['name']} sekarang terhubung");
    // Logika bisnis Anda di sini
}

function handleDeviceDisconnected($device) {
    error_log("Perangkat {$device['name']} sekarang terputus");
    // Logika bisnis Anda di sini
}

// Health check
function healthCheck() {
    http_response_code(200);
    echo json_encode([
        'status' => 'healthy',
        'processed_events' => count($processedEvents)
    ]);
}

// Penanganan route
$requestUri = $_SERVER['REQUEST_URI'] ?? '';

if (strpos($requestUri, '/webhook') !== false) {
    webhookHandler();
} elseif (strpos($requestUri, '/health') !== false) {
    healthCheck();
}

// Jalankan handler
webhookHandler();
?>

Go

Implementasi Lengkap

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "os"
    "sync"
    "time"
)

// Konfigurasi
const (
    SECRET_KEY = os.Getenv("WEBHOOK_SECRET_KEY")
    PORT      = os.Getenv("PORT")
)

var (
    processedEvents = make(map[string]bool)
    mu            sync.RWMutex
)

// Struktur event
type WebhookPayload struct {
    Event          string      `json:"event"`
    Timestamp      int64       `json:"timestamp"`
    ConversationID string      `json:"conversation_id"`
    Message        Message     `json:"message"`
    Device         Device      `json:"device,omitempty"`
}

type Message struct {
    ID         string       `json:"id"`
    SenderName string       `json:"sender_name"`
    Channel    Channel      `json:"channel"`
    Bisnis     Bisnis      `json:"bisnis"`
    User       User         `json:"user"`
    Content    Content      `json:"content"`
    Agent      *Agent       `json:"agent,omitempty"`
    AI         *AI          `json:"ai,omitempty"`
}

type Channel struct {
    ID     string `json:"id"`
    Name   string `json:"name"`
    Engine string `json:"engine"`
}

type Content struct {
    Type         string       `json:"type"`
    Text         string       `json:"text,omitempty"`
    Attachments  []Attachment  `json:"attachments,omitempty"`
}

// ... definisi struct lainnya

func webhookHandler(w http.ResponseWriter, r *http.Request) {
    // Validasi method
    if r.Method != http.MethodPost {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }
    
    // Validasi autentikasi
    authHeader := r.Header.Get("Authorization")
    if authHeader != SECRET_KEY {
        log.Println("Secret webhook tidak valid")
        http.Error(w, "Unauthorized", http.StatusUnauthorized)
        return
    }
    
    // Parse payload
    var payload WebhookPayload
    err := json.NewDecoder(r.Body).Decode(&payload)
    if err != nil {
        log.Printf("Error decoding payload: %v", err)
        http.Error(w, "Invalid payload", http.StatusBadRequest)
        return
    }
    
    // Deduplikasi event
    eventID := fmt.Sprintf("%s_%s", payload.Event, payload.Message.ID)
    mu.RLock()
    _, exists := processedEvents[eventID]
    mu.RUnlock()
    
    if exists {
        log.Printf("Event duplikat: %s", eventID)
        w.WriteHeader(http.StatusOK)
        fmt.Fprintf(w, "OK")
        return
    }
    
    // Proses berdasarkan jenis event
    switch payload.Event {
    case "channel.message_in":
        handleIncomingMessage(payload.Message, payload.ConversationID)
    case "agent.message_out":
        handleAgentMessage(payload.Message, payload.ConversationID)
    case "ai.message_generated":
        handleAIMessage(payload.Message, payload.ConversationID)
    case "device.connected":
        handleDeviceConnected(payload.Device)
    case "device.disconnected":
        handleDeviceDisconnected(payload.Device)
    default:
        log.Printf("Jenis event tidak dikenal: %s", payload.Event)
    }
    
    // Tandai sebagai sudah diproses
    mu.Lock()
    processedEvents[eventID] = true
    mu.Unlock()
    
    // Respons segera
    w.WriteHeader(http.StatusOK)
    fmt.Fprintf(w, "OK")
}

func handleIncomingMessage(message Message, conversationID string) {
    log.Printf("Pesan baru dari: %s", message.SenderName)
    log.Printf("Konten: %s", message.Content.Text)
    log.Printf("Channel: %s", message.Channel.Name)
    // Logika bisnis Anda di sini
}

func handleAgentMessage(message Message, conversationID string) {
    log.Printf("Agen %s mengirim pesan", message.Agent.Name)
    // Logika bisnis Anda di sini
}

func handleAIMessage(message Message, conversationID string) {
    log.Printf("AI %s menghasilkan respons", message.AI.Name)
    // Logika bisnis Anda di sini
}

func handleDeviceConnected(device Device) {
    log.Printf("Perangkat %s sekarang terhubung", device.Name)
    // Logika bisnis Anda di sini
}

func handleDeviceDisconnected(device Device) {
    log.Printf("Perangkat %s sekarang terputus", device.Name)
    // Logika bisnis Anda di sini
}

func healthHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]interface{}{
        "status":           "healthy",
        "processed_events": len(processedEvents),
    })
}

func main() {
    // Bersihkan event yang diproses secara berkala
    go func() {
        for {
            time.Sleep(time.Hour)
            mu.Lock()
            if len(processedEvents) > 10000 {
                // Hapus 5000 event tertua
                count := 0
                for key := range processedEvents {
                    if count >= 5000 {
                        delete(processedEvents, key)
                    }
                    count++
                }
            }
            mu.Unlock()
        }
    }()
    
    // Setup route
    http.HandleFunc("/webhook", webhookHandler)
    http.HandleFunc("/health", healthHandler)
    
    // Jalankan server
    port := PORT
    if port == "" {
        port = "3000"
    }
    log.Printf("Server webhook berjalan di port %s", port)
    log.Fatal(http.ListenAndServe(":"+port, nil))
}

Menguji Webhook Anda

Uji dengan curl

# Uji webhook channel.message_in
curl -X POST https://your-domain.com/webhook \
  -H "Authorization: your_secret_key" \
  -H "Content-Type: application/json" \
  -d '{
    "event": "channel.message_in",
    "timestamp": 1738056000,
    "conversation_id": "conv_test123",
    "conversation_label": "Test User",
    "need_human": 0,
    "message": {
      "id": "msg_test456",
      "sender_name": "Test User",
      "channel": {
        "id": "channel_test",
        "name": "WhatsApp Business",
        "engine": "wa"
      },
      "bisnis": {
        "id": "biz_test",
        "name": "Test Business"
      },
      "user": {
        "id": "merchant_test",
        "name": "Test Merchant"
      },
      "content": {
        "type": "text",
        "text": "Halo, saya butuh bantuan"
      }
    }
  }'

Uji dengan Postman

Buat request baru
- Method: POST
- URL: https://your-domain.com/webhook
Tambahkan header
- Authorization: your_secret_key
- Content-Type: application/json

Tambahkan body (raw JSON)

{
  "event": "channel.message_in",
  "timestamp": 1738056000,
  "conversation_id": "conv_test123",
  "message": {
    "id": "msg_test456",
    "sender_name": "Test User",
    "channel": {
      "name": "WhatsApp Business",
      "engine": "wa"
    },
    "content": {
      "type": "text",
      "text": "Pesan test"
    }
  }
}

Kirim request dan verifikasi Anda menerima 200 OK

Selalu uji dengan payload real sebelum deploy ke produksi.

Checklist Produksi

Sebelum go live, pastikan Anda telah menyelesaikan langkah-langkah ini.

Langkah Selanjutnya

Konfigurasi

Siapkan webhook di dashboard

Praktik Terbaik

Pastikan penanganan yang andal

Referensi Event

Dokumentasi event lengkap

Troubleshooting

Debug masalah webhook

Troubleshooting Webhook

Webhooks

Event Webhook

Referensi Webhook

Pengenalan

Daftar Isi

Node.js/Express

Implementasi Lengkap

Python/Flask

Implementasi Lengkap

PHP

Implementasi Lengkap

Go

Implementasi Lengkap

Menguji Webhook Anda

Uji dengan curl

Uji dengan Postman

Checklist Produksi

Langkah Selanjutnya

Konfigurasi

Praktik Terbaik

Referensi Event

Troubleshooting

​Pengenalan

​Daftar Isi

​Node.js/Express

​Implementasi Lengkap

​Python/Flask

​Implementasi Lengkap

​PHP

​Implementasi Lengkap

​Go

​Implementasi Lengkap

​Menguji Webhook Anda

​Uji dengan curl

​Uji dengan Postman

​Checklist Produksi

​Langkah Selanjutnya

Konfigurasi

Praktik Terbaik

Referensi Event

Troubleshooting

Pengenalan

Daftar Isi

Node.js/Express

Implementasi Lengkap

Python/Flask

Implementasi Lengkap

PHP

Implementasi Lengkap

Go

Implementasi Lengkap

Menguji Webhook Anda

Uji dengan curl

Uji dengan Postman

Checklist Produksi

Langkah Selanjutnya