# Managing Webhooks

Register and manage your outbound webhook programmatically: set the destination, choose which events it receives, switch payload mode, delete, and inspect or replay recent deliveries.

> The API Reference is also the SDK and CLI reference. Consecutive code fences marked `tab=HTTP`, `tab=Node`, `tab=Python` and `tab=CLI` are the same call on each surface (a fence marked `tab=HTTP,CLI` is the same text for both), and a block between `:::surface <names>` and `:::` applies only to the surfaces it names. Identifiers in the text are written as in Node and in HTTP JSON (camelCase); the Python SDK spells methods, parameters and result attributes in snake_case (`sendMessage` → `send_message`, `reconnectionLink` → `reconnection_link`), while names inside HTTP JSON stay camelCase.

Register and manage the webhook that receives [workflow and account events](/docs/webhook-event-types). For general Admin API information, see the [Admin overview](/docs/admin-overview). A client may hold one active webhook at a time.

Everything on this page can also be done in the [platform dashboard](https://app.linkedapi.io/webhook) – registering the endpoint, switching payload mode, choosing events, signing, custom headers, and inspecting recent deliveries. Use these endpoints when you want it in code; the two reach the same webhook.

:::surface node
In the Node SDK these endpoints are methods of `admin.webhooks` on the [admin client](/docs/admin-overview#authentication), named after the endpoint: `webhook.setPayloadMode` is `admin.webhooks.setPayloadMode()`. Each method returns the content of `result` unwrapped: the webhook (`TWebhookSubscription`) from `set`, the other `set…` methods, `deleteHeader`, `revealSecret` and `rotateSecret`; an array from `get`, `eventTypes` and `deliveries` (`TWebhookDelivery`); and nothing from `delete`, `replayDelivery` and `sendTest`. A failed call throws `LinkedApiError` – see [error handling](/docs/admin-overview#authentication).
:::

:::surface python
In the Python SDK these endpoints are methods of `admin.webhooks` on the [admin client](/docs/admin-overview#authentication), in snake_case: `webhook.setPayloadMode` is `admin.webhooks.set_payload_mode()`. A method that takes parameters takes them as a params model exported from `linkedapi`, such as `SetWebhookPayloadModeParams`. Each method returns the content of `result` unwrapped: a `WebhookSubscription` from `set`, the other `set_…` methods, `delete_header`, `reveal_secret` and `rotate_secret`; a list from `get`, `event_types` and `deliveries` (`WebhookDelivery`); and `None` from `delete`, `replay_delivery` and `send_test`. Fields are snake_case, such as `payload_mode` and `header_names`. A failed call raises `LinkedApiError` – see [error handling](/docs/admin-overview#authentication).
:::

:::surface cli
In the CLI these endpoints are the `linkedin admin webhook` commands, in kebab-case: `webhook.setPayloadMode` is `set-payload-mode`, and `webhook.replayDelivery` is `replay`. The webhook `id` and the other required values are positional arguments. The signing secret and header values never appear on screen or on the command line unless you ask – see [secrets in the CLI](/docs/webhook-signature-verification) and [header values in the CLI](/docs/webhook-custom-headers).
:::

## webhook.set

Register the webhook. Enforces a maximum of one active webhook per client. There is no endpoint that changes the destination `url` – for that, delete the webhook and set a new one. Payload mode, the event selection, signing and custom headers are all changeable in place.

```bash tab=HTTP
curl -X POST https://api.linkedapi.io/admin/webhook.set \
  -H "Content-Type: application/json" \
  -H "linked-api-token: linked_your_token_here" \
  -d '{
    "url": "https://example.com/hooks/linkedapi",
    "payloadMode": "fat"
  }'
```

```typescript tab=Node
const webhook = await admin.webhooks.set({
  url: "https://example.com/hooks/linkedapi",
  payloadMode: "fat",
});
```

```python tab=Python
from linkedapi import SetWebhookParams

webhook = admin.webhooks.set(
    SetWebhookParams(url="https://example.com/hooks/linkedapi", payload_mode="fat")
)
```

```bash tab=CLI
linkedin admin webhook set https://example.com/hooks/linkedapi --payload-mode fat --json
```

:::surface cli
In the CLI this is `linkedin admin webhook set`:

```bash
linkedin admin webhook set <url> [flags]
```

| Flag | Type | Description |
| --- | --- | --- |
| `--payload-mode` | string | `fat` (default) or `thin` |
| `--signing` | boolean | Sign every delivery. The returned secret is shown as `[REDACTED]` |
| `--events` | string | Comma-separated event types and `<namespace>.*` wildcards. Omitted means every event |
| `--headers-stdin` | boolean | Read the custom headers from stdin, as a JSON object of names and values |

```bash
cat headers.json | linkedin admin webhook set https://example.com/hooks \
  --signing --events "workflow.*,inbox.messageReceived" --headers-stdin
```
:::

**Body:**

- `url` – HTTPS endpoint that will receive deliveries. Required.
- `payloadMode` – `fat` (default) or `thin`. See [payload modes](/docs/webhooks#payload-modes). Optional.
- `signingEnabled` – `true` to sign every delivery. Defaults to `false`. When `true`, the response includes `secret`. See [signature verification](/docs/webhook-signature-verification). Optional.
- `headers` – custom headers sent with every delivery, as a name-to-value object. See [custom delivery headers](/docs/webhook-custom-headers). Optional.
- `events` – the events to deliver: exact event types and `<namespace>.*` wildcards, such as `["workflow.completed", "inbox.*"]`. Omitted or `null` means every event. See [event selection](/docs/webhook-event-types#event-selection). Optional.

**Response:**

```json
{
  "success": true,
  "result": {
    "webhook": {
      "id": "whs-...",
      "url": "https://example.com/hooks/linkedapi",
      "payloadMode": "fat",
      "signingEnabled": false,
      "headerNames": [],
      "events": null,
      "isActive": true,
      "createdAt": "2026-06-25T12:00:00.000Z"
    }
  }
}
```

- `id` – webhook identifier, used by the other endpoints.
- `url` – the registered destination.
- `payloadMode` – current payload mode.
- `signingEnabled` – whether deliveries are signed.
- `headerNames` – names of the configured [custom headers](/docs/webhook-custom-headers), never their values.
- `events` – the stored [event selection](/docs/webhook-event-types#event-selection), de-duplicated and sorted, or `null` for every event.
- `isActive` – whether the webhook is active.
- `createdAt` – ISO 8601 timestamp.
- `secret` – the signing secret. Present **only** on a `webhook.set` that enabled signing, on `webhook.setSigning` when enabling, on `webhook.revealSecret` and on `webhook.rotateSecret`. Every other response omits it.

> A `url` that is a bare IP address in a private or internal range is rejected. Deliveries are only ever sent to public addresses.

## webhook.get

List the active webhook for this client. Returns an array with at most one entry. Never returns the signing secret – use `webhook.revealSecret` for that.

```bash tab=HTTP
curl -X POST https://api.linkedapi.io/admin/webhook.get \
  -H "Content-Type: application/json" \
  -H "linked-api-token: linked_your_token_here"
```

```typescript tab=Node
const webhooks = await admin.webhooks.get();
```

```python tab=Python
webhooks = admin.webhooks.get()
```

```bash tab=CLI
linkedin admin webhook get --json
```

**Response:**

```json
{
  "success": true,
  "result": {
    "webhooks": [
      {
        "id": "whs-...",
        "url": "https://example.com/hooks/linkedapi",
        "payloadMode": "fat",
        "signingEnabled": false,
        "headerNames": [],
        "events": null,
        "isActive": true,
        "createdAt": "2026-06-25T12:00:00.000Z"
      }
    ]
  }
}
```

## webhook.setPayloadMode

Switch the [payload mode](/docs/webhooks#payload-modes) between `fat` and `thin`.

```bash tab=HTTP
curl -X POST https://api.linkedapi.io/admin/webhook.setPayloadMode \
  -H "Content-Type: application/json" \
  -H "linked-api-token: linked_your_token_here" \
  -d '{ "id": "whs-...", "payloadMode": "thin" }'
```

```typescript tab=Node
await admin.webhooks.setPayloadMode({ id: "whs-...", payloadMode: "thin" });
```

```python tab=Python
from linkedapi import SetWebhookPayloadModeParams

admin.webhooks.set_payload_mode(
    SetWebhookPayloadModeParams(id="whs-...", payload_mode="thin")
)
```

```bash tab=CLI
linkedin admin webhook set-payload-mode whs-... thin --json
```

**Body:**

- `id` – webhook identifier. Required.
- `payloadMode` – `fat` or `thin`. Required.

## webhook.setEvents

Replace the [event selection](/docs/webhook-event-types#event-selection) in place. `null` goes back to every event. Saving the selection the webhook already has, even reordered or with duplicates, changes nothing. Returns the updated webhook.

```bash tab=HTTP
curl -X POST https://api.linkedapi.io/admin/webhook.setEvents \
  -H "Content-Type: application/json" \
  -H "linked-api-token: linked_your_token_here" \
  -d '{ "id": "whs-...", "events": ["workflow.completed", "inbox.*"] }'
```

```typescript tab=Node
const webhook = await admin.webhooks.setEvents({
  id: "whs-...",
  events: ["workflow.completed", "inbox.*"],
});
```

```python tab=Python
from linkedapi import SetWebhookEventsParams

webhook = admin.webhooks.set_events(
    SetWebhookEventsParams(id="whs-...", events=["workflow.completed", "inbox.*"])
)
```

```bash tab=CLI
linkedin admin webhook set-events whs-... "workflow.completed,inbox.*" --json
```

:::surface node
`events` is typed as `Array<TWebhookEventSelector> | null`, so TypeScript flags an unknown event type or wildcard at compile time. An entry that Linked API rejects throws `LinkedApiError` with type `invalidRequestPayload`. The same applies to `events` in `set`.
:::

:::surface python
The params model checks each entry against the `WebhookEventSelector` values as you build it and raises `pydantic.ValidationError` for an unknown one, before any request is sent. An entry that Linked API rejects raises `LinkedApiError` with type `invalidRequestPayload`. The same applies to `events` in `SetWebhookParams`.
:::

:::surface cli
In the CLI this is `linkedin admin webhook set-events`. It takes the selection as one comma-separated argument, or `--all` for every event (`null`) – exactly one of the two:

```bash
linkedin admin webhook set-events <id> <events>
linkedin admin webhook set-events <id> --all
```

An empty entry, such as one left by a trailing comma, is refused with exit code `5` before anything is sent. `set --events` takes the same list.
:::

**Body:**

- `id` – webhook identifier. Required.
- `events` – exact event types and `<namespace>.*` wildcards, or `null` for every event. Required, so a request without it never clears a selection by accident.

An invalid entry is rejected with `invalidRequestPayload` naming it, and the stored selection stays as it was.

## webhook.eventTypes

List the event types a selection can name, in the order Linked API defines them. `webhook.test` is not among them, because it is always delivered. It works before you register a webhook, so you can build a selection first.

```bash tab=HTTP
curl -X POST https://api.linkedapi.io/admin/webhook.eventTypes \
  -H "Content-Type: application/json" \
  -H "linked-api-token: linked_your_token_here"
```

```typescript tab=Node
const eventTypes = await admin.webhooks.eventTypes();
```

```python tab=Python
event_types = admin.webhooks.event_types()
```

```bash tab=CLI
linkedin admin webhook event-types --json
```

**Response:**

```json
{
  "success": true,
  "result": {
    "eventTypes": [
      "workflow.created",
      "workflow.started",
      "workflow.completed",
      "account.active",
      "account.reconnectionRequired",
      "account.frozen",
      "account.deleted",
      "inbox.messageReceived",
      "inbox.messageSent",
      "network.connectionAccepted",
      "network.connectionAdded",
      "network.connectionRequestReceived"
    ]
  }
}
```

The wildcards are not listed: each namespace in this list, the part before the first `.`, can be selected as `<namespace>.*`.

## webhook.setSigning

Turn [signature verification](/docs/webhook-signature-verification) on or off for this webhook. Returns the signing secret when enabling, so you can configure your verifier in the same step. No other endpoint changes the signing state.

```bash tab=HTTP
curl -X POST https://api.linkedapi.io/admin/webhook.setSigning \
  -H "Content-Type: application/json" \
  -H "linked-api-token: linked_your_token_here" \
  -d '{ "id": "whs-...", "signingEnabled": true }'
```

```typescript tab=Node
const { secret } = await admin.webhooks.setSigning({ id: "whs-...", signingEnabled: true });
```

```python tab=Python
from linkedapi import SetWebhookSigningParams

secret = admin.webhooks.set_signing(
    SetWebhookSigningParams(id="whs-...", signing_enabled=True)
).secret
```

```bash tab=CLI
linkedin admin webhook set-signing whs-... --on --json
```

:::surface cli
In the CLI this is `linkedin admin webhook set-signing <id>` with `--on` or `--off`, exactly one of the two. When enabling, the returned secret is shown as `[REDACTED]`; read it with [`reveal-secret`](#webhook-revealsecret).
:::

**Body:**

- `id` – webhook identifier. Required.
- `signingEnabled` – `true` to sign deliveries, `false` to stop. Required.

## webhook.setHeader

Add or replace one [custom header](/docs/webhook-custom-headers), leaving the others untouched. This is the endpoint to use when editing an existing configuration, because header values cannot be read back.

```bash tab=HTTP
curl -X POST https://api.linkedapi.io/admin/webhook.setHeader \
  -H "Content-Type: application/json" \
  -H "linked-api-token: linked_your_token_here" \
  -d '{ "id": "whs-...", "name": "Authorization", "value": "Bearer your_endpoint_token" }'
```

```typescript tab=Node
await admin.webhooks.setHeader({
  id: "whs-...",
  name: "Authorization",
  value: "Bearer your_endpoint_token",
});
```

```python tab=Python
from linkedapi import SetWebhookHeaderParams

admin.webhooks.set_header(
    SetWebhookHeaderParams(
        id="whs-...",
        name="Authorization",
        value="Bearer your_endpoint_token",
    )
)
```

```bash tab=CLI
printf 'Bearer %s' "$ENDPOINT_TOKEN" \
  | linkedin admin webhook set-header whs-... Authorization --value-stdin --json
```

:::surface cli
In the CLI this is `linkedin admin webhook set-header`. The value is never an argument: it comes from stdin or from an environment variable, exactly one of the two.

```bash
linkedin admin webhook set-header <id> <name> --value-stdin
linkedin admin webhook set-header <id> <name> --value-env <variable>
```

| Flag | Type | Description |
| --- | --- | --- |
| `--value-stdin` | boolean | Read the value from stdin. One trailing newline is removed |
| `--value-env` | string | Name of the environment variable that holds the value |

An empty value, or an environment variable that is not set, is refused with exit code `5` before anything is sent. See [header values in the CLI](/docs/webhook-custom-headers).
:::

**Body:**

- `id` – webhook identifier. Required.
- `name` – header name. An existing header with the same name, ignoring case, is replaced. Required.
- `value` – header value. Required.

## webhook.deleteHeader

Remove one custom header by name. The name is matched ignoring case.

```bash tab=HTTP
curl -X POST https://api.linkedapi.io/admin/webhook.deleteHeader \
  -H "Content-Type: application/json" \
  -H "linked-api-token: linked_your_token_here" \
  -d '{ "id": "whs-...", "name": "Authorization" }'
```

```typescript tab=Node
await admin.webhooks.deleteHeader({ id: "whs-...", name: "Authorization" });
```

```python tab=Python
from linkedapi import DeleteWebhookHeaderParams

admin.webhooks.delete_header(DeleteWebhookHeaderParams(id="whs-...", name="Authorization"))
```

```bash tab=CLI
linkedin admin webhook delete-header whs-... Authorization --json
```

**Body:**

- `id` – webhook identifier. Required.
- `name` – header name to remove. Required.

## webhook.setHeaders

Replace **all** custom headers at once. `{}` or `null` removes every header. Use this only when you hold every value – it is the programmatic path; for editing one header, use `webhook.setHeader`.

```bash tab=HTTP
curl -X POST https://api.linkedapi.io/admin/webhook.setHeaders \
  -H "Content-Type: application/json" \
  -H "linked-api-token: linked_your_token_here" \
  -d '{ "id": "whs-...", "headers": { "Authorization": "Bearer your_endpoint_token" } }'
```

```typescript tab=Node
await admin.webhooks.setHeaders({
  id: "whs-...",
  headers: { Authorization: "Bearer your_endpoint_token" },
});
```

```python tab=Python
from linkedapi import SetWebhookHeadersParams

admin.webhooks.set_headers(
    SetWebhookHeadersParams(
        id="whs-...",
        headers={"Authorization": "Bearer your_endpoint_token"},
    )
)
```

```bash tab=CLI
# headers.json: { "Authorization": "Bearer your_endpoint_token" }
cat headers.json | linkedin admin webhook set-headers whs-... --stdin --json
```

:::surface cli
In the CLI this is `linkedin admin webhook set-headers <id>` with exactly one of two flags:

| Flag | Type | Description |
| --- | --- | --- |
| `--stdin` | boolean | Read the headers from stdin, as a JSON object of names and values |
| `--clear` | boolean | Remove every header (sends `null`) |

An empty value in the JSON object is refused with exit code `5` before anything is sent; an empty object `{}` clears every header, like `--clear`.
:::

**Body:**

- `id` – webhook identifier. Required.
- `headers` – name-to-value object, or `null` to clear. Required.

## webhook.revealSecret

Return the current signing secret. Use it when you need the secret again after enabling signing – for example when configuring a second environment.

```bash tab=HTTP
curl -X POST https://api.linkedapi.io/admin/webhook.revealSecret \
  -H "Content-Type: application/json" \
  -H "linked-api-token: linked_your_token_here" \
  -d '{ "id": "whs-..." }'
```

```typescript tab=Node
const { secret } = await admin.webhooks.revealSecret({ id: "whs-..." });
```

```python tab=Python
from linkedapi import RevealWebhookSecretParams

secret = admin.webhooks.reveal_secret(RevealWebhookSecretParams(id="whs-...")).secret
```

```bash tab=CLI
linkedin admin webhook reveal-secret whs-... --print-secret
linkedin admin webhook reveal-secret whs-... --secret-file webhook-secret.txt
```

:::surface cli
In the CLI this is `linkedin admin webhook reveal-secret <id>`, and it needs exactly one of two flags that say where the secret goes:

| Flag | Type | Description |
| --- | --- | --- |
| `--print-secret` | boolean | Write only the secret and a newline to stdout, ignoring `--json` and `--fields`, so it fits `$(...)` |
| `--secret-file` | string | Create a new file with mode `0600` holding the secret, and print its path instead of the secret. A path that already exists is refused |
:::

**Body:**

- `id` – webhook identifier. Required.

## webhook.rotateSecret

Generate a new signing secret, store it and return it. This replaces a leaked secret without deleting the webhook, which would change its `id`.

```bash tab=HTTP
curl -X POST https://api.linkedapi.io/admin/webhook.rotateSecret \
  -H "Content-Type: application/json" \
  -H "linked-api-token: linked_your_token_here" \
  -d '{ "id": "whs-..." }'
```

```typescript tab=Node
const { secret } = await admin.webhooks.rotateSecret({ id: "whs-..." });
```

```python tab=Python
from linkedapi import RotateWebhookSecretParams

secret = admin.webhooks.rotate_secret(RotateWebhookSecretParams(id="whs-...")).secret
```

```bash tab=CLI
linkedin admin webhook rotate-secret whs-... --secret-file new-webhook-secret.txt
```

:::surface cli
In the CLI this is `linkedin admin webhook rotate-secret <id>`. It warns on stderr that the old secret stops working at once, and takes the same two flags as [`reveal-secret`](#webhook-revealsecret), both optional. With `--secret-file`, the file is created before the secret rotates, so a path that already exists stops the command before anything changes. Without either flag, the new secret is shown as `[REDACTED]`; read it with `reveal-secret`.
:::

**Body:**

- `id` – webhook identifier. Required.

> Rotation takes effect immediately and there is no overlap period: the old secret stops signing the moment the new one is stored, so every delivery fails verification until your endpoint holds the new value. Rotate when you are ready to deploy it.

## webhook.delete

Delete the webhook. This is a soft delete: the delivery history is preserved and any still-pending deliveries are dropped. Because only active webhooks count toward the one-per-client limit, you can register a fresh webhook afterwards.

```bash tab=HTTP
curl -X POST https://api.linkedapi.io/admin/webhook.delete \
  -H "Content-Type: application/json" \
  -H "linked-api-token: linked_your_token_here" \
  -d '{ "id": "whs-..." }'
```

```typescript tab=Node
await admin.webhooks.delete({ id: "whs-..." });
```

```python tab=Python
from linkedapi import DeleteWebhookParams

admin.webhooks.delete(DeleteWebhookParams(id="whs-..."))
```

```bash tab=CLI
linkedin admin webhook delete whs-...
```

**Body:**

- `id` – webhook identifier. Required.

## webhook.deliveries

Return the most recent deliveries (newest first) as a debug feed – useful for confirming an endpoint is receiving and acknowledging events.

```bash tab=HTTP
curl -X POST https://api.linkedapi.io/admin/webhook.deliveries \
  -H "Content-Type: application/json" \
  -H "linked-api-token: linked_your_token_here"
```

```typescript tab=Node
const deliveries = await admin.webhooks.deliveries();
```

```python tab=Python
deliveries = admin.webhooks.deliveries()
```

```bash tab=CLI
linkedin admin webhook deliveries --json
```

**Response:**

```json
{
  "success": true,
  "result": {
    "deliveries": [
      {
        "id": "whd-...",
        "eventType": "workflow.completed",
        "eventId": "workflow.completed:wf-...",
        "status": "success",
        "attempts": 1,
        "responseStatusCode": 200,
        "lastError": null,
        "createdAt": "2026-06-25T12:00:00.000Z",
        "updatedAt": "2026-06-25T12:00:01.000Z"
      }
    ]
  }
}
```

- `id` – delivery identifier, passed to `webhook.replayDelivery`.
- `eventType` – the event `type` that was delivered.
- `eventId` – the envelope `id` of the delivered event.
- `status` – `pending`, `delivering`, `success`, or `failed`.
- `attempts` – delivery attempts made so far.
- `responseStatusCode` – HTTP status your endpoint returned on the last attempt, or `null`.
- `lastError` – error text from the last failed attempt, or `null`.
- `createdAt` / `updatedAt` – ISO 8601 timestamps.

## webhook.replayDelivery

Re-arm an already-settled (`success` or `failed`) delivery for redelivery. The same `eventId` is reused, so consumer-side deduplication still applies – this is a true redelivery, not a new event.

```bash tab=HTTP
curl -X POST https://api.linkedapi.io/admin/webhook.replayDelivery \
  -H "Content-Type: application/json" \
  -H "linked-api-token: linked_your_token_here" \
  -d '{ "deliveryId": "whd-..." }'
```

```typescript tab=Node
await admin.webhooks.replayDelivery({ deliveryId: "whd-..." });
```

```python tab=Python
from linkedapi import ReplayWebhookDeliveryParams

admin.webhooks.replay_delivery(ReplayWebhookDeliveryParams(delivery_id="whd-..."))
```

```bash tab=CLI
linkedin admin webhook replay whd-...
```

**Body:**

- `deliveryId` – delivery identifier from `webhook.deliveries`. Required.

## webhook.sendTest

Emit a synthetic `webhook.test` event to the active webhook through the normal delivery path. Its `data` carries a single `message` field. Use it to verify a freshly registered endpoint without waiting for a real event.

```bash tab=HTTP
curl -X POST https://api.linkedapi.io/admin/webhook.sendTest \
  -H "Content-Type: application/json" \
  -H "linked-api-token: linked_your_token_here"
```

```typescript tab=Node
await admin.webhooks.sendTest();
```

```python tab=Python
admin.webhooks.send_test()
```

```bash tab=CLI
linkedin admin webhook send-test
```
