---
title: "വെബ്‌ഹുക്കുകളുടെ അവലോകനം"
description: "ThunderPhone തത്സമയ ഇവന്റുകൾ എങ്ങനെ കൈമാറുന്നു, സിഗ്നേച്ചറുകൾ എങ്ങനെ പരിശോധിക്കാം, ലെഗസി, എൻഡ്‌പോയിന്റ്-അടിസ്ഥാനത്തിലുള്ള ഡെലിവറി മോഡലുകൾ എങ്ങനെ താരതമ്യം ചെയ്യപ്പെടുന്നു എന്നിവ."
---

ThunderPhone ഒരു കോളിനിടെ സംഭവങ്ങൾ ഉണ്ടാകുമ്പോൾ നിങ്ങളുടെ സെർവറിലേക്ക് HTTP `POST` അഭ്യർത്ഥനകൾ അയയ്ക്കുന്നു — ഇൻബൗണ്ട് കോൾ ആരംഭിക്കുക, കോൾ അവസാനിക്കുക, ഗ്രേഡിംഗ് റൺ പൂർത്തിയാകുക, അലേർട്ട് പ്രവർത്തനക്ഷമമാകുക തുടങ്ങിയവ. **രണ്ട് ഡെലിവറി മോഡലുകൾ** ഉണ്ട്:

<CardGroup cols={2}>
  <Card title="Webhook എൻഡ്‌പോയിന്റുകൾ (ശുപാർശ ചെയ്യുന്നത്)" icon="bolt" href="/ml/webhooks/endpoints">
    ഒന്നിലധികം URL-കൾ, ഓരോ എൻഡ്‌പോയിന്റിനും സീക്രട്ടുകൾ, ഓരോ എൻഡ്‌പോയിന്റിനും ഇവന്റ് ഫിൽട്ടറുകൾ,
    സ്വയമേവയുള്ള റീട്രൈകൾ.
    `GET/POST/PATCH/DELETE /v1/developer/webhook-endpoints` വഴി നിയന്ത്രിക്കുക.
  </Card>
  <Card title="ഒറ്റ-URL ലെഗസി webhook" icon="link" href="/api-reference/organizations#legacy-single-url-webhook">
    ഓരോ ഓർഗനൈസേഷനും ഒരു URL. **ബ്ലോക്കിംഗ്** കോൺഫിഗറേഷൻ എക്സ്ചേഞ്ചുകൾ ഉൾപ്പെടെയുള്ള
    കോൾ-ലൈഫ്‌സൈക്കിൾ ഇവന്റുകൾ ഇതിൽ ഉൾപ്പെടുന്നു. `GET/PUT /v1/webhook` ൽ നിയന്ത്രിക്കുന്നു.
  </Card>
</CardGroup>

[ഇവന്റ്സ് കാറ്റലോഗിലെ](/ml/webhooks/events) പത്ത് ഇവന്റ് തരങ്ങളും webhook എൻഡ്‌പോയിന്റുകളിലൂടെ
ഡെലിവർ ചെയ്യപ്പെടുന്നു. ആറ് കോൾ-ലൈഫ്‌സൈക്കിൾ ഇവന്റുകൾ
(`telephony.incoming`, `telephony.complete`, `telephony.tool`,
`web.incoming`, `web.complete`, `web.tool`) ലെഗസി ഒറ്റ-URL webhook-ലേക്കും
**അയയ്ക്കപ്പെടുന്നു** — നിങ്ങൾക്ക് ഒരു ലെഗസി URL-ഉം പൊരുത്തപ്പെടുന്ന ഒരു എൻഡ്‌പോയിന്റും ഉണ്ടെങ്കിൽ,
നിങ്ങൾക്ക് ഇവന്റ് **രണ്ട്** പാതകളിലും ലഭിക്കും. ബ്ലോക്കിംഗ് പെരുമാറ്റം
([`telephony.incoming` / `web.incoming` കോൺഫിഗറേഷൻ
എക്സ്ചേഞ്ച്](/ml/webhooks/call-incoming), webhook-മോഡ്
[ടൂൾ ഡിസ്പാച്ച്](/ml/tools/overview)) ലെഗസി പാതയിൽ മാത്രമേ ഉള്ളൂ;
ഓരോ എൻഡ്‌പോയിന്റ് ഡെലിവറിയും ഫയർ-ആൻഡ്-ഫോർഗെറ്റ് അറിയിപ്പാണ്.

