लग इननिःशुल्क ट्रायल सुरु गर्नुहोस्
Meta Tech Provider

Coexistence नम्बरमा Node.js र Python मा WhatsApp AI एजेन्ट बनाउनुहोस्

कुनै नम्बरका म्यासेजहरू X-EC-Signature हस्ताक्षरसहित फर्वार्ड गरिएका, जसलाई तपाईंले प्रमाणित गर्नुहुन्छ, वा यूआरएलमा गोप्य कुञ्जी भएको Meta को वेबहुकबाट सिधै प्राप्त गर्न सकिन्छ। त्यसपछि पहिले नै प्रशोधन गरिएको म्यासेज आईडी छोड्नुहोस्, smb_message_echoes देखिएको च्याटमा शान्त रहनुहोस् (व्यक्तिले फोनबाट जवाफ दिएको संकेत), र ग्राहकको अन्तिम म्यासेजको 24 घण्टाभित्र मात्र Cloud API मार्फत आफ्नो मोडेलको जवाफ पठाउनुहोस्।

easyCoexistence ले व्यवसायले WhatsApp Business app मा प्रयोग गरिरहेको नम्बरलाई Meta को Cloud API सँग जडान गर्छ, get_api_credentials मार्फत तपाईंको कोडलाई यसका क्रेडेन्सियल दिन्छ, र automations सक्रिय भएको अवस्थामा म्यासेजलाई Meta बाट सिधै तपाईंको सर्भरमा वा हस्ताक्षरित फर्वार्ड मार्फत रुट गर्छ।

5 min

t र तपाईंको घडीबीचको सबैभन्दा ठूलो स्वीकार्य अन्तर; हरेक पुनःप्रयास नयाँ t सहित फेरि हस्ताक्षरित हुन्छ।

10 s

फर्वार्ड गरिएको POST ले 2xx को प्रतीक्षा कति समय गर्छ, त्यसपछि easyCoexistence ले त्यो डेलिभरीको पुनःप्रयास तालिका बनाउँछ।

7 days

Meta ले HTTP 200 नपाएको सिधा webhook कति समयसम्म पुनःप्रयास गर्छ, जसले एउटै म्यासेज दुई पटक पुग्न सक्छ।

24 hours

प्रयोगकर्ताको अन्तिम म्यासेजपछिको ग्राहक सेवा विन्डो; यसभन्दा बाहिर Meta ले केवल टेम्प्लेट म्यासेज स्वीकार गर्छ।

20 mps

WhatsApp Business app र Cloud API दुवैसँग प्रयोग गरिएको नम्बरको निश्चित थ्रुपुट।

कुन रुट कोडेड एजेन्टले प्रयोग गर्नुपर्छ?

फर्वार्ड भनेको नम्बर Automations on मोडमा रहन्छ: Meta ले easyCoexistence मा डेलिभर गर्छ, automations अझै चल्न सक्छन्, र Meta को हरेक परिवर्तनको हस्ताक्षरित प्रतिलिपि तपाईंको Forward URL मा जान्छ। एउटा भेरियन्टमा फर्वार्डको आवश्यकता पर्दैन: automation को “Call my webhook” चरणले म्यासेज तपाईंको endpoint मा POST गर्छ र 20 सेकेन्डभित्र तपाईंले फर्काएको {"reply"} पठाउँछ, साथमा दोहोरिने जाँच, फोन रोक्ने र 24 घण्टाको जाँच तपाईंका लागि गरिन्छ।

