Webhook events: payloads for every event
The envelope every webhook delivery shares, the data each event carries with examples, the opt-in conversation, intake and action events, who receives them, and how retries work.
Webhooks tell your system the moment something happens in a business. Setting them up in the dashboard is covered in Webhooks; this page is the reference for what arrives.
The request
POST https://example.com/ordina/events
Content-Type: application/json
User-Agent: Ordina-Webhooks/1.0 (+https://www.useordina.com)
X-Ordina-Event: booking.created
X-Ordina-Delivery: 98231
X-Ordina-Signature: t=1790848800,v1=5f2c...e9a1
Always verify the signature before trusting a delivery.
The envelope
Every event has the same outer shape:
{
"id": "evt_Qm9yZGluYS1leGFtcGxl",
"event": "booking.created",
"created_at": "2026-10-01T10:00:00.000Z",
"business": { "id": "6f1c...", "handle": "brightsalon", "name": "Bright Salon" },
"data": { }
}
id is unique per event. The same event can reach you more than once after a retry, so use id to ignore duplicates.
Events and their data
| Event | data |
|---|---|
| booking.created | { booking } |
| booking.rescheduled | { booking, previous: { date, time } } |
| booking.cancelled | { booking, cancelled_by: "client" or "merchant", reason }, or { booking, action: "no_show", reason } for a no-show |
| booking.completed | { booking }, with completed_by: "client" when the customer confirmed it |
| order.created | { order } |
| order.preparing, order.ready, order.dispatched, order.fulfilled | { order } |
| order.cancelled | { order, reason } |
| payment.received | { kind: "booking" or "order", amount, currency, reference, booking or order }. A booking with a booking fee sends a second one when its balance is collected at the visit, with amount the balance and reference null |
| lead.created | { lead: { id, name, contact, message, source, created_at } } |
| review.created | { review: { id, rating, body, client_name, status, submitted_at } } |
| form.submitted | { form: { id, slug, title, private_answers }, submission: { id, name, email, phone, answers: [{ id, label, value }], source, created_at } }. With private_answers true, the form keeps its answers private: your own endpoints still get every answer, and an endpoint a connected app made gets each value as null. |
| ping | { message }, sent by the Test button in the dashboard |
booking and order are the same objects the REST API returns. See API reference.
Apart from ping, which the Test button sends to one endpoint whatever it subscribes to, these 14 are the classic events: * means all of them.
Example: booking.rescheduled
{
"id": "evt_...",
"event": "booking.rescheduled",
"created_at": "2026-10-01T10:00:00.000Z",
"business": { "id": "6f1c...", "handle": "brightsalon", "name": "Bright Salon" },
"data": {
"booking": { "id": 4182, "status": "confirmed", "date": "2026-10-04", "time": "10:00", "...": "..." },
"previous": { "date": "2026-10-03", "time": "14:30" }
}
}
Example: lead.created
{
"event": "lead.created",
"data": {
"lead": { "id": 311, "name": "Tunde", "contact": "tunde@example.com", "message": "Do you run corporate sessions?", "source": "page", "created_at": "2026-10-01T09:58:40.000Z" }
}
}
Partner apps receive no contact details
An endpoint that a connected app created (through Connect to Ordina) receives these events without the customer's contact details. The fields stay in the payload, set to null, so your parser does not change:
- the customer's
name,emailandphonein a booking's or order'sclient; - a booking's
location,notesandlinks(the customer's own reschedule and cancel links); - an order's
delivery_address,delivery_notes,notesandtracking_url; - a lead's
name,contactandmessage, and a review'sclient_name; - a form submission's
name,emailandphone, and thevalueof every answer that holds an email, a phone number, an address or a person's name.
Ids, dates and times, the service or items, amounts, payment status, statuses and conversation_id are the same as everyone else's. Endpoints the owner adds in the dashboard, and endpoints made with the business's own API keys, receive the full event.
Opt-in events
Nine more events tell you about conversations, intakes, connected actions and the connection itself. An endpoint receives one only when it names it. * never includes them, so an existing subscription or Zap never starts receiving them. Subscribe to them alone, or beside *:
{ "url": "https://example.com/ordina/events", "events": ["*", "conversation.completed", "action.failed"] }
| Event | Sent when |
|---|---|
| conversation.completed | A Secretary conversation went quiet: see below |
| intake.completed | The Secretary collected every required answer of an intake |
| action.requested | The Secretary asked the customer to confirm a write action |
| action.confirmed | The customer confirmed it, before Ordina calls your endpoint |
| action.declined | It was dropped without running |
| action.failed | The confirmed write did not go through |
| action.enabled, action.disabled | The action was switched on or off |
| app.disconnected | Your app's connection to the business ended |
Who receives an opt-in event
An endpoint that names the event receives it when it is:
- one the owner added in the dashboard, or one made with one of the business's API keys (the owner's own tools); or
- one your app made, and the event is about your action, your intake, or a conversation in which your action or intake was used.
Your app never receives an event about another app's action, intake or conversation. Endpoints made through the API before Ordina recorded who made what receive no opt-in event, because nothing says whose they are.
No contact details
No opt-in event carries the customer's name, email or phone, nor the summary the customer was asked to confirm, which can hold them. They carry ids, the channel, your action's own parameters, and the names of the contact fields your action receives. The one exception is by design: intake.completed carries the answers your intake asked for, including an email or phone the owner approved for it, and goes only to the app that made the intake and to the owner.
action events
| Event | data |
|---|---|
| action.requested | { action: { id, name, title }, proposal_id, conversation: { id, channel }, arguments, customer_fields } |
| action.confirmed | The same, plus confirmed_at |
| action.declined | The same, plus reason: declined (the customer said no), expired (no yes within 30 minutes: the customer's next message came later, or the conversation went quiet), replaced (a newer request took its place), moved_on (the customer wrote about something else, or confirmed an older request) |
| action.failed | The same, plus reason: not_run (Ordina did not send it, for example because the action changed or was switched off before the yes), failed (your endpoint answered { "ok": false } or a non-2xx, or Ordina could not connect to it at all), unknown (no answer within 10 seconds, the connection dropped, or a 2xx that did not say "ok": true or "ok": false); and status_code when your endpoint answered |
| action.enabled, action.disabled | { action: { id, name, title }, reason }. reason: owner (the owner, in the dashboard), changed (a change through the API switched it off until the owner approves it again), key_revoked, app_disconnected |
proposal_id is the Idempotency-Key the confirmed call carries, so the events and the call match. A write that went through sends action.confirmed and no action.failed; your endpoint already knows it succeeded.
{
"event": "action.requested",
"data": {
"action": { "id": 12, "name": "create_support_ticket", "title": "Support ticket" },
"proposal_id": "3f0c2a8e-5b1d-4b8e-9a7c-2d4e6f8a1b3c",
"conversation": { "id": "5e55c0f2-...", "channel": "whatsapp" },
"arguments": { "tracking_number": "SC123456789", "problem": "Damaged", "summary": "The box was crushed and the lamp inside is broken" },
"customer_fields": ["email"]
}
}
app.disconnected
{ client_id, reason }, with reason owner (the owner pressed Disconnect) or app_revoked (you revoked your token). It is sent to your endpoints before they are switched off, and tried once: once they are off there is nothing to retry to. Then your endpoints and actions are switched off, and each action is announced as action.disabled, reason app_disconnected, to the owner's endpoints.
intake.completed
{ intake: { id, name, title }, response_id, conversation: { id, channel }, answers: [{ id, label, type, value, proof }], completed_at }. proof (verified or stated) is on email and phone answers: verified when the channel proved it, as for write actions.
conversation.completed
{
"event": "conversation.completed",
"data": {
"conversation": {
"id": "5e55c0f2-...", "channel": "whatsapp",
"started_at": "2026-10-15T09:52:11.000Z", "last_message_at": "2026-10-15T10:01:12.000Z",
"customer_messages": 5
},
"outcome": "resolved",
"outcomes": ["resolved"],
"summary": "Support ticket went through after 5 messages on WhatsApp.",
"references": {
"appointment_ids": [], "order_ids": [], "store_order_ids": [], "intake_response_ids": [],
"action_calls": [
{ "action": "track_shipment", "status": "ok", "idempotency_key": null },
{ "action": "create_support_ticket", "status": "ok", "idempotency_key": "3f0c2a8e-5b1d-4b8e-9a7c-2d4e6f8a1b3c" }
]
},
"resumed": false
}
}
- When. A conversation is complete when its last message is 30 minutes old and the customer wrote at least twice. Ordina checks every 15 minutes, so it arrives 30 to 45 minutes after the last message. Only Secretary conversations count (web chat, WhatsApp, Instagram, Messenger, Telegram, email and phone calls), not a booking form's contact step or a booking an AI assistant made over MCP.
- Once. Each conversation is reported once. If the customer comes back later and it goes quiet again, it is reported again with
resumed: trueand the whole conversation's records. - outcomes lists every outcome that applies; outcome is the first of them, in this order:
| outcome | When |
|---|---|
| booked | A booking was made in the conversation |
| ordered | An order was placed |
| intake | An intake was completed |
| lead | The customer left an email or phone and a question for the team |
| resolved | A write action went through, or the team's answer was passed on |
| handed_off | A question for the team is still waiting, or the customer was pointed to the business's own contact details |
| abandoned | A booking, an order, a write action waiting for a yes, or an intake was left unfinished |
| resolved | Anything else: the Secretary answered |
- summary is written by Ordina from the records, never by AI, and holds no contact details.
- references are ids you can look up:
appointment_idsandorder_idsin the API,store_order_idsfor orders placed in a connected Shopify or WooCommerce store,intake_response_ids, and every action call in the conversation with its status (ok,error,timeout,rejectedorunknown) and, for a write, its Idempotency-Key. - Conversations older than a day are not sent, so subscribing does not replay a business's history.
Answering
- Answer with any 2xx within 10 seconds. Do the real work after answering, for example in a queue.
- A redirect, a timeout, or any other status is a failure.
- A failed delivery is tried again up to 5 more times, at least 1, 5, 30, 120 and 720 minutes after the attempt before: six attempts over about 15 hours. Then the delivery is marked failed, and the owner sees it in the endpoint's history.
- Those times are minimums. Retries are sent by a job that runs every 15 minutes (at :00, :15, :30 and :45), so a retry goes out at the first quarter hour after its time: the first retry, due 1 minute after a failure, can go out up to 15 minutes after it.
- Deliveries are not guaranteed to arrive in order. Use
created_at, and the object's ownstatus, rather than arrival order.
