لاگ اِن کریںفری ٹرائل شروع کریں
Meta Tech Provider

Coexistence نمبر پر Node.js اور Python میں WhatsApp AI ایجنٹ بنائیں

نمبر کے میسجز یا تو HMAC دستخط کے ساتھ فارورڈ شدہ موصول کریں جس کی آپ تصدیق کریں (X-EC-Signature)، یا URL میں سیکریٹ کے ساتھ براہ راست Meta کے ویب ہک سے۔ پھر ہر وہ میسج آئی ڈی چھوڑ دیں جو پہلے ہینڈل ہو چکی ہو، اس چیٹ پر خاموش رہیں جہاں ایکو بتائے کہ کسی شخص نے فون سے جواب دیا ہے، اور اپنے ماڈل کا جواب Cloud API کے ذریعے صرف گاہک کے آخری میسج کے 24 گھنٹوں کے اندر بھیجیں۔

easyCoexistence کاروبار کے اس نمبر کو جو وہ WhatsApp Business ایپ میں استعمال کرتا رہتا ہے Meta کے Cloud API سے جوڑتا ہے، آپ کے کوڈ کو get_api_credentials کے ذریعے اس کے کریڈینشلز دیتا ہے، اور آٹومیشنز آن ہونے کی صورت میں میسجز کو Meta سے براہ راست آپ کے سرور تک، یا دستخط شدہ فارورڈ کے ذریعے روٹ کرتا ہے۔

5 min

دستخط کے t اور آپ کی گھڑی کے درمیان قبول کیا جانے والا زیادہ سے زیادہ فرق؛ ہر ری ٹرائی ایک نئے t کے ساتھ دوبارہ دستخط شدہ ہوتی ہے۔

10 s

فارورڈ شدہ POST کتنی دیر 2xx جواب کا انتظار کرتی ہے، اس سے پہلے easyCoexistence اس ڈیلیوری کی ری ٹرائی شیڈول کرتا ہے۔

7 days

Meta براہ راست ویب ہک کو کتنی دیر دوبارہ بھیجتا ہے جسے HTTP 200 نہیں ملا، جس سے وہی میسج دو بار پہنچ سکتا ہے۔

24 hours

صارف کے آخری میسج کے بعد کسٹمر سروس ونڈو؛ اس سے باہر Meta صرف ٹیمپلیٹ میسجز قبول کرتا ہے۔

20 mps

وہ مقررہ تھرو پٹ جو اس نمبر کا ہوتا ہے جو WhatsApp Business ایپ اور Cloud API دونوں کے ساتھ استعمال ہو۔

کوڈ والے ایجنٹ کو کون سا راستہ استعمال کرنا چاہیے؟

فارورڈ کا مطلب ہے کہ نمبر آٹومیشنز آن موڈ میں رہتا ہے: Meta easyCoexistence کو ڈیلیور کرتا ہے، آٹومیشنز پھر بھی چل سکتی ہیں، اور Meta کی ہر تبدیلی کی دستخط شدہ کاپی آپ کے Forward URL پر جاتی ہے۔ ایک ویریئنٹ کو کوئی فارورڈ درکار نہیں: آٹومیشن کا Call my webhook مرحلہ میسج کو آپ کے اینڈ پوائنٹ پر POST کرتا ہے اور 20 سیکنڈ کے اندر آپ کا واپس کیا ہوا {"reply"} بھیج دیتا ہے، جبکہ ڈپلیکیٹ چیک، فون کا وقفہ اور 24 گھنٹے کی جانچ آپ کے لیے ہو جاتی ہے۔

براہ راست کا مطلب ہے کہ Meta اپنا ویب ہک براہ راست آپ کے اینڈ پوائنٹ پر بھیجتا ہے، جو set_webhook_destination سے سیٹ ہوتا ہے، اور easyCoexistence میسجز کبھی نہیں دیکھتا۔ اس نمبر کے لیے آٹومیشنز بند ہوتی ہیں، اس لیے ہر گارڈ آپ کی ذمہ داری ہے، اور 6 ماہ کی ہسٹری امپورٹ بھی، جو اس صورت میں ہوتی ہے جب ڈیسٹینیشن کنیکٹ ہونے کے 24 گھنٹے کے اندر محفوظ ہو۔ نیچے دیے گئے نمونے تینوں انٹری پوائنٹس ایک مشترکہ کور کے ساتھ ہینڈل کرتے ہیں۔

