Webhook

Pengujian & Contoh Kode

Copy page

Pengujian dan log pengiriman

Mengirim test event

Anda tidak perlu menunggu pesan atau perubahan status sungguhan untuk memastikan endpoint Anda berfungsi. Dari daftar webhook, klik ikon tabung reaksi (Test) pada baris webhook mana pun:

1. Pilih salah satu jenis event yang dilanggan webhook tersebut.
2. Klik Send Test.

Chatmo membuat payload contoh yang realistis untuk event tersebut dan mengirimkannya ke endpoint Anda saat itu juga, menggunakan jalur signing dan pengiriman yang sama seperti event sungguhan. Hasilnya (berhasil atau gagal, beserta error jika ada) langsung ditampilkan di modal, dan percobaan tersebut dicatat seperti pengiriman lainnya — ditandai dengan badge Test agar mudah dibedakan dari trafik sungguhan.

:::tip Uji setiap jenis event yang Anda langgan Payload contoh menggunakan data placeholder, tapi tetap menjalankan jalur parsing dan verifikasi signature yang sesungguhnya pada endpoint Anda — cara yang baik untuk menemukan handler yang bermasalah sebelum benar-benar berdampak. :::

Membaca log pengiriman

Klik View Logs pada baris webhook untuk melihat setiap grup percobaan pengiriman untuk endpoint tersebut.

Daftar ini menampilkan, per pengiriman:

Kolom	Deskripsi
Triggered At	Kapan event terjadi
Event Type	Event apa yang terpicu
Channel	Channel asal event
Status	SUCCESS, FAILED, atau PENDING
HTTP	Kode status HTTP yang dikembalikan endpoint Anda (kosong jika tidak pernah merespons)
Response Time	Berapa lama endpoint Anda merespons
Retries	Berapa kali percobaan dilakukan untuk pengiriman ini

Semua filter — rentang tanggal, status pengiriman, kode status HTTP, jenis event, dan pencarian — dijalankan di sisi server, sehingga tetap cepat meskipun riwayatnya banyak.

Melihat detail satu pengiriman

Klik View Log pada baris mana pun untuk membuka detail lengkap: payload dan header request persis yang dikirim Chatmo, serta status, header, dan body response persis yang dikembalikan endpoint Anda.

Mengirim ulang pengiriman

Dari tampilan detail, klik Resend untuk menandatangani ulang dan mengirim ulang event yang sama ke endpoint saat itu juga. Berguna setelah memperbaiki bug di sisi Anda — daripada menunggu event sungguhan berikutnya, Anda bisa memutar ulang event yang gagal. Resend selalu membuat entri log baru; entri asli tetap ada di log apa adanya untuk keperluan audit.

Contoh kode

Contoh berikut memverifikasi header X-Chatmo-Signature yang dijelaskan pada Autentikasi & Keamanan. Masing-masing menghitung HMAC-SHA256 dari raw request body menggunakan signing secret webhook Anda, lalu membandingkannya dengan header tersebut secara constant-time.

Ganti YOUR_SIGNING_SECRET dengan secret yang ditampilkan saat Anda membuat webhook.

cURL — simulasi pengiriman secara lokal

Berguna untuk menguji handler Anda tanpa menunggu event sungguhan atau menggunakan tombol Test di dashboard:

Code
SECRET="YOUR_SIGNING_SECRET"
BODY='{"event":"message.received","created_at":"2026-09-16T10:00:00Z","data":{"message_id":"test-1"}}'
SIGNATURE="sha256=$(printf '%s' "$BODY" | openssl dgst -sha256 -hmac "$SECRET" | awk '{print $2}')"

curl -X POST https://your-server.com/webhooks/chatmo \
  -H "Content-Type: application/json" \
  -H "X-Chatmo-Event: message.received" \
  -H "X-Chatmo-Signature: $SIGNATURE" \
  -d "$BODY"

Node.js

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

const SIGNING_SECRET = process.env.CHATMO_WEBHOOK_SECRET;

