---
title: "વેબહુક્સનો પરિચય"
description: "ThunderPhone રીઅલ-ટાઇમ ઇવેન્ટ્સ કેવી રીતે પહોંચાડે છે, સહી કેવી રીતે ચકાસવી અને લેગસી તથા એન્ડપોઇન્ટ-આધારિત ડિલિવરી મોડલ્સની સરખામણી કેવી રીતે થાય છે."
---

ThunderPhone કૉલ દરમિયાન ઘટનાઓ બને ત્યારે તમારા સર્વર પર HTTP `POST` વિનંતીઓ મોકલે છે — ઇનબાઉન્ડ કૉલ શરૂ થાય, કૉલ સમાપ્ત થાય, ગ્રેડિંગ રન પૂર્ણ થાય, એલર્ટ ટ્રિગર થાય, વગેરે. **બે ડિલિવરી મોડલ્સ** છે:

<CardGroup cols={2}>
  <Card title="વેબહૂક એન્ડપૉઇન્ટ્સ (ભલામણ કરેલ)" icon="bolt" href="/gu/webhooks/endpoints">
    એકથી વધુ URL, દરેક એન્ડપૉઇન્ટ માટે સિક્રેટ્સ, દરેક એન્ડપૉઇન્ટ માટે ઇવેન્ટ ફિલ્ટર્સ,
    અને સ્વચાલિત રિટ્રાય.
    `GET/POST/PATCH/DELETE /v1/developer/webhook-endpoints` દ્વારા મેનેજ કરો.
  </Card>
  <Card title="સિંગલ-URL લેગસી વેબહૂક" icon="link" href="/api-reference/organizations#legacy-single-url-webhook">
    દરેક ઑર્ગ માટે એક URL. તેમાં **બ્લૉકિંગ** કૉન્ફિગરેશન એક્સચેન્જ સહિત
    કૉલ-લાઇફસાયકલ ઇવેન્ટ્સ હોય છે. `GET/PUT /v1/webhook` પર મેનેજ કરવામાં આવે છે.
  </Card>
</CardGroup>

