פרסום ל-Instagram, TikTok ו-Facebook מ-Node.js באמצעות ממשק API אחד
עם easyCoexistence, ה-backend ב-Node.js או TypeScript מפרסם ל-Instagram, Facebook, TikTok, YouTube ו-LinkedIn דרך ה-API הרשמי של כל רשת. חשבונות מתחברים פעם אחת דרך קישור שמתארח אצלנו. קריאת fetch אחת מחזירה אסימון טרי לכל משימה ב-TikTok, ב-YouTube וב-LinkedIn, ואירועים חתומים מביאים תגובות והודעות ישירות לנתיב שלכם. סוכנים שנבנו על ערכת ה-SDK של MCP ל-TypeScript מקבלים את אותם חשבונות ככלים.
סרטונים שנקודת הקצה לפרסום של TikTok מקבלת לכל חשבון, בקצב של לא יותר משישה בדקה.
כמה רחוק מראש ניתן לתזמן פוסט בעמוד Facebook, כשהשדה published מוגדר false והשדה scheduled_publish_time מקבל ערך.
כותרת התגובה שנושאת את ה-URN של פוסט חדש ב-LinkedIn, ונשלחת עם סטטוס 201.
כמה מהר TikTok שולח את האירוע comment.update אחרי שתגובה נוצרת, נמחקת או משנה את הנראות שלה.
כמה זמן קישור החיבור של Partner API נשאר פתוח לפני שהסשן שלו פוקע.
איך ה-backend ב-Node.js מחבר חשבונות ומקבל את האסימונים שלהם?
ה-backend שלכם פותח סשן חיבור, ובעל החשבון מסיים את התהליך בדפדפן. קריאת POST אל /connect-sessions, עם המפתח ec_live_ כאסימון נושא (bearer), ערוץ כמו tiktok או linkedin, השדה redirect_url והשדה external_ref של הלקוח, מחזירה את השדה url: כתובת בדומיין easycoexistence.com. שם בעל החשבון נכנס דרך מסך ההסכמה של הרשת עצמה, וחוזר לאפליקציה שלכם עם status=connected ועם channel_id. ניסיון שבוטל אפשר לנסות שוב מאותו קישור, עד שהוא פוקע, שעה אחרי שנוצר.
כל משימה מתחילה אז בקריאה GET /channels/{id}?credentials=1. התשובה כוללת אסימון תקף כרגע (לא ב-Instagram וב-Facebook, שאסימוניהם אינם מוחזרים לעולם) ואת השדות שכל רשת צריכה: ב-Instagram וב-Facebook, graph_api_base וגם account_id_on_meta; ב-TikTok, api_base וגם business_id; ב-YouTube, channel_id; וב-LinkedIn, author_urn וגם required_headers. אירועים חתומים, channel.connected, channel.disconnected, channel.removed וגם channel.suspended, נשלחים לכתובת ה-URL לאירועים שהגדרתם בלוח הבקרה, ומודיעים לאפליקציה שלכם מתי חשבון משתנה.
const EC = "https://easycoexistence.com/api/v1";
const KEY = { Authorization: `Bearer ${process.env.EC_API_KEY}` }; // ec_live_...
type Network = "instagram" | "facebook" | "tiktok" | "youtube" | "linkedin";
// A hosted sign-in link for one of your customers on one network
export async function connectLink(customerId: string, channel: Network): Promise<string> {
const r = await fetch(`${EC}/connect-sessions`, {
method: "POST",
headers: { ...KEY, "Content-Type": "application/json" },
body: JSON.stringify({
channel,
redirect_url: "https://app.example.com/connected",
external_ref: customerId,
}),
});
const session = (await r.json()) as { url: string; error?: { message: string } };
if (!r.ok) throw new Error(session.error?.message);
return session.url; // they come back with ?session=...&status=connected&channel_id=...
}
// At the start of every job: the API base and a token that is valid now
export async function credentials(channelId: string) {
const r = await fetch(`${EC}/channels/${channelId}?credentials=1`, { headers: KEY });
const body: any = await r.json(); // the credential fields differ by network
if (!r.ok) throw new Error(body.error.message);
if (!body.credentials.access_token) throw new Error(body.credentials.note);
return body.credentials;
}איך מפרסמים ל-Instagram ול-Facebook מ-Node.js?
Instagram מפרסם דרך קונטיינר. ל-Reel יוצרים אותו עם media_type מוגדר REELS, עם video_url והכיתוב, בודקים את status_code שוב ושוב עד שהוא מציג FINISHED, ואז מפעילים את media_publish ומעבירים את מזהה הקונטיינר בשדה creation_id. Meta ממליצה לבדוק פעם בדקה בערך ולוותר אחרי חמש דקות. הערך ERROR או EXPIRED אומר שהקונטיינר לא יתפרסם, וקונטיינר שלא פורסם תוך 24 שעות פג מעצמו.
עמוד Facebook מעלה תמונה בקריאה אחת אל /{page-id}/photos, עם הפרמטר url של התמונה והכיתוב, ואילו טקסט וקישורים נשלחים אל /{page-id}/feed. שתי הקריאות מקבלות את השדה published בערך false, ביחד עם scheduled_publish_time, ו-Meta עצמה מפרסמת את הפוסט כשמגיע הזמן, בין 10 דקות ל-30 ימים קדימה. האסימון נשלח ככותרת bearer, גרסת ה-Graph API כבר כלולה ב-graph_api_base, והמדיה חייבת לשבת בכתובת ציבורית ש-Meta מורידה.
type Meta = { graph_api_base: string; access_token: string };
async function graph(c: Meta, path: string, body?: object) {
const r = await fetch(`${c.graph_api_base}/${path}`, {
method: body ? "POST" : "GET",
headers: { Authorization: `Bearer ${c.access_token}`, "Content-Type": "application/json" },
body: body && JSON.stringify(body),
});
const data: any = await r.json();
if (!r.ok) throw new Error(data.error?.message ?? `Graph API ${r.status}`);
return data;
}
export async function postReel(channelId: string, videoUrl: string, caption: string) {
const c = await credentials(channelId);
const ig = c.account_id_on_meta;
const { id } = await graph(c, `${ig}/media`, { media_type: "REELS", video_url: videoUrl, caption });
for (let check = 0; check < 5; check++) {
await new Promise((wake) => setTimeout(wake, 60_000)); // about once a minute, as Meta advises
const { status_code } = await graph(c, `${id}?fields=status_code`);
if (status_code === "FINISHED") return graph(c, `${ig}/media_publish`, { creation_id: id });
if (status_code === "ERROR" || status_code === "EXPIRED") throw new Error(`Reel container ${status_code}`);
}
throw new Error("The Reel is still processing after five minutes");
}
export async function schedulePagePhoto(channelId: string, url: string, caption: string, at: Date) {
const c = await credentials(channelId);
return graph(c, `${c.account_id_on_meta}/photos`, {
url,
caption,
published: false,
scheduled_publish_time: Math.floor(at.getTime() / 1000), // 10 minutes to 30 days ahead
});
}איך מפרסמים ל-LinkedIn ומעלים ל-YouTube מ-Node.js?
LinkedIn דורש שתי כותרות מעבר לאסימון הנושא בכל קריאה: LinkedIn-Version, עם הערך בפורמט YYYYMM שמוחזר בשדה required_headers, וכותרת X-Restli-Protocol-Version עם הערך 2.0.0. פוסט הוא קריאת POST אל /rest/posts, עם URN של המחבר, הטקסט בשדה commentary, הערך PUBLIC בשדה visibility, ה-feed הראשי בשדה distribution והערך PUBLISHED בשדה lifecycleState. LinkedIn עונה 201, וה-URN של הפוסט החדש מופיע בכותרת x-restli-id. כל URN שמוכנס לנתיב של כתובת חייב להיות מקודד בפורמט URL.
YouTube דורש שתי בקשות. POST לנקודת הקצה להעלאה עם uploadType=resumable וגם part=snippet,status שולח את המטא-נתונים ומחזיר את כתובת הסשן בכותרת Location. PUT של הבייטים של הקובץ לכתובת הזו מחזיר את משאב הוידאו עם ה-id שלו. העלאה במצב private עם תאריך בשדה publishAt משאירה את הפרסום למתזמן של YouTube, כך שאין צורך שמשהו שלכם ירוץ בשעה הזו.
import { readFile } from "node:fs/promises";
export async function postOnLinkedIn(channelId: string, text: string) {
const c = await credentials(channelId);
const r = await fetch(`${c.api_base}/posts`, {
method: "POST",
headers: {
Authorization: `Bearer ${c.access_token}`,
"LinkedIn-Version": c.required_headers["LinkedIn-Version"],
"X-Restli-Protocol-Version": "2.0.0",
"Content-Type": "application/json",
},
body: JSON.stringify({
author: c.author_urn, // urn:li:organization:... or urn:li:person:...
commentary: text,
visibility: "PUBLIC",
distribution: { feedDistribution: "MAIN_FEED", targetEntities: [], thirdPartyDistributionChannels: [] },
lifecycleState: "PUBLISHED",
isReshareDisabledByAuthor: false,
}),
});
if (r.status !== 201) throw new Error(`LinkedIn ${r.status}: ${await r.text()}`);
return r.headers.get("x-restli-id"); // the new post's URN
}
export async function scheduleOnYouTube(channelId: string, file: string, title: string, publishAt: string) {
const c = await credentials(channelId);
const auth = { Authorization: `Bearer ${c.access_token}` };
const start = await fetch(
"https://www.googleapis.com/upload/youtube/v3/videos?uploadType=resumable&part=snippet,status",
{
method: "POST",
headers: { ...auth, "Content-Type": "application/json; charset=UTF-8", "X-Upload-Content-Type": "video/mp4" },
body: JSON.stringify({
snippet: { title },
status: { privacyStatus: "private", publishAt, selfDeclaredMadeForKids: false },
}),
},
);
const session = start.headers.get("location");
if (!start.ok || !session) throw new Error(`YouTube ${start.status}: ${await start.text()}`);
const done = await fetch(session, {
method: "PUT",
headers: { ...auth, "Content-Type": "video/mp4" },
body: await readFile(file),
});
const video = (await done.json()) as { id: string };
return video.id;
}איך מקבלים תגובות והודעות בנתיב ב-Node.js?
הקריאה PUT /channels/{id}/webhook מקבלת את כתובת ה-URL שאליה כל ערוץ יעביר אירועים, ומחזירה פעם אחת את signing_secret של הערוץ. כל משלוח הוא POST עם platform, account_id, external_id וגם entry, וכותרת X-EC-Signature בצורה t=<unix>,v1=<hex>, כאשר v1 הוא ה-HMAC-SHA256 של t, נקודה והגוף הגולמי. קראו את הגוף כטקסט לפני הפיענוח, דחו t שישן מחמש דקות, והשוו עם הפונקציה timingSafeEqual.
באינסטגרם ובפייסבוק, entry הוא רשומת הוובהוק (Webhook) של Meta כפי ש-Meta שלחה אותה: השדה changes לתגובות ולאזכורים, והשדה messaging להודעות ישירות. ב-TikTok הוא מחזיק את אירוע comment.update, ש-TikTok שולח תוך חמש דקות מהתגובה, כשהשדות comment_id ו-video_id הם מחרוזות, כדי ש-JavaScript לא יעגל מספרים בני 64 ביט. יש ניסיון משלוח אחד לכל אירוע, ואין עותק שמור, לכן מחזירים קוד 204 מיד ומעבדים מתור.
import { createHmac, timingSafeEqual } from "node:crypto";
const secrets = new Map<string, string>(); // channel id -> signing_secret, kept in your database
export async function forwardEvents(channelId: string, url: string) {
const r = await fetch(`${EC}/channels/${channelId}/webhook`, {
method: "PUT",
headers: { ...KEY, "Content-Type": "application/json" },
body: JSON.stringify({ url }),
});
const body = (await r.json()) as { signing_secret: string; error?: { message: string } };
if (!r.ok) throw new Error(body.error?.message);
secrets.set(channelId, body.signing_secret); // returned only this once
}
function verify(raw: string, header: string | null, secret: string): boolean {
const parts = Object.fromEntries((header ?? "").split(",").map((kv) => kv.split("=", 2)));
const t: string = parts.t ?? "";
const v1: string = parts.v1 ?? "";
if (!/^[0-9]+$/.test(t) || Math.abs(Date.now() / 1000 - Number(t)) > 300) return false;
const mac = createHmac("sha256", secret).update(`${t}.${raw}`).digest("hex");
return mac.length === v1.length && timingSafeEqual(Buffer.from(mac), Buffer.from(v1));
}
// POST /hooks/social as a web-standard handler (Next.js, Hono, Bun and others)
export async function POST(req: Request) {
const raw = await req.text(); // the signature covers these exact bytes
const event = JSON.parse(raw); // { platform, account_id, external_id, entry }
const secret = secrets.get(event.account_id);
if (!secret || !verify(raw, req.headers.get("x-ec-signature"), secret)) {
return new Response("invalid signature", { status: 401 });
}
await enqueue(event); // one attempt per event and no retries: acknowledge first
return new Response(null, { status: 204 });
}איך עונים לתגובות ולהודעות מ-Node.js?
עם קריאת credentials טרייה ועם המזהים שבאירוע. ב-Instagram וב-Facebook, תשובה להודעה ישירה נשלחת אל /{account-id}/messages, עם השדה account_id_on_meta, כאשר בשדה recipient נכנס מזהה השולח, ובתוך 24 שעות מההודעה האחרונה שלו. בעמוד מצרפים את messaging_type עם הערך RESPONSE, ו-Instagram מאפשר עד 1,000 בייט טקסט. תגובה מקבלת מענה ציבורי בנתיב /{comment-id}/replies ב-Instagram או בנתיב /{comment-id}/comments ב-Facebook, או מענה פרטי אחד עד 7 ימים.
שיחות ב-TikTok נשארות ציבוריות, כי אין הודעות ישירות ב-TikTok. הקריאה business/comment/reply/create/ עם הכותרת Access-Token ועם השדות business_id, video_id ו-comment_id, מפרסמת תשובה של עד 1,200 תווים. קראו את השדה code בתשובה, שבו 0 פירושו הצלחה, ולא את סטטוס ה-HTTP. פועלים רק על אירועים שבהם השדה comment_action מוגדר insert והשדה comment_type מוגדר comment, כי גם התשובות שלכם מגיעות כאירועים.
export async function reply(event: any, text: string) {
const c = await credentials(event.account_id);
if (event.platform === "tiktok") {
const e = event.entry.content; // the comment.update event, ids as strings
if (e.comment_action !== "insert" || e.comment_type !== "comment") return; // your replies arrive as "reply"
const r = await fetch(`${c.api_base}/business/comment/reply/create/`, {
method: "POST",
headers: { "Access-Token": c.access_token, "Content-Type": "application/json" },
body: JSON.stringify({ business_id: c.business_id, video_id: e.video_id, comment_id: e.comment_id, text }),
});
const out = (await r.json()) as { code: number; message: string };
if (out.code !== 0) throw new Error(out.message); // 0 is success, whatever the HTTP status
} else if (event.platform === "facebook") {
for (const m of event.entry.messaging ?? []) {
if (!m.message || m.message.is_echo) continue; // only what people sent the Page
await graph(c, `${c.account_id_on_meta}/messages`, {
recipient: { id: m.sender.id },
messaging_type: "RESPONSE", // within 24 hours of their last message
message: { text },
});
}
}
}איך מפרסמים ל-TikTok ונותנים לסוכן TypeScript את הכלים האלה?
שניהם עוברים דרך שרת ה-MCP של easyCoexistence בכתובת https://easycoexistence.com/api/mcp, שמקבל רק OAuth 2.1: רישום לקוח דינמי, קוד הרשאה עם PKCE, ואסימוני גישה שתקפים שעה ואסימוני רענון. עם @modelcontextprotocol/client, ערכת ה-SDK הרשמית ל-TypeScript עבור Node 20 ומעלה, אובייקט OAuthClientProvider שומר את הלקוח, האסימונים ואת ה-PKCE verifier. החיבור הראשון שולח את המשתמש להתחבר ומעלה UnauthorizedError, והפונקציה finishAuth עם ה-query של ה-callback משלימה אותו.
פרסום ל-TikTok נמצא כאן כי TikTok מוריד מדיה רק מקידומות של כתובות URL שאומתו לאפליקציית המפתח שמאחורי האסימון. הכלי publish_tiktok_post לוקח את קישור ה-HTTPS שלכם ונותן ל-TikTok כתובת חתומה במסלול המדיה המאומת של easyCoexistence, והכלי get_tiktok_publish_status עוקב אחרי הפוסט. אותו לקוח מעמיד לרשות הסוכן את כל הכלים של רשתות החשבון. קראו קודם לכלי list_social_accounts, שהערך בשדה account_id שלו הוא מזהה הערוץ של Partner API.
import { createInterface } from "node:readline/promises";
import { Client, StreamableHTTPClientTransport, UnauthorizedError, type OAuthClientProvider } from "@modelcontextprotocol/client";
const MCP = new URL("https://easycoexistence.com/api/mcp");
const saved: Record<string, any> = {}; // persist this, so the browser sign-in happens once
const provider: OAuthClientProvider = {
redirectUrl: "http://localhost:8090/callback",
clientMetadata: { client_name: "My social agent", redirect_uris: ["http://localhost:8090/callback"] },
state: () => (saved.state = crypto.randomUUID()),
clientInformation: () => saved.client,
saveClientInformation: (info) => { saved.client = info; },
tokens: () => saved.tokens,
saveTokens: (tokens) => { saved.tokens = tokens; },
saveCodeVerifier: (verifier) => { saved.verifier = verifier; },
codeVerifier: () => saved.verifier,
redirectToAuthorization: (url) => console.log("Sign in to easyCoexistence:", url.href),
};
const client = new Client({ name: "my-social-agent", version: "1.0.0" });
const transport = new StreamableHTTPClientTransport(MCP, { authProvider: provider });
try {
await client.connect(transport);
} catch (error) {
if (!(error instanceof UnauthorizedError)) throw error;
const rl = createInterface({ input: process.stdin, output: process.stdout });
const back = new URL(await rl.question("Paste the address you were sent back to: ")).searchParams;
rl.close();
if (back.get("state") !== saved.state) throw new Error("state mismatch");
await transport.finishAuth(back);
await client.connect(new StreamableHTTPClientTransport(MCP, { authProvider: provider }));
}
const result = await client.callTool({
name: "publish_tiktok_post",
arguments: {
account_id: process.env.TIKTOK_CHANNEL_ID, // the Partner API channel id
video_url: "https://cdn.example.com/launch.mp4",
caption: "New drop #behindthescenes",
},
});
console.log(result.content); // a share_id to follow with get_tiktok_publish_statusטעויות נפוצות
- חישוב ה-HMAC על JSON שפוענח והומר מחדש. החתימה מכסה את הגוף הגולמי בית אחר בית, לכן קראו את הגוף קודם בעזרת req.text() ופענחו רק אחר כך, אחרת כל משלוח ייכשל בבדיקה.
- המרת מזהי TikTok למספרים. מזהי התגובה והסרטון הם בני 64 ביט, והפונקציה Number() מעגלת אותם, לכן שמרו את המחרוזות שהאירוע מכיל כשעונים לתגובה או מחפשים אותה.
- שמירה של channel_id בלבד מההפניה חזרה. חיבור לפייסבוק או ל-LinkedIn יכול להוסיף כמה עמודים בבת אחת, לכן מציגים את כולם בקריאה GET /channels?external_ref= ושומרים כל אחד.
- מענה להודעת Messenger או Instagram מתוך אצווה לילית. כשעוברות יותר מ-24 שעות מההודעה האחרונה של האדם, השליחה נכשלת, לכן עונים מתוך מטפל האירוע בזמן שהחלון פתוח.
easyCoexistence נותן ל-backend של Node.js ולסוכני AI הגעה ללקוחות ב-WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn וערוצים נוספים, כל אחד דרך ה-API הרשמי שלו. מחברים חשבונות עם Partner API, מושכים אסימונים טריים ואירועים חתומים, ומאפשרים לסוכני TypeScript לפעול דרך שרת ה-MCP, כשכל חיבור מנוטר 24/7. מ-US$ 9 עד US$ 0.75 לחיבור בחודש, והמחיר יורד ככל שמוסיפים חיבורים, עם 3 ימי ניסיון חינם בהתחלה.
שאלות נפוצות
האם צריך ערכת SDK כדי לקרוא לממשקי ה-API האלה מ-Node?
לא. ה-Partner API וממשקי ה-API של הרשתות הם HTTPS רגיל, ולכן fetch הגלובלי ב-Node 18 ומעלה מספיק לכולם. @modelcontextprotocol/client נחוץ רק לכלי ה-MCP, וביניהם פרסום ב-TikTok.
למה פרסום ל-TikTok עובר דרך שרת ה-MCP?
TikTok מוריד סרטונים ותמונות רק מדומיין או מקידומת כתובת URL שאומתו לאפליקציית המפתחים, והאפליקציה הזו היא של easyCoexistence. הכלי publish_tiktok_post מגיש את הקובץ שלכם מהכתובת המאומתת הזו, ולכן לדומיין שלכם אין צורך באימות.
האם אפשר לחבר כמה עמודי Facebook או LinkedIn בכניסה אחת?
כן. כל עמוד, וב-LinkedIn הפרופיל האישי של החבר, הופך לערוץ משלו ולחיבור משלו. ההפניה חזרה כוללת את ה-channel_id הראשון, וקריאת GET /channels?external_ref= מציגה את כולם.
כמה עולה easyCoexistence ל-Node.js?
מ-US$ 9 עד US$ 0.75 לחיבור בחודש, והמחיר יורד ככל שמוסיפים חיבורים, וזהה בכל הרשתות. המחבר ל-MCP ו-Partner API כלולים, בלי מושבים, ו-3 הימים הראשונים הם ניסיון חינם.
המשיכו לקרוא
מחברים את הערוץ הראשון שלכם תוך שתי דקות.
בלי לחכות לאישורים של הפלטפורמות. מחברים את WhatsApp, Instagram, TikTok או ערוץ אחר, מבקשים מה-AI לפרסם, להשיב או להפיק דוח, ורואים אותו עובד.
- 3 ימי ניסיון חינם
- ביטול בכל עת
- רק ממשקי API רשמיים
- ניטור 24/7
נבדק ב-