function isValidSignature(rawBody, signatureHeader) {
  if (!signatureHeader || !signatureHeader.startsWith('sha256=')) return false;
  const expected = crypto
    .createHmac('sha256', SIGNING_SECRET)
    .update(rawBody)
    .digest('hex');
  const provided = signatureHeader.slice('sha256='.length);
  const expectedBuf = Buffer.from(expected, 'hex');
  const providedBuf = Buffer.from(provided, 'hex');
  return (
    expectedBuf.length === providedBuf.length &&
    crypto.timingSafeEqual(expectedBuf, providedBuf)
  );
}

// express.raw() menjaga req.body tetap sebagai Buffer — dibutuhkan untuk verifikasi signature.
app.post('/webhooks/chatmo', express.raw({ type: 'application/json' }), (req, res) => {
  if (!isValidSignature(req.body, req.header('X-Chatmo-Signature'))) {
    return res.status(401).send('invalid signature');
  }
  const event = JSON.parse(req.body);
  res.status(200).send('ok');
  // proses `event` secara asynchronous di sini
});

Python

Code
import hashlib
import hmac
import os
from flask import Flask, request, abort

app = Flask(__name__)
SIGNING_SECRET = os.environ["CHATMO_WEBHOOK_SECRET"]

def is_valid_signature(raw_body: bytes, signature_header: str | None) -> bool:
    if not signature_header or not signature_header.startswith("sha256="):
        return False
    expected = hmac.new(SIGNING_SECRET.encode(), raw_body, hashlib.sha256).hexdigest()
    provided = signature_header.removeprefix("sha256=")
    return hmac.compare_digest(expected, provided)

@app.post("/webhooks/chatmo")
def chatmo_webhook():
    raw_body = request.get_data()  # raw bytes, bukan request.json
    if not is_valid_signature(raw_body, request.headers.get("X-Chatmo-Signature")):
        abort(401)

    event = request.get_json()
    # proses `event` secara asynchronous di sini
    return "ok", 200

PHP

Code
<?php

$signingSecret = getenv('CHATMO_WEBHOOK_SECRET');

function isValidSignature(string $rawBody, ?string $signatureHeader, string $secret): bool
{
    if ($signatureHeader === null || !str_starts_with($signatureHeader, 'sha256=')) {
        return false;
    }
    $expected = hash_hmac('sha256', $rawBody, $secret);
    $provided = substr($signatureHeader, strlen('sha256='));
    return hash_equals($expected, $provided);
}

$rawBody = file_get_contents('php://input'); // raw bytes, bukan $_POST
$signatureHeader = $_SERVER['HTTP_X_CHATMO_SIGNATURE'] ?? null;

if (!isValidSignature($rawBody, $signatureHeader, $signingSecret)) {
    http_response_code(401);
    exit('invalid signature');
}

$event = json_decode($rawBody, true);
http_response_code(200);
echo 'ok';
// proses $event secara asynchronous di sini

Go

Code
package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"io"
	"net/http"
	"os"
	"strings"
)

var signingSecret = os.Getenv("CHATMO_WEBHOOK_SECRET")

func isValidSignature(rawBody []byte, signatureHeader string) bool {
	const prefix = "sha256="
	if !strings.HasPrefix(signatureHeader, prefix) {
		return false
	}
	mac := hmac.New(sha256.New, []byte(signingSecret))
	mac.Write(rawBody)
	expected := hex.EncodeToString(mac.Sum(nil))
	provided := strings.TrimPrefix(signatureHeader, prefix)
	return hmac.Equal([]byte(expected), []byte(provided))
}

func chatmoWebhookHandler(w http.ResponseWriter, r *http.Request) {
	rawBody, err := io.ReadAll(r.Body)
	if err != nil {
		http.Error(w, "failed to read body", http.StatusBadRequest)
		return
	}

	if !isValidSignature(rawBody, r.Header.Get("X-Chatmo-Signature")) {
		http.Error(w, "invalid signature", http.StatusUnauthorized)
		return
	}

	var event map[string]any
	if err := json.Unmarshal(rawBody, &event); err != nil {
		http.Error(w, "invalid json", http.StatusBadRequest)
		return
	}

	w.WriteHeader(http.StatusOK)
	// proses `event` secara asynchronous di sini
}