Forwarded, signedDirect from Meta
Number modeAutomations on (managed)Direct to your server
BodyOne Meta change: id, event, received_at, connection, valueMeta's envelope: object, entry, changes
AuthenticationX-EC-Signature, HMAC-SHA256 with a per-number secretA secret in the URL path
AcknowledgeAny 2xx within 10 secondsHTTP 200; Meta retries other codes
Retries7 attempts over about 33 hoursUp to 7 days
ReplyGraph API, or {"reply"} to a Call my webhook stepGraph API
History importNot requestedRequested if saved within 24 hours of connecting

Node.js میں ایجنٹ کسی میسج کے ساتھ کیا کرتا ہے؟

agent.mjs وہ منطق رکھتی ہے جو دونوں راستے شیئر کرتے ہیں۔ یہ گاہک کے آخری میسج کا وقت ریکارڈ کرتی ہے، کسی چیٹ پر 4 گھنٹے کے لیے پیچھے ہٹ جاتی ہے جب کوئی smb_message_echoes ایونٹ دکھائے کہ کسی نے WhatsApp Business ایپ سے جواب دیا ہے (یہی ڈیفالٹ easyCoexistence آٹومیشنز استعمال کرتی ہیں)، ایسی میسج آئی ڈی چھوڑ دیتی ہے جو پہلے ہینڈل ہو چکی ہو، اور صرف 24 گھنٹے کی ونڈو کے اندر بھیجتی ہے۔ ونڈو میسج کے اپنے ٹائم اسٹیمپ سے ناپی جاتی ہے، اس وقت سے نہیں جب وہ آپ تک پہنچا، کیونکہ ری ٹرائی ہوئی ڈیلیوری کئی گھنٹے دیر سے بھی پہنچ سکتی ہے۔

صارفین BSUID سے شناخت ہوتے ہیں (from_user_id، یا echoes پر to_user_id)، جبکہ فون نمبر فال بیک ہے، اور جس صارف کو صرف BSUID سے جانا جائے اسے to کے بجائے recipient کے ساتھ جواب دیا جاتا ہے۔ ماڈل کال کسی بھی OpenAI-compatible chat completions API کو استعمال کرتی ہے؛ اگر آپ چاہیں تو اپنے پرووائیڈر کا SDK لگا دیں۔

agent.mjs: the shared logic
// agent.mjs: what the agent does with one Meta change, whichever route brought it.
const DAY = 24 * 3600 * 1000;
const PAUSE = 4 * 3600 * 1000;   // quiet time after a person replies (automations default to 4 h)
const seen = new Set();          // handled ids: use Redis or your database in production
const lastInbound = new Map();   // user -> ms of their last message
const quietUntil = new Map();    // user -> ms until which a person has the chat

export function firstTime(id) {
  if (seen.has(id)) return false;
  seen.add(id);
  return true;
}

export async function handleChange(field, value) {
  if (field === "smb_message_echoes") {
    // Someone answered from the WhatsApp Business app: step back on that chat.
    for (const e of value.message_echoes ?? []) {
      quietUntil.set(e.to_user_id ?? e.to, Number(e.timestamp) * 1000 + PAUSE);
    }
    return;
  }
  if (field !== "messages") return;              // statuses ride in value.statuses: ignored here
  for (const m of value.messages ?? []) {
    if (!firstTime(m.id)) continue;               // Meta delivered this message before
    const user = m.from_user_id ?? m.from;        // BSUID first, phone number as fallback
    lastInbound.set(user, Math.max(Number(m.timestamp) * 1000, lastInbound.get(user) ?? 0));
    if ((quietUntil.get(user) ?? 0) > Date.now()) continue; // a person has this chat
    if (m.type !== "text") continue;              // media: fetch it by id first (see the FAQ)
    const reply = await askModel([{ role: "user", content: m.text.body }]);
    if (!reply) continue;
    if (Date.now() - lastInbound.get(user) >= DAY) continue; // window closed: template only
    await sendText({ phone: m.from, bsuid: m.from_user_id }, reply);
  }
}

