ThunderPhone v3 હવે લાઇવ છે.સેલ્ફ-સર્વ, 2¢/મિનિટથી.જાહેરાત વાંચો

Operations

વેબહૂક સહીની ચકાસણી કરો

ThunderPhone મોકલે છે તે દરેક વેબહૂક અને ટૂલ વિનંતી પર ટાઇમસ્ટેમ્પ સાથે સહી કરવામાં આવે છે. અહીં આપેલી રેસીપી અથવા SDK સહાયકથી તેની ચકાસણી કરો અને પાંચ મિનિટથી જૂની ફરીથી મોકલાયેલી વિનંતીઓને નકારી કાઢો.

અમે તમારા સર્વર પર મોકલીએ છીએ તે દરેક વિનંતી (webhook ડિલિવરીઝ, લેગસી single-URL webhook અને tool-endpoint કૉલ્સ)માં બે signature headers હોય છે. બંને એક જ secret સાથે HMAC-SHA256 છે.

Headerસહી કરે છેરીપ્લે સુરક્ષા
X-ThunderPhone-Signature-V2 (ભલામણ કરેલ)Timestamp, method, path, query અને body5 મિનિટથી જૂની વિનંતીઓને નકારો
X-ThunderPhone-Signatureમાત્ર bodyકોઈ નહીં: કૅપ્ચર કરેલી વિનંતી હંમેશા વેરિફાય થાય છે

નવી integrationsમાં X-ThunderPhone-Signature-V2 વેરિફાય કરો અને હાલની integrationsને તેના પર ખસેડો. X-ThunderPhone-Signature હજુ પણ દરેક વિનંતી સાથે, અપરિવર્તિત રીતે મોકલવામાં આવે છે, તેથી તેના પર આધારિત verifiers કાર્યરત રહે છે. અમે તેને મોકલવાનું બંધ કરીએ તે પહેલાં તારીખ જાહેર કરીશું.

સહી V2

X-ThunderPhone-Signature-V2: t=1767225600,v1=03a89bec521f78d55727237ca4713bb0b8dcdf2e09e450865b5b5637b80c1c4e
  • t એ Unix સમય છે, સેકન્ડમાં, જ્યારે અમે વિનંતી મોકલી હતી. ફરી પ્રયાસ કરેલી ડિલિવરી મોકલવામાં આવે ત્યારે તેની પોતાની t સાથે ફરીથી સહી કરવામાં આવે છે.
  • v1 એ નીચેની સહી કરેલી સ્ટ્રિંગનો હેક્સ HMAC-SHA256 છે, જે તમારી સિક્રેટ વડે કી કરાયેલો છે.

મૂલ્ય એ અલ્પવિરામથી અલગ કરાયેલા key=value જોડીઓની સૂચિ છે. જે કી તમે ઓળખતા ન હો તે અવગણો અને જો કોઈપણ v1 મેળ ખાતું હોય તો વિનંતી સ્વીકારો: ભવિષ્યના ફેરફાર દરમિયાન અમે બીજી સહી ઉમેરી શકીએ છીએ.

સહી કરેલી સ્ટ્રિંગ

ચાર ફીલ્ડ, જેમાં દરેક પછી એક નવી લાઇન (\n, બાઇટ 0x0A) આવે છે, છેલ્લા ફીલ્ડ સિવાય:

<t>\n<METHOD>\n<path and query>\n<body>
ફીલ્ડમૂલ્ય
tહેડરમાંથી t મૂલ્ય
METHODમોટા અક્ષરોમાં HTTP મેથડ: POST, GET, PUT, PATCH અથવા DELETE
પાથ અને ક્વેરીHTTP વિનંતી લાઇનમાંથી વિનંતી લક્ષ્ય: પાથ, પછી ? અને જો ક્વેરી સ્ટ્રિંગ હોય તો તે. કોઈ સ્કીમ, હોસ્ટ અથવા ફ્રેગમેન્ટ નહીં. ડીકોડ કર્યા વિના અથવા પેરામીટરોનો ક્રમ બદલ્યા વિના, તે જેમ પ્રાપ્ત થયું હોય તેમ જ વાપરો
bodyરૉ વિનંતી બોડી. GET અને DELETE ટૂલ કૉલમાં બોડી હોતી નથી, તેથી તેમની સહી કરેલી સ્ટ્રિંગ પાથ પછીની નવી લાઇન પર સમાપ્ત થાય છે

