WhatsApp మెసేజ్లు మీ సర్వర్కు ఎలా చేరతాయి: డైరెక్ట్ లేదా మేనేజ్డ్, సంతకాన్ని ధృవీకరించడం
easyCoexistence ద్వారా కనెక్ట్ చేసిన ప్రతి నంబర్కు ఒకే ఇన్బౌండ్ మోడ్ ఉంటుంది. మీ సిస్టమ్కు నేరుగా (డైరెక్ట్): Meta తన వెబ్హుక్లను మీ HTTPS ఎండ్పాయింట్కు పంపుతుంది, URLలోని రహస్యం క్రెడెన్షియల్గా ఉంటుంది, మరియు ఆటోమేషన్లు ఆఫ్లో ఉంటాయి. easyCoexistence ద్వారా (మేనేజ్డ్): Meta easyCoexistenceకు పంపుతుంది, ఆటోమేషన్లు జవాబు ఇవ్వగలవు, మరియు ఐచ్ఛిక ఫార్వర్డ్ URLకు Meta యొక్క ఒరిజినల్ విలువ కనెక్షన్ వివరాలతో వెళ్తుంది, మీరు ధృవీకరించడానికి X-EC-Signature తో సంతకం చేయబడుతుంది.
ఫార్వర్డ్ చేసిన ప్రతి డెలివరీకి ప్రయత్నాలు 1 నిమిషం, 5 నిమిషాలు, 30 నిమిషాలు, 2 గంటలు, 6 గంటలు మరియు 24 గంటల వ్యవధిలో, మొత్తం సుమారు 33 గంటలు.
ప్రతి ఫార్వర్డ్ ప్రయత్నం 2xx కోసం ఎంతసేపు వేచి ఉంటుందో, ఆ తర్వాత అది విఫలమైనదిగా లెక్కించబడుతుంది.
సంతకంలోని t పై సూచించిన వయస్సు పరిమితి; రీట్రైలు మళ్ళీ సంతకం చేయబడతాయి, కాబట్టి నిజమైన డెలివరీలు ఆ పరిమితిలోనే ఉంటాయి.
HTTP 200 కాకుండా ఏదైనా వచ్చినప్పుడు డైరెక్ట్ వెబ్హుక్ను Meta ఎంతసేపు మళ్ళీ ప్రయత్నిస్తుంది; ఇది మెసేజ్లను పునరావృతం చేయవచ్చు.
Meta పంపే అతి పెద్ద వెబ్హుక్ పేలోడ్, హిస్టరీ చంక్లతో సహా.
మేనేజ్డ్ నంబర్ కోసం ఉంచే రన్ లాగ్లు, మెసేజ్ మరియు జవాబు టెక్స్ట్తో; మెసేజ్ టెక్స్ట్ స్వయంగా 30, 90 లేదా 365 రోజులు ఉంచబడుతుంది, మీ ఎంపిక.
డైరెక్ట్ మరియు మేనేజ్డ్ మధ్య తేడా ఏమిటి?
నంబర్ యొక్క మెసేజ్ వెబ్హుక్లను Meta ఎక్కడికి పంపుతుందో అది నిర్ణయిస్తుంది. మేనేజ్డ్ అంటే, easyCoexistence ద్వారా అని చూపబడుతుంది, Meta easyCoexistenceకు పంపుతుంది; easyCoexistence Meta సంతకాన్ని తనిఖీ చేస్తుంది, మీ ఆటోమేషన్లను నడుపుతుంది, Conversations కోసం చాట్లను ఉంచుతుంది, మరియు మీరు ఫార్వర్డ్ URL సెట్ చేస్తే, ప్రతి Meta మార్పును మీరు మాత్రమే కలిగి ఉండే రహస్యంతో సంతకం చేసి మీకు పంపుతుంది. డైరెక్ట్ అంటే, మీ సిస్టమ్కు నేరుగా అని చూపబడుతుంది; easyCoexistence నంబర్ యొక్క WhatsApp Business Account పై మీ HTTPS ఎండ్పాయింట్ను వెబ్హుక్ ఓవర్రైడ్గా సెట్ చేస్తుంది, కాబట్టి Meta నేరుగా మీకు పోస్ట్ చేస్తుంది మరియు మెసేజ్లు easyCoexistence కు ఎప్పటికీ చేరవు.
మానిటరింగ్ వెనుక ఉన్న ఆపరేషనల్ వెబ్హుక్లు, ఉదాహరణకు account_update మరియు క్వాలిటీ మార్పులు, రెండు మోడ్లలోనూ easyCoexistence వద్దే ఉంటాయి, అందుకే అలర్ట్లు ఎలాగైనా పనిచేస్తూనే ఉంటాయి.
| Managed: Through easyCoexistence | Direct: Straight to your system | |
|---|---|---|
| Meta delivers to | easyCoexistence, which verifies Meta's signature | Your HTTPS endpoint |
| Automations | Run on the number | Off |
| Your copy | Optional Forward URL, one Meta change per POST | Meta's envelope, unchanged |
| Proof it is genuine | X-EC-Signature, HMAC-SHA256 with the number's secret | A long random secret in the URL path |
| Failed deliveries | 7 attempts over about 33 hours | Meta retries for up to 7 days |
| History import | Not requested | Requested when saved within 24 hours of connecting |
| Kept by easyCoexistence | Message text 30, 90 or 365 days, run logs 30 days | Nothing |
నంబర్ను రెండింటి మధ్య ఎలా మార్చాలి?
నంబర్ పేజీలో, ఇన్కమింగ్ మెసేజ్లు ఎక్కడికి వెళ్తాయి కార్డ్ మోడ్ను రెండు ఎంపికలుగా చూపుతుంది: easyCoexistence ద్వారా మరియు మీ సిస్టమ్కు నేరుగా. మీ స్వంత వెబ్హుక్కు ఇన్కమింగ్ మెసేజ్లను రూట్ చేయండి కార్డ్లో, లేదా set_webhook_destination తో వెబ్హుక్ గమ్యాన్ని సేవ్ చేయడం వల్ల నంబర్ డైరెక్ట్ అవుతుంది. easyCoexistence ద్వారా ఎంచుకోవడం వెంటనే Meta వద్ద ఆ గమ్యాన్ని తొలగిస్తుంది, కాబట్టి స్వీకరణ కొనసాగాలంటే అదే URLను ఫార్వర్డ్ URLగా జోడించండి. నంబర్ మేనేజ్డ్ మోడ్ నుండి బయటకు వెళ్ళినప్పుడు క్యూలో ఉన్న ఫార్వర్డ్లు తొలగించబడతాయి, మరియు వెబ్హుక్ URL లేకుండా కనెక్ట్ చేసిన నంబర్లు మేనేజ్డ్గా ప్రారంభమవుతాయి.
మీ AI నుండి, set_inbound_mode మోడ్ను మారుస్తుంది మరియు ఒకే కాల్లో ఫార్వర్డ్ను సెట్ చేస్తుంది, ఫార్వర్డ్ రహస్యాన్ని ఒకసారి మాత్రమే తిరిగి ఇస్తుంది:
// set_inbound_mode arguments
{
"connection_id": "3f2a9c1e-7b4d-4e8a-9c2f-1a2b3c4d5e6f",
"mode": "managed",
"forward_url": "https://agent.example.com/ec/forward"
}
// result: forward_secret is shown once
{
"connection_id": "3f2a9c1e-7b4d-4e8a-9c2f-1a2b3c4d5e6f",
"mode": "managed",
"forward_url": "https://agent.example.com/ec/forward",
"forward_secret": "whsec_Qm9vbXRoZXNlY3JldHNhcmVmYWtlMTIz",
"secret_note": "Shown once. Verify X-EC-Signature: t=<unix>,v1=<hex HMAC-SHA256 of \"<t>.<raw body>\"> with it; the body's value is Meta's original payload.",
"direct_destination": null
}ఫార్వర్డ్ చేసిన POST లో ఏముంటుంది?
ఒక్కో అభ్యర్థనలో ఒక Meta మార్పు మాత్రమే ఉంటుంది, Meta యొక్క object, entry మరియు changes ఎన్వలప్కు బదులుగా ర్యాప్ చేయబడి ఉంటుంది. id అనేది డెలివరీ ID, ఇది X-EC-Delivery లో పునరావృతమవుతుంది మరియు రీట్రైల అంతటా స్థిరంగా ఉంటుంది. event అనేది Meta ఫీల్డ్ పేరు: messages, smb_message_echoes, history లేదా smb_app_state_sync, ఇది X-EC-Event లో పునరావృతమవుతుంది. received_at అనేది easyCoexistence మార్పును Meta నుండి ఎప్పుడు అందుకుందో, connection అనేది నంబర్ను గుర్తిస్తుంది, మరియు value అనేది Meta పంపినదే ఖచ్చితంగా, కాబట్టి Meta పేలోడ్ కోసం రాసిన పార్సింగ్ కోడ్ దీనిపై పనిచేస్తుంది. డెలివరీ స్టేటస్లు messages ఈవెంట్ల లోపల, value.statuses కింద వస్తాయి.
POST /ec/forward HTTP/1.1
Content-Type: application/json
User-Agent: easyCoexistence-forward/1
X-EC-Event: messages
X-EC-Delivery: 8c1d7e52-0f4b-4a3e-9d61-2b7f5a9e0c13
X-EC-Signature: t=1794405732,v1=<64 hex characters>
{
"id": "8c1d7e52-0f4b-4a3e-9d61-2b7f5a9e0c13",
"event": "messages",
"received_at": "2026-11-11T14:02:11.482Z",
"connection": {
"id": "3f2a9c1e-7b4d-4e8a-9c2f-1a2b3c4d5e6f",
"phone": "+1 631-555-0142",
"phone_number_id": "106540352242922",
"waba_id": "102290129340398",
"external_ref": null
},
"value": {
"messaging_product": "whatsapp",
"metadata": { "display_phone_number": "16315550142", "phone_number_id": "106540352242922" },
"contacts": [{ "profile": { "name": "Ana Souza" }, "wa_id": "5511987654321", "user_id": "BR.13491208655302741918" }],
"messages": [{
"from": "5511987654321",
"from_user_id": "BR.13491208655302741918",
"id": "wamid.HBgNNTUxMTk4NzY1NDMyMRUCABIYFjNFQjBDNzE4RjQ2QjI5RDkxQTNFAA==",
"timestamp": "1794405731",
"type": "text",
"text": { "body": "Do you deliver on Sundays?" }
}]
}
}Node.js లో X-EC-Signature ను ఎలా ధృవీకరించాలి?
హెడర్ను t=<unix seconds>,v1=<64 hex characters> గా చదవండి. మీ క్లాక్ నుండి 5 నిమిషాలకు మించి దూరంగా ఉన్న t ను తిరస్కరించండి, t, ఒక డాట్ మరియు రా బాడీ పై HMAC-SHA256 లెక్కించండి, దానిని UTF-8 టెక్స్ట్గా మొత్తం ఫార్వర్డ్ రహస్యంతో కీ చేయండి, మరియు ఫలితాన్ని v1 తో స్థిరమైన సమయంలో పోల్చండి. అప్పుడే JSON ను పార్స్ చేయండి. 10 సెకన్లలోపు 2xx తో జవాబివ్వండి, పని తర్వాత చేయండి, మరియు మీరు అంగీకరించిన డెలివరీ IDలను గుర్తుంచుకోండి, తద్వారా రీట్రై రెండుసార్లు ప్రాసెస్ కాదు.
// forward-receiver.mjs: node forward-receiver.mjs (no dependencies)
import crypto from "node:crypto";
import http from "node:http";
const SECRET = process.env.EC_FORWARD_SECRET; // the whole whsec_... string is the HMAC key
const taken = new Set(); // delivery ids already accepted: use a database in production
export function verifyEcSignature(raw, header, secret = SECRET, maxAgeSec = 300) {
const m = /^t=(\d+),v1=([0-9a-f]{64})$/.exec(String(header ?? "").trim());
if (!m || !secret) return false;
if (Math.abs(Math.floor(Date.now() / 1000) - Number(m[1])) > maxAgeSec) return false;
const mac = crypto.createHmac("sha256", secret).update(`${m[1]}.`).update(raw).digest();
return crypto.timingSafeEqual(mac, Buffer.from(m[2], "hex"));
}
http.createServer((req, res) => {
const chunks = [];
req.on("data", (c) => chunks.push(c));
req.on("end", () => {
const raw = Buffer.concat(chunks);
if (req.method !== "POST" || !verifyEcSignature(raw, req.headers["x-ec-signature"])) {
res.writeHead(401).end();
return;
}
res.writeHead(200).end(); // a 2xx within 10 s, before any work
const d = JSON.parse(raw.toString("utf8"));
if (taken.has(d.id)) return; // a retry of a delivery already accepted
taken.add(d.id);
// d.event is the Meta field (messages, smb_message_echoes, history, smb_app_state_sync)
// d.value is Meta's change value, unchanged; queue it for your worker here.
console.log(d.event, d.connection.phone_number_id, Object.keys(d.value));
});
}).listen(process.env.PORT ?? 3000);Python లో దానిని ఎలా ధృవీకరించాలి?
అదే నాలుగు తనిఖీలు స్టాండర్డ్ లైబ్రరీతో: హెడర్ కోసం కఠినమైన ప్యాటర్న్, t వయస్సు, t, డాట్ మరియు రా బైట్లపై hmac.new, మరియు hmac.compare_digest. FastAPI లో రా బాడీ await request.body() నుండి వస్తుంది, మరియు 200 పంపిన తర్వాత BackgroundTasks పనిని నడుపుతుంది. Flask లో request.get_data() ఉపయోగించండి, మరియు బాడీని json.dumps తో ఎప్పుడూ పునర్నిర్మించవద్దు, ఎందుకంటే Python యొక్క డిఫాల్ట్ సెపరేటర్లు స్పేస్లు జోడిస్తాయి మరియు సంతకం ఇక సరిపోలదు.
# forward_receiver.py: pip install fastapi uvicorn, then uvicorn forward_receiver:app
import hashlib, hmac, json, os, re, time
from fastapi import BackgroundTasks, FastAPI, Request, Response
app = FastAPI()
SECRET = os.environ["EC_FORWARD_SECRET"].encode() # the whole whsec_... string, as bytes
SIGNATURE = re.compile(r"t=([0-9]+),v1=([0-9a-f]{64})")
taken = set() # delivery ids already accepted: use a database in production
def verify_ec_signature(raw: bytes, header: str, max_age: int = 300) -> bool:
m = SIGNATURE.fullmatch(header.strip())
if not m or abs(int(time.time()) - int(m[1])) > max_age:
return False
mac = hmac.new(SECRET, m[1].encode() + b"." + raw, hashlib.sha256).hexdigest()
return hmac.compare_digest(mac, m[2])
def process(delivery: dict) -> None:
if delivery["id"] in taken: # a retry of a delivery already accepted
return
taken.add(delivery["id"])
print(delivery["event"], delivery["connection"]["phone_number_id"], list(delivery["value"]))
@app.post("/ec/forward")
async def forward(request: Request, tasks: BackgroundTasks):
raw = await request.body()
if not verify_ec_signature(raw, request.headers.get("x-ec-signature", "")):
return Response(status_code=401)
tasks.add_task(process, json.loads(raw)) # runs after the 200 goes out
return Response(status_code=200)విఫలమైన డెలివరీలు ఎలా మళ్ళీ ప్రయత్నించబడతాయి?
మీ ఎండ్పాయింట్ 10 సెకన్లలో ఏ 2xx ఇచ్చినా ఫార్వర్డ్ డెలివర్ అయినట్లు లెక్కించబడుతుంది. మిగతావన్నీ, టైమ్అవుట్, 4xx, 5xx లేదా అనుసరించని రీడైరెక్ట్, తదుపరి ప్రయత్నాన్ని సుమారు 1 నిమిషం, 5 నిమిషాలు, 30 నిమిషాలు, 2 గంటలు, 6 గంటలు మరియు 24 గంటల తర్వాత షెడ్యూల్ చేస్తుంది, మరియు ఏడవ ప్రయత్నం తర్వాత డెలివరీ వదిలివేయబడుతుంది. ప్రతి ప్రయత్నం కొత్త t తో మళ్ళీ సంతకం చేయబడుతుంది, మరియు URL పబ్లిక్ HTTPS అయి ఉండాలి; దానిని సేవ్ చేసినప్పుడు మరియు ప్రతి పంపే ముందు మళ్ళీ తనిఖీ చేస్తారు. డెలివరీలు పాతవి మొదట వెళ్తాయి, కానీ మళ్ళీ ప్రయత్నించిన ఒకటి కొత్తవాటి తర్వాత చేరవచ్చు, కాబట్టి Meta టైమ్స్టాంప్ల ప్రకారం క్రమబద్ధీకరించండి.
డైరెక్ట్ గమ్యంలో రీట్రైలు Meta చేస్తుంది: HTTP 200 కాకుండా ఏదైనా 7 రోజుల వరకు తగ్గుతున్న ఫ్రీక్వెన్సీతో మళ్ళీ ప్రయత్నించబడుతుంది, మరియు ఆ రీట్రైలు ఒక మెసేజ్ను పునరావృతం చేయవచ్చు. రెండు మోడ్లలోనూ Meta మెసేజ్ ID ఆధారంగా డూప్లికేట్లను తొలగించండి, ఎందుకంటే Meta మళ్ళీ పంపిన మార్పు కొత్త డెలివరీ ID తో మళ్ళీ ఫార్వర్డ్ అవుతుంది.
డైరెక్ట్ ఎండ్పాయింట్కు వచ్చే POST నిజమైనదని ఎలా తెలుస్తుంది?
X-Hub-Signature-256 నుండి కాదు. Meta సబ్స్క్రిప్షన్ను కలిగి ఉన్న యాప్ యొక్క యాప్ సీక్రెట్తో సంతకం చేస్తుంది; ఇక్కడ కనెక్ట్ చేసిన నంబర్ కోసం అది easyCoexistence దే మరియు పంచుకోబడదు, కాబట్టి మీ స్వంత Meta యాప్ సీక్రెట్తో ఆ హెడర్ను తనిఖీ చేస్తే నిజమైన డెలివరీలు తిరస్కరించబడతాయి. verify token ఒక్కసారి మాత్రమే ఎండ్పాయింట్ను రుజువు చేస్తుంది, Meta యొక్క GET హ్యాండ్షేక్ సమయంలో. బదులుగా పనిచేసేవి:
- కాల్బ్యాక్ URL పాత్లో 32 లేదా అంతకంటే ఎక్కువ యాదృచ్ఛిక అక్షరాలు ఉంచండి, అవి లేని అభ్యర్థనలను తిరస్కరించండి; రొటేట్ చేయడానికి, కొత్త URL సేవ్ చేయండి.
- జనరిక్ రిసీవర్ ఉపయోగించండి, ఉదాహరణకు n8n Webhook నోడ్, మీ స్వంత Meta యాప్ను ఆశించే WhatsApp ట్రిగ్గర్ కాదు.
- నంబర్ టోకెన్తో Meta నుండి మీడియాను ID ద్వారా డౌన్లోడ్ చేయండి, తద్వారా నకిలీ ID సులభంగా విఫలమవుతుంది.
- స్వీయ-హోస్ట్ సర్వర్లలో, ఐచ్ఛికంగా AS32934 ప్రకటించిన రూట్లైన Meta నెట్వర్క్ను మాత్రమే అనుమతించండి.
- లేదా ఫార్వర్డ్ URL తో మేనేజ్డ్కు మారండి; అక్కడ X-EC-Signature ప్రతి POST ను రుజువు చేస్తుంది.
సాధారణ పొరపాట్లు
- Meta envelope కోసం రాసిన కోడ్ను మార్పు లేకుండా ఫార్వర్డ్ URL కు పంపడం. ఒక ఫార్వర్డ్లో ఒకే మార్పు ఉంటుంది: object, entry మరియు changes కాదు, event మరియు value ను చదవండి.
- X-EC-Event statuses అవుతుందని ఎదురుచూడటం. డెలివరీ స్టేటస్లు messages ఈవెంట్లలో, value.statuses లో వస్తాయి, మరియు యాప్లో టైప్ చేసిన జవాబులు smb_message_echoes గా వస్తాయి.
- జవాబివ్వకముందే పని చేయడం. ఫార్వర్డ్ 10 సెకన్లు వేచి ఉంటుంది, తర్వాత అదే డెలివరీ కొత్త t తో తిరిగి వస్తుంది; ముందుగా 2xx ఇవ్వండి, క్యూ నుండి ప్రాసెస్ చేయండి.
- మేనేజ్డ్కు మారి పాత URL ఇంకా స్వీకరిస్తుందని భావించడం. ఆ క్షణంలో డైరెక్ట్ గమ్యం తొలగించబడుతుంది; అదే set_inbound_mode కాల్లో forward_url పంపండి.
easyCoexistence ఒక WhatsApp Business యాప్ నంబర్ను Coexistence ద్వారా Meta యొక్క Cloud API కి కనెక్ట్ చేస్తుంది, మరియు ప్రతి నంబర్కు మీ మెసేజ్లు ఎక్కడికి వెళ్తాయో ఎంచుకోవచ్చు: నేరుగా Meta నుండి మీ సర్వర్కు, లేదా easyCoexistence ద్వారా, తద్వారా ఆటోమేషన్లు జవాబివ్వగలవు మరియు సంతకం చేసిన కాపీ మీ ఫార్వర్డ్ URL కు చేరుతుంది. మానిటరింగ్ మరియు అలర్ట్లు రెండు మోడ్లలోనూ పనిచేస్తాయి. US$ 9 నుండి US$ 0.75 వరకు ప్రతి నంబర్కు నెలకు, మీరు నంబర్లను జోడించే కొద్దీ తగ్గుతుంది, మొదటి 3 రోజులు ఉచితం.
తరచుగా అడిగే ప్రశ్నలు
మీ సర్వర్ ఆటోమేషన్ ఏమి జవాబిచ్చిందో చూడగలదా?
టెక్స్ట్ కాదు. Meta API పంపకాలను messages ఈవెంట్లలో స్టేటస్లుగా (sent, delivered, read) నివేదిస్తుంది, మెసేజ్ ID తో; టెక్స్ట్ స్వయంగా ఆటోమేషన్ రన్ లాగ్లో ఉంటుంది, Runs ట్యాబ్లో 30 రోజులు ఉంచబడుతుంది, మరియు Conversations లో మీరు ఎంచుకున్న కాలం వరకు ఉంటుంది.
ఫార్వర్డ్ రహస్యాన్ని ఎలా రొటేట్ చేయాలి?
నంబర్ పేజీలో New secret పై క్లిక్ చేయండి, లేదా rotate_secret ను true గా సెట్ చేసి set_inbound_mode కాల్ చేయండి. కొత్త రహస్యం ఒకసారి మాత్రమే చూపబడుతుంది మరియు అప్పటి నుండి అన్నింటిపై సంతకం చేస్తుంది, పాత డెలివరీల రీట్రైలతో సహా, కాబట్టి మీ సర్వర్ను వెంటనే అప్డేట్ చేయండి.
ఫార్వర్డ్ URL కు Meta యొక్క GET హ్యాండ్షేక్ అవసరమా?
లేదు. డైరెక్ట్ గమ్యాన్ని మాత్రమే Meta పిలుస్తుంది, మరియు అది hub.challenge ను ప్రతిధ్వనించాలి. ఫార్వర్డ్ URL ను easyCoexistence పిలుస్తుంది మరియు సంతకం చేసిన POST లను మాత్రమే స్వీకరిస్తుంది.
ఒక నంబర్కు ఒకేసారి డైరెక్ట్ గమ్యం మరియు ఫార్వర్డ్ URL ఉండగలవా?
లేదు. ఫార్వర్డ్ URL నంబర్ మేనేజ్డ్గా ఉన్నప్పుడు మాత్రమే పనిచేస్తుంది, మరియు డైరెక్ట్ గమ్యాన్ని సేవ్ చేస్తే అది డైరెక్ట్ అవుతుంది. ఫార్వర్డ్ URL మరియు దాని రహస్యం ఉంచబడతాయి, కాబట్టి తిరిగి మేనేజ్డ్కు మారితే ఫార్వర్డింగ్ మళ్ళీ కొనసాగుతుంది.
చదవడం కొనసాగించండి
ప్రారంభించడానికి సిద్ధంగా ఉన్నారా?
నెలల్లో కాదు, నిమిషాల్లో WhatsApp Coexistence సెటప్ చేయండి. యాప్ ఫోన్లో పనిచేస్తూనే ఉంటుంది.
ఉచిత ట్రయల్ ప్రారంభించండిధృవీకరించిన తేదీ