> ## Documentation Index
> Fetch the complete documentation index at: https://stage-docs.oktivo.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Panzo CRM

> Let Panzo place Oktivo AI calls for your leads and receive the call results back in Panzo

# Panzo CRM

Panzo is a CRM. With this setup, Panzo asks Oktivo to call a lead with your AI agent, and when the call is over Oktivo sends the result (status, duration, summary, transcript, recording link, extracted answers) back to that lead in Panzo.

> [!NOTE]
>
> **Quick overview**
>
> * **What you need:** an Oktivo account with the CRM API and Webhooks features, one Oktivo agent, and a Panzo account with AI Calls enabled.
> * **Time to set up:** about 30 minutes, plus a test call.
> * **Who does what:**
>   * **Oktivo admin:** creates the API token, the agent, the analysis schema and the webhook (steps 1 to 5).
>   * **Panzo admin:** enters the token, agent ID and webhook secret in Panzo (step 6).
> * **No Panzo tile:** Panzo is not listed under **Connecter**. You connect it with an API token and a webhook, as described below.

Panzo's own documentation for this is at [app.thepanzo.com/developers](https://app.thepanzo.com/developers#webhooks).

## How it works

```
┌────────────┐  1. Place a call (API token)               ┌──────────────┐
│   Panzo    │ ─────────────────────────────────────────▶ │    Oktivo    │
│            │                                             │  AI agent    │
│  Results   │  2. Call result (signed webhook)            │  calls the   │
│   Link     │ ◀───────────────────────────────────────── │  lead        │
└────────────┘                                             └──────────────┘
```

1. A lead arrives in Panzo and Panzo sends a call request to Oktivo. Oktivo answers with a call ID (`contactUID`).
2. Oktivo calls the lead.
3. Oktivo sends results to Panzo's **Results Link**. Every result carries the same call ID, so Panzo knows which lead it belongs to.

## Before you start

* [ ] Your Oktivo plan includes **CRM API** and **Webhooks**. If **Settings > API Tokens** or **Connecter > Webhooks** is missing from your dashboard, ask Oktivo support to enable them.
* [ ] You have an Oktivo agent that is ready to call (script written and tested).
* [ ] Your Oktivo account has enough credits.
* [ ] You know who the Panzo admin is, and that person can open Panzo's AI Calls connection settings.
* [ ] You have a safe place to store secrets (a password manager). The API token and the webhook secret are each shown only once.

## Set up

**1. Create an API token (Oktivo admin)**

In the Oktivo dashboard open **Settings** (bottom of the left menu), then the **API Tokens** tab, and click **Create Token**. Give it a name such as `panzo` and choose an expiry between 1 and 365 days. An account can have at most 5 active tokens.

> [!WARNING]
>
> The token starts with `okt_` and is shown only once. Copy it now. Write down the expiry date: on that day Panzo stops being able to place calls until you rotate or replace the token and update Panzo.