ચકાસવા માટે:

  1. કોઈપણ પાર્સિંગ પહેલાં, હેડર, મેથડ, રૉ પાથ અને ક્વેરી, અને રૉ બોડી વાંચો.
  2. હેડરમાંથી t અને દરેક v1 લો.
  3. જો t તમારી ઘડિયાળ કરતાં 300 સેકન્ડ પહેલાં અથવા પછી હોય તો વિનંતી નકારી દો.
  4. તમારી સિક્રેટ સાથે સહી કરેલી સ્ટ્રિંગનો હેક્સ HMAC-SHA256 ગણો.
  5. તેને v1 સાથે કોન્સ્ટન્ટ ટાઇમમાં સરખાવો. કંઈ મેળ ન ખાય તો 401 પ્રતિસાદ આપો.

કાર્યકારી ઉદાહરણ

સિક્રેટ whsec_example_4c1f2a9b. અમે આ વિનંતી t = 1767225600 (2026-01-01 00:00:00 UTC) પર મોકલીએ છીએ:

POST /tools/lookup?region=us HTTP/1.1
Host: api.example.com
Content-Type: application/json
X-ThunderPhone-Signature-V2: t=1767225600,v1=03a89bec521f78d55727237ca4713bb0b8dcdf2e09e450865b5b5637b80c1c4e
 
{"customer_id":"cust_123"}

સહી કરેલી સ્ટ્રિંગ આ ચાર લાઇન છે, જેમાં બોડી પછી કોઈ નવી લાઇન નથી:

1767225600
POST
/tools/lookup?region=us
{"customer_id":"cust_123"}

તેનો HMAC-SHA256 03a89bec521f78d55727237ca4713bb0b8dcdf2e09e450865b5b5637b80c1c4e છે. તેની સામે તમારા અમલીકરણની ચકાસણી કરો, અથવા તેને openssl વડે પુનઃઉત્પન્ન કરો:

printf '1767225600\nPOST\n/tools/lookup?region=us\n{"customer_id":"cust_123"}' \
  | openssl dgst -sha256 -hmac 'whsec_example_4c1f2a9b'

એ જ સેકન્ડે /tools/lookup?customer_id=cust_123 માટેના GET ટૂલ કૉલમાં ખાલી બોડી હોય છે. તેની સહી કરેલી સ્ટ્રિંગ 1767225600\nGET\n/tools/lookup?customer_id=cust_123\n છે અને તેની સહી 3ce214cb0b8f2bf39b1d19d4e7265df9dbaff5a5f838d3cc6c753a8f7a4ad280 છે.

SDK સાથે

Python અને TypeScript SDKમાં હેલ્પર શામેલ છે (thunderphone 0.2.0 અથવા પછીનું, @thunderphone/sdk 0.2.0 અથવા પછીનું). તે 5-મિનિટની વિન્ડો ચકાસે છે, કોન્સ્ટન્ટ ટાઇમમાં સરખામણી કરે છે અને સિક્રેટની સૂચિ સ્વીકારે છે જેથી તમે ડાઉનટાઇમ વિના રોટેટ કરી શકો.

Python
from thunderphone import verify_signature
 
ok = verify_signature(
    header,            # the X-ThunderPhone-Signature-V2 value
    secret=SECRET,     # or [NEW_SECRET, OLD_SECRET] while rotating
    method=method,     # "POST"
    path=path,         # "/tools/lookup?region=us", exactly as received
    body=raw_body,     # bytes, before any JSON parsing
    tolerance=300,     # optional; seconds
)
Node.js
import { verifySignature } from "@thunderphone/sdk";
 
const ok = verifySignature({
  header,               // the X-ThunderPhone-Signature-V2 value
  secret: SECRET,       // or [NEW_SECRET, OLD_SECRET] while rotating
  method,               // "POST"
  path,                 // "/tools/lookup?region=us", exactly as received
  body: rawBody,        // Buffer or string, before any JSON parsing
  toleranceSeconds: 300, // optional
});

SDK વિના

Python
import hashlib
import hmac
import time
 