सिधा भनेको Meta ले आफ्नै webhook सिधै तपाईंको endpoint मा पठाउँछ, set_webhook_destination ले सेट गरिएको, र easyCoexistence ले म्यासेज कहिल्यै देख्दैन। त्यो नम्बरका लागि automations बन्द हुन्छन्, त्यसैले सबै सुरक्षा जाँच तपाईंको जिम्मामा हुन्छ, र गन्तव्य जडान भएको 24 घण्टाभित्र सुरक्षित गरिएमा 6 महिनाको इतिहास आयात पनि तपाईंकै हो। तल दिइएका नमुनाले तीनै प्रवेशबिन्दु एउटै साझा कोरसँग चलाउँछन्।

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 ले दुवै रुटले साझा गर्ने तर्क राख्छ। यसले ग्राहकको अन्तिम म्यासेजको समय रेकर्ड गर्छ, smb_message_echoes घटनाले WhatsApp Business app बाट कसैले जवाफ दिएको देखाएमा च्याटमा 4 घण्टासम्म हट्छ (easyCoexistence automations ले डिफल्टमा प्रयोग गर्ने व्यवहार), पहिले नै प्रशोधन गरिएको म्यासेज आईडी छोड्छ, र 24 घण्टाको विन्डोभित्र मात्र पठाउँछ। विन्डो म्यासेजको आफ्नै टाइमस्ट्याम्पबाट नापिन्छ, तपाईंसम्म कहिले पुग्यो त्यहाँबाट होइन, किनभने पुनःप्रयास गरिएको डेलिभरी घण्टौंपछि आउन सक्छ।

