SMS Webhooks

Bodek SMS pushes events to your server as they happen: a text arriving on one of your numbers, someone replying STOP, every delivery-status change of a message you sent, and every step of a flow (text conversation). You create endpoints on SMS webhooks or through the API, pick exactly which events each one wants, and verify a signature on every request.

Manage    https://dev.bodek.us/sms-webhooks
API       https://sms.bodek.us/api/v1/webhooks
Payloads  POST <your URL>   Content-Type: application/json
Version   2026-10-25  (sent as X-Bodek-Api-Version and api_version)
  • Deliveries are queued and sent out of band — normally within a second, never inside the request that caused them. Your endpoint being slow never slows down a send.
  • Answer any 2xx within 10 seconds. Anything else is retried (schedule).
  • Events are at-least-once. Deduplicate on the event id (evt_…) — see the payload.
  • Up to 20 endpoints per account; each can watch one number or all of them.

⚠ Opt-out policy — read this before you send

Bodek SMS will not stop sending messages because a recipient sent an opt-out message. When someone replies STOP, UNSUBSCRIBE, CANCEL or any other opt-out keyword, Bodek SMS records it and raises a message.opt_out webhook event. It does not suppress that recipient, it does not cancel queued messages to them, and it does not reply to them on your behalf. Delivery is stopped only if and when Bodek administration decides to stop delivery.

The company integrating with Bodek SMS is responsible for receiving these webhooks and stopping delivery. That means: subscribe at least one active endpoint to message.opt_out, record the recipient in your own suppression list the moment the event arrives, and stop sending to them.

Violation of this rule can result in suspension of the Bodek SMS service — for the API key, the number, or the whole account, at Bodek administration's discretion.

Practical consequences of this design, so nothing is a surprise:

A number that replied STOPstill receives everything you queue for it. Nothing is filtered.
Messages already queued to themare still sent. Cancel them yourself with DELETE /v1/messages/{id} while they are queued.
Flows and text menusno keyword is reserved. A flow may trigger on STOP, and a running conversation continues. If you want a flow to acknowledge an opt-out, build that branch yourself.
Automatic confirmation textsnone are sent. Bodek SMS never texts your recipients on its own.
The recordis kept and readable at GET /v1/opt-outs, and is what Bodek administration reviews if compliance is questioned. Every opt-out payload carries "delivery_blocked_by_bodek": false as a plain restatement of the above.

You remain responsible for compliance with the TCPA, CTIA messaging principles and your carriers' rules. Bodek SMS gives you the signal; acting on it is yours.

Create an endpoint

In the console: SMS webhooks → Add an endpoint. Or over the API with a key that has webhooks:write:

POST /v1/webhooks
curl -X POST https://sms.bodek.us/api/v1/webhooks \
  -H "Authorization: Bearer bs_live_…" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Production listener",
    "url": "https://your.app/hooks/bodek-sms",
    "events": ["message.received", "message.opt_out", "message.delivered", "message.failed"],
    "number_id": 12
  }'
{
  "ok": true,
  "webhook": { "id": "wh_9f3c…", "name": "Production listener", "url": "https://your.app/hooks/bodek-sms",
               "active": true, "events": ["message.received","message.opt_out","message.delivered","message.failed"],
               "opt_out_keywords": ["stop","stopall",…], "using_default_keywords": {"opt_out": true, …},
               "stats": {"queued":0,"delivered":0,"failed":0,"pending":0}, "api_version": "2026-10-25" },
  "secret": "whsec_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
}
FieldDescription
urlrequiredAn https:// URL on a publicly reachable host. Checked when you save it and again on every delivery.
eventsrequiredEvent names, or a family: message.*, flow.*, *.
nameoptionalYour label (≤ 120 chars).
number_idoptionalOnly events for this number. Omit for every number on the account.
activeoptionalDefault true. A paused endpoint keeps queueing events and sends them when you switch it back on.
include_bodyoptionalDefault true. false sends body: null on every message — for platforms that must not receive message text.
keywordsoptionalYour own trigger words for message.keyword.
optout_keywords
optin_keywords
help_keywords
optionalOverride the platform lists for this endpoint. See Keyword lists.
headersoptionalUp to 5 extra request headers, e.g. {"X-My-Token": "…"}. X-Bodek-* is reserved.

