Open in
વેબહૂક સહીની ચકાસણી કરો
ThunderPhone મોકલે છે તે દરેક વેબહૂક અને ટૂલ વિનંતી પર ટાઇમસ્ટેમ્પ સાથે સહી કરવામાં આવે છે. અહીં આપેલી રેસીપી અથવા SDK સહાયકથી તેની ચકાસણી કરો અને પાંચ મિનિટથી જૂની ફરીથી મોકલાયેલી વિનંતીઓને નકારી કાઢો.
અમે તમારા સર્વર પર મોકલીએ છીએ તે દરેક વિનંતી (webhook ડિલિવરીઝ, લેગસી single-URL webhook અને tool-endpoint કૉલ્સ)માં બે signature headers હોય છે. બંને એક જ secret સાથે HMAC-SHA256 છે.
| Header | સહી કરે છે | રીપ્લે સુરક્ષા |
|---|---|---|
X-ThunderPhone-Signature-V2 (ભલામણ કરેલ) | Timestamp, method, path, query અને body | 5 મિનિટથી જૂની વિનંતીઓને નકારો |
X-ThunderPhone-Signature | માત્ર body | કોઈ નહીં: કૅપ્ચર કરેલી વિનંતી હંમેશા વેરિફાય થાય છે |
નવી integrationsમાં X-ThunderPhone-Signature-V2 વેરિફાય કરો અને
હાલની integrationsને તેના પર ખસેડો. X-ThunderPhone-Signature હજુ પણ દરેક
વિનંતી સાથે, અપરિવર્તિત રીતે મોકલવામાં આવે છે, તેથી તેના પર આધારિત verifiers કાર્યરત રહે છે. અમે તેને મોકલવાનું બંધ કરીએ તે પહેલાં તારીખ જાહેર કરીશું.
સહી V2
X-ThunderPhone-Signature-V2: t=1767225600,v1=03a89bec521f78d55727237ca4713bb0b8dcdf2e09e450865b5b5637b80c1c4etએ 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 ટૂલ કૉલમાં બોડી હોતી નથી, તેથી તેમની સહી કરેલી સ્ટ્રિંગ પાથ પછીની નવી લાઇન પર સમાપ્ત થાય છે |
ચકાસવા માટે:
- કોઈપણ પાર્સિંગ પહેલાં, હેડર, મેથડ, રૉ પાથ અને ક્વેરી, અને રૉ બોડી વાંચો.
- હેડરમાંથી
tઅને દરેકv1લો. - જો
tતમારી ઘડિયાળ કરતાં 300 સેકન્ડ પહેલાં અથવા પછી હોય તો વિનંતી નકારી દો. - તમારી સિક્રેટ સાથે સહી કરેલી સ્ટ્રિંગનો હેક્સ HMAC-SHA256 ગણો.
- તેને
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-મિનિટની વિન્ડો ચકાસે છે, કોન્સ્ટન્ટ ટાઇમમાં સરખામણી કરે છે અને સિક્રેટની સૂચિ
સ્વીકારે છે જેથી તમે ડાઉનટાઇમ વિના રોટેટ કરી શકો.
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
)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 વિના
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)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 હેલ્પરને કૉલ કરે છે.
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}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);
},
);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 webhook | GET /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 પર સ્થાનાંતરિત થાય ત્યાં સુધી તે હજી પણ દરેક વિનંતી સાથે મોકલવામાં આવે છે.
- raw request body વાંચો — અમે તમને મોકલેલા ચોક્કસ bytes.
hmac_sha256(secret, body).hexdigest()ગણતરી કરો.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 માટે પણ આ જ લાગુ પડે છે.
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 "")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),
);
}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))
}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 પ્રતિસાદ આપો.