## പേലോഡ് ഫോർമാറ്റ്

എൻഡ്‌പോയിന്റ് ഡെലിവറികൾ `data`, `event_id`, `type` എന്നിവയുള്ള ഒരു JSON ഒബ്ജക്റ്റാണ്:

```json
{
  "data": {
    "call_id": 987654321,
    "from_number": "+14155550199",
    "to_number": "+15551234567"
  },
  "event_id": "3f6b2ad0-1c9e-4a57-9f2b-8f6f0f9d2f11",
  "type": "telephony.incoming"
}
```

`event_id` ഓരോ എമിറ്റ് ചെയ്ത ഇവന്റിനും അദ്വിതീയമാണ്. റീട്രൈകളിലുടനീളവും
ഇവന്റ് സ്വീകരിക്കുന്ന എല്ലാ എൻഡ്‌പോയിന്റുകളിലുടനീളവും ഇത് ഒരുപോലെയാണ് —
അതുപയോഗിച്ച് ഡീഡ്യൂപ്പ് ചെയ്യുക.

ലെഗസി ഒറ്റ-URL webhook അതേ `type`, `data` എന്നിവ അയയ്ക്കുന്നു, എന്നാൽ
`event_id` **ഇല്ലാതെ**:

```json
{
  "type": "telephony.incoming",
  "data": { "call_id": 987654321, "from_number": "+14155550199", "to_number": "+15551234567" }
}
```

വയറിലൂടെ, ഓരോ ബോഡിയും കാനോനിക്കലായി സീരിയലൈസ് ചെയ്യപ്പെടുന്നു — കീകൾ
അക്ഷരമാലാക്രമത്തിൽ അടുക്കിയിരിക്കും, വൈറ്റ്സ്പേസ് ഇല്ല, UTF-8. ഈ ഡോക്യുമെന്റുകളിലെ
മനോഹരമായി ഫോർമാറ്റ് ചെയ്ത ഉദാഹരണങ്ങൾ വായനാസൗകര്യത്തിനായി മാത്രമാണ്.

ഇവന്റ് തരങ്ങളുടെയും പേലോഡ് ഫീൽഡുകളുടെയും പൂർണ്ണ പട്ടികയ്ക്കായി
[ഇവന്റ്സ് കാറ്റലോഗ്](/ml/webhooks/events) കാണുക.

## സിഗ്നേച്ചർ പരിശോധന

ഓരോ റിക്വസ്റ്റിലും `X-ThunderPhone-Signature` ഹെഡറിൽ **അസംസ്കൃത റിക്വസ്റ്റ്
ബോഡി** അടിസ്ഥാനമാക്കിയുള്ള HMAC-SHA256 സിഗ്നേച്ചർ ഉണ്ടായിരിക്കും. സൈനിംഗ് കീ
എൻഡ്പോയിന്റിന്റെ `secret` ആണ് (അല്ലെങ്കിൽ ലെഗസി ഡെലിവറികൾക്കായി നിങ്ങളുടെ
org-തല webhook `secret`).

### ഘട്ടങ്ങൾ

1. ഏതെങ്കിലും പാഴ്സിങ്ങിന് **മുമ്പ്** അസംസ്കൃത റിക്വസ്റ്റ് ബോഡി വായിക്കുക.
2. `hmac_sha256(secret, body).hexdigest()` കണക്കാക്കുക.
3. `X-ThunderPhone-Signature` ഹെഡറുമായി സ്ഥിരസമയത്ത് താരതമ്യം ചെയ്യുക.

ഞങ്ങൾ കൈമാറുന്ന കൃത്യമായ ബൈറ്റുകളിലാണ് സൈൻ ചെയ്യുന്നത്, ആ ബൈറ്റുകൾ
കാനോനിക്കൽ JSON സീരിയലൈസേഷനാണ് (ക്രമീകരിച്ച കീകൾ, കോംപാക്റ്റ് സെപ്പറേറ്ററുകൾ).
അതിനാൽ അസംസ്കൃത ബോഡിക്കെതിരെ പരിശോധിക്കുന്നത് എല്ലായ്പ്പോഴും പ്രവർത്തിക്കും —
നിങ്ങളുടെ ഫ്രെയിംവർക്ക് പാഴ്സ് ചെയ്ത JSON മാത്രം നൽകുന്നുവെങ്കിൽ, ക്രമീകരിച്ച
കീകളും കോംപാക്റ്റ് സെപ്പറേറ്ററുകളും ഉപയോഗിച്ച് വീണ്ടും സീരിയലൈസ് ചെയ്യുന്നത്
അതേ ബൈറ്റുകൾ സൃഷ്ടിക്കും. രണ്ട് രീതികളും [പരിശോധന
ഗൈഡിൽ](/ml/guides/verify-webhook-signatures) ഉൾപ്പെടുത്തിയിട്ടുണ്ട്.