The secret is returned once, here and in the console. Store it — it signs every payload. Rotate it with POST /v1/webhooks/{id}/rotate_secret.

POST /v1/webhooks/{id}/test

Queues a webhook.test event so you can check the whole path, including your signature check, before any real traffic.

The payload

Every delivery is the same envelope. Only data changes between event types.

POST https://your.app/hooks/bodek-sms
Content-Type: application/json; charset=utf-8
X-Bodek-Event: message.opt_out
X-Bodek-Event-Id: evt_7b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5e
X-Bodek-Webhook-Id: wh_9f3c1a2b3c4d5e6f7a8b9c0d1e2f3a4b
X-Bodek-Signature: t=1792000000,v1=5f0c9a…
X-Bodek-Attempt: 1
X-Bodek-Api-Version: 2026-10-25
{
  "id": "evt_7b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5e",
  "type": "message.opt_out",
  "api_version": "2026-10-25",
  "created_at": "2026-10-25T14:03:11+00:00",
  "webhook_id": "wh_9f3c1a2b3c4d5e6f7a8b9c0d1e2f3a4b",
  "account_id": 4120,
  "data": { … }
}
idUnique per (event, endpoint). Deduplicate on this. A retry reuses it.
typeThe event name, same as X-Bodek-Event.
X-Bodek-Attempt1 on the first try, 2 on the first retry, and so on.
api_versionThe payload shape. Bumped only when an existing field changes meaning.

Order is not guaranteed. message.delivered can arrive before message.sent if a retry delayed one of them. Treat the message's delivery block and its timestamps as the truth, not the arrival order.

Verifying the signature

X-Bodek-Signature is t=<unix seconds>,v1=<hex> where the hex is HMAC-SHA256(secret, "<t>.<raw request body>"). Hash the raw body, before any JSON parsing or re-encoding. Reject anything older than ~5 minutes to stop replays, and compare in constant time.

// PHP
$raw    = file_get_contents('php://input');
$sig    = $_SERVER['HTTP_X_BODEK_SIGNATURE'] ?? '';
$secret = getenv('BODEK_SMS_WEBHOOK_SECRET');

if (sscanf($sig, 't=%d,v1=%s', $t, $v1) !== 2
    || abs(time() - $t) > 300
    || !hash_equals(hash_hmac('sha256', $t . '.' . $raw, $secret), $v1)) {
    http_response_code(400);
    exit('bad signature');
}
$event = json_decode($raw, true);
// Answer fast, then do the work: queue it and return 200 immediately.
http_response_code(200);
// Node (express — note express.raw, not express.json)
app.post('/hooks/bodek-sms', express.raw({ type: 'application/json' }), (req, res) => {
  const m = /^t=(\d+),v1=([0-9a-f]+)$/.exec(req.get('X-Bodek-Signature') || '');
  if (!m) return res.status(400).end();
  const [, t, v1] = m;
  if (Math.abs(Date.now() / 1000 - Number(t)) > 300) return res.status(400).end();
  const mac = crypto.createHmac('sha256', process.env.BODEK_SMS_WEBHOOK_SECRET)
                    .update(`${t}.${req.body}`).digest('hex');
  if (!crypto.timingSafeEqual(Buffer.from(mac), Buffer.from(v1))) return res.status(400).end();
  const event = JSON.parse(req.body.toString('utf8'));
  res.sendStatus(200);
});
# Python (Flask)
raw = request.get_data()
sig = request.headers.get("X-Bodek-Signature", "")
parts = dict(p.split("=", 1) for p in sig.split(",") if "=" in p)
t, v1 = parts.get("t", "0"), parts.get("v1", "")
if abs(time.time() - int(t)) > 300: abort(400)
mac = hmac.new(SECRET.encode(), f"{t}.".encode() + raw, hashlib.sha256).hexdigest()
if not hmac.compare_digest(mac, v1): abort(400)
event = json.loads(raw)

During a secret rotation accept either secret for a few minutes: payloads already queued were signed with the old one.

Event catalogue

Subscribe to exact names, or to a family (message.*, flow.*, *). GET /v1/webhooks/events returns this list at run time together with the default keyword lists and the retry schedule.

Inbound messages