// Any OpenAI-compatible chat completions API (OpenAI, OpenRouter...).
export async function askModel(turns) {
  const res = await fetch(`${process.env.AI_BASE_URL}/chat/completions`, {
    method: "POST",
    headers: { Authorization: `Bearer ${process.env.AI_KEY}`, "Content-Type": "application/json" },
    body: JSON.stringify({
      model: process.env.AI_MODEL,
      messages: [{ role: "system", content: process.env.AI_INSTRUCTIONS ?? "Answer briefly." }, ...turns],
    }),
  });
  if (!res.ok) throw new Error(`AI provider answered ${res.status}`);
  const data = await res.json();
  return data.choices?.[0]?.message?.content?.trim() ?? "";
}

// send_endpoint and access_token come from get_api_credentials.
async function sendText({ phone, bsuid }, text) {
  const res = await fetch(process.env.SEND_ENDPOINT, {
    method: "POST",
    headers: { Authorization: `Bearer ${process.env.WA_TOKEN}`, "Content-Type": "application/json" },
    body: JSON.stringify({
      messaging_product: "whatsapp",
      recipient_type: "individual",
      ...(phone ? { to: phone } : { recipient: bsuid }), // a BSUID-only user gets recipient
      type: "text",
      text: { body: text.slice(0, 4096) },
    }),
  });
  if (!res.ok) throw new Error(`Graph API answered ${res.status}: ${await res.text()}`);
}

Node.js میں ایونٹس کی تصدیق اور روٹنگ کیسے کریں؟

server.mjs تینوں انٹری پوائنٹس فراہم کرتی ہے۔ /ec/forward منیج شدہ نمبرز کے فارورڈز قبول کرتا ہے: یہ raw bytes پر نمبر کے فارورڈ سیکریٹ سے X-EC-Signature کی تصدیق کرتا ہے، کسی بھی کام سے پہلے 200 جواب دیتا ہے، اور ایسی ڈیلیوری آئی ڈی چھوڑ دیتا ہے جو پہلے قبول ہو چکی ہو، کیونکہ ری ٹرائی میں وہی آئی ڈی نئے دستخط کے ساتھ آتی ہے۔ باڈی کا event وہی Meta فیلڈ نام ہے اور value وہی Meta کی change ہے، بغیر تبدیلی کے۔ /ec/agent اس آٹومیشن کے اپنے Signing secret سے دستخط شدہ Call my webhook مرحلے کا جواب دیتا ہے اور ہسٹری کو چیٹ ٹرنز میں بدلتا ہے۔ /meta/:secret براہ راست راستہ ہے: یہ Meta کے GET ہینڈ شیک کو خام hub.challenge کے ساتھ جواب دیتا ہے اور POST صرف secret والے پاتھ پر قبول کرتا ہے۔

HMAC کی کلید مکمل secret ہے، whsec_ پری فکس سمیت، بطور UTF-8 متن۔ express.raw بائٹس کو برقرار رکھتا ہے، اور اس کی 5 MB حد Meta کے 3 MB تک کے پے لوڈز کے لیے گنجائش چھوڑتی ہے۔

server.mjs: verification and routes (Express)
// server.mjs: Node 18+, npm i express, then node server.mjs
import crypto from "node:crypto";
import express from "express";
import { askModel, firstTime, handleChange } from "./agent.mjs";

const app = express();

