"use client"; import React, { useState } from "react"; import { BookOpen, ChevronDown, ChevronRight, Copy } from "lucide-react"; type EventType = { type: string; label: string; description: string; example?: unknown }; const RETRIES = "1 minute, 5 minutes, 30 minutes, 2 hours and 12 hours"; const VERIFY_NODE = `// Node.js / Express — check the signature before trusting a request. const crypto = require("crypto"); const SECRET = process.env.CROSSEVENTS_WEBHOOK_SECRET; // whsec_… app.post("/crossevents-hook", express.raw({ type: "application/json" }), (req, res) => { const header = req.get("X-CrossEvents-Signature") || ""; // t=1767225600,v1=5f0c… const { t, v1 } = Object.fromEntries(header.split(",").map(p => p.split("="))); const body = req.body.toString("utf8"); // the raw body, unparsed const expected = crypto.createHmac("sha256", SECRET).update(\`\${t}.\${body}\`).digest("hex"); const fresh = Math.abs(Date.now() / 1000 - Number(t)) < 300; // within 5 minutes if (!fresh || !v1 || !crypto.timingSafeEqual(Buffer.from(v1), Buffer.from(expected))) { return res.status(400).send("bad signature"); } const event = JSON.parse(body); // Deliveries can repeat: skip an event.id you've already handled. res.sendStatus(200); // answer quickly, then do the slow work handle(event); });`; const VERIFY_PHP = ` 300 || !hash_equals($expected, $sig['v1'] ?? '')) { http_response_code(400); exit('bad signature'); } $event = json_decode($body, true); http_response_code(200);`; function CopyButton({ text, label = "Copy" }: { text: string; label?: string }) { const [done, setDone] = useState(false); return ( ); } function Code({ text }: { text: string }) { return (
{text}
); } const H = ({ children }: { children: React.ReactNode }) =>

{children}

; /** * Site settings → Webhooks → "How webhooks work": what arrives, when, how to check it's from us, * and an example of every event type, for whoever builds the receiving side. */ export function WebhookGuide({ eventTypes, keepDays, defaultOpen = false }: { eventTypes: EventType[]; keepDays: number; defaultOpen?: boolean }) { const [open, setOpen] = useState(defaultOpen); const [openType, setOpenType] = useState(null); const [lang, setLang] = useState<"node" | "php">("node"); const envelope = (t: EventType) => JSON.stringify({ id: "evt_3f9c2a1e-6d4b-4c8e-9a51-2b7d0e6f1c34", type: t.type, createdAt: "2026-10-29T08:16:01.512Z", data: t.example ?? {} }, null, 2); return (
{open && (
What happens
  1. Something happens here, such as a registration or a payment, that one of your webhooks is set to send.
  2. A second or two later, an HTTP POST with a JSON body goes to that webhook's address. Everything is sent from the server; nothing comes from people's browsers.
  3. Your side answers with any 2xx status within 10 seconds, and the delivery is done.
  4. Anything else counts as a failure: another status, no answer, or a redirect (redirects aren't followed). The delivery is tried again after {RETRIES}, then marked failed. You can send any delivery again from its Delivery log.
Using it without writing code

In Zapier, use Webhooks by Zapier → Catch Hook; in Make, use Webhooks → Custom webhook. Paste the address it gives you here, choose the events, then click Send test. The fields in the examples below become available to map into ChurchSuite, Planning Center, a spreadsheet, Mailchimp and so on.

What arrives

Every request has the same envelope. data depends on the type (see the examples below).

FieldMeaning
idThe event's id (evt_…). It stays the same on retries, so use it to skip events you've already handled.
typeThe event type, e.g. registration.paid. The Send test button sends webhook.test.
createdAtWhen it happened (ISO 8601, UTC).
dataThe details. Amounts are in rand; dates are ISO 8601 in UTC.

Headers:

Content-Typeapplication/json
User-AgentCrossEvents-Webhooks/1
X-CrossEvents-EventThe event type, the same as type.
X-CrossEvents-DeliveryThis delivery's id. Each webhook gets its own, and it's the same on retries.
X-CrossEvents-Signaturet=<unix seconds>,v1=<signature>, explained below.
Checking it came from here

Anyone who knows the address could post to it, so check the signature before acting on a request. v1 is the HMAC-SHA256, in hex, of t, a full stop, and the raw request body (<t>.<body>). It's keyed with the webhook's signing secret, the whsec_… shown once when you add the webhook or make a new secret. Work it out on the raw body before parsing the JSON, compare in constant time, and reject a t more than 5 minutes old.

{(["node", "php"] as const).map(l => ( ))}
Good to know
  • An event can arrive more than once, for example after a retry or a manual resend, so use id to skip ones you've already handled.
  • Events can arrive out of order. Use createdAt and the record's status, not the order they arrive in.
  • Each payload is built about a second after the event, from the record as it is then, and retries send that same payload. If a registration is paid and then changed back within that second, nothing is sent.
  • Kids check-in and volunteer tickets are never sent. A registration made only of those sends nothing, and those lines are left out of items.
  • Only https addresses on the public internet are allowed. Each webhook's log keeps what was sent for {keepDays} days.
  • Turning a webhook off stops new deliveries to it. Deleting it removes its log too.
Event types and examples
    {eventTypes.map(t => (
  • {openType === t.type &&
    }
  • ))}
  • webhook.test · Sent by Send test. data is {`{ "message": "…" }`}, so your side can answer 2xx and ignore it.
)}
); }