message.receivedSomeone texted one of your numbers (any inbound message).
message.opt_outAn inbound message matched the opt-out keyword list (STOP, UNSUBSCRIBE, …).
message.opt_inAn inbound message matched the start/opt-in keyword list (START, YES, …).
message.helpAn inbound message matched the help keyword list (HELP, INFO, …).
message.keywordAn inbound message matched this endpoint's own keyword list.

Delivery status

message.queuedA message you sent was accepted and queued.
message.sendingA queued message was handed to a sending phone.
message.sentThe message left the phone and the carrier accepted it.
message.deliveredThe carrier confirmed delivery to the handset.
message.readThe recipient’s handset reported the message as read (MMS/RCS only).
message.failedThe message could not be sent (retries exhausted or a send error).
message.bouncedThe carrier rejected the message permanently (unreachable, invalid or blocked number).
message.expiredThe message was still queued when its TTL ran out and was never sent.
message.cancelledThe message was cancelled before it was sent.

Flows

flow.run.startedA flow run (text conversation) started.
flow.run.stepA flow run executed a step.
flow.run.inputThe person replied to a flow run.
flow.run.completedA flow run finished normally.
flow.run.expiredA flow run timed out waiting for a reply.
flow.run.stoppedA flow run was stopped (by you, the API, or because the flow was switched off).
flow.run.errorA flow run ended in an error.
flow.updatedA flow was created, changed, activated, paused or deleted.

Calls (voice)

call.receivedAn inbound call reached one of your numbers (before it is answered).
call.answeredA call was answered and a call flow started running.
call.consentThe recording announcement was played to the caller (carries the exact words and the time).
call.inputThe caller pressed a key in a call flow menu.
call.forwardedA call was forwarded or bridged to another number.
call.recordedA recording (voicemail or recorded call) is ready to download.
call.completedA call flow finished and the call ended.
call.failedA call flow could not run or ended in an error.
call.missedAn inbound call was not answered (rang out, declined or blocked).
call.unsupportedA call flow needed something the answering number cannot do yet (see `primitive`).
voice_flow.updatedA call flow was created, changed, activated, paused or deleted.

Other

webhook.testA test event you sent yourself from the console or the API.

Inbound messages

One arriving text can raise several events to the same endpoint — message.received for the text itself, plus message.opt_out if it matched your opt-out list. Each is a separate delivery with its own event id, so you can subscribe to the opt-outs alone and get nothing else:

{ "events": ["message.opt_out"] }          // only opt-outs, no other inbound traffic
{ "events": ["message.opt_out", "message.opt_in"] }   // stops and starts
{ "events": ["message.received"] }         // every inbound, opt-outs included

The data for an inbound event:

{
  "message": {
    "id": "msg_af6d1cbbb042d08e5ddeef055306fd5a",
    "seq": 48122,
    "direction": "in",
    "from": "+15557654321",          // the person who texted you
    "to": "+15551230000",            // your number
    "number_id": 12,
    "number": "+15551230000",
    "body": "STOP",
    "status": "received",
    "source": "inbound",
    "segments": 1,
    "created_at": "2026-10-25T14:03:11+00:00",
    "media": [],
    "delivery": { "state": "received", "terminal": false, "read": false, "bounced": false }
  },
  "number":  { "id": 12, "number": "+15551230000", "label": "Front desk" },
  "group":   null,                   // or {"id": 7, "name": "U12 Team"} if they are in a group
  "is_group_member": false,
  "keyword_match": "opt_out",        // "opt_out" | "opt_in" | "help" | null
  "opt_out_state": "opted_out",      // "opted_out" | "opted_in" | null
  "delivery_stopped_by_bodek": false // always false — see the opt-out policy
}

Picture messages (MMS) arrive with a media list; download each with its url and the same bearer key. include_body: false on the endpoint sends "body": null and leaves everything else intact.

Keyword lists

Matching is on the whole message, normalised: lower-cased, trimmed, inner whitespace collapsed, surrounding punctuation stripped. So "STOP." and " Stop " match, and "stop by at 5" does not — a sentence is a conversation, not a command, and treating it as one would produce false opt-outs.

Bodek's default lists:

message.opt_outstop, stopall, stop all, unsubscribe, unsub, cancel, end, quit, optout, opt out, opt-out, revoke, remove me, no more, delete
message.opt_instart, unstop, yes, subscribe, optin, opt in, opt-in, resume, continue
message.helphelp, info, support