// X-EC-Signature: t=<unix>,v1=<hex HMAC-SHA256 of "<t>.<raw body>">, keyed with the whole secret.
export function verifyEc(raw, header, secret, toleranceSec = 300) {
  const m = /^t=(\d+),v1=([0-9a-f]{64})$/.exec(String(header ?? "").trim());
  if (!m || !Buffer.isBuffer(raw) || !secret) return false;
  if (Math.abs(Date.now() / 1000 - Number(m[1])) > toleranceSec) return false; // stale or replayed
  const expected = crypto.createHmac("sha256", secret).update(`${m[1]}.`).update(raw).digest();
  return crypto.timingSafeEqual(expected, Buffer.from(m[2], "hex"));
}

function sameSecret(a, b) {
  const x = Buffer.from(String(a)), y = Buffer.from(String(b ?? ""));
  return x.length === y.length && crypto.timingSafeEqual(x, y);
}

// Route A, forwarded: a managed number's Forward URL. One Meta change per POST.
app.post("/ec/forward", express.raw({ type: "*/*", limit: "5mb" }), (req, res) => {
  if (!verifyEc(req.body, req.get("X-EC-Signature"), process.env.EC_FORWARD_SECRET)) return res.sendStatus(401);
  res.sendStatus(200);                                   // acknowledge inside 10 s, then work
  const d = JSON.parse(req.body.toString("utf8"));
  if (!firstTime(`delivery:${d.id}`)) return;            // a retry of a delivery already taken
  handleChange(d.event, d.value).catch(console.error);   // d.event is the Meta field name
});

// Route A, synchronous: a "Call my webhook" step. Answer {"reply"} within 20 s.
app.post("/ec/agent", express.raw({ type: "*/*", limit: "1mb" }), async (req, res) => {
  if (!verifyEc(req.body, req.get("X-EC-Signature"), process.env.EC_AUTOMATION_SECRET)) return res.sendStatus(401);
  const step = JSON.parse(req.body.toString("utf8"));
  const turns = step.history.map((h) => ({ role: h.direction === "in" ? "user" : "assistant", content: h.text }));
  while (turns[0]?.role === "assistant") turns.shift();
  if (!turns.length) turns.push({ role: "user", content: step.message?.text ?? "" }); // tests carry no history
  res.json({ reply: await askModel(turns) });            // step.dry_run is true on "Test it"
});

// Route B, direct: Meta's own envelope. The secret path is the credential.
app.get("/meta/:secret", (req, res) => {
  if (!sameSecret(req.params.secret, process.env.PATH_SECRET)) return res.sendStatus(404);
  if (req.query["hub.mode"] === "subscribe" && req.query["hub.verify_token"] === process.env.VERIFY_TOKEN) {
    return res.type("text/plain").send(String(req.query["hub.challenge"]));
  }
  res.sendStatus(403);
});

app.post("/meta/:secret", express.json({ limit: "5mb" }), (req, res) => {
  if (!sameSecret(req.params.secret, process.env.PATH_SECRET)) return res.sendStatus(404);
  res.sendStatus(200);                                   // Meta retries anything but 200
  for (const entry of req.body.entry ?? []) {
    for (const change of entry.changes ?? []) handleChange(change.field, change.value).catch(console.error);
  }
});

app.listen(process.env.PORT ?? 3000);

Python میں یہی ایجنٹ کیسا دکھتا ہے؟

ایک Flask فائل جس میں وہی تین راستے اور وہی قواعد ہیں۔ request.get_data() HMAC کے لیے خام باڈی دیتا ہے، hmac.compare_digest کانسٹنٹ ٹائم موازنہ کرتا ہے، اور کام 200 کے بعد ایک بیک گراؤنڈ تھریڈ پر چلتا ہے، تاکہ نہ easyCoexistence اور نہ Meta آپ کے ماڈل کا انتظار کرے۔ ڈیولپمنٹ کے دوران اسے flask --app agent run سے چلائیں اور پروڈکشن میں gunicorn یا کسی اور WSGI سرور کے پیچھے رکھیں۔