TOLERANCE_SECONDS = 300
 
 
def verify_v2(header: str, secret: str, method: str, path: str, body: bytes) -> bool:
    """path is the path plus ?query exactly as received; body is the raw body."""
    timestamp, signatures = None, []
    for item in (header or "").split(","):
        key, _, value = item.strip().partition("=")
        if key == "t" and value.isdigit() and len(value) <= 15:
            timestamp = int(value)
        elif key == "v1":
            signatures.append(value)
    if timestamp is None or abs(time.time() - timestamp) > TOLERANCE_SECONDS:
        return False
    signed = f"{timestamp}\n{method.upper()}\n{path}\n".encode() + body
    expected = hmac.new(secret.encode(), signed, hashlib.sha256).hexdigest()
    return any(hmac.compare_digest(expected.encode(), s.encode()) for s in signatures)
Node.js
import crypto from "node:crypto";
 
const TOLERANCE_SECONDS = 300;
 
// path is the path plus ?query exactly as received; body is the raw Buffer.
export function verifyV2(header, secret, method, path, body) {
  let timestamp;
  const signatures = [];
  for (const item of (header || "").split(",")) {
    const [key, value = ""] = item.trim().split("=", 2);
    if (key === "t" && /^\d+$/.test(value)) timestamp = Number(value);
    else if (key === "v1") signatures.push(value);
  }
  if (timestamp === undefined) return false;
  if (Math.abs(Date.now() / 1000 - timestamp) > TOLERANCE_SECONDS) return false;
  const expected = Buffer.from(
    crypto
      .createHmac("sha256", secret)
      .update(`${timestamp}\n${method.toUpperCase()}\n${path}\n`)
      .update(body)
      .digest("hex"),
  );
  return signatures.some((sig) => {
    const candidate = Buffer.from(sig);
    return (
      candidate.length === expected.length &&
      crypto.timingSafeEqual(candidate, expected)
    );
  });
}

ફ્રેમવર્ક ગોઠવણી

દરેક ઉદાહરણ કાચો પાથ અને ક્વેરી તથા કાચું બોડી વાંચે છે, પછી SDK હેલ્પરને કૉલ કરે છે.

FastAPI
import json
 
from fastapi import FastAPI, HTTPException, Request
from thunderphone import verify_signature
 
app = FastAPI()
 
 
def raw_path_and_query(request: Request) -> str:
    path = (request.scope.get("raw_path") or request.url.path.encode()).decode("latin-1")
    query = request.scope.get("query_string", b"").decode("latin-1")
    return f"{path}?{query}" if query else path
 
 
@app.post("/thunderphone-webhook")
async def hook(request: Request):
    body = await request.body()  # raw bytes, NOT request.json()
    if not verify_signature(
        request.headers.get("X-ThunderPhone-Signature-V2"),
        secret=SECRET,
        method=request.method,
        path=raw_path_and_query(request),
        body=body,
    ):
        raise HTTPException(status_code=401)
    event = json.loads(body)
    # … dispatch on event["type"] …
    return {"ok": True}
Express
import express from "express";
import { verifySignature } from "@thunderphone/sdk";
 
const app = express();
 
app.post(
  "/thunderphone-webhook",
  // IMPORTANT: parse as raw; do NOT use express.json() here.
  express.raw({ type: "application/json" }),
  (req, res) => {
    const ok = verifySignature({
      header: req.header("X-ThunderPhone-Signature-V2"),
      secret: process.env.WEBHOOK_SECRET,
      method: req.method,
      path: req.originalUrl, // path and query as received
      body: req.body,
    });
    if (!ok) return res.sendStatus(401);
    const event = JSON.parse(req.body.toString("utf8"));
    // … dispatch on event.type …
    res.sendStatus(204);
  },
);
Django
import json
 
from django.http import HttpResponseForbidden, JsonResponse
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_POST
from thunderphone import verify_signature
 
 
@csrf_exempt
@require_POST
def hook(request):
    if not verify_signature(
        request.headers.get("X-ThunderPhone-Signature-V2"),
        secret=SECRET,
        method=request.method,
        path=request.get_full_path(),
        body=request.body,  # raw bytes
    ):
        return HttpResponseForbidden("invalid signature")
    event = json.loads(request.body)
    # … dispatch on event["type"] …
    return JsonResponse({"ok": True})