Each endpoint may replace any of these with its own list — useful for another language, a narrower set, or extra words your customers actually use. A list you don't override keeps the platform default, so the two can never disagree:

curl -X PATCH https://sms.bodek.us/api/v1/webhooks/wh_9f3c… \
  -H "Authorization: Bearer bs_live_…" -H "Content-Type: application/json" \
  -d '{
    "optout_keywords": ["stop", "stopall", "unsubscribe", "cancelar", "basta", "no mas"],
    "optin_keywords":  ["start", "si", "subscribe"],
    "keywords":        ["BOOK", "QUOTE", "HOURS"]
  }'

Up to 40 keywords per list, 40 characters each. Send null to go back to the platform default. Overriding a list changes which events you are told about — it does not change what Bodek records, and it never changes what Bodek delivers.

message.keyword uses your own keywords list and is independent of the three above, so BOOK can route to your booking system while message.opt_out keeps feeding your suppression list.

Delivery status

Every message you send reports its whole life. Subscribe to the ones you care about, or to message.* for all of them. Each status fires at most once per message — a re-queued send, a duplicated phone report or a repeated maintenance pass cannot produce a second copy.

EventMeansFinal?
message.queuedAccepted and waiting for a sending phone.no
message.sendingHanded to a phone. from is now the real sending number.no
message.sentLeft the phone; the carrier accepted it.no
message.deliveredThe carrier confirmed delivery to the handset.yes
message.readThe handset returned a read report. MMS/RCS only — plain SMS has no read receipts, so most messages never fire this.yes
message.bouncedPermanently rejected: the number is invalid, not in service, unreachable, blocked, or outside the US/Canada. Retrying will never work.yes
message.failedCould not be sent for a reason that might not repeat (no signal, a generic carrier error, no result from the phone). Already retried internally before you hear about it.yes
message.expiredStill queued when its ttl ran out; never sent.yes
message.cancelledYou cancelled it with DELETE /v1/messages/{id} before it was sent.yes

The data is the full message plus, on a failure, why:

{
  "message": {
    "id": "msg_af6d1cbbb042d08e5ddeef055306fd5a",
    "seq": 48125,
    "direction": "out",
    "from": "+15551230000",        // your sending number
    "to": "+15557654321",          // the recipient
    "number_id": 12,
    "body": "Your table is ready!",
    "status": "delivered",
    "source": "api",
    "segments": 1,
    "attempts": 1,
    "client_ref": "order-8412",    // your own reference, echoed back
    "api_key_id": 31,              // which key sent it
    "error": null,
    "created_at":   "2026-10-25T14:03:11+00:00",   // accepted / queued
    "send_after":   null,
    "expires_at":   "2026-10-26T14:03:11+00:00",
    "sent_at":      "2026-10-25T14:03:14+00:00",   // left the phone
    "delivered_at": "2026-10-25T14:03:19+00:00",   // carrier receipt
    "read_at":      null,
    "updated_at":   "2026-10-25T14:03:19+00:00",
    "media": [],
    "delivery": { "state": "delivered", "terminal": true, "read": false, "bounced": false },

    "failure_code": null,          // present on failed / bounced / expired
    "failure_type": null           // "permanent" | "transient" | "expired"
  }
}

client_ref is the field to key on: set it when you send and every status event for that message carries it back, so you never have to store our ids to match a status to your own record.

Flow events

Flows (text menus and automations) report every step, so a platform that builds flows through the Flows API can follow a conversation live instead of polling the run.

flow.run.startedA conversation began (missed call, keyword, any text, or your API call).
flow.run.stepOne step ran: a reply sent, a menu choice taken, an answer saved, an API step called, a branch evaluated, a staff alert sent.
flow.run.inputThe person replied.
flow.run.completedThe conversation finished normally.
flow.run.expiredNo reply within the flow's timeout.
flow.run.stoppedStopped by you, by the API, or because the flow was switched off.
flow.run.errorThe run ended in an error.
flow.updatedA flow was created, changed, activated, paused or deleted — whether from the API or the editor.
{
  "run": {
    "id": 431, "flow_id": 5, "number_id": 12, "to": "+15557654321",
    "trigger": "keyword", "status": "active", "waiting_on_step": "ask_order",
    "messages_sent": 2, "steps": 3,
    "vars": { "name": "Ann", "order": "10442" },
    "started_at": "…", "updated_at": "…", "expires_at": "…"
  },
  "flow":   { "id": 5, "name": "Front desk", "number_id": 12, "number": "+15551230000" },
  "step":   { "id": "ask_order", "kind": "answer", "detail": "order = 10442" },
  "caller": "+15557654321",
  "vars":   { "name": "Ann", "order": "10442" }
}