<CodeGroup>
```python Python
import hmac
import hashlib

def verify_signature(body: bytes, signature: str, secret: str) -> bool:
    expected = hmac.new(
        secret.encode("utf-8"),
        body,
        hashlib.sha256,
    ).hexdigest()
    return hmac.compare_digest(expected, signature or "")

# Example Flask handler
from flask import Flask, request, abort
app = Flask(__name__)

@app.post("/thunderphone-webhook")
def handle():
    body = request.get_data()
    sig = request.headers.get("X-ThunderPhone-Signature", "")
    if not verify_signature(body, sig, WEBHOOK_SECRET):
        abort(401)
    event = request.get_json()
    # dispatch on event["type"] …
    return "", 204
```

```javascript Node.js (Express)
import crypto from "node:crypto";
import express from "express";

function verifySignature(body, signature, secret) {
  const expected = crypto
    .createHmac("sha256", secret)
    .update(body)
    .digest("hex");
  if (!signature || expected.length !== signature.length) return false;
  return crypto.timingSafeEqual(
    Buffer.from(expected),
    Buffer.from(signature),
  );
}

const app = express();
app.post(
  "/thunderphone-webhook",
  express.raw({ type: "application/json" }),
  (req, res) => {
    const sig = req.header("X-ThunderPhone-Signature") || "";
    if (!verifySignature(req.body, sig, process.env.WEBHOOK_SECRET)) {
      return res.sendStatus(401);
    }
    const event = JSON.parse(req.body.toString("utf8"));
    // dispatch on event.type …
    res.sendStatus(204);
  },
);
```
</CodeGroup>

## ഡെലിവറി സെമാന്റിക്സ്

ഈ സെമാന്റിക്സ് **എൻഡ്‌പോയിന്റ്** ഡെലിവറികൾക്ക് ബാധകമാണ്. ലെഗസി സിംഗിൾ-URL
webhook റീട്രൈകളില്ലാത്ത ഒറ്റ സിൻക്രണസ് ശ്രമമാണ്.

