התחברותהתחילו תקופת ניסיון
Meta Tech Provider

בניית סוכן AI ל-WhatsApp ב-Node.js וב-Python על מספר Coexistence

מקבלים את הודעות המספר, או מועברות אליכם עם חתימת HMAC שאתם מאמתים (X-EC-Signature), או ישירות מהוובהוק של Meta עם סוד בכתובת ה-URL. אחר כך מדלגים על כל הודעה שמזהה ההודעה שלה כבר טופל, שותקים בצ'אט שבו הד מראה שאדם ענה מהטלפון, ושולחים את תשובת המודל דרך Cloud API רק בתוך 24 שעות מההודעה האחרונה של הלקוח.

easyCoexistence מחבר את המספר שהעסק ממשיך להשתמש בו באפליקציית WhatsApp Business ל-Cloud API של Meta, מעניק לקוד שלכם את פרטי ההתחברות דרך 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 נשלח לכתובת ה-URL של ההעברה שלכם. יש גרסה שאינה דורשת העברה כלל: שלב Call my Webhook באוטומציה שולח את ההודעה לנקודת הקצה שלכם בשיטת POST, ומחזיר את מה שתחזירו ב-{"reply"} תוך 20 שניות, והדילוג על כפילויות, ההשהיה כשאדם עונה ובדיקת 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, או to_user_id באירועי הד) עם מספר הטלפון כגיבוי, ולמשתמש שמזוהה רק לפי BSUID נשלחת תשובה עם recipient במקום to. קריאת המודל משתמשת בכל API תואם לנקודת chat completions של OpenAI; החליפו ב-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 הוא ה-change של Meta ללא שינוי. /ec/agent עונה לשלב Call my Webhook, חתום עם ה-Signing secret של אותה אוטומציה, והופך את ההיסטוריה לתורות בצ'אט. /meta/:secret הוא המסלול הישיר: הוא עונה לבקשת האימות GET של Meta עם hub.challenge גולמי, ומקבל POST רק בנתיב הסודי.

מפתח ה-HMAC הוא הסוד כולו, כולל הקידומת whsec_, כמחרוזת טקסט רגילה. 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 או למסד הנתונים שלכם, באמצעות כתיבה שמתבצעת רק אם המפתח עדיין לא קיים, עם תוקף לתפוגה למזהי ההודעות, אחרת שני תהליכים יענו לאותה הודעה.

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. וובהוק ישיר נוסה שוב עד 7 ימים אחרי כל תשובה שאינה HTTP 200; שמרו מאגר של מזהי הודעות ודלגו על מזהים שכבר טופלו.
  • ניסיונות חוזרים של ההעברה. easyCoexistence מנסה שוב מסירה שלא קיבלה 2xx תוך 10 שניות, עם אותו מזהה; דלגו על מזהים שכבר התקבלו, ואז בצעו ניקוי כפילויות לפי מזהה ההודעה, כי שינוי ש-Meta שולחת שוב מועבר שוב תחת מזהה חדש.
  • אישורים איטיים. ענו קודם ועבדו אחר כך; מטפל שממתין למודל נופל על פסק זמן, והאירוע חוזר.
  • אדם בטלפון. אירוע smb_message_echoes אומר שמישהו ענה מהאפליקציה; שתקו בצ'אט הזה כמה שעות.
  • כמה תהליכי עבודה. מאגרים שבזיכרון לא נשמרים בין תהליכים; העבירו אותם ל-Redis או למסד הנתונים שלכם.
  • שני מגיבים. אוטומציית תשובה מבוססת AI והסוכן שלכם באותם צ'אטים יענו שניהם, ושליחות 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

טעויות נפוצות

  • בדיקת HMAC על ה-JSON שסודר מחדש. json.dumps של Python מוסיף רווחים אחרי מפרידים כברירת מחדל, כך שגוף שנותח ונשמר שוב כבר לא תואם; אמתו את הבייטים הגולמיים.
  • פענוח Base64 של הסוד או השמטת הקידומת whsec_. המפתח הוא המחרוזת כולה כטקסט UTF-8, בדיוק כפי שהוצגה לכם פעם אחת.
  • אימות X-Hub-Signature-256 בנתיב הישיר עם סוד האפליקציה שלכם ב-Meta. Meta חותמת עם סוד האפליקציה של easyCoexistence, שאינו משותף, ולכן אירועים אמיתיים נכשלים; אמתו עם סוד הנתיב.
  • קריאת הזמן מזמן ההגעה. העברה שנוסתה שוב אחרי שעות עדיין נושאת את החותמת המקורית של Meta; השוו אליה, אחרת הסוכן ישיב אחרי 24 שעות ו-Meta תדחה את השליחה.