req.originalUrl (Express) અને ASGI raw_path તથા query_string (FastAPI) પ્રાપ્ત થયેલા જ ટાર્ગેટ છે. Djangoનું get_full_path() અને Flaskનું request.path પહેલાં પાથ ડીકોડ કરે છે, જે સામાન્ય પાથ માટે સમાન સ્ટ્રિંગ આપે છે. જો તમારા એન્ડપૉઇન્ટ પાથમાં %2F, ; અથવા = જેવા ટકા-એન્કોડેડ અથવા આરક્ષિત અક્ષરો હોય, તો તેના બદલે તમારું સર્વર જે કાચો ટાર્ગેટ આપે તે વાંચો (ઉદાહરણ તરીકે, Gunicorn પર request.META["RAW_URI"]).

કયું સિક્રેટ?

એક જ secret બંને header પર સહી કરે છે.

સ્રોતસિક્રેટ
Webhook એન્ડપોઇન્ટ (/v1/developer/webhook-endpoints)બનાવતી વખતે એકવાર પરત મળતું પ્રતિ-એન્ડપોઇન્ટ secret (48 હેક્સ અક્ષરો)
લેગસી સિંગલ-URL webhookGET /v1/webhook પર પરત મળતું પ્રતિ-org secret
ટૂલ-એન્ડપોઇન્ટ ઇન્વોકેશન (તમારા endpoint.url પર સીધો કૉલ)org-સ્તરનું webhook સિક્રેટ (લેગસી સિંગલ-URL webhook જેવું જ) — પ્રતિ-એન્ડપોઇન્ટ સિક્રેટ નહીં

સિક્રેટને તમારા સિક્રેટ મેનેજર અથવા env var માં સ્ટોર કરો — તેને ક્યારેય કમિટ કરશો નહીં.

ટૂલ કૉલ્સની ચકાસણી

જ્યારે એજન્ટ તમારા ફંક્શન ટૂલ્સમાંથી કોઈ એકને સીધું જ ઇન્વોક કરે છે (ટૂલમાં endpoint હોય છે), ત્યારે વિનંતીમાં તમારા કન્ફિગર કરેલા endpoint.headers સાથે આ ThunderPhone હેડર્સ પણ હોય છે:

  • X-ThunderPhone-Call-ID — લાઇવ કૉલનું સંખ્યાત્મક ID.
  • X-ThunderPhone-Signature-V2 — ઉપર દર્શાવેલ ટાઇમસ્ટેમ્પવાળું સિગ્નેચર, જે તમારા સંસ્થાસ્તરીય વેબહૂક સિક્રેટથી કી કરેલું હોય છે.
  • X-ThunderPhone-Signature — લેગસી માત્ર-બૉડી સિગ્નેચર, સમાન કી સાથે.

ફોન કૉલમાં X-ThunderPhone-From-Number, X-ThunderPhone-To-Number અને X-ThunderPhone-Call-Direction પણ હોય છે (વિગતો). દરેક હેડરની જેમ, તેમાંથી કોઈ પણ સિગ્નેચર દ્વારા આવરી લેવામાં આવતા નથી.

તમારી સંસ્થાએ લેગસી વેબહૂક ક્યારેય કન્ફિગર ન કર્યું હોય તો પણ, દરેક ટૂલ વિનંતી પર સિગ્નેચર હોય છે: ThunderPhone સંસ્થાનો સિક્રેટ આપમેળે બનાવે છે. તેને GET /v1/webhookમાંથી વાંચો.

વેબહૂકથી એક બાબત અલગ છે: GET / DELETE ટૂલ્સમાં બૉડી હોતી નથી. આર્ગ્યુમેન્ટ્સ ક્વેરી પેરામીટર્સ તરીકે મોકલાય છે. V2 સિગ્નેચર પાથ અને ક્વેરી દ્વારા તેમને આવરી લે છે, અને બૉડી ફીલ્ડ ખાલી હોય છે. મૂળ ક્વેરી સ્ટ્રિંગથી ચકાસો: પેરામીટર્સ પાર્સ કરીને નવી ક્વેરી સ્ટ્રિંગ બનાવવાથી તેમનો ક્રમ અથવા એન્કોડિંગ બદલાઈ શકે છે. લેગસી હેડર ખાલી બાઇટ સ્ટ્રિંગ પર સિગ્નેચર કરે છે.

@app.api_route("/tools/search-appointments", methods=["GET", "POST"])
async def tool(request: Request):
    body = await request.body()  # b"" for GET/DELETE tools
    if not verify_signature(
        request.headers.get("X-ThunderPhone-Signature-V2"),
        secret=ORG_WEBHOOK_SECRET,
        method=request.method,
        path=raw_path_and_query(request),
        body=body,
    ):
        raise HTTPException(status_code=401)
    call_id = request.headers.get("X-ThunderPhone-Call-ID", "")
    args = json.loads(body) if body else dict(request.query_params)
    ...