[ઇવેન્ટ્સ કેટલોગ](/gu/webhooks/events)માંના તમામ 10 ઇવેન્ટ પ્રકારો
વેબહૂક એન્ડપૉઇન્ટ્સ દ્વારા ડિલિવર થાય છે. 6 કૉલ-લાઇફસાયકલ ઇવેન્ટ્સ
(`telephony.incoming`, `telephony.complete`, `telephony.tool`,
`web.incoming`, `web.complete`, `web.tool`) લેગસી સિંગલ-URL વેબહૂક પર
**પણ** મોકલવામાં આવે છે — જો તમારી પાસે લેગસી URL અને મેળ ખાતો
એન્ડપૉઇન્ટ બંને હોય, તો તમને ઇવેન્ટ **બંને** પાથ પર મળે છે. બ્લૉકિંગ
વર્તન ([`telephony.incoming` / `web.incoming` કૉન્ફિગરેશન
એક્સચેન્જ](/gu/webhooks/call-incoming) અને વેબહૂક-મોડ
[ટૂલ ડિસ્પૅચ](/gu/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 વેબહૂક સમાન `type` અને `data` મોકલે છે, પરંતુ
`event_id` **વિના**:

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

ટ્રાન્સમિશનમાં, દરેક બૉડી કેનોનિકલી સિરિયલાઇઝ થાય છે — કીઝ
આલ્ફાબેટિકલ ક્રમમાં, કોઈ વ્હાઇટસ્પેસ નહીં, UTF-8. આ ડૉક્સમાંના
સુઘડ રીતે ફૉર્મેટ કરેલા ઉદાહરણો ફક્ત વાંચવાની સરળતા માટે છે.

ઇવેન્ટ પ્રકારો અને પેલોડ ફીલ્ડ્સની સંપૂર્ણ યાદી માટે
[ઇવેન્ટ્સ કેટલોગ](/gu/webhooks/events) જુઓ.

## સહી ચકાસણી

દરેક વિનંતીમાં `X-ThunderPhone-Signature` હેડરમાં **કાચા વિનંતી
બૉડી** પર HMAC-SHA256 સહી હોય છે. સાઇનિંગ કી એ એન્ડપૉઇન્ટનું `secret` છે
(અથવા લેગસી ડિલિવરી માટે તમારું org-સ્તરનું webhook `secret`).

### પગલાં

1. કોઈપણ પાર્સિંગ **પહેલાં** કાચો વિનંતી બૉડી વાંચો.
2. `hmac_sha256(secret, body).hexdigest()` ગણતરી કરો.
3. `X-ThunderPhone-Signature` હેડર સાથે કૉન્સ્ટન્ટ સમયમાં સરખામણી કરો.

અમે જે બાઇટ્સ ટ્રાન્સમિટ કરીએ છીએ તેના પર જ સહી કરીએ છીએ, અને તે બાઇટ્સ
કેનોનિકલ JSON સિરિયલાઇઝેશન છે (ક્રમબદ્ધ કીઓ, કોમ્પેક્ટ સેપરેટર્સ). તેથી
કાચા બૉડી સામે ચકાસણી હંમેશાં કાર્ય કરે છે — અને જો તમારું ફ્રેમવર્ક તમને
ફક્ત પાર્સ કરેલ JSON આપે, તો તેને ક્રમબદ્ધ કીઓ અને કોમ્પેક્ટ સેપરેટર્સ સાથે
ફરીથી સિરિયલાઇઝ કરવાથી એકસરખા બાઇટ્સ બને છે. બંને રીતો
[ચકાસણી માર્ગદર્શિકા](/gu/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
વેબહુક એક જ સિંક્રોનસ પ્રયાસ છે, જેમાં કોઈ પુનઃપ્રયાસ નથી.

<AccordionGroup>
  <Accordion title="પુનઃપ્રયાસો">
    દરેક ઇવેન્ટનો તરત એક વખત પ્રયાસ થાય છે. કોઈપણ `2xx` પ્રતિસાદ
    ડિલિવરીને સ્વીકારે છે. અન્ય કોઈપણ પરિણામ પર (non-2xx,
    કનેક્શન એરર, સમયસમાપ્તિ) અમે **પ્રથમ પ્રયાસ પછી 1 મિનિટ, 5 મિનિટ, 30 મિનિટ, 2 કલાક, 6 કલાક,
    12 કલાક અને 24 કલાકે** પુનઃપ્રયાસ કરીએ છીએ — 24 કલાકમાં
    8 પ્રયાસો. જો દરેક પ્રયાસ નિષ્ફળ જાય, તો ડિલિવરી બંધ થાય છે અને એન્ડપોઇન્ટને
    [વેબહુક એન્ડપોઇન્ટ્સ](/gu/webhooks/endpoints)માં
    `status="failing"` તરીકે ચિહ્નિત કરવામાં આવે છે. પેલોડ ટકાઉ રીતે સ્વીકારાય
    એટલે શક્ય તેટલું વહેલું `2xx` પરત કરો; અસિંક્રોનસ રીતે પ્રક્રિયા કરો.
  </Accordion>

  <Accordion title="ક્રમ">
    ડિલિવરીનો ક્રમ શ્રેષ્ઠ પ્રયાસ આધારિત છે. વ્યવહારમાં અમે ઇવેન્ટ્સ જે
    ક્રમે ઉત્પન્ન થાય તે ક્રમે ડિલિવર કરીએ છીએ, પરંતુ નિષ્ફળતા સમયે પુનઃપ્રયાસો ક્રમ બદલી શકે છે.
    હંમેશા `call_id` / ઑબ્જેક્ટ id દ્વારા ડિડુપ કરો અને સમાધાન કરો.
  </Accordion>

  <Accordion title="ડુપ્લિકેટ્સ">
    ડિલિવરી **ઓછામાં-ઓછું-એકવાર** છે: જે પ્રતિસાદ અમે ક્યારેય
    જોયો નથી તે પછીનો પુનઃપ્રયાસ ઇવેન્ટની ડુપ્લિકેટ બનાવી શકે છે. દરેક પુનઃપ્રયાસમાં સમાન
    `event_id` હોય છે, તેથી પ્રક્રિયા કરેલી ids સંગ્રહો અને પુનરાવર્તનો છોડો. `event_id`
    એન્ડપોઇન્ટ્સ વચ્ચે પણ શેર થાય છે — એક જ ઇવેન્ટ માટે સબ્સ્ક્રાઇબ થયેલા બે
    એન્ડપોઇન્ટ્સને સમાન `event_id` મળે છે.
  </Accordion>

  <Accordion title="સમયસમાપ્તિઓ">
    એન્ડપોઇન્ટ ડિલિવરીમાં દરેક પ્રયાસ માટે **30 સેકન્ડ**ની સમયસમાપ્તિ હોય છે. લેગસી
    પાથ પર, લાઇવ કૉલ વર્તન નિયંત્રિત કરતી બ્લોકિંગ વિનંતીઓ — 
    [`telephony.incoming` / `web.incoming`](/gu/webhooks/call-incoming)
    કન્ફિગરેશન વિનિમય — **10 સેકન્ડ** પછી સમયસમાપ્ત થાય છે, પરંતુ ધીમો
    પ્રતિસાદ કૉલ ઉપાડવામાં વિલંબ કરે છે, તેથી બે-એક સેકન્ડમાં જવાબ આપવાનો
    પ્રયાસ કરો. વેબહુક-મોડ [ટૂલ ડિસ્પેચ](/gu/tools/overview) માટે ડિફૉલ્ટ રૂપે 20 સેકન્ડ
    મંજૂર છે, અને ટૂલ ઘોષણાઓ ટોપ-લેવલ `timeout` સેટ કરી શકે છે.
  </Accordion>

  <Accordion title="સ્ત્રોત IPs">
    આઉટબાઉન્ડ વેબહુક્સ ThunderPhoneની ક્લાઉડ IP રેન્જમાંથી આવે છે.
    જો તમારા ફાયરવૉલને allowlist જરૂરી હોય, તો સપોર્ટનો સંપર્ક કરો અને અમે
    વર્તમાન રેન્જ શેર કરીશું.
  </Accordion>
</AccordionGroup>

## લેગસી અને એન્ડપોઇન્ટ-આધારિત વેબહુક્સ વચ્ચે પસંદગી

| સુવિધા | લેગસી (`/v1/webhook`) | એન્ડપોઇન્ટ્સ (`/v1/developer/webhook-endpoints`) |
|---------|------------------------|----------------------------------------------|
| URLsની સંખ્યા | પ્રતિ સંસ્થા 1 | પ્રતિ સંસ્થા ઘણા |
| ઇવેન્ટ કવરેજ | માત્ર `telephony.*` / `web.*` | તમામ 10 ઇવેન્ટ પ્રકારો |
| ઇવેન્ટ ફિલ્ટર | — | પ્રતિ એન્ડપોઇન્ટ |
| પુનઃપ્રયાસો | કોઈ નહીં | 24 કલાકમાં 8 પ્રયાસો |
| એન્વલપ | `type` + `data` | `type` + `data` + `event_id` |
| સિક્રેટ રોટેશન | એકમાત્ર સિક્રેટને બદલે છે | પ્રતિ એન્ડપોઇન્ટ સિક્રેટ |
| ડિલીટ કર્યા વિના અક્ષમ કરવું | `{"url": ""}` સાથે `PUT /v1/webhook` | `status=disabled` |
| સ્ટેટસ દૃશ્યતા | — | `active` / `disabled` / `failing` |
| બ્લોકિંગ કન્ફિગરેશન વિનિમય | હા ([`telephony.incoming` / `web.incoming`](/gu/webhooks/call-incoming)) | ક્યારેય નહીં — માત્ર સૂચનાઓ |
| આ માટે શ્રેષ્ઠ | ડાયનેમિક કૉલ કન્ફિગરેશન | પ્રોડક્શનમાં ઇવેન્ટ ઉપભોગ |

નવી ઇન્ટિગ્રેશન્સે એન્ડપોઇન્ટ-આધારિત વેબહુક્સ દ્વારા ઇવેન્ટ્સ
ઉપભોગ કરવા જોઈએ. જો તમે કૉલ ઉપાડતી વખતે કૉલ્સને
ડાયનેમિક રીતે કન્ફિગર કરો છો અથવા વેબહુક-મોડ ટૂલ ડિસ્પેચનો ઉપયોગ કરો છો, તો જ લેગસી URL રાખો
(અથવા ઉમેરો) — તે વિનંતી/પ્રતિસાદ વિનિમયો માત્ર લેગસી પાથ પર ચાલે છે.

---

## સંબંધિત

<CardGroup cols={2}>
  <Card title="ઇવેન્ટ્સ કેટલોગ" icon="list" href="/gu/webhooks/events">
    તમામ ઇવેન્ટ પ્રકારો અને તેમના પેલોડ્સ.
  </Card>
  <Card title="વેબહુક એન્ડપોઇન્ટ્સ" icon="bolt" href="/gu/webhooks/endpoints">
    ઘણા એન્ડપોઇન્ટ્સ, ઇવેન્ટ ફિલ્ટર્સ અને સિક્રેટ્સ મેનેજ કરો.
  </Card>
  <Card title="telephony.incoming / web.incoming" icon="phone" href="/gu/webhooks/call-incoming">
    કૉલ્સ કન્ફિગર કરવા માટે તમારા સર્વરે જવાબ આપવી જરૂરી એવી બ્લોકિંગ વિનંતી.
  </Card>
  <Card title="telephony.complete / web.complete" icon="phone" href="/gu/webhooks/call-complete">
    ટ્રાન્સક્રિપ્ટ, રેકોર્ડિંગ અને મેટ્રિક્સ સાથેનો કૉલ-પછીનો પેલોડ.
  </Card>
</CardGroup>