> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://developer.jelliu.co/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://developer.jelliu.co/_mcp/server.

# List a webhook's deliveries

GET https://api.jelliu.co/api/webhooks/{webhookId}/deliveries

Returns the endpoint's deliveries, newest first: one record per event (retries of an event update
the same record; individual attempts are available from `GET /api/webhooks/deliveries/{deliveryId}`).
Deliveries are retained for 30 days.

**Pagination.** Opaque cursor. Pass `meta.next_cursor` as `cursor` to fetch the next page; `null`
indicates the last page. Filter with `status` and `type`.

Events excluded by the endpoint's `events` or `filters` never create a delivery; an empty log for
an expected event usually indicates a subscription or filter mismatch.

**Idempotency.** A read with no side effects. Safe to retry.

**Access**

* **Required scope:** `read` or `write`. Any workspace role can call it.
* **Rate limit:** General API — 120 requests/min per workspace on Starter or with no active plan, 200 on Growth, 300 on Business, 600 on Enterprise. See [Rate limits](/rate-limits).
* **Plan:** Available on every plan and also without an active subscription. See [Billing and usage](/platform/billing-and-usage#without-an-active-subscription).

Reference: https://developer.jelliu.co/api-reference/webhooks/get-webhooks-by-webhook-id-deliveries

## Authentication

- `Authorization` header (bearer token, required) — Workspace API key: `jl_` followed by 64 lowercase hex characters, created by the workspace owner in the dashboard (**Settings → API Keys**) and sent as `Authorization: Bearer jl_...`. The plaintext is shown once, at creation; Jelliu stores only a SHA-256 hash. A workspace can hold up to 25 active keys. | Scope | GET / HEAD | POST / PUT / PATCH / DELETE | Admin-only routes | | --- | --- | --- | --- | | `read` | Yes | No | No | | `write` | Yes | Yes | No | | `full` | Yes | Yes | Yes | Operations restricted to admins or owners reject keys without the `full` scope with `403`, and say so in their description. No key, whatever its scope, can mint or revoke API keys or rotate a webhook secret — that requires a signed-in owner session. A revoked key stops authenticating within about 10 seconds. See [Authentication](/authentication).

## Request

### Path parameters

- `webhookId` (string, required) — UUID of the outbound webhook endpoint, returned as `id` by `GET /api/webhooks`. It must belong to the authenticated workspace; an id from another workspace, an unknown id or a value that is not a UUID answers `404`.

### Query parameters

- `status` (enum, optional) — Only deliveries in this state.
  - Allowed values: `pending`, `delivering`, `succeeded`, `failed`, `canceled`
- `type` (string, optional) — Only deliveries of this event type (exact match).
- `cursor` (string, optional) — `meta.next_cursor` from the previous page.
- `limit` (integer, optional, default: 50) — Rows per page, 1 to 100.

## Response

### 200

One page of deliveries, newest first.

- `data` (list of WebhookDelivery, required)
- `meta` (ApiWebhooksWebhookIdDeliveriesGetResponsesContentApplicationJsonSchemaMeta, required)

## Errors

### 400 Bad Request Error

A query parameter is not valid.

- `error` (ErrorResponseError, required) — The error object. Always has `code` and `message`.

### 401 Unauthorized Error

No usable credential. Either the `Authorization` header is missing or is not a well-formed `Bearer jl_…` key, or the key is unknown, revoked or expired. Do not retry with the same key. See [Authentication](/authentication#401-unauthorized).

- `error` (ErrorResponseError, required) — The error object. Always has `code` and `message`.

### 403 Forbidden Error

Authenticated, but not allowed: the key's scope does not cover the method, the route is restricted to workspace admins/owners and the key is not `full`, or the workspace is suspended (`TENANT_SUSPENDED`). See [Authentication](/authentication#scopes).

- `error` (ErrorResponseError, required) — The error object. Always has `code` and `message`.

### 404 Not Found Error

No webhook with this id in the workspace, it was deleted, or `webhookId` is not a UUID.

- `error` (ErrorResponseError, required) — The error object. Always has `code` and `message`.

### 429 Too Many Requests Error

Rate limit exceeded for the current 60-second window (`RATE_LIMIT_EXCEEDED`). Wait `Retry-After` seconds, then retry. The `message` differs per limiter; the code does not. See [Rate limits](/rate-limits).

- `error` (ErrorResponseError, required) — The error object. Always has `code` and `message`.

## Types

### WebhookDelivery

One event sent, or scheduled to be sent, to one endpoint. Retries update the same record.

- `id` (string, required) — The delivery id, sent as `x-jelliu-delivery-id`. Use it with `GET /api/webhooks/deliveries/{deliveryId}`.
- `event_id` (string, required) — The event id (the `webhook-id` header).
- `event_type` (string, required)
- `status` (enum, required) — `pending` (awaiting its first attempt or a retry), `delivering` (an attempt is in flight), `succeeded` (a `2xx` response), `failed` (a non-retryable response, or all attempts used), `canceled` (not sent: the endpoint was deleted or disabled, the workspace has no active subscription, or the event expired).
  - Allowed values: `pending`, `delivering`, `succeeded`, `failed`, `canceled`
- `attempt_count` (integer, required) — Attempts made so far (up to 12 automatic ones; a manual retry adds one).
- `next_attempt_at` (datetime, required, nullable) — When the next attempt is due, while `pending`.
- `last_attempt_at` (datetime, required, nullable)
- `last_status_code` (integer, required, nullable) — HTTP status of the last attempt; `null` when there was no HTTP response.
- `last_error` (string, required, nullable) — Machine-readable code of the last failure or cancellation reason, `null` on success: `timeout`, `url_not_allowed`, `connection_error[:<errno>]`, `http_<status>`, `signing_secret_unreadable`, `custom_headers_unreadable`, `custom_headers_invalid`, `attempt_abandoned`, `endpoint_deleted`, `endpoint_disabled`, `event_missing`, `subscription_inactive`.
- `last_duration_ms` (integer, required, nullable) — Duration of the last attempt in milliseconds.
- `manual` (boolean, required) — `true` for tests, manual retries and replays. Manual deliveries never count toward the endpoint's health.
- `created_at` (datetime, required)

### ApiWebhooksWebhookIdDeliveriesGetResponsesContentApplicationJsonSchemaMeta

- `next_cursor` (string, required, nullable) — Cursor for the next page, or `null` on the last page.

### ErrorResponseError

The error object. Always has `code` and `message`.

- `code` (string, required) — Stable machine-readable error code (for example `VALIDATION_FAILED`, `PAYLOAD_TOO_LARGE`, `UNAUTHORIZED`, `FORBIDDEN`, `NOT_FOUND`, `BILLING_ERROR`, `COMPLIANCE_BLOCKED`, `RATE_LIMIT_EXCEEDED`, `INTERNAL_ERROR`). Switch on this, not on `message`. See [Errors](/errors).
- `message` (string, required) — Human-readable explanation. English or Spanish depending on the route; may change without notice.
- `details` (ErrorResponseErrorDetails, optional) — Present on `VALIDATION_FAILED` only. Its shape depends on how the route validates: * a field map, either Zod's `flatten()` output (`{ "formErrors": [], "fieldErrors": { "name": ["..."] } }`) or just its `fieldErrors` part (`{ "name": ["..."] }`); * an issue list, where each issue has at least `path`, `message` and `code`. `path` is a dot-separated string on routes that let the schema throw, and an array of keys on routes that forward Zod's raw issues (those also carry Zod's extra issue fields); * for a rejected multipart upload (file in an unexpected field, too many files), a list with the upload error `code` (for example `LIMIT_UNEXPECTED_FILE`) and the `field` name. Absent when the value was rejected outside the route's own validation: a malformed id, number or date the database could not read, or a JSON body that does not parse.
- `metadata` (map from string to any, optional) — Structured detail exposed for a small allowlist of codes only — for example `BILLING_ERROR` carries `limit`, `current` and `tier` (resource caps), `tier` alone (feature gates), or `tier` = `none` with `kind` = `subscription_required` when the workspace has no active subscription. See [Errors](/errors).

### ErrorResponseErrorDetails

Present on `VALIDATION_FAILED` only. Its shape depends on how the route validates: * a field map, either Zod's `flatten()` output (`{ "formErrors": [], "fieldErrors": { "name": ["..."] } }`) or just its `fieldErrors` part (`{ "name": ["..."] }`); * an issue list, where each issue has at least `path`, `message` and `code`. `path` is a dot-separated string on routes that let the schema throw, and an array of keys on routes that forward Zod's raw issues (those also carry Zod's extra issue fields); * for a rejected multipart upload (file in an unexpected field, too many files), a list with the upload error `code` (for example `LIMIT_UNEXPECTED_FILE`) and the `field` name. Absent when the value was rejected outside the route's own validation: a malformed id, number or date the database could not read, or a JSON body that does not parse.

- Field map: Field map
- Issue list: list of ErrorResponseErrorDetailsOneOf1Items

### Field map

- `formErrors` (list of string, optional)
- `fieldErrors` (map from string to list of string, optional)

### ErrorResponseErrorDetailsOneOf1Items

- `path` (ErrorResponseErrorDetailsOneOf1ItemsPath, optional) — Dot-separated string, or an array of keys.
- `message` (string, optional)
- `code` (string, optional) — Zod issue code, for example `invalid_type`.

### ErrorResponseErrorDetailsOneOf1ItemsPath

Dot-separated string, or an array of keys.

- string
- list of ErrorResponseErrorDetailsOneOf1ItemsPathOneOf1Items

### ErrorResponseErrorDetailsOneOf1ItemsPathOneOf1Items

- string
- integer

## Examples

**Response**

```json
{
  "data": [
    {
      "id": "dlv_01K6B3X0R2A5C8E1G4J7K0M3N6",
      "event_id": "evt_01K6B3X0Q9Z4T7M2N5P8R1S3V6",
      "event_type": "call.completed",
      "status": "succeeded",
      "attempt_count": 1,
      "next_attempt_at": null,
      "last_attempt_at": "2026-09-27T21:04:05.402Z",
      "last_status_code": 200,
      "last_error": null,
      "last_duration_ms": 184,
      "manual": false,
      "created_at": "2026-09-27T21:04:05.130Z"
    },
    {
      "id": "dlv_01K6B2W7M4P1R8T5V2X9Z6B3D0",
      "event_id": "evt_01K6B2W7M1N8P5R2T9V6X3Z0B7",
      "event_type": "call.failed",
      "status": "pending",
      "attempt_count": 2,
      "next_attempt_at": "2026-09-27T20:48:12.000Z",
      "last_attempt_at": "2026-09-27T20:46:10.004Z",
      "last_status_code": 503,
      "last_error": "http_503",
      "last_duration_ms": 96,
      "manual": false,
      "created_at": "2026-09-27T20:45:39.870Z"
    }
  ],
  "meta": {
    "next_cursor": "ZGx2XzAxSzZCMlc3TTRQMVI4VDVWMlg5WjZCM0Qw"
  }
}
```

**SDK Code**

```python Webhooks_getWebhooksByWebhookIdDeliveries_example
import requests

url = "https://api.jelliu.co/api/webhooks/9a7b6c5d-4e3f-4a2b-8c1d-0e9f8a7b6c5d/deliveries"

querystring = {"limit":"50","status":"failed","type":"call.completed"}

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())
```

```javascript Webhooks_getWebhooksByWebhookIdDeliveries_example
const url = 'https://api.jelliu.co/api/webhooks/9a7b6c5d-4e3f-4a2b-8c1d-0e9f8a7b6c5d/deliveries?limit=50&status=failed&type=call.completed';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Webhooks_getWebhooksByWebhookIdDeliveries_example
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.jelliu.co/api/webhooks/9a7b6c5d-4e3f-4a2b-8c1d-0e9f8a7b6c5d/deliveries?limit=50&status=failed&type=call.completed"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Webhooks_getWebhooksByWebhookIdDeliveries_example
require 'uri'
require 'net/http'

url = URI("https://api.jelliu.co/api/webhooks/9a7b6c5d-4e3f-4a2b-8c1d-0e9f8a7b6c5d/deliveries?limit=50&status=failed&type=call.completed")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

```java Webhooks_getWebhooksByWebhookIdDeliveries_example
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.jelliu.co/api/webhooks/9a7b6c5d-4e3f-4a2b-8c1d-0e9f8a7b6c5d/deliveries?limit=50&status=failed&type=call.completed")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Webhooks_getWebhooksByWebhookIdDeliveries_example
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.jelliu.co/api/webhooks/9a7b6c5d-4e3f-4a2b-8c1d-0e9f8a7b6c5d/deliveries?limit=50&status=failed&type=call.completed', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

echo $response->getBody();
```

```csharp Webhooks_getWebhooksByWebhookIdDeliveries_example
using RestSharp;

var client = new RestClient("https://api.jelliu.co/api/webhooks/9a7b6c5d-4e3f-4a2b-8c1d-0e9f8a7b6c5d/deliveries?limit=50&status=failed&type=call.completed");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Webhooks_getWebhooksByWebhookIdDeliveries_example
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.jelliu.co/api/webhooks/9a7b6c5d-4e3f-4a2b-8c1d-0e9f8a7b6c5d/deliveries?limit=50&status=failed&type=call.completed")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```