Webhooks quick start

npm install standardwebhooks express

pip install standardwebhooks flask

go get github.com/standard-webhooks/standard-webhooks/libraries/go

const express = require("express");
const { Webhook } = require("standardwebhooks");

const wh = new Webhook(process.env.BODYGUARD_WEBHOOK_SECRET); // "whsec_..."
const app = express();

// Keep the raw body: the signature covers the exact bytes Bodyguard sent.
app.post("/webhook", express.raw({ type: "application/json" }), (req, res) => {
  let event;
  try {
    event = wh.verify(req.body, req.headers);
  } catch (err) {
    return res.status(400).send("Invalid signature");
  }

  switch (event.type) {
    case "message.updated":
      console.log("Message updated:", event.data.id, event.data);
      break;
    case "author.updated":
      console.log("Author updated:", event.data.id, event.data);
      break;
  }

  // Any 2xx response acknowledges the delivery.
  res.sendStatus(200);
});

app.listen(8080, () => console.log("Listening on port 8080"));

import os

from flask import Flask, request
from standardwebhooks import Webhook, WebhookVerificationError

wh = Webhook(os.environ["BODYGUARD_WEBHOOK_SECRET"])  # "whsec_..."
app = Flask(__name__)


@app.post("/webhook")
def webhook():
    # Use the raw body: the signature covers the exact bytes Bodyguard sent.
    try:
        event = wh.verify(request.get_data(), request.headers)
    except WebhookVerificationError:
        return "Invalid signature", 400

    if event["type"] == "message.updated":
        print("Message updated:", event["data"])
    elif event["type"] == "author.updated":
        print("Author updated:", event["data"])

    # Any 2xx response acknowledges the delivery.
    return "", 200


if __name__ == "__main__":
    app.run(port=8080)

package main

import (
	"encoding/json"
	"io"
	"log"
	"net/http"
	"os"

	standardwebhooks "github.com/standard-webhooks/standard-webhooks/libraries/go"
)

func main() {
	wh, err := standardwebhooks.NewWebhook(os.Getenv("BODYGUARD_WEBHOOK_SECRET")) // "whsec_..."
	if err != nil {
		log.Fatal(err)
	}

	http.HandleFunc("/webhook", func(w http.ResponseWriter, r *http.Request) {
		// Use the raw body: the signature covers the exact bytes Bodyguard sent.
		body, err := io.ReadAll(r.Body)
		if err != nil {
			http.Error(w, "Cannot read body", http.StatusBadRequest)
			return
		}

		if err := wh.Verify(body, r.Header); err != nil {
			http.Error(w, "Invalid signature", http.StatusBadRequest)
			return
		}

		var event struct {
			Type string          `json:"type"`
			Data json.RawMessage `json:"data"`
		}
		if err := json.Unmarshal(body, &event); err != nil {
			http.Error(w, "Invalid payload", http.StatusBadRequest)
			return
		}

		switch event.Type {
		case "message.updated":
			log.Printf("Message updated: %s", event.Data)
		case "author.updated":
			log.Printf("Author updated: %s", event.Data)
		}

		// Any 2xx response acknowledges the delivery.
		w.WriteHeader(http.StatusOK)
	})

	log.Println("Listening on port 8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

BODYGUARD_WEBHOOK_SECRET="whsec_..." node index.js

BODYGUARD_WEBHOOK_SECRET="whsec_..." python app.py

BODYGUARD_WEBHOOK_SECRET="whsec_..." go run .