ان میموری سیٹس اور ڈکشنریاں ایک پروسیس کے لیے موزوں ہیں۔ کئی ورکرز یا انسٹنسز کے ساتھ انہیں Redis یا اپنے ڈیٹابیس میں منتقل کریں، میسج آئی ڈیز کے لیے ایکسپائری والے set-if-absent رائٹ کے ساتھ، ورنہ دو ورکرز ایک ہی میسج کا جواب دے دیں گے۔

agent.py: the whole agent (Flask)
# agent.py: pip install flask requests, then flask --app agent run
import hashlib, hmac, json, os, re, threading, time
import requests
from flask import Flask, abort, request

app = Flask(__name__)
DAY, PAUSE = 24 * 3600, 4 * 3600
seen, last_inbound, quiet_until = set(), {}, {}  # use Redis or a database in production
lock = threading.Lock()

def verify_ec(raw: bytes, header: str, secret: str, tolerance: int = 300) -> bool:
    m = re.fullmatch(r"t=([0-9]+),v1=([0-9a-f]{64})", (header or "").strip())
    if not m or not secret or abs(time.time() - int(m[1])) > tolerance:
        return False
    expected = hmac.new(secret.encode(), m[1].encode() + b"." + raw, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, m[2])

def first_time(key: str) -> bool:
    with lock:
        if key in seen:
            return False
        seen.add(key)
        return True

def ask_model(turns: list) -> str:  # any OpenAI-compatible chat completions API
    r = requests.post(f"{os.environ['AI_BASE_URL']}/chat/completions", timeout=30,
                      headers={"Authorization": f"Bearer {os.environ['AI_KEY']}"},
                      json={"model": os.environ["AI_MODEL"], "messages": [
                          {"role": "system", "content": os.environ.get("AI_INSTRUCTIONS", "Answer briefly.")}, *turns]})
    r.raise_for_status()
    return (r.json()["choices"][0]["message"]["content"] or "").strip()

def send_text(phone, bsuid, text: str) -> None:  # SEND_ENDPOINT and WA_TOKEN: get_api_credentials
    to = {"to": phone} if phone else {"recipient": bsuid}
    r = requests.post(os.environ["SEND_ENDPOINT"], timeout=15,
                      headers={"Authorization": f"Bearer {os.environ['WA_TOKEN']}"},
                      json={"messaging_product": "whatsapp", "recipient_type": "individual", **to,
                            "type": "text", "text": {"body": text[:4096]}})
    r.raise_for_status()

def handle_change(field: str, value: dict) -> None:
    if field == "smb_message_echoes":  # a person answered from the app: step back
        for e in value.get("message_echoes", []):
            quiet_until[e.get("to_user_id") or e.get("to")] = int(e["timestamp"]) + PAUSE
        return
    if field != "messages":
        return
    for m in value.get("messages", []):
        if not first_time(m["id"]):  # Meta delivered this message before
            continue
        user = m.get("from_user_id") or m.get("from")
        last_inbound[user] = max(int(m["timestamp"]), last_inbound.get(user, 0))
        if quiet_until.get(user, 0) > time.time() or m.get("type") != "text":
            continue
        reply = ask_model([{"role": "user", "content": m["text"]["body"]}])
        if reply and time.time() - last_inbound[user] < DAY:  # past 24 h: template only
            send_text(m.get("from"), m.get("from_user_id"), reply)

def later(field, value):
    threading.Thread(target=handle_change, args=(field, value), daemon=True).start()

@app.post("/ec/forward")  # route A: a managed number's Forward URL
def forward():
    raw = request.get_data()
    if not verify_ec(raw, request.headers.get("X-EC-Signature", ""), os.environ["EC_FORWARD_SECRET"]):
        abort(401)
    d = json.loads(raw)
    if first_time("delivery:" + d["id"]):  # skip retries of a delivery already taken
        later(d["event"], d["value"])
    return "", 200

@app.post("/ec/agent")  # route A: a "Call my webhook" step, answer within 20 s
def agent_step():
    raw = request.get_data()
    if not verify_ec(raw, request.headers.get("X-EC-Signature", ""), os.environ["EC_AUTOMATION_SECRET"]):
        abort(401)
    step = json.loads(raw)
    turns = [{"role": "user" if h["direction"] == "in" else "assistant", "content": h["text"]}
             for h in step["history"]]
    while turns and turns[0]["role"] == "assistant":
        turns.pop(0)
    turns = turns or [{"role": "user", "content": step["message"]["text"] or ""}]
    return {"reply": ask_model(turns)}

