# How do EnableCalls webhooks deliver call results?

Webhooks push each result to your URL the moment it happens, signed so you can check it came from EnableCalls.

## Which events can I receive?

| type | When |
| --- | --- |
| `call.completed` | A call reached the person: outcome, summary, captured details, the person and their contact fields. |
| `call.not_connected` | A single call was not reached after its last attempt. `data.call` is the call object. |
| `call.inbound_missed` | Someone rang your number and nobody answered (outside hours, employee switched off, no coins). `data.missed_call` says who, why, and whether and when they are called back. |
| `lead.updated` | A lead's details or outcome changed after a call. |
| `appointment.booked` | An appointment was booked on a call or by your team. |
| `appointment.updated` | An appointment was confirmed, moved, cancelled or completed. |

Create endpoints with `POST /webhook-endpoints` (or in the dashboard under Integrations). Subscribe to `*` for every type. Events are kept for 30 days and listed by `GET /events`.

A delivery:

```json
{
  "id": "4b1f0c3a-9d2e-4f6a-8b7c-1d2e3f4a5b6c",
  "type": "call.not_connected",
  "api_version": "2026-10-31",
  "created_at": "2026-10-31T06:02:11Z",
  "test": false,
  "data": {
    "call": {
      "object": "call",
      "id": "8f0c1d6e-2b9a-4a51-9c1e-3c4f5a6b7c8d",
      "status": "not_connected",
      "status_detail": "Not reached after 2 attempt(s).",
      "attempts_made": 2,
      "max_attempts": 2,
      "external_id": "lead-1042",
      "result": null
    }
  }
}
```

## How do I verify a signature?

Every delivery carries `X-EnableCalls-Timestamp` (Unix seconds) and `X-EnableCalls-Signature`, which is `sha256=` followed by the hex HMAC-SHA256 of `timestamp.raw_body` with your endpoint's secret. Compare in constant time and reject timestamps older than 5 minutes.

Node.js:

```javascript
// Express: use the RAW body; re-serialised JSON will not match.
const crypto = require("crypto");

app.post("/enablecalls", express.raw({ type: "application/json" }), (req, res) => {
  const timestamp = req.get("X-EnableCalls-Timestamp");
  const given = req.get("X-EnableCalls-Signature") || "";
  const expected = "sha256=" + crypto
    .createHmac("sha256", process.env.ENABLECALLS_WEBHOOK_SECRET)
    .update(timestamp + ".")
    .update(req.body)
    .digest("hex");
  const fresh = Math.abs(Date.now() / 1000 - Number(timestamp)) < 300;
  const ok = given.length === expected.length &&
    crypto.timingSafeEqual(Buffer.from(given), Buffer.from(expected));
  if (!ok || !fresh) return res.sendStatus(400);
  res.sendStatus(200);              // answer quickly…
  handle(JSON.parse(req.body));     // …then do the work
});
```

Python:

```python
import hashlib, hmac, os, time

def verify(raw_body: bytes, timestamp: str, signature: str) -> bool:
    secret = os.environ["ENABLECALLS_WEBHOOK_SECRET"].encode()
    expected = "sha256=" + hmac.new(
        secret, timestamp.encode() + b"." + raw_body, hashlib.sha256
    ).hexdigest()
    fresh = abs(time.time() - int(timestamp)) < 300
    return fresh and hmac.compare_digest(expected, signature)
```

## What happens if my endpoint is down?

Only a 2xx answer within 10 seconds counts as delivered; redirects count as failures. A failed delivery is tried 6 times: at once, then after 1 minute, 5 minutes, 30 minutes, 2 hours and 6 hours. See every attempt with `GET /webhook-endpoints/{id}/deliveries` and send one again with `…/deliveries/{id}/resend`.

- Deliveries can arrive out of order and, rarely, twice. Use the event `id` to skip duplicates.
- URLs must be public `https` addresses; private and local network addresses are refused.
- `POST /webhook-endpoints/{id}/test` sends a `test` event with `"test": true`.
- `POST /webhook-endpoints/{id}/rotate-secret` issues a new secret; the old one stops at once.

## Can the employee ask my own system during a call?

Yes. In the dashboard, open an employee, then Instructions → Your systems, and add an action: a short name such as `order_status`, when to use it, and your `https` address. When a caller needs it, the employee says a few words ("One moment, let me check") while EnableCalls sends your address a signed POST, then answers from your reply. Your system must answer within 3 seconds.

What your system receives:

```json
{
  "action": "order_status",
  "request": "order 4521",
  "call": {
    "id": "8f0c1d6e-2b9a-4a51-9c1e-3c4f5a6b7c8d",
    "employee_id": "EMPLOYEE_ID",
    "caller_number": "+91XXXXXXXXXX",
    "test": false
  },
  "sent_at": "2026-11-02T10:15:00Z"
}
```

- Signed like webhooks: verify `X-EnableCalls-Signature` with the action's own secret (shown once when you add it). `X-EnableCalls-Action` names the action.
- Answer with JSON `{"reply": "..."}` or plain text in plain words the employee can say; the first 1,000 characters are used.
- No answer within 3 seconds, or an error status, and the employee tells the caller the team will confirm after the call.
- `call.test` is `true` for test calls and for the dashboard's Test button.

## More EnableCalls API docs

- [Overview](https://enablecalls.com/developers.md): Place AI phone calls, run calling campaigns and get every conversation's outcome, summary and transcript from your CRM, website, n8n, Make or Zapier.
- [Authentication](https://enablecalls.com/developers/authentication.md): Create EnableCalls API keys on the Developers page, choose full or read-only access, and send them as a Bearer token. Keys are shown once and can be revoked at once.
- [Calls and retries](https://enablecalls.com/developers/calls.md): How EnableCalls API calls move from queued to completed: calling hours, do-not-call, coins, the 30-minute cooldown, automatic retries for unanswered calls and every status.
- [Errors and limits](https://enablecalls.com/developers/errors.md): The EnableCalls API error format, rate limits per key, Idempotency-Key for safe retries, dry runs and starting_after pagination.
- [n8n, Make, Zapier](https://enablecalls.com/developers/no-code.md): Call new leads from n8n, Make, Zapier or Pabbly Connect with an HTTP request to the EnableCalls API, and receive call results with a webhook trigger.
- [API reference](https://enablecalls.com/developers/reference.md): Every EnableCalls API endpoint: calls, leads, campaigns, contacts, appointments, do-not-call, webhooks, events, employees and phone numbers, with parameters and fields.

Canonical page: https://enablecalls.com/developers/webhooks