step.kind is one of start, reply, choice, answer, invalid, set, branch, webhook, notify, ring, join_group, input, error, end. A flow's own API step is a different thing — a request your flow makes mid-conversation, whose reply steers it; see Flows → API steps.

Pulling message details

Webhooks push; the API lets you pull the same facts whenever you want — every message a platform sent, both numbers, the text, the segment count, which key sent it and every timestamp it passed through.

GET /v1/messages
# Everything this key sent yesterday, with delivery status
curl -G https://sms.bodek.us/api/v1/messages \
  -H "Authorization: Bearer bs_live_…" \
  --data-urlencode "direction=out" \
  --data-urlencode "source=api" \
  --data-urlencode "sent_after=2026-10-24T00:00:00Z" \
  --data-urlencode "sent_before=2026-10-25T00:00:00Z" \
  --data-urlencode "limit=200"

# One message by your own reference
curl -G https://sms.bodek.us/api/v1/messages --data-urlencode "client_ref=order-8412" \
  -H "Authorization: Bearer bs_live_…"

# One message by its secure id
curl https://sms.bodek.us/api/v1/messages/msg_af6d1cbbb042d08e5ddeef055306fd5a \
  -H "Authorization: Bearer bs_live_…"
FilterDescription
directionin or out.
statusqueued, sending, sent, delivered, failed, received, cancelled, expired.
read=1Only messages with a read receipt.
phoneThe other party's number.
number_idOne of your numbers.
client_refYour own reference, exactly as you sent it.
sourceapi, web, group, flow, inbound, phone, call, command.
created_after / created_before
sent_after / sent_before
ISO-8601 timestamps or unix seconds.
since_id / before_id / limitPaging, on the seq cursor. limit max 200.

Secure message ids

Every message has an opaque id, msg_ plus 32 hex characters, generated from a CSPRNG. That is the id in every API response and every webhook payload, and it is what /v1/messages/{id} takes — so an id can be logged, passed between systems or put in a support ticket without exposing how much traffic anyone sends, and no one can walk your message history by counting. The database row number is still returned as seq, because since_id and before_id page on it. /v1/messages/{id} accepts either form.

GET /v1/messages/{id}/events

Needs webhooks:read. The delivery audit trail for one message: every webhook event we raised about it, to which endpoint, with the payload we sent, the HTTP status we got back and how many attempts it took. This is the record to check when an integration claims it was never told about an opt-out.

The opt-out record

GET /v1/opt-outs

Needs optouts:read. Everyone who has sent an opt-out (or opt-in) keyword to your numbers. This is a record, not a block list — read the opt-out policy.

curl -G https://sms.bodek.us/api/v1/opt-outs \
  -H "Authorization: Bearer bs_live_…" \
  --data-urlencode "state=opted_out" \
  --data-urlencode "since=2026-10-01T00:00:00Z"
{
  "ok": true,
  "opt_outs": [
    { "phone": "+15557654321", "number_id": 12, "number": "+15551230000",
      "state": "opted_out", "keyword": "stop",
      "opted_out_at": "2026-10-25T14:03:11+00:00", "opted_in_at": null,
      "updated_at": "2026-10-25T14:03:11+00:00",
      "delivery_blocked_by_bodek": false }
  ],
  "policy": "Delivery is not blocked by these records. Suppress these recipients in your own system."
}

Query: state (opted_out/opted_in), since, number_id, phone, limit (max 500), offset. Reconcile this list against your own suppression list on a schedule — a webhook your server was down for is still recorded here.

GET /v1/opt-outs/{phone}

One number's state across your numbers.

POST /v1/opt-outs

Needs messages:send. Records an opt-out (or opt-in) you collected elsewhere — a web form, a phone call, an email — so the record Bodek administration reviews matches what you actually know. It never sends a message, and like every other row here it blocks nothing.

curl -X POST https://sms.bodek.us/api/v1/opt-outs \
  -H "Authorization: Bearer bs_live_…" -H "Content-Type: application/json" \
  -d '{ "phone": "+15557654321", "number_id": 12, "state": "opted_out", "keyword": "web form" }'