@app.get("/meta/<secret>")  # route B: Meta's GET handshake
def meta_handshake(secret):
    if not hmac.compare_digest(secret.encode(), os.environ["PATH_SECRET"].encode()):
        abort(404)
    if (request.args.get("hub.mode") == "subscribe"
            and request.args.get("hub.verify_token") == os.environ["VERIFY_TOKEN"]):
        return request.args.get("hub.challenge", ""), 200, {"Content-Type": "text/plain"}
    abort(403)

@app.post("/meta/<secret>")  # route B: Meta's envelope, straight from Meta
def meta_events(secret):
    if not hmac.compare_digest(secret.encode(), os.environ["PATH_SECRET"].encode()):
        abort(404)
    for entry in (request.get_json(silent=True) or {}).get("entry", []):
        for change in entry.get("changes", []):
            later(change.get("field"), change.get("value", {}))
    return "", 200

ڈپلیکیٹ جوابات سے کیسے بچیں؟

ڈپلیکیٹس کی چھ عام وجوہات ہیں، اور اوپر کے نمونے پہلی پانچ کو ہینڈل کرتے ہیں:

  • Meta کی ری ٹرائیاں۔ براہ راست ویب ہک HTTP 200 کے علاوہ کسی بھی جواب کے بعد 7 دن تک دوبارہ بھیجا جاتا ہے؛ میسج آئی ڈیز کا اسٹور رکھیں اور پہلے ہینڈل ہو چکی آئی ڈیز چھوڑ دیں۔
  • فارورڈ کی ری ٹرائیاں۔ easyCoexistence 10 سیکنڈ میں 2xx نہ ملنے والی ڈیلیوری کو اسی آئی ڈی کے ساتھ دوبارہ بھیجتا ہے؛ پہلے قبول شدہ آئی ڈیز چھوڑ دیں، پھر میسج آئی ڈی پر ڈپلیکیٹ ہٹائیں، کیونکہ وہ تبدیلی جو Meta دوبارہ بھیجے نئی آئی ڈی کے ساتھ دوبارہ فارورڈ ہوتی ہے۔
  • سست رسید۔ پہلے جواب دیں اور بعد میں کام کریں؛ جو ہینڈلر ماڈل کا انتظار کرتا ہے وہ ٹائم آؤٹ ہوتا ہے، اور وہی ایونٹ واپس آ جاتا ہے۔
  • فون پر موجود شخص۔ smb_message_echoes ایونٹ کا مطلب ہے کہ کسی نے ایپ سے جواب دیا؛ اس چیٹ پر چند گھنٹے خاموش رہیں۔
  • کئی ورکرز۔ ان میموری سیٹس پروسیسز میں نہیں پھیلتے؛ اسٹورز کو Redis یا اپنے ڈیٹابیس میں منتقل کریں۔
  • دو جواب دہندگان۔ ایک AI-reply آٹومیشن اور آپ کا اپنا ایجنٹ ایک ہی چیٹس پر دونوں جواب دیتے ہیں، اور آپ کے Graph API کے بھیجے گئے میسجز ایکو نہیں ہوتے، اس لیے وہ آٹومیشنز کو نہیں روکتے۔ ہر نمبر کے لیے ایک جواب دہندہ چنیں۔

سیکریٹس اور کریڈینشلز کہاں سے آتے ہیں؟

