## Get a webhook endpoint

**get** `/v1/webhook_endpoints/{endpoint}`

Reads one endpoint, including its delivery health.

### Path Parameters

- `endpoint: string`

### Returns

- `Endpoint object { id, created_at, disabled_at, 8 more }`

  A destination this brand's events are delivered to.

  - `id: string`

    The endpoint's id.

  - `created_at: string`

  - `disabled_at: string`

    When this endpoint was last disabled. `null` while it is enabled.

  - `event_kinds: array of string`

    The event kinds delivered here, or `null` for every kind (including kinds added later).

  - `health: EndpointHealth`

    How a destination has been behaving, taken from the deliveries actually
    attempted against it. Worth reading before assuming an integration is
    healthy: a destination that has been refusing events shows up here well
    before anyone notices they are missing.

    - `consecutive_failures: number`

      Failed attempts since the last success. Reset to 0 by any success.

    - `last_failure_at: string`

      When a delivery to this endpoint last failed. `null` if none ever has.

    - `last_failure_reason: string`

      A short reason for the last failure, written for a human reading it. The wording is not stable; do not branch on it.

    - `last_failure_status: number`

      The HTTP status of that last failure. `null` when the attempt never reached a response at all — a name that did not resolve, a refused connection, a timeout, or an address we will not dial.

    - `last_success_at: string`

      When a delivery to this endpoint last succeeded. `null` if none ever has.

  - `status: string`

    `enabled` or `disabled`. A disabled endpoint receives nothing, and events are not queued for it — see the update operation. Values grow additively.

  - `updated_at: string`

  - `url: string`

    Where events are POSTed. `https` only.

  - `backlog_dropped: optional number`

    How many undelivered events were dropped by THIS request, present only
    on the response to a request that disabled or deleted the endpoint.
    Disabling is a cutoff: everything still queued for this endpoint is
    dropped then and there rather than waiting to be replayed later.

  - `backlog_resume_cursor: optional string`

    Where to pick the dropped events back up: pass it as the `cursor` query
    parameter to `GET /v1/streams/events` and the first event you receive is the
    first one dropped. Present alongside `backlog_dropped` and only then.

    **Keep it if you rely on webhooks alone.** A webhook carries the event's
    identity but not its position in the stream, so this response is the only
    place a push-only integration is handed the position of the gap it just
    created. Reconnecting without a cursor starts at the present moment and
    skips the gap entirely.

    It stays valid while the events behind it are retained; past that the
    stream answers `410 cursor_expired` rather than pretending.

  - `description: optional string`

    Your own label for this endpoint.

### Example

```http
curl https://whatsapp.messages.api.linqapp.com/v1/webhook_endpoints/$ENDPOINT \
    -H "Authorization: Bearer $LINQ_WHATSAPP_API_KEY"
```

#### Response

```json
{
  "id": "id",
  "created_at": "2019-12-27T18:11:19.117Z",
  "disabled_at": "2019-12-27T18:11:19.117Z",
  "event_kinds": [
    "string"
  ],
  "health": {
    "consecutive_failures": 0,
    "last_failure_at": "2019-12-27T18:11:19.117Z",
    "last_failure_reason": "last_failure_reason",
    "last_failure_status": 0,
    "last_success_at": "2019-12-27T18:11:19.117Z"
  },
  "status": "status",
  "updated_at": "2019-12-27T18:11:19.117Z",
  "url": "url",
  "backlog_dropped": 0,
  "backlog_resume_cursor": "backlog_resume_cursor",
  "description": "description"
}
```