Retries & the delivery log

A delivery is attempted straight away. Anything that is not a 2xx — a timeout, a 5xx, a redirect (we don't follow them), a body over 64 KB — is retried on this schedule until a 2xx arrives or 10 attempts are used, about 22 hours in all:

10s  →  30s  →  1m  →  5m  →  15m  →  30m  →  1h  →  2h  →  6h  →  12h
  • 404 or 410 stops the retries immediately — we take it to mean the URL is gone. Fix the URL and use retry_failed.
  • A paused endpoint doesn't lose events: they wait and go out when you switch it on.
  • An endpoint with more than 20,000 events waiting starts droppeding new ones, with the reason recorded. A dropped delivery keeps no payload and cannot be retried.
  • Nothing is ever auto-disabled for failing. An endpoint that stops receiving opt-outs because we switched it off would be worse than one that keeps retrying.
GET /v1/webhooks/{id}/deliveries

The log, kept 30 days: each attempt's status, HTTP code, timing, the first 500 bytes of your response, and the exact payload we sent. Query: status, event, message_id, before_id, limit.

{"ok": true, "webhook_id": "wh_9f3c…", "deliveries": [{
  "id": "evt_7b1c…", "event": "message.opt_out", "status": "delivered",
  "attempts": 2, "http_status": 200, "response_ms": 142, "response_body": "{\"ok\":true}",
  "error": null, "message_id": 48122, "phone": "+15557654321",
  "next_attempt_at": null,
  "created_at": "2026-10-25T14:03:11+00:00", "delivered_at": "2026-10-25T14:03:42+00:00",
  "payload": { … exactly what we POSTed … }
}]}
POST /v1/webhooks/{id}/deliveries/{event_id}/retry
POST /v1/webhooks/{id}/deliveries/retry_failed

Replay one delivery, or every failed one, after you've fixed your end. Your handler must be idempotent anyway — dedupe on the event id.

Managing endpoints via API

EndpointScopePurpose
GET /v1/webhooks/events
—Event catalogue, default keywords, retry schedule, the opt-out policy in one line.
GET /v1/webhooks
webhooks:readYour endpoints, with delivery stats.
POST /v1/webhooks
webhooks:writeCreate one; the secret is returned once.
GET /v1/webhooks/{id}
webhooks:readOne endpoint, including its secret.
PATCH /v1/webhooks/{id}
webhooks:writeChange any subset of its fields.
DELETE /v1/webhooks/{id}
webhooks:writeDelete it and its log; queued events are discarded.
POST /v1/webhooks/{id}/test
webhooks:writeQueue a webhook.test event (10/min per endpoint).
POST /v1/webhooks/{id}/rotate_secret
webhooks:writeNew signing secret.
GET /v1/webhooks/{id}/deliveries
webhooks:readThe delivery log.
GET /v1/messages/{id}/events
webhooks:readEvery event raised about one message.
GET /v1/opt-outs
optouts:readThe opt-out record.

Endpoint ids are opaque (wh_ + 32 hex). A key bound to one number can only create and see endpoints for that number. Webhook writes are rate-limited to 30/min per account.

Security

  • Always verify the signature. Your URL is reachable by anyone; the signature is what makes a request ours. Reject unsigned and stale requests.
  • Where we will and won't connect. Only https:// (plain http:// is refused), only hosts that resolve entirely to public addresses — no loopback, private, link-local, CGNAT, multicast or cloud-metadata ranges, and not this server's own addresses. The connection is pinned to the address we checked, so a DNS answer cannot change between the check and the connect. Redirects are never followed and responses are capped at 64 KB.
  • Credentials belong in a header, not in the URL — a URL with user:pass@ is refused. Add up to 5 of your own headers; values are write-only once saved.
  • Answer fast. 10-second timeout. Acknowledge with 200, then do the work in a queue.
  • Be idempotent. At-least-once delivery, unordered. Dedupe on the event id.
  • Rotate on exposure. If a secret leaks, rotate it; accept both for a few minutes.
  • Don't put message text where you shouldn't. include_body: false sends body: null if your platform must not receive it.

Questions, or a suspension to appeal: quote the X-Request-Id of an API call or an event id from the delivery log.