Expressમાં, બૉડી પાર્સર GET પર req.bodyને ખાલી ઑબ્જેક્ટ તરીકે રાખે છે, તેથી Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0) પાસ કરો.

વેબહૂક-મોડ ટૂલ ડિસ્પૅચ (endpoint વિનાની ટૂલ્સ, જે તમારી સંસ્થાના વેબહૂક પર telephony.tool / web.tool તરીકે પહોંચાડવામાં આવે છે) સામાન્ય સહી કરાયેલ વેબહૂક છે — ઉપરોક્ત માનક પદ્ધતિ લાગુ પડે છે. બંને વિનંતિ આકારો માટે ફંક્શન ટૂલ્સ જુઓ.

લેગસી સહી: X-ThunderPhone-Signature

મૂળ હેડર માત્ર raw body નો hex HMAC-SHA256 છે, જેમાં એ જ secret વપરાય છે. તેમાં કોઈ timestamp નથી, તેથી એક સહી કરેલી વિનંતી પકડી લેનાર કોઈપણ વ્યક્તિ તેને ફરી ચલાવી શકે છે. ઇન્ટિગ્રેશન્સ V2 પર સ્થાનાંતરિત થાય ત્યાં સુધી તે હજી પણ દરેક વિનંતી સાથે મોકલવામાં આવે છે.

  1. raw request body વાંચો — અમે તમને મોકલેલા ચોક્કસ bytes.
  2. hmac_sha256(secret, body).hexdigest() ગણતરી કરો.
  3. X-ThunderPhone-Signature સામે constant time માં સરખામણી કરો.

અમે મોકલીએ છીએ એ જ ચોક્કસ bytes પર સહી કરીએ છીએ. આ bytes payload નું canonical JSON serialization પણ છે — keys ને મૂળાક્ષરક્રમમાં ગોઠવેલી, compact separators (સ્પેસ વિનાના , અને :), UTF-8. જો તમારું framework ફક્ત parsed JSON જ ઉપલબ્ધ કરાવતું હોય, તો તેને canonically ફરી serialize કરો અને તેનું HMAC કરો:

# Equivalent to hashing the raw body:
import json
canonical = json.dumps(payload, separators=(",", ":"), sort_keys=True).encode("utf-8")

raw body ને પ્રાથમિકતા આપો — તેમાં એક પગલું ઓછું છે અને કેટલીક ભાષાઓમાં JSON number ને ફરી round-trip કરતી વખતે થતી વિચિત્રતાઓથી સુરક્ષિત છે. V2 ના body field માટે પણ આ જ લાગુ પડે છે.

Python
import hashlib
import hmac
 
 
def verify(body: bytes, signature: str, secret: str) -> bool:
    """Constant-time HMAC-SHA256 verification."""
    expected = hmac.new(
        secret.encode("utf-8"),
        body,
        hashlib.sha256,
    ).hexdigest()
    return hmac.compare_digest(expected, signature or "")
Node.js
import crypto from "node:crypto";
 
export function verify(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),
  );
}
Go
package webhook
 
import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
)
 
func Verify(body []byte, signature, secret string) bool {
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write(body)
    expected := hex.EncodeToString(mac.Sum(nil))
    return hmac.Equal([]byte(expected), []byte(signature))
}
Ruby
require "openssl"
 
def verify(body, signature, secret)
  expected = OpenSSL::HMAC.hexdigest("SHA256", secret, body)
  Rack::Utils.secure_compare(expected, signature.to_s)
end

સામાન્ય ખામીઓ

ઘડિયાળનો સમયભેદ

5-મિનિટની વિન્ડો તમારા સર્વરની ઘડિયાળના આધારે માપવામાં આવે છે. તેને NTP સાથે સમન્વયિત રાખો; 5 મિનિટથી વધુ ખોટી ઘડિયાળ દરેક વિનંતીને નકારી કાઢે છે.

પ્રોક્સી પાથ ફરીથી લખે છે