<AccordionGroup>
  <Accordion title="റീട്രൈകൾ">
    ഓരോ ഇവന്റും ഉടൻ ഒരിക്കൽ ശ്രമിക്കും. ഏത് `2xx` പ്രതികരണവും
    ഡെലിവറി അംഗീകരിക്കുന്നു. മറ്റേതെങ്കിലും ഫലത്തിൽ (non-2xx,
    കണക്ഷൻ പിശക്, ടൈംഔട്ട്) **ആദ്യ ശ്രമത്തിന് ശേഷം 1 m, 5 m, 30 m, 2 h, 6 h,
    12 h, 24 h സമയങ്ങളിൽ** ഞങ്ങൾ റീട്രൈ ചെയ്യും — 24 മണിക്കൂർ
    വ്യാപിക്കുന്ന 8 ശ്രമങ്ങൾ. എല്ലാ ശ്രമങ്ങളും പരാജയപ്പെട്ടാൽ, ഡെലിവറി നിർത്തുകയും എൻഡ്‌പോയിന്റിനെ
    [webhook എൻഡ്‌പോയിന്റുകളിൽ](/ml/webhooks/endpoints) `status="failing"` ആയി
    അടയാളപ്പെടുത്തുകയും ചെയ്യും. payload സ്ഥിരമായി സ്വീകരിച്ചാലുടൻ `2xx` നൽകുക;
    അസിങ്ക്രണസായി പ്രോസസ് ചെയ്യുക.
  </Accordion>

  <Accordion title="ക്രമം">
    ഡെലിവറി ക്രമം മികച്ച-ശ്രമ അടിസ്ഥാനത്തിലാണ്. പ്രായോഗികമായി, ഇവന്റുകൾ
    എമിറ്റ് ചെയ്യുന്ന ക്രമത്തിൽ ഞങ്ങൾ ഡെലിവർ ചെയ്യുന്നു, എന്നാൽ പരാജയത്തിൽ
    റീട്രൈകൾ ക്രമം മാറ്റിയേക്കാം. എല്ലായ്പ്പോഴും `call_id` / ഒബ്ജക്റ്റ് id പ്രകാരം
    ഡീഡ്യൂപ്പ് ചെയ്യുകയും പൊരുത്തപ്പെടുത്തുകയും ചെയ്യുക.
  </Accordion>

  <Accordion title="ഡ്യൂപ്ലിക്കേറ്റുകൾ">
    ഡെലിവറി **കുറഞ്ഞത്-ഒരിക്കലെങ്കിലും** ആണ്: ഞങ്ങൾ ഒരിക്കലും കണ്ടിട്ടില്ലാത്ത പ്രതികരണത്തിന് ശേഷമുള്ള
    റീട്രൈ ഒരു ഇവന്റിനെ ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്തേക്കാം. ഓരോ റീട്രൈയിലും ഒരേ
    `event_id` ഉണ്ടായിരിക്കും, അതിനാൽ പ്രോസസ് ചെയ്ത id-കൾ സൂക്ഷിച്ച് ആവർത്തനങ്ങൾ ഒഴിവാക്കുക. `event_id`
    എൻഡ്‌പോയിന്റുകൾക്കിടയിലും പങ്കിടുന്നു — ഒരേ ഇവന്റിലേക്ക് സബ്സ്ക്രൈബ് ചെയ്ത രണ്ട്
    എൻഡ്‌പോയിന്റുകൾക്കും ഒരേ `event_id` ലഭിക്കും.
  </Accordion>

  <Accordion title="ടൈംഔട്ടുകൾ">
    എൻഡ്‌പോയിന്റ് ഡെലിവറികൾക്ക് ഓരോ ശ്രമത്തിനും **30 s** ടൈംഔട്ട് ഉണ്ട്. ലെഗസി
    പാതയിൽ, ലൈവ് കോൾ പെരുമാറ്റം നിയന്ത്രിക്കുന്ന ബ്ലോക്കിംഗ് റിക്വസ്റ്റുകൾ — 
    [`telephony.incoming` / `web.incoming`](/ml/webhooks/call-incoming)
    കോൺഫിഗറേഷൻ എക്സ്ചേഞ്ച് — **10 s** കഴിഞ്ഞ് ടൈംഔട്ട് ആകും, എന്നാൽ മന്ദഗതിയിലുള്ള
    പ്രതികരണം കോൾ പിക്കപ്പ് വൈകിപ്പിക്കും, അതിനാൽ ഏതാനും സെക്കൻഡുകൾക്കുള്ളിൽ
    മറുപടി നൽകാൻ ലക്ഷ്യമിടുക. webhook-മോഡ് [ടൂൾ ഡിസ്പാച്ച്](/ml/tools/overview) ഡിഫോൾട്ടായി 20 s
    അനുവദിക്കുന്നു, കൂടാതെ ടൂൾ ഡിക്ലറേഷനുകൾക്ക് ടോപ്പ്-ലെവൽ `timeout` സജ്ജമാക്കാം.
  </Accordion>

  <Accordion title="സോഴ്സ് IP-കൾ">
    ഔട്ട്ബൗണ്ട് webhooks ThunderPhone-ന്റെ ക്ലൗഡ് IP ശ്രേണിയിൽ നിന്നാണ് വരുന്നത്.
    നിങ്ങളുടെ ഫയർവാളിന് allowlist ആവശ്യമാണെങ്കിൽ, സപ്പോർട്ടുമായി ബന്ധപ്പെടുക; നിലവിലെ
    ശ്രേണികൾ ഞങ്ങൾ പങ്കിടും.
  </Accordion>
</AccordionGroup>

## ലെഗസിയും എൻഡ്‌പോയിന്റ്-അടിസ്ഥാനത്തിലുള്ള webhooks-ഉം തമ്മിൽ തിരഞ്ഞെടുക്കൽ