More detail: [Authentication](https://stage-docs.oktivo.com/authentication.md).

**2. Find the Agent ID (Oktivo admin)**

Open **Agents** in the left menu, open the agent that should call Panzo leads, and copy its ID. Panzo sends this value as `agentId` with every call request.

Developers can also list agents:

```bash theme={null}
curl https://client-backend.oktivo.com/api/v1/crm/agents \
  -H "Authorization: Bearer okt_your_token_here"
```

**3. Use Panzo's variables in the agent script (Oktivo admin)**

Panzo sends details about the lead with each call. In your agent script, use these names exactly, with double curly braces:

| Variable | Meaning |
| - | - |
| `{{name}}` | Lead's full name |
| `{{first_name}}` | Lead's first name |
| `{{source}}` | Where the lead came from |
| `{{area}}` | Area or location the lead is interested in |

Panzo also sends its own lead number as `panzo_lead_id`. You do not need it in the script, but it comes back in every result under `data.dynamicVariables`, which helps when you check a call later.

**4. Choose the answers to extract (Oktivo admin)**

An **analysis schema** is the list of answers Oktivo should pull out of each conversation, such as budget or preferred callback time. Panzo shows them as `data.analysis`.

Open **Analysis Schemas** in the left menu, create or choose a schema, and attach it to the agent. A typical schema for property leads:

| Field | Type | Notes |
| - | - | - |
| `budget` | text or number | The lead's budget |
| `property_type` | text | For example apartment or villa |
| `callback_time` | text | Must be written as ISO 8601, for example `2026-01-02T09:30:00Z`. Say so in the field's description. |
| `summary` | text | Short summary of the call |

> [!NOTE]
>
> Add a `summary` field. Panzo's summary is taken from your schema's `summary` field. If there is none, Oktivo uses its own automatic conversation summary instead. If neither exists, the summary is left out.

**5. Create the webhook (Oktivo admin)**

Oktivo needs the address Panzo gave you. In Panzo open **Control Panel > Connections > AI Calls** and copy the **Results Link**. Copy it exactly; do not retype it.

Then in Oktivo:

1. Open **Connecter** in the left menu, then the **Webhooks** tab, and click **Add webhook tool**.
2. **Events step:** tick `call.ended`, `call.analysis_ready` and `call.completed`. Click **Next**.
3. **Endpoint step:** paste the Results Link into **Endpoint URL**. Add a description such as "Panzo results".
4. **Agent Filter (optional):** leave it as "All agents (default)" or click **Customize** and pick the agent from step 2. See [Webhook Filtering](https://stage-docs.oktivo.com/guides/webhook-filtering.md).
5. **Payload Mode:** keep **Standard**.
6. **Delivery format:** choose **Panzo CRM**. This option only appears in Standard mode.
7. Click **Next**, then **Create**.
8. A **Webhook Secret** window opens. Click the copy icon, store the secret safely, then click **Done**.

> [!WARNING]
>
> If **Delivery format** stays on **Standard (default)**, Panzo cannot read the signature and rejects every delivery with HTTP 401.

Developers can create the same endpoint with the API instead. See [Create the webhook with the API](#create-the-webhook-with-the-api).

**6. Enter the details in Panzo (Panzo admin)**

Send the [handoff checklist](#handoff-checklist-for-the-panzo-admin) to the Panzo admin. In Panzo's AI Calls connection settings they enter the API token, the agent ID, the webhook secret and the variable names.

**7. Place a test call**

Create a test lead in Panzo with your own phone number and let Panzo place the call. Answer it and talk for a few seconds.

Then check three places:

* **Monitor > Logs > Webhook Logs** in Oktivo. You should see `call.ended` first, then `call.analysis_ready` and `call.completed`, each with status `200`.
* The lead in Panzo. The call status, summary and transcript should appear.
* The extracted answers. If `callback_time` or `budget` are missing, check the analysis schema.

> [!WARNING]
>
> Do not use **Send Test** on the last page of the webhook wizard for Panzo. That test request is sent without a signature, because the secret does not exist yet, so Panzo answers 401. This is expected and does not mean your setup is wrong. Use a real test call, or the signed test below.

## Check the secret without placing a call

This sends a correctly signed sample result straight to Panzo. Use it to confirm that the Results Link and the secret match. A lead that does not exist in Panzo is fine; Panzo accepts the request and ignores it.

```bash macOS / Linux theme={null}
RESULTS_LINK="PASTE_THE_PANZO_RESULTS_LINK"
SECRET="PASTE_THE_WEBHOOK_SECRET"
BODY='{"event":"call.ended","type":"call.ended","data":{"contactUID":"cnt_does_not_exist","callStatus":"ended","callDuration":5}}'

SIG=$(printf '%s' "$BODY" | openssl dgst -sha256 -hmac "$SECRET" | sed 's/^.* //')

curl -i -X POST "$RESULTS_LINK" \
  -H "Content-Type: application/json" \
  -H "X-Oktivo-Signature: $SIG" \
  --data-binary "$BODY"
```

| Answer | Meaning |
| - | - |
| `200` with `{"ok":true}` | The Results Link and the secret are correct |
| `401` | The secret does not match the one stored in Panzo |
| `404` | The Results Link is wrong or no longer active in Panzo |

## What Panzo sends to place a call

This is the request Panzo makes to Oktivo. A developer can run it to test the API side without Panzo.

```bash cURL theme={null}
curl -X POST https://client-backend.oktivo.com/api/v1/crm/calls \
  -H "Authorization: Bearer okt_your_token_here" \
  -H "Content-Type: application/json" \
  -d '{
    "phone": "+14155550100",
    "name": "Jane Smith",
    "agentId": "YOUR_AGENT_ID",
    "dynamicVariables": {
      "name": "Jane Smith",
      "first_name": "Jane",
      "source": "Website form",
      "area": "Downtown",
      "panzo_lead_id": "12345"
    }
  }'
```

A successful answer (HTTP 201) contains the call ID. It comes back as `data.contactUID` in every webhook for this call:

```json theme={null}
{
  "success": true,
  "data": {
    "contactUID": "contact_7f8a9b0c1d2e",
    "campaignUID": "campaign_3e4f5g6h7i8j"
  }
}
```

Phone numbers must be in international format with a leading `+`. All `dynamicVariables` values must be text. See [Trigger Call](https://stage-docs.oktivo.com/api-reference/calls/trigger-call.md) for every field and error.

### When Oktivo cannot place the call right now

| HTTP code | Meaning | What Panzo should do |
| - | - | - |
| `429` | Either too many calls are already running at the same time (concurrency limit), or Panzo sent more than 60 requests in a minute. The `Retry-After` header is present for the second case | Wait and try again, with growing delays |
| `402` | Not enough credits | Top up credits in Oktivo, then retry |
| `403` | The lead is on the Do Not Disturb list, or calling is not allowed at this time of day | Do not retry immediately |
| `503` | Voice service temporarily unavailable. The `Retry-After` header says how many seconds to wait | Retry after the delay |
| `404` | The agent ID does not exist in your account | Fix the agent ID in Panzo |

Panzo can add `"deferIfUnavailable": true` to the request. Oktivo then queues the call (HTTP 202) when the calling window is closed or voice is briefly down, instead of refusing it.

**Concurrent-call limit.** Your account can only run a set number of calls at once. The Oktivo dashboard does not show this number to customers. Ask Oktivo support for the current value, and ask them to raise it if Panzo regularly receives 429.

### Avoiding duplicate calls

The call request has no idempotency key. If a request times out, the call may still have been placed, so Panzo should not repeat it blindly. Check first with [Get Call Status](https://stage-docs.oktivo.com/api-reference/calls/get-call-status.md), or match on `panzo_lead_id` in the results.

## What Oktivo sends back

Oktivo sends one webhook per event. Subscribe to these three:

| Event | When it is sent | What it contains |
| - | - | - |
| `call.ended` | As soon as the call has ended. Always sent, even for unanswered calls | Call status, duration, timestamps, number of attempts |
| `call.analysis_ready` | When Oktivo has finished analysing the conversation | Extracted answers, summary |
| `call.completed` | When everything is ready: call details, transcript, answers and recording. If something is still missing 5 minutes after the call, it is sent anyway with what exists | All of the above, plus transcript and recording link |

> [!NOTE]
>
> Subscribe to `call.completed`. It is the only event that carries the transcript and the recording link. Oktivo has no `call.failed` event; an unanswered call arrives as `call.ended` with a status such as `not picked`.

### Example: `call.ended`

All values are made up.

```json theme={null}
{
  "id": "cnt_sample_12345678:call.ended:1",
  "version": "1.0",
  "type": "call.ended",
  "timestamp": "2026-01-01T10:01:08.000Z",
  "data": {
    "contactUID": "cnt_sample_12345678",
    "phone": "+14155550100",
    "campaignUID": "cmp_sample_abc",
    "agentId": "agt_sample_xyz",
    "orgUID": "org_sample_000",
    "callStatus": "ended_by_user",
    "disconnectReason": "CLIENT_INITIATED",
    "billingDuration": 70,
    "callDuration": 67,
    "participantJoinedAt": "2026-01-01T10:00:00.000Z",
    "participantLeftAt": "2026-01-01T10:01:07.000Z",
    "callAnsweredAt": "2026-01-01T10:00:03.000Z",
    "attempts": 1,
    "callType": "ai_agent",
    "transcriptionStatus": "pending",
    "analysisStatus": "pending",
    "direction": "outbound",
    "dynamicVariables": {
      "name": "Jane Smith",
      "first_name": "Jane",
      "source": "Website form",
      "area": "Downtown",
      "panzo_lead_id": "12345"
    }
  },
  "event": "call.ended"
}
```

### Example: `call.analysis_ready`

This event has no `callStatus` or `callDuration`; those come with `call.ended` and `call.completed`.

```json theme={null}
{
  "id": "cnt_sample_12345678:call.analysis_ready:1",
  "version": "1.0",
  "type": "call.analysis_ready",
  "timestamp": "2026-01-01T10:01:30.000Z",
  "data": {
    "contactUID": "cnt_sample_12345678",
    "phone": "+14155550100",
    "campaignUID": "cmp_sample_abc",
    "agentId": "agt_sample_xyz",
    "orgUID": "org_sample_000",
    "analysis_id": "default",
    "analysis": {
      "budget": "500000",
      "property_type": "apartment",
      "callback_time": "2026-01-02T09:30:00Z",
      "summary": "Jane asked about two-bedroom apartments and agreed to a call tomorrow morning."
    },
    "conversation_summary": "Short enquiry about apartment prices.",
    "direction": "outbound",
    "dynamicVariables": {
      "panzo_lead_id": "12345"
    },
    "summary": "Jane asked about two-bedroom apartments and agreed to a call tomorrow morning."
  },
  "event": "call.analysis_ready"
}
```

### Example: `call.completed`

```json theme={null}
{
  "id": "cnt_sample_12345678:call.completed:1",
  "version": "1.0",
  "type": "call.completed",
  "timestamp": "2026-01-01T10:01:40.000Z",
  "data": {
    "contactUID": "cnt_sample_12345678",
    "phone": "+14155550100",
    "campaignUID": "cmp_sample_abc",
    "agentId": "agt_sample_xyz",
    "orgUID": "org_sample_000",
    "callStatus": "ended_by_user",
    "disconnectReason": "CLIENT_INITIATED",
    "billingDuration": 70,
    "callDuration": 67,
    "participantJoinedAt": "2026-01-01T10:00:00.000Z",
    "participantLeftAt": "2026-01-01T10:01:07.000Z",
    "callAnsweredAt": "2026-01-01T10:00:03.000Z",
    "attempts": 1,
    "callType": "ai_agent",
    "transcriptionStatus": "completed",
    "analysisStatus": "completed",
    "transcription": {
      "items": [
        { "id": "item_1", "type": "message", "role": "assistant", "content": ["Hello Jane, this is Oktivo calling about your enquiry."] },
        { "id": "item_2", "type": "message", "role": "user", "content": ["Hi, yes. I wanted to ask about two-bedroom apartments."] }
      ]
    },
    "analysis_id": "default",
    "analysis": {
      "budget": "500000",
      "property_type": "apartment",
      "callback_time": "2026-01-02T09:30:00Z",
      "summary": "Jane asked about two-bedroom apartments and agreed to a call tomorrow morning."
    },
    "conversation_summary": "Short enquiry about apartment prices.",
    "recordingUrl": "https://example.com/recordings/sample.ogg",
    "direction": "outbound",
    "dynamicVariables": {
      "panzo_lead_id": "12345"
    },
    "summary": "Jane asked about two-bedroom apartments and agreed to a call tomorrow morning.",
    "transcript": [
      { "role": "assistant", "text": "Hello Jane, this is Oktivo calling about your enquiry." },
      { "role": "user", "text": "Hi, yes. I wanted to ask about two-bedroom apartments." }
    ]
  },
  "event": "call.completed"
}
```

Which fields appear depends on what exists for that call. For example, `recordingUrl` is left out when there is no recording, and `transcript` is left out when nobody spoke.

### What Panzo reads

| Panzo reads | Where it comes from in the Oktivo payload | Notes |
| - | - | - |
| Event name | `event` | Same value as `type` |
| Which lead | `data.contactUID` | The call ID returned when the call was placed. Required by Panzo; a result without it is rejected with 422 |
| Call status | `data.callStatus` | See [call status values](#call-status-values) |
| Duration in seconds | `data.callDuration` | Greater than 0 means the lead answered |
| Summary | `data.summary` | The `summary` field of your analysis schema, or Oktivo's automatic summary |
| Transcript | `data.transcript` | List of `{ role, text }`. `role` is `assistant` (the AI agent) or `user` (the lead) |
| Recording | `data.recordingUrl` | HTTPS link that stops working after 7 days |
| Extracted answers | `data.analysis` | The fields of your analysis schema |

### Call status values

Oktivo sends `callStatus` as it is. These are the values you can see, with a plain meaning. The most reliable way to tell whether the lead answered is `callDuration` greater than 0.

| Value | Meaning | Answered? |
| - | - | - |
| `ended` | The call connected and ended normally | Yes |
| `ended_by_user` | The lead hung up | Yes |
| `ended_by_agent` | The AI agent or Oktivo ended the call | Yes |
| `media_failure` | The call connected but the audio failed | Maybe. Check `callDuration` |
| `rejected` | The lead declined the call or the number was unavailable | No |
| `not picked` | The phone rang but nobody answered | No |
| `not_answered` | The call was not answered (other reasons, such as busy) | No |
| `failed` | The call could not be completed. For example, it was still unanswered when a campaign was stopped | No |
| `dispatch_failed` | Oktivo could not start the call, so nothing was dialled | No |
| `force_stopped` | A campaign was stopped by a user while the call was waiting | No |
| `dialing`, `ringing`, `active`, `hangup`, `unknown` | Unusual in a final result. The call state could not be worked out | Use `callDuration` |

Rarely, `callStatus` can hold a raw telephone disconnect reason instead. Treat any value not in this table as "check `callDuration`".

### Recording links expire after 7 days

`recordingUrl` is a private link that stops working 7 days after it was created. Panzo should download or store the recording when it receives it.

### Large calls

Panzo accepts results up to 400,000 characters. When a Panzo CRM delivery would be larger than 350,000 characters, Oktivo removes the duplicate full `transcription` object. The readable `transcript` list stays.

## Signature

Every delivery is signed so Panzo can tell it came from Oktivo. The signature is in the `X-Oktivo-Signature` header and is made with your webhook secret.

| Delivery format | Headers | What is signed |
| - | - | - |
| **Panzo CRM** | `X-Oktivo-Signature` | Hex HMAC-SHA256 of the exact request body, nothing else |
| Standard (default) | `X-Oktivo-Signature` and `X-Oktivo-Timestamp` | Hex HMAC-SHA256 of the timestamp, a `.`, then the exact request body |

Use **Panzo CRM**. Panzo checks the signature against the exact bytes it receives. Oktivo also sends `X-Oktivo-Timestamp` in Panzo CRM mode, but it is not part of the signed text. Oktivo never sends an unsigned result.

## Retries and failures

* Oktivo waits up to 10 seconds for an answer.
* A failed delivery is retried up to 8 more times, after 10 seconds, 30 seconds, 1 minute, 5 minutes, 15 minutes, 30 minutes, 1 hour and 2 hours.
* After 50 failed deliveries in a row, Oktivo switches the endpoint off automatically. See below to switch it back on.
* Panzo answers `200` with `{"ok":true}` when it accepted a result, including for calls it does not know. It answers `401` for a bad signature, `404` for an unknown Results Link, `413` when the body is too large, `422` when `data.contactUID` is missing, and `429` when more than 3,000 results per hour arrive for one company.

See [Webhooks](https://stage-docs.oktivo.com/concepts/webhooks.md) for the full behaviour.

## If something goes wrong

| What you see | Likely cause | What to do |
| - | - | - |
| Webhook Logs show HTTP `401` | The secret in Panzo is wrong, or **Delivery format** is not **Panzo CRM** | Edit the webhook, set **Delivery format** to **Panzo CRM**. Use **Regenerate Secret** on the Review step if needed, then enter the new secret in Panzo |
| Webhook Logs show HTTP `404` | The Results Link is wrong or switched off in Panzo | Copy the Results Link from Panzo again and update the **Endpoint URL** |
| Webhook Logs show HTTP `422` | The result had no `data.contactUID` | The call was probably not placed through Panzo. Check which agent the webhook is filtered to |
| Webhook Logs show HTTP `429` | Panzo received more than 3,000 results in an hour | Wait. Oktivo retries automatically |
| Error text "Signing secret unavailable" | Oktivo cannot read the secret for this webhook | Open the webhook, click **Regenerate Secret** on the Review step, and enter the new secret in Panzo |
| Webhook Logs show nothing | The webhook was switched off after 50 failures, or the agent filter excludes the agent | In **Connecter > Webhooks**, open the webhook, switch **Webhook Status** to Active, and click **Update** |
| The lead shows no transcript or recording | `call.completed` is not ticked, or the call was never answered | Add the event to the webhook. Unanswered calls have no transcript or recording |
| The summary is empty | The analysis schema has no `summary` field and the call had no conversation | Add a `summary` field to the schema |
| `callback_time` is not understood | The value is not in ISO 8601 format | Describe the format in the field's description, with an example |
| Panzo cannot place calls (401 from Oktivo) | The API token expired, was deleted or is mistyped | Create or rotate a token in **Settings > API Tokens**, then update Panzo |
| Panzo gets 429 from Oktivo | Too many calls at once | Panzo should retry later. Ask support to raise the concurrent-call limit |
| The same result arrives twice | Oktivo retried because Panzo's answer was slow or lost | Safe. Panzo should treat the same event for the same `contactUID` as one |

## FAQ

> [accordion] Do I need a developer?
>
> No. Everything on the Oktivo side is done in the dashboard. A developer is only needed if you want to run the API requests on this page yourself.

> [accordion] Can one webhook serve several agents?
>
> Yes. Leave **Agent Filter** on "All agents", or pick several. You can also create one webhook per agent, each with its own secret.

> [accordion] What happens when the API token expires?
>
> Panzo can no longer place calls and gets an authentication error. Rotate the token in **Settings > API Tokens**, then enter the new token in Panzo. Results for calls already placed keep arriving, because they use the webhook secret, not the token.

> [accordion] Can I change an existing webhook to the Panzo format?
>
> Yes. In **Connecter > Webhooks** open the webhook, go to the **Endpoint** step, set **Delivery format** to **Panzo CRM**, and click **Update**. Results queued before the change keep the old format. If you do not have the secret any more, use **Regenerate Secret** and give Panzo the new one. The old secret stops working immediately.

> [accordion] I changed the secret in Oktivo. What now?
>
> Enter the new secret in Panzo straight away. Until you do, Panzo rejects results with 401, and Oktivo retries them.

> [accordion] How do I see the concurrent-call limit?
>
> Customers cannot see it in the dashboard. Ask Oktivo support. Developers can read it with the login token (not the API token) from `GET /api/v2/my-concurrency`.

> [accordion] Can I use Zapier, n8n or another tool instead?
>
> Yes. See [Using n8n, Zapier or other tools](#using-n8n-zapier-or-other-tools) below.

## Create the webhook with the API

Developers can create the webhook in code instead of the dashboard. This request needs the **login token (JWT)** of an Oktivo user, not the `okt_` API token. See [Authentication](https://stage-docs.oktivo.com/authentication.md).

```bash cURL theme={null}
curl -X POST https://client-backend.oktivo.com/webhooks/endpoints \
  -H "Authorization: Bearer YOUR_JWT" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "PASTE_THE_PANZO_RESULTS_LINK",
    "eventTypes": ["call.ended", "call.analysis_ready", "call.completed"],
    "description": "Panzo results",
    "agentIds": ["YOUR_AGENT_ID"],
    "deliveryProfile": "panzo"
  }'
```

The answer contains the secret once:

```json theme={null}
{
  "success": true,
  "endpoint": {
    "webhookId": "wh_abc123def456",
    "deliveryProfile": "panzo",
    "isActive": true
  },
  "secret": "3f1c...64 hexadecimal characters...9a2e"
}
```

See [Create Endpoint](https://stage-docs.oktivo.com/api-reference/webhooks/create-endpoint.md) for all fields.

## Using n8n, Zapier or other tools

Panzo is not the only way to use this. The same two building blocks work with any tool that can send and receive web requests, such as n8n or Zapier:

1. The tool places a call with the [Trigger Call](https://stage-docs.oktivo.com/api-reference/calls/trigger-call.md) request, using an API token.
2. The tool receives results through a webhook. Create the webhook as above, but keep **Delivery format** on **Standard (default)** and use the tool's webhook URL. The Standard format has its own signature, described in [Webhooks](https://stage-docs.oktivo.com/concepts/webhooks.md#hmac-signature-verification).

The [CRM Integration guide](https://stage-docs.oktivo.com/guides/crm-integration.md) walks through this with code. Choose the **Panzo CRM** delivery format only for Panzo.

## Handoff checklist for the Panzo admin

Send these to the person who configures Panzo:

* [ ] API token (`okt_...`) and the date it expires
* [ ] Agent ID
* [ ] Webhook secret (the one shown when the webhook was created)
* [ ] Variable names used in the script: `name`, `first_name`, `source`, `area`
* [ ] Confirmation that the Results Link in Panzo matches the webhook's Endpoint URL in Oktivo
* [ ] The Oktivo concurrent-call limit (from Oktivo support)
* [ ] Reminder: on HTTP `429` or `503` from Oktivo, wait and try again with growing delays
* [ ] Reminder: after a timeout, check [Get Call Status](https://stage-docs.oktivo.com/api-reference/calls/get-call-status.md) before placing the call again
* [ ] Reminder: download recordings within 7 days

## Related

> [card] [Connectors Overview](https://stage-docs.oktivo.com/connectors/overview.md)
>
> Compare the ways to connect Oktivo

> [card] [Webhooks](https://stage-docs.oktivo.com/concepts/webhooks.md)
>
> Events, signatures and retries

> [card] [CRM Integration Guide](https://stage-docs.oktivo.com/guides/crm-integration.md)
>
> Generic CRM setup with code samples

> [card] [Authentication](https://stage-docs.oktivo.com/authentication.md)
>
> Create and manage API tokens


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.