સહી કરેલો પાથ એ છે જેની અમે વિનંતી કરી હતી: તમે ThunderPhone માં કૉન્ફિગર કરેલા URL નો પાથ. જો રિવર્સ પ્રોક્સી અથવા API ગેટવે તમારી એપ્લિકેશન વિનંતી જુએ તે પહેલાં પ્રીફિક્સ દૂર કરે અથવા ઉમેરે, તો ચકાસણી પહેલાં અમે મોકલેલો પાથ ફરીથી બનાવો (ઉદાહરણ તરીકે, પ્રીફિક્સ પાછો ઉમેરો).

ડિફૉલ્ટ ફૉર્મેટિંગ સાથે ફરીથી સિરિયલાઇઝ કરવું

બોડીને પાર્સ કરીને તમારી JSON લાઇબ્રેરીના ડિફૉલ્ટ્સ સાથે ફરીથી ડમ્પ કરવાથી (, / : પછી ખાલી જગ્યાઓ, દાખલાના ક્રમમાં કીઓ) અલગ બાઇટ્સ બને છે અને HMAC તૂટી જાય છે. કાચી બોડી ચકાસો — અથવા જો તમારે ફરીથી સિરિયલાઇઝ કરવું જ પડે, તો અમારા કૅનોનિકલ ફૉર્મેટ સાથે બરાબર મેળ બેસાડો: ક્રમબદ્ધ કીઓ, સંક્ષિપ્ત વિભાજકો, UTF-8.

ફ્રેમવર્ક આપમેળે JSON પાર્સ કરે છે

Expressનું express.json() મિડલવેર બોડી સ્ટ્રીમ વાપરી લે છે અને તમે રૉ બાઇટ્સ ગુમાવો છો. ખાસ કરીને વેબહૂક રૂટ પર express.raw() વાપરો, અથવા પ્રી-મિડલવેરમાં રૉ બોડી બફર કરો. NestJS / Koa માટે પણ આ જ વાત લાગુ પડે છે — તેમના "રૉ બોડી" દસ્તાવેજો તપાસો.

ટાઇમિંગ-અસુરક્ષિત સરખામણી

JSમાં expected === signature અથવા Pythonમાં expected == signature ટાઇમિંગ-વેરિએબલ સરખામણીઓ છે. અનુક્રમે crypto.timingSafeEqual અથવા hmac.compare_digest વાપરો. કામગીરીમાં તફાવત નગણ્ય છે.

ટૂલ એન્ડપૉઇન્ટ્સ માટે ખોટો સિક્રેટ

સીધા ટૂલ-એન્ડપૉઇન્ટ કૉલ્સ પર સંસ્થા-સ્તરનું વેબહૂક સિક્રેટ (GET /v1/webhook) વડે સહી કરવામાં આવે છે — /v1/developer/webhook-endpoints ના કોઈપણ પ્રતિ-એન્ડપૉઇન્ટ સિક્રેટ વડે નહીં. એ જ હેલ્પરનો ફરીથી ઉપયોગ કરો, પરંતુ ખાતરી કરો કે ટૂલ રૂટ્સ પર તમે તેને સંસ્થાનો સિક્રેટ આપો.

GET/DELETE ટૂલ્સ પર ક્વેરી સ્ટ્રિંગ્સ

V2 ક્વેરી સ્ટ્રિંગ પર મોકલવામાં આવી હોય તેવી જ રીતે સહી કરે છે. લેગસી હેડર ખાલી બોડી પર સહી કરે છે અને ક્વેરી સ્ટ્રિંગ પર ક્યારેય નહીં, તેથી લેગસી હેડર માટે URL ને હૅશ કરવાથી ક્યારેય મેળ નહીં આવે.

વિન્ડોની અંદર ડુપ્લિકેટ્સ

ટાઇમસ્ટૅમ્પ 5 મિનિટથી જૂના રિપ્લેને રોકે છે, તે વિન્ડોની અંદરની બીજી નકલને નહીં. એન્ડપૉઇન્ટ ડિલિવરીઓ ઓછામાં ઓછી એક વાર થાય છે, તેથી એ જ ઇવેન્ટનો ફરી પ્રયાસ પણ આવી શકે છે; એન્વલપના event_id પર ડિડુપ્લિકેટ કરો.

અસંગતતા પર 401 પરત ન કરવું

ચકાસણી નિષ્ફળ જાય ત્યારે 200 પરત કરવાથી હેન્ડલર રીપ્લે લક્ષ્ય બને છે. ચકાસણી નિષ્ફળ જાય તો હંમેશા નૉન-2xx પ્રતિસાદ આપો.


આગળનાં પગલાં