| സവിശേഷത | ലെഗസി (`/v1/webhook`) | എൻഡ്‌പോയിന്റുകൾ (`/v1/developer/webhook-endpoints`) |
|---------|------------------------|----------------------------------------------|
| URL-കളുടെ എണ്ണം | ഓരോ org-നും 1 | ഓരോ org-നും നിരവധി |
| ഇവന്റ് കവറേജ് | `telephony.*` / `web.*` മാത്രം | എല്ലാ 10 ഇവന്റ് തരങ്ങളും |
| ഇവന്റ് ഫിൽറ്റർ | — | ഓരോ എൻഡ്‌പോയിന്റിനും |
| റീട്രൈകൾ | ഇല്ല | 24 h-ൽ 8 ശ്രമങ്ങൾ |
| എൻവലപ്പ് | `type` + `data` | `type` + `data` + `event_id` |
| സീക്രട്ട് റൊട്ടേഷൻ | ഒറ്റ സീക്രട്ട് മാറ്റിസ്ഥാപിക്കുന്നു | ഓരോ എൻഡ്‌പോയിന്റിനും സീക്രട്ട് |
| ഡിലീറ്റ് ചെയ്യാതെ പ്രവർത്തനരഹിതമാക്കൽ | `PUT /v1/webhook` ഉപയോഗിച്ച് `{"url": ""}` | `status=disabled` |
| സ്റ്റാറ്റസ് ദൃശ്യത | — | `active` / `disabled` / `failing` |
| ബ്ലോക്കിംഗ് കോൺഫിഗറേഷൻ എക്സ്ചേഞ്ച് | ഉണ്ട് ([`telephony.incoming` / `web.incoming`](/ml/webhooks/call-incoming)) | ഒരിക്കലുമില്ല — അറിയിപ്പുകൾ മാത്രം |
| ഏറ്റവും അനുയോജ്യം | ഡൈനാമിക് കോൾ കോൺഫിഗറേഷൻ | പ്രൊഡക്ഷനിലെ ഇവന്റ് കൺസംപ്ഷൻ |

പുതിയ ഇന്റഗ്രേഷനുകൾ എൻഡ്‌പോയിന്റ്-അടിസ്ഥാനത്തിലുള്ള
webhooks വഴി ഇവന്റുകൾ കൺസ്യൂം ചെയ്യണം. പിക്കപ്പ് സമയത്ത് കോളുകൾ
ഡൈനാമിക്കായി കോൺഫിഗർ ചെയ്യുന്നെങ്കിലോ webhook-മോഡ് ടൂൾ ഡിസ്പാച്ച് ഉപയോഗിക്കുന്നെങ്കിലോ മാത്രം
ലെഗസി URL നിലനിർത്തുക (അല്ലെങ്കിൽ ചേർക്കുക) — ആ
റിക്വസ്റ്റ്/റെസ്പോൺസ് എക്സ്ചേഞ്ചുകൾ ലെഗസി പാതയിൽ മാത്രമേ പ്രവർത്തിക്കൂ.

---

## ബന്ധപ്പെട്ടവ

<CardGroup cols={2}>
  <Card title="ഇവന്റുകളുടെ കാറ്റലോഗ്" icon="list" href="/ml/webhooks/events">
    എല്ലാ ഇവന്റ് തരങ്ങളും അവയുടെ payload-കളും.
  </Card>
  <Card title="Webhook എൻഡ്‌പോയിന്റുകൾ" icon="bolt" href="/ml/webhooks/endpoints">
    ഒന്നിലധികം എൻഡ്‌പോയിന്റുകൾ, ഇവന്റ് ഫിൽറ്ററുകൾ, സീക്രട്ടുകൾ എന്നിവ മാനേജ് ചെയ്യുക.
  </Card>
  <Card title="telephony.incoming / web.incoming" icon="phone" href="/ml/webhooks/call-incoming">
    കോളുകൾ കോൺഫിഗർ ചെയ്യാൻ നിങ്ങളുടെ സർവർ മറുപടി നൽകേണ്ട ബ്ലോക്കിംഗ് റിക്വസ്റ്റ്.
  </Card>
  <Card title="telephony.complete / web.complete" icon="phone" href="/ml/webhooks/call-complete">
    ട്രാൻസ്ക്രിപ്റ്റ്, റെക്കോർഡിംഗ്, മെട്രിക്കുകൾ എന്നിവയുള്ള കോൾ-ശേഷമുള്ള payload.
  </Card>
</CardGroup>