ڈیش بورڈ یا MCP کنیکٹر سے، اور وہ صرف آپ کے سرور کے ماحول میں رہنے چاہئیں۔ get_api_credentials واپس کرتا ہے graph_api_base، waba_id، phone_number_id، send_endpoint اور access_token، جو کاروبار کا اپنا ٹوکن ہے؛ نمبر کا صفحہ وہی ویلیوز Plug in your own system کے تحت دکھاتا ہے۔ اگر access_token null ہو تو کمپیوٹر سے نمبر کو Reconnect کے ساتھ دوبارہ کنیکٹ کریں تاکہ ٹوکن جاری ہو۔ ٹوکن کو پاس ورڈ کی طرح سنبھالیں، کیونکہ جس کے پاس یہ ہو وہ کاروبار کے نام سے میسج کر سکتا ہے۔

EC_FORWARD_SECRETShown once when you save a Forward URL, or returned once by set_inbound_mode; New secret rotates it
EC_AUTOMATION_SECRETSigning secret on the automation's page, under its Call my webhook step
SEND_ENDPOINT, WA_TOKENsend_endpoint and access_token from get_api_credentials
PATH_SECRET, VERIFY_TOKENDirect route: 32 or more random characters in the URL, and the handshake token you chose
AI_BASE_URL, AI_KEY, AI_MODELAny OpenAI-compatible API, such as https://api.openai.com/v1 or https://openrouter.ai/api/v1

عام غلطیاں

  • دوبارہ سیریلائز شدہ JSON پر HMAC کی جانچ کرنا۔ Python کا json.dumps ڈیفالٹ میں سیپریٹرز کے بعد اسپیس ڈالتا ہے، اس لیے پارس اور دوبارہ ڈمپ کی گئی باڈی اب مماثل نہیں رہتی؛ خام بائٹس کی تصدیق کریں۔
  • سیکریٹ کو Base64 سے ڈی کوڈ کرنا یا اس کا whsec_ پری فکس ہٹانا۔ کلید پوری سٹرنگ ہے بطور UTF-8 متن، بالکل ویسی جیسی ایک بار آپ کو دکھائی گئی تھی۔
  • براہ راست راستے پر اپنے Meta ایپ سیکریٹ سے X-Hub-Signature-256 کی تصدیق کرنا۔ Meta easyCoexistence کے ایپ سیکریٹ سے دستخط کرتا ہے، جو شیئر نہیں کیا جاتا، اس لیے اصل ایونٹس ناکام ہوتے ہیں؛ پاتھ سیکریٹ سے توثیق کریں۔
  • ونڈو کو پہنچنے کے وقت سے پڑھنا۔ کئی گھنٹے بعد ری ٹرائی ہونے والا فارورڈ بھی Meta کا اصل ٹائم اسٹیمپ رکھتا ہے؛ اسی سے موازنہ کریں، ورنہ ایجنٹ 24 گھنٹے کے بعد جواب دے گا اور Meta بھیجنے سے انکار کر دے گا۔
EasyCoexistence کے ساتھ یہ کام کرنا

ہر نمبر 24/7 مانیٹر ہوتا ہے، اور کنیکشن ٹوٹنے پر الرٹس آتے ہیں۔ فی نمبر ماہانہ US$ 9 سے US$ 0.75 تک، نمبرز بڑھانے کے ساتھ قیمت کم ہوتی ہے، اور پہلے 3 دن کا فری ٹرائل۔

اکثر پوچھے جانے والے سوالات

کیا ایجنٹ وائس نوٹس اور تصاویر سمجھ سکتا ہے؟

ہاں، اپنے کوڈ کے ساتھ۔ Meta کے پے لوڈ میں میڈیا آئی ڈی ہوتی ہے: اسے GET /<media-id> اور نمبر کے ٹوکن سے ڈاؤن لوڈ کریں، واپس آنے والے URL کو اسی Authorization ہیڈر کے ساتھ حاصل کریں، پھر اپنے ماڈل سے اسے ٹرانسکرائب یا بیان کریں۔ آٹومیشنز صرف [voice message] جیسے پلیس ہولڈرز دیکھتی ہیں۔

نمونے کون سے ماڈلز استعمال کر سکتے ہیں؟