प्रयोगकर्ताहरू BSUID (from_user_id, वा echo मा 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 ले व्यवस्थित नम्बरका फर्वार्डहरू लिन्छ: नम्बरको फर्वार्ड सिक्रेटसँग कच्चा बाइटमा X-EC-Signature प्रमाणित गर्छ, कुनै पनि काम अघि 200 फर्काउँछ, र पहिले नै स्वीकार गरिएको डेलिभरी आईडी छोड्छ, किनभने पुनःप्रयासमा उही आईडी तर नयाँ हस्ताक्षर हुन्छ। शरीरको event Meta को फिल्ड नाम हो र value Meta को change हो, जस्ताको तस्तै। /ec/agent ले “Call my webhook” चरणको जवाफ दिन्छ, त्यस automation को आफ्नै Signing secret ले हस्ताक्षरित हुन्छ, र इतिहासलाई च्याट टर्नमा बदल्छ। /meta/:secret सिधा रुट हो: यसले Meta को GET ह्यान्डशेकलाई कच्चा hub.challenge सहित जवाफ दिन्छ र POST केवल secret पथमा मात्र स्वीकार गर्छ।

HMAC कुञ्जी whsec_ उपसर्ग सहित सम्पूर्ण गोप्य हो, UTF-8 पाठको रूपमा। express.raw ले बाइटहरू अक्षुण्ण राख्छ, र यसको 5 MB सीमाले 3 MB सम्मका Meta पेलोडका लागि ठाउँ छोड्छ।

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 पछि काम background thread मा चल्छ, त्यसैले easyCoexistence वा Meta ले तपाईंको मोडेलको लागि कुर्दैनन्। विकासको समयमा flask --app agent run ले चलाउनुहोस्, र उत्पादनमा gunicorn वा अर्को WSGI सर्भरपछि।

मेमोरीभित्रको set र dictionary एउटै प्रक्रियाका लागि उपयुक्त छन्। धेरै वर्कर वा इन्स्ट्यान्स भएमा, म्यासेज आईडीका लागि expiry सहित set-if-absent लेखाइ प्रयोग गरेर Redis वा आफ्नो डाटाबेसमा सार्नुहोस्, नत्र दुई वर्करले एउटै म्यासेजको जवाफ दिनेछन्।

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 का पुनःप्रयास। सिधा webhook लाई HTTP 200 बाहेक केहीमा 7 दिनसम्म पुनःप्रयास गरिन्छ; म्यासेज आईडीको भण्डार राखी पहिले नै प्रशोधन गरिएका आईडी छोड्नुहोस्।
  • फर्वार्ड पुनःप्रयास। easyCoexistence ले 10 सेकेन्डभित्र 2xx नपाएको डेलिभरी उही आईडीसहित पुनःप्रयास गर्छ; पहिले नै स्वीकार गरिएका आईडी छोड्नुहोस्, त्यसपछि म्यासेज आईडीमा दोहोरिएको जाँच गर्नुहोस्, किनभने Meta ले पुनः डेलिभर गरेको परिवर्तन नयाँ आईडीमा फेरि फर्वार्ड हुन्छ।
  • ढिलो स्वीकृति। पहिले जवाफ दिनुहोस्, पछि काम गर्नुहोस्; मोडेलको लागि कुर्ने ह्यान्डलर टाइमआउट हुन्छ, र उही इभेन्ट फेरि आउँछ।
  • एउटा व्यक्ति फोनमा। smb_message_echoes घटनाले एपबाट कसैले जवाफ दिएको जनाउँछ; त्यस च्याटमा केही घण्टा शान्त रहनुहोस्।
  • धेरै वर्कर। मेमोरीका set प्रक्रियाहरूबीच साझा हुँदैनन्; भण्डारहरू Redis वा आफ्नो डाटाबेसमा सार्नुहोस्।
  • दुई उत्तरदाता। AI-reply automation र तपाईंको आफ्नै एजेन्ट एउटै च्याटमा दुवैले जवाफ दिन्छन्, र तपाईंको Graph API पठाइहरू echo होइनन्, त्यसैले तिनले automations रोक्दैनन्। प्रति नम्बर एउटा मात्र उत्तरदाता छान्नुहोस्।

गोप्य कुरा र क्रेडेन्सियल कहाँबाट आउँछन्?

ड्यासबोर्ड वा 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 ले डिफल्टमा separator पछि स्पेस थप्छ, त्यसैले पार्स गरेर फेरि dump गरिएको शरीर मेल खाँदैन; कच्चा बाइट प्रमाणित गर्नुहोस्।
  • सिक्रेटलाई Base64 डिकोड गर्नु वा यसको whsec_ उपसर्ग हटाउनु। कुञ्जी भनेको सम्पूर्ण स्ट्रिङ UTF-8 पाठको रूपमा हो, तपाईंलाई एक पटक देखाइएकै रूपमा।
  • सिधा रुटमा तपाईंको आफ्नै Meta app secret सँग X-Hub-Signature-256 प्रमाणित गर्नु। Meta ले easyCoexistence को app secret सँग हस्ताक्षर गर्छ, जुन साझा गरिएको छैन, त्यसैले वास्तविक इभेन्ट असफल हुन्छन्; पथको secret ले प्रमाणित गर्नुहोस्।
  • आगमन समयबाट विन्डो पढ्नु। घण्टौंपछि पुनःप्रयास गरिएको फर्वार्डमा अझै Meta को मूल टाइमस्ट्याम्प हुन्छ; त्यसैसँग तुलना गर्नुहोस्, नत्र एजेन्टले 24 घण्टापछि जवाफ दिन्छ र Meta ले पठाउन अस्वीकार गर्छ।
EasyCoexistence मार्फत यो काम

हरेक नम्बर 24/7 निगरानी गरिन्छ, जडान टुट्दा अलर्टसहित। प्रति नम्बर प्रति महिना US$ 9 देखि US$ 0.75 सम्म, नम्बर थप्दै जाँदा घट्दै, पहिलो 3 दिन निःशुल्क।

बारम्बार सोधिने प्रश्नहरू

एजेन्टले भ्वाइस नोट र फोटो बुझ्न सक्छ?

हो, आफ्नै कोडसँग। Meta को पेलोडमा मिडिया आईडी हुन्छ: GET /<media-id> र नम्बरको टोकनसँग डाउनलोड गर्नुहोस्, फिर्ता आएको यूआरएल उही Authorization हेडरसहित तान्नुहोस्, त्यसपछि आफ्नो मोडेलबाट ट्रान्सक्राइब वा वर्णन गर्नुहोस्। Automations ले [voice message] जस्ता प्लेसहोल्डर मात्र देख्छन्।

नमुनाहरूले कुन मोडेल प्रयोग गर्न सक्छन्?

OpenAI-compatible chat completions endpoint पछाडिको कुनै पनि मोडेल, OpenAI का र OpenRouter मार्फत पुग्ने मोडेलसहित, वा askModel र ask_model लाई तपाईंको प्रदायकको SDK ले बदल्नुहोस्। easyCoexistence ले AI का लागि कहिल्यै बिल गर्दैन: तपाईंको प्रदायकले तपाईंलाई सिधै बिल गर्छ।

एजेन्टले कुराकानी सुरु गर्न सक्छ?

केवल स्वीकृत टेम्प्लेटसँग, उही send endpoint मा type template सहित पठाएर। Coexistence नम्बरमा टेम्प्लेट API मार्फत मात्र जान्छन्, फोन एपबाट कहिल्यै होइन, र Meta ले ती व्यवसायको आफ्नै WhatsApp Business Account मा प्रति म्यासेज बिल गर्छ।

एउटा एजेन्टले धेरै नम्बर सेवा दिन सक्छ?

हो। value.metadata.phone_number_id वा connection.phone_number_id अनुसार रुट गर्नुहोस्, र प्रति नम्बर एउटा send endpoint, टोकन र फर्वार्ड सिक्रेट राख्नुहोस्, किनभने हरेक नम्बरको आफ्नै हुन्छ।

पढ्दै जानुहोस्

WhatsApp म्यासेज तपाईंको सर्भरसम्म कसरी पुग्छन्: डाइरेक्ट वा म्यानेज्ड, र हस्ताक्षर प्रमाणीकरणडाइरेक्ट: Meta सिधै तपाईंको सर्भरमा पठाउँछ। म्यानेज्ड: स्वचालनले जवाफ दिन्छ र हस्ताक्षरित प्रति फर्वार्ड यूआरएलमा जान्छ।आफ्नो AI एजेन्टलाई मेमोरी दिनुहोस्: 6 महिनाका WhatsApp च्याट र सम्पर्कCoexistence नम्बरबाट 180 दिनसम्मका च्याट र सम्पर्क सूची AI एजेन्टको मेमोरीमा लोड गर्नुहोस्: 24 घण्टाको नियम, खण्ड, प्रगति र भण्डारण।WhatsApp युजरनेम र व्यवसाय-सीमित प्रयोगकर्ता ID (BSUID): Cloud API वेबहुकमा के बदलिन्छWhatsApp युजरनेमले Cloud API वेबहुकमा ल्याउने परिवर्तनहरू: user_id मा BSUID, wa_id कहिले हट्छ र Coexistence मा के बदलिन्छ।n8n मा WhatsApp AI एजेन्ट, जवाफ तपाईंको वर्कफ्लोले लेख्छn8n मा WhatsApp AI एजेन्ट चलाउनुहोस्: हस्ताक्षरित POST ले म्यासेज ल्याउँछ, AI Agent नोडले जवाफ लेख्छ, र 20 सेकेन्डभित्र जवाफ फिर्ता आउँछ।smb_message_echoes वेबहुकWhatsApp Business एपबाट मानिसले पठाएको कुरा सफ्टवेयरले कसरी देख्छ। यो Coexistence नम्बरमा मात्र हुन्छ, बेवास्ता गर्दा दोहोरो प्रतिक्रिया जान्छ।व्यवसाय प्रकार अनुसार WhatsApp AI: रेस्टुरेन्ट, क्लिनिक, सेलुन र पसलका तयार फ्लोरेस्टुरेन्ट, क्लिनिक, सेलुन, अनलाइन पसल, घरजग्गा र कोर्स बनाउनेका लागि WhatsApp स्वचालन: ट्रिगर, चरण, AI प्रम्प्ट र हस्तान्तरण।

सुरु गर्न तयार हुनुहुन्छ?

महिनौं होइन, केही मिनेटमै WhatsApp Coexistence सेट अप गर्नुहोस्। एप फोनमा चलिरहन्छ।

निःशुल्क ट्रायल सुरु गर्नुहोस्

प्रमाणीकरण गरिएको