Skip to main content

Pending & Events

Inspect and cancel pending delivery retries before they fire, list the raw outbox events that drive delivery bindings, and replay any event on demand via API.

Two surfaces sit underneath the delivery items and dead-letter queue: the pending retries — delivery jobs sitting in the queue that have not run yet — and the raw delivery events, the outbox rows that bindings consume. Use them to see what is scheduled to go out, cancel a queued retry before it fires, and replay an event through the whole binding flow from the source signal.

A pending retry is a queued delivery job in one of three states: delayed (scheduled for a future backoff slot), waiting (runnable, awaiting a worker), or active (currently executing). The pending list groups counts by state and lists each job with its binding, event, attempt number, and — for delayed jobs — the wall-clock time of the next attempt. Cancel a single job by its job_id, cancel every pending retry for one binding, or clear the whole tenant queue in one call.

Events are the upstream signals — domain occurrences like a document structured or a run completed — recorded in the delivery outbox before any binding matching happens. Each row shows whether it was dispatched (processing_status: "enqueued"), matched nothing (no-subscribers), or failed to process. Replaying an event marks it unprocessed so the poller re-dispatches it on its next tick, fanning out to every binding that matches now — including bindings created after the event originally fired.

The two replay verbs compose into a debugging workflow: when a delivery went wrong, check the item history first (was the payload built and rejected?), then the DLQ (did it exhaust retries?), and reach for event replay when the problem was routing — a binding that did not exist yet, was inactive, or had the wrong signal filter when the event first fired.

GET/v1/delivery/pending

Pending Response

Response fields

countsobjectJob totals per state: `delayed`, `waiting`, `active`.
itemsarrayThe pending retry jobs.
items[].job_idstringQueue job id — the handle for DELETE /v1/delivery/pending/:jobId.
items[].event_idstringOutbox event the job would deliver.
items[].binding_idstringBinding the job belongs to.
items[].attemptintegerAttempt number this job will run as.
items[].statusstring`delayed`, `waiting`, or `active`.
items[].next_attempt_atstring | nullScheduled run time for delayed jobs; null for waiting/active jobs, which are runnable now.

curl

curl -s https://api.talonic.com/v1/delivery/pending \
  -H "Authorization: Bearer tlnc_your_api_key"

Response

{
  "counts": { "delayed": 2, "waiting": 0, "active": 1 },
  "items": [
    {
      "job_id": "18234",
      "event_id": "98765",
      "binding_id": "d4e5f6a7-b8c9-0123-defa-345678901234",
      "attempt": 3,
      "status": "delayed",
      "next_attempt_at": "2026-08-29T12:08:00.000Z"
    }
  ]
}
The pending surface is best-effort under deep backlogs: it caps how many jobs it inspects per queue state, so counts can understate a very large backlog. An active job is already executing and cancellation cannot stop the in-flight attempt — it prevents future retries only.
DELETE/v1/delivery/pending/:jobId

Path parameters

jobId*stringThe queue job id from the pending list (not a UUID).
DELETE/v1/delivery/pending
POST/v1/delivery/bindings/:id/cancel-pending

Path parameters

id*uuidThe binding id.

Listing and replaying events

The events list is the outbox log, newest first, with an optional event_type filter and limit/offset paging (default 50 per page). Each row carries the full signal payload that resolvers receive, plus processing bookkeeping: processed_at, processing_attempts, processing_status, and error. A no-subscribers status means the event fired but no active binding matched it — the usual first clue when an expected delivery never appears in the item history.

GET/v1/delivery/events

Query parameters

event_typestringFilter by signal type, e.g. `document.structured`.
limitintegerMaximum events to return. Default: 50
offsetintegerNumber of events to skip. Default: 0

Response

{
  "items": [
    {
      "id": "98765",
      "event_type": "document.structured",
      "payload": { "document_id": "doc-a1b2…", "pipeline_id": "p-c3d4…" },
      "dedup_key": "doc:doc-a1b2…:structured:p-c3d4…",
      "created_at": "2026-08-29T11:59:59.000Z",
      "processed_at": "2026-08-29T12:00:00.000Z",
      "processing_attempts": 1,
      "processing_status": "enqueued",
      "error": null
    }
  ],
  "total": 412
}
POST/v1/delivery/events/:id/replay

Path parameters

id*stringThe event id to replay.
Event replay fans out to every matching binding with fresh delivery attempts — receivers that do not deduplicate on the idempotency key will see duplicates on bindings that already delivered this event. Cancellation and replay are write operations and are rejected in master view (an organization-wide key must select one tenant).

Frequently asked questions

What is a pending delivery retry?+
A queued delivery job that has not completed: `delayed` jobs wait for their backoff slot, `waiting` jobs are runnable and queued for a worker, `active` jobs are executing right now. Cancel by `job_id`, per binding, or tenant-wide before the job runs.
How is replaying an event different from replaying an item?+
Event replay re-runs binding matching from the source signal, so it reaches every binding that matches now — including ones created after the event fired. Item replay re-sends one already-produced delivery for a specific (binding, event) pair. Use events for routing problems, items for transport problems.
What does processing_status: "no-subscribers" mean?+
The event was published and polled, but no active binding matched its type and filter, so nothing was enqueued. Create or activate a matching binding, then replay the event to deliver it retroactively.
How do I stop a queued delivery before it goes out?+
Use DELETE /v1/delivery/pending/:jobId for one job, POST /v1/delivery/bindings/:id/cancel-pending for one binding, or DELETE /v1/delivery/pending to clear every delayed and waiting retry in the tenant. An `active` job is already running and cannot be interrupted mid-attempt.