עושים את זה עם EasyCoexistence

כל מספר מנוטר 24/7, עם התראות כשחיבור נופל. החל מ-US$ 9 לכל מספר מחובר בחודש, יורד ל-US$ 0.75 ככל שמוסיפים מספרים, ותקופת ניסיון של 3 ימים.

שאלות נפוצות

האם הסוכן יכול להבין הודעות קוליות ותמונות?

כן, עם הקוד שלכם. המטען של Meta נושא את מזהה המדיה: מורידים אותו עם GET /<media-id> ואסימון המספר, מביאים את כתובת ה-URL שהוחזרה עם אותה כותרת Authorization, ואז מתמללים או מתארים אותה בעזרת המודל שלכם. אוטומציות רואות רק סימון מקום, למשל [voice message], ולא את התוכן.

אילו מודלים הדוגמאות יכולות להשתמש בהם?

כל מודל הפועל מאחורי נקודת chat completions תואמת ל-OpenAI, כולל של OpenAI ואלה שמגיעים דרך OpenRouter, או החליפו את askModel ו-ask_model ב-SDK של הספק שלכם. easyCoexistence לא גובה עבור AI לעולם: הספק שלכם גובה אתכם ישירות.

האם הסוכן יכול להתחיל שיחה?

רק עם תבנית שאושרה, שנשלחת עם type template לאותה נקודת שליחה. במספר Coexistence תבניות יוצאות דרך ה-API בלבד, לעולם לא מאפליקציית הטלפון, ו-Meta גובה עליהן לפי הודעה מחשבון WhatsApp Business של העסק עצמו.

האם סוכן אחד משרת כמה מספרים?

כן. מנתבים לפי value.metadata.phone_number_id או connection.phone_number_id, ושומרים נקודת שליחה, אסימון וסוד העברה לכל מספר, כי לכל מספר יש את שלו.

המשיכו לקרוא

איך הודעות WhatsApp מגיעות לשרת שלכם: ישירות או מנוהלות, ואימות החתימהישיר: Meta שולחת לשרת שלכם. מנוהל: אוטומציות עונות ועותק חתום נשלח ל-Forward URL. ה-payload, X-EC-Signature ב-Node ו-Python, וניסיונות חוזרים.תנו לסוכן ה-AI שלכם זיכרון: שישה חודשי צ'אטים ואנשי קשר ב-WhatsAppטענו עד 180 יום של צ'אטים ורשימת אנשי הקשר לזיכרון סוכן ה-AI בחיבור Coexistence: כלל 24 השעות, מקטעים, התקדמות ואחסון.שמות משתמש ב-WhatsApp ומזהי BSUID: מה משתנה בוובהוקים (Webhook) של Cloud APIאיך שמות משתמש ב-WhatsApp משנים את הוובהוקים של Cloud API: ה-BSUID בשדה user_id, מתי השדה wa_id נעלם, מענה לנמען ושינויים ב-Coexistence.סוכן AI ל-WhatsApp ב-n8n, והתשובה נכתבת בזרימת העבודה שלכםהפעילו סוכן AI ל-WhatsApp ב-n8n: POST חתום מביא את ההודעה והשיחה, והתשובה חוזרת תוך 20 שניות.וובהוק (Webhook) smb_message_echoesאיך תוכנה רואה מה אדם שלח מאפליקציית WhatsApp Business. קיים רק במספרי Coexistence, והתעלמות ממנו גורמת לתשובות כפולות.WhatsApp AI לפי סוג עסק: תסריטים מוכנים למסעדות, מרפאות, מכוני יופי וחנויותתסריטי פתיחה ל-WhatsApp למסעדות, מרפאות, מכוני יופי, חנויות מקוונות, נדל"ן ויוצרי קורסים: טריגרים מדויקים, שלבים, פרומפט AI והעברה לאדם.

מוכנים להתחיל?

מגדירים WhatsApp Coexistence בתוך דקות, לא חודשים. האפליקציה ממשיכה לעבוד בטלפון.

התחילו תקופת ניסיון בחינם

נבדק ב-