Webhook events reference
This is the list of event types Atender currently emits to Webhook subscriptions. Every delivery has the same envelope shape:
{
"event": "<event name from the table below>",
"eventId": "<unique delivery UUID>",
"deliveredAt": "<ISO 8601>",
"payload": { ... }
}
The payload shape varies by event type. eventId matches the X-Webhook-Delivery header — use it to deduplicate.
Deliveries are at-least-once, so the same event can arrive more than once. Dedupe on eventId.
GET /api/v1/webhooks returns the authoritative list of currently-emitted events in meta.availableEvents — if this page and the API ever disagree, trust the API. Some older event names are still accepted as subscription values for backward compatibility but are not emitted; they’re listed under Accepted but not emitted below.
One exception: POST /api/v1/conversations/import writes historical records only and does not emit conversation or message webhooks. Replaying history as live events would notify external systems incorrectly. Demo and trial fabricated history is suppressed the same way.
Conversation lifecycle
conversation.created— A new conversation is created — via any channel, including viaPOST /api/v1/conversations/outbound.conversation.resolved— A conversation moves to Archived.conversation.reopened— A conversation moves from Done or Archived back to Active, usually because the customer replied.conversation.commented— A teammate adds an internal comment to a conversation, or one is added through the API. Programmatic notes — an automation’s Add internal note action, or Atender’s own System and Sidekick notes — don’t fire it.
Useful for keeping a third-party system in sync with conversation state, or for shipping resolution data downstream (analytics, CSAT triggers from your own systems, etc.).
Messages
message.received— An inbound message arrives from a customer, on any channel.message.sent— An agent (or an Agent Stack, or an automation) sends a reply.
Useful when you’ve pushed a conversation in via the API and need the agent’s reply back. Subscribe to message.sent and ship the reply wherever the customer is (your own chat surface, your CRM, your marketplace inbox).
SLA
sla.warning— A conversation is approaching its SLA deadline. The exact warning threshold is set on the SLA policy. The payload’ssla.levelfield iswarningorurgent.sla.breached— A conversation has missed its SLA.
Useful for paging out, pinging a Slack channel, or triggering escalation in your own systems before or after a breach.
Cases
case.created— A new case is created.case.updated— A case’s fields change. The payload includes aprevioussnapshot so you can diff state.case.deleted— A case is removed.case.transitioned— A case moves to a different workflow stage.case.assigned— A case’s assignee changes.case.status_changed— A case’s status changes.case.commented— A comment is added to a case.case.action_sent— An action on a case is sent.case.action_completed— An action on a case completes.case.conversation_linked— A conversation is linked to a case.case.conversation_unlinked— A conversation is unlinked from a case.
Useful for mirroring case state into an external ticketing or order system.
Issues
issue.created— A new issue is created. If the issue was reported from a conversation, that reporter conversation is linked when applicable.issue.updated— An issue changes — fields, labels, assignee, comments, attachments, linked conversations, and merge state all collapse onto this one event.
Subscribing to issue events through the API requires the issues:read scope.
The payload includes these fields:
versionchangeIdrevisionissue.statusBehaviorchanges— so you can tell what changedoccurredAt
It also includes issue metadata and a URL. It does not include customer-visible issue text — treat deliveries as lightweight notifications and refetch the issue if you need more detail.
Issue events are grouped, so they arrive roughly 5 to 35 seconds after the change rather than instantly. Deliveries can also arrive out of order. For each issue, keep the event with the highest revision and drop any with a lower one.
Incidents and maintenance
incident.created— An incident is created.incident.updated— An incident is updated — edits and status moves both fire this event.incident.resolved— An incident is resolved.maintenance.created— A planned maintenance window is created.maintenance.updated— A planned maintenance window is updated — edits and status moves both fire this event.maintenance.resolved— A planned maintenance window is resolved.
incident.* events fire for incidents, and maintenance.* events fire for planned maintenance windows.
The payload carries the incident’s id, title, kind, status, severity, visibility, affected components, and a plain-text update message. Internal incidents fire these events too, so check visibility before mirroring an incident anywhere customers can see it.
Useful for mirroring status page incidents into an external system, or for notifying your own teams when an incident or maintenance window starts, changes, or ends.
Knowledge Base articles
kb.article.created— A new article is added.kb.article.updated— An article changes — content edits, publishes, unpublishes, archives, review-state changes, and translation syncs all collapse onto this one event. The payload’schangefield tells you which kind of update it was.kb.article.deleted— An article is removed.
The payload identifies the article (id, slug, title, status, and more) but doesn’t carry the content — treat deliveries as lightweight notifications and refetch the full article via the public API.
Handbook procedures
handbook.procedure.created— A new procedure is added.handbook.procedure.updated— A procedure changes. The payload’schangefield describes the update; for this event it is alwayscontent.handbook.procedure.deleted— A procedure is removed.
Treat these as lightweight notifications and refetch the full procedure via the public API.
Accepted but not emitted
For backward compatibility, the API still accepts these event names when you create or update a subscription — a subscription listing them stays valid — but no producer dispatches them today, so your endpoint will never receive them:
conversation.updated— Accepted, not currently emitted.contact.created— Accepted, not currently emitted.contact.updated— Accepted, not currently emitted.assignment.changed— Accepted, not currently emitted.tag.added— Accepted, not currently emitted.tag.removed— Accepted, not currently emitted.
Picking events to subscribe to
Subscribe to the events you actually need to react to. Atender will not let you reduce noise after the fact — every subscription gets every event in its events array.
Common patterns:
- Mirror conversations into a third-party system:
conversation.created,conversation.commented,message.received,message.sent,conversation.resolved,conversation.reopened. - Ship agent replies back to a custom channel:
message.sentonly. - Page on SLA breaches:
sla.warningandsla.breached. - Mirror case state into a ticketing or order system: the
case.*events. - Mirror issue state into an external system:
issue.createdandissue.updated. - Mirror status page incidents into an external system: the
incident.*andmaintenance.*events. - Sync your help center or runbook into an external system: the
kb.article.*andhandbook.procedure.*events.