کوئی بھی ماڈل جو OpenAI-compatible chat completions اینڈ پوائنٹ کے پیچھے ہو، بشمول OpenAI کے اور وہ جو OpenRouter کے ذریعے پہنچیں، یا askModel اور ask_model کو اپنے پرووائیڈر کے SDK سے بدل دیں۔ easyCoexistence AI کے لیے کبھی بل نہیں کرتا: آپ کا پرووائیڈر براہ راست آپ سے بل لیتا ہے۔

کیا ایجنٹ گفتگو شروع کر سکتا ہے؟

صرف منظور شدہ ٹیمپلیٹ کے ذریعے، جو type template کے ساتھ اسی send اینڈ پوائنٹ پر بھیجا جائے۔ Coexistence نمبر پر ٹیمپلیٹس صرف API کے ذریعے جاتے ہیں، فون ایپ سے کبھی نہیں، اور Meta انہیں کاروبار کے اپنے WhatsApp Business Account پر فی میسج بل کرتا ہے۔

کیا ایک ایجنٹ کئی نمبرز سنبھال سکتا ہے؟

ہاں۔ value.metadata.phone_number_id یا connection.phone_number_id کے ذریعے روٹ کریں، اور ہر نمبر کے لیے ایک send اینڈ پوائنٹ، ایک ٹوکن اور ایک فارورڈ سیکریٹ رکھیں، کیونکہ ہر نمبر کا اپنا ہوتا ہے۔

مزید پڑھیں

WhatsApp پیغام آپ کے سرور تک کیسے پہنچتے ہیں: ڈائریکٹ یا مینیج، اور دستخط کی تصدیقڈائریکٹ: Meta آپ کے سرور پر پوسٹ کرتا ہے۔ مینیج: آٹومیشنز جواب دیتی ہیں، اور دستخط شدہ کاپی Forward URL پر جاتی ہے۔ X-EC-Signature، پے لوڈ، دوبارہ کوششیں۔اپنے AI ایجنٹ کو میموری دیں: WhatsApp چیٹس اور رابطوں کے چھ مہینےCoexistence نمبر پر 180 دن تک کی WhatsApp چیٹس اور رابطوں کی فہرست اپنے AI ایجنٹ کی میموری میں لوڈ کریں: 24 گھنٹے کا اصول، چنکس، پیش رفت اور اسٹوریجWhatsApp یوزر نیمز اور کاروبار کے دائرے میں صارف آئی ڈیز (BSUID): کلاؤڈ API ویب ہکس میں کیا بدلتا ہےWhatsApp یوزر نیمز کلاؤڈ API ویب ہکس کو کیسے بدلتے ہیں: user_id میں BSUID، wa_id اور from کب ہٹتے ہیں، recipient سے جواب، اور Coexistence کی تبدیلیاں۔n8n میں WhatsApp AI ایجنٹ، جواب آپ کا ورک فلو لکھےn8n میں واٹس ایپ AI ایجنٹ چلائیں: دستخط شدہ POST میسج اور حالیہ چیٹ لاتی ہے، AI Agent نوڈ جواب لکھتا ہے، اور جواب 20 سیکنڈ میں واپس آتا ہے۔smb_message_echoes ویب ہکیہ جانیں کہ WhatsApp Business ایپ سے انسان نے کیا بھیجا۔ یہ صرف Coexistence نمبرز پر ہوتا ہے، اسے نظرانداز کرنے سے دوہرے جواب جاتے ہیں۔کاروبار کی قسم کے مطابق WhatsApp AI: ریسٹورنٹ، کلینک، سیلون اور اسٹور کے لیے تیار فلوریسٹورنٹ، کلینک، سیلون، آن لائن اسٹور، رئیل اسٹیٹ اور کورس بنانے والوں کے لیے WhatsApp کی تیار آٹومیشن: ٹریگر، مراحل، AI پرامپٹ اور فرد کو منتقلی۔

شروع کرنے کے لیے تیار ہیں؟

WhatsApp Coexistence چند منٹ میں سیٹ اپ کریں، مہینوں میں نہیں۔ ایپ فون پر کام کرتی رہتی ہے۔

فری ٹرائل شروع کریں

تصدیق شدہ تاریخ