Publicați pe Instagram, TikTok și Facebook din Node.js printr-un singur API
Cu easyCoexistence, un backend Node.js sau TypeScript publică pe Instagram, Facebook, TikTok, YouTube și LinkedIn prin API-ul oficial al fiecărei rețele. Conturile se conectează o singură dată printr-un link găzduit; un singur fetch returnează apoi un token proaspăt pentru fiecare job pe TikTok, YouTube și LinkedIn, iar evenimentele semnate aduc comentariile și mesajele directe (DM) către ruta dumneavoastră. Agenții construiți pe SDK-ul MCP pentru TypeScript primesc aceleași conturi ca unelte.
Postările video pe care endpoint-ul de publicare al TikTok le acceptă pe cont, la cel mult șase pe minut.
Cu cât în avans poate fi programată o postare pe Pagina de Facebook, cu published false și scheduled_publish_time.
Antetul de răspuns care transportă URN-ul unei postări noi pe LinkedIn, trimis cu statusul 201.
Cât de repede trimite TikTok evenimentul comment.update după ce un comentariu este creat, șters sau i se schimbă vizibilitatea.
Cât timp rămâne deschis linkul de conectare Partner API înainte ca sesiunea să expire.
Cum conectează un backend Node.js conturile și își obține token-urile?
Backend-ul dumneavoastră deschide o sesiune de conectare, iar titularul contului o finalizează în browser. Un POST către /connect-sessions, cu cheia ec_live_ a dumneavoastră drept bearer token, un canal precum tiktok sau linkedin, un redirect_url și un external_ref pentru clientul dumneavoastră, returnează un url pe easycoexistence.com. Acolo titularul se autentifică pe ecranul de consimțământ al rețelei și revine la redirect_url cu status=connected și un channel_id. O încercare anulată poate fi reluată de la același link până expiră, la o oră după creare.
Fiecare job începe apoi cu GET /channels/{id}?credentials=1. Răspunsul conține un token valabil acum (nu pe Instagram și Facebook, ale căror token-uri nu sunt niciodată furnizate), plus câmpurile de care are nevoie fiecare rețea: graph_api_base și account_id_on_meta pentru Instagram și Facebook, api_base și business_id pentru TikTok, channel_id pentru YouTube, author_urn și required_headers pentru LinkedIn. Evenimentele semnate channel.connected, channel.disconnected, channel.removed și channel.suspended, trimise către URL-ul de evenimente setat în panoul de control, îi spun aplicației dumneavoastră când se schimbă un cont.
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;
}Cum publicați pe Instagram și Facebook din Node.js?
Instagram publică printr-un container. Pentru un Reel, creați-l cu media_type REELS, video_url și legenda, interogați câmpul status_code până indică FINISHED, apoi apelați media_publish cu id-ul containerului drept creation_id. Meta recomandă interogarea aproximativ o dată pe minut și renunțarea după cinci minute. ERROR sau EXPIRED înseamnă că393 containerul nu va fi publicat, iar un container nepublicat timp de 24 de ore expiră singur.
O Pagină de Facebook primește o fotografie dintr-un singur apel către /{page-id}/photos, cu URL-ul imaginii și o legendă, în timp ce textul și linkurile merg către /{page-id}/feed. Ambele acceptă published false cu un scheduled_publish_time, iar Meta publică singură postarea la momentul respectiv, cu între 10 minute și 30 de zile în avans. Tokenul circulă ca antet bearer, versiunea Graph API este deja inclusă în graph_api_base, iar media trebuie să se afle la un URL public pe care Meta îl descarcă.
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
});
}Cum publicați pe LinkedIn și încărcați pe YouTube din Node.js?
LinkedIn cere, pe lângă bearer token, două antete la fiecare apel: LinkedIn-Version, cu valoarea YYYYMM pe care easyCoexistence o returnează în required_headers, și X-Restli-Protocol-Version setat la 2.0.0. O postare este un POST către /rest/posts cu URN-ul autorului, textul ca commentary, visibility PUBLIC, feed-ul principal ca distribution și lifecycleState PUBLISHED. LinkedIn răspunde cu 201 și pune URN-ul noii postări în antetul x-restli-id. Orice URN pus în calea unui URL trebuie codificat cu URL-encoding.
YouTube necesită două cereri. Un POST către endpoint-ul de încărcare cu uploadType=resumable și part=snippet,status trimite metadatele și returnează adresa sesiunii în antetul Location. Un PUT cu octeții fișierului către acea adresă returnează resursa video cu id-ul ei. Încărcarea ca privat, cu o dată publishAt, lasă publicarea în seama programatorului YouTube, așa că nu trebuie să ruleze nimic din partea dumneavoastră la ora respectivă.
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;
}Cum primiți comentarii și mesaje directe într-o rută Node.js?
Fiecare canal trimite evenimente către URL-ul pe care îl dați prin PUT /channels/{id}/webhook, iar acest apel returnează signing_secret-ul canalului o singură dată. Fiecare livrare este un POST cu platform, account_id, external_id și entry, având antetul X-EC-Signature de forma t=<unix>,v1=<hex>, unde v1 este HMAC-SHA256 calculat pe t, un punct și corpul brut. Citiți corpul ca text înainte de a-l parsa, respingeți un t mai vechi de cinci minute și comparați cu timingSafeEqual.
Pentru Instagram și Facebook, entry este webhook-ul Meta așa cum l-a trimis Meta: changes pentru comentarii și mențiuni, messaging pentru mesajele directe. Pentru TikTok conține evenimentul comment.update, pe care TikTok îl trimite în cinci minute de la un comentariu, cu comment_id și video_id ca șiruri de caractere, astfel încât JavaScript să nu rotunjească aceste numere pe 64 de biți. Există o singură încercare per eveniment și nicio copie stocată, așa că răspundeți imediat cu 204 și procesați din coadă.
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 });
}Cum răspundeți la comentarii și mesaje directe din Node.js?
Cu un apel credentials proaspăt și cu id-urile din eveniment. Pe Instagram și Facebook, un răspuns la un mesaj direct merge către /{account-id}/messages, folosind account_id_on_meta, cu id-ul expeditorului drept destinatar și în 24 de ore de la ultimul său mesaj. O Pagină adaugă messaging_type RESPONSE, iar Instagram admite cel mult 1.000 de octeți de text. Un comentariu primește un răspuns public, la /{comment-id}/replies pe Instagram sau /{comment-id}/comments pe Facebook, ori un singur răspuns privat în 7 zile.
Conversațiile de pe TikTok rămân publice, pentru că pe TikTok nu există mesaje directe. business/comment/reply/create/, cu antetul Access-Token, business_id, video_id și comment_id, publică un răspuns de până la 1.200 de caractere. Citiți câmpul code din răspuns, unde 0 înseamnă succes, nu codul de stare HTTP. Acționați doar la comment_action insert cu comment_type comment, pentru că answerele proprii sosesc și ele ca evenimente.
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 },
});
}
}
}Cum publicați pe TikTok și dați unui agent TypeScript aceste unelte?
Ambele trec prin serverul MCP al easyCoexistence, la https://easycoexistence.com/api/mcp, care acceptă doar OAuth 2.1: înregistrare dinamică a clientului, un cod de autorizare cu PKCE, token-uri de acces valabile o oră și token-uri de reîmprospătare. Cu @modelcontextprotocol/client, SDK-ul oficial TypeScript pentru Node 20 și versiunile ulterioare, un OAuthClientProvider păstrează clientul, token-urile și verificatorul PKCE. Prima conectare trimite utilizatorul să se autentifice și aruncă UnauthorizedError, iar finishAuth cu parametrii de interogare ai callback-ului o finalizează.
Publicarea pe TikTok se află aici pentru că TikTok descarcă media doar de la prefixe de URL verificate pentru aplicația de dezvoltator din spatele token-ului. publish_tiktok_post primește linkul dumneavoastră HTTPS și îi dă TikTok o adresă semnată pe ruta verificată de media a easyCoexistence, iar get_tiktok_publish_status urmărește postarea. Același client oferă unui agent toate uneltele rețelelor contului. Apelați mai întâi list_social_accounts, al cărui account_id este id-ul de canal al 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_statusGreșeli frecvente
- Calcularea HMAC pe JSON parsat și reserializat. Semnătura acoperă corpul brut, octet cu octet, așa că apelați mai întâi req.text() și parsați după aceea, altfel fiecare livrare eșuează la verificare.
- Transformarea id-urilor TikTok în numere. Id-urile de comentariu și de video au 64 de biți, iar Number() le rotunjește, așa că păstrați șirurile pe care le conține evenimentul când răspundeți sau căutați un comentariu.
- Păstrarea doar a channel_id din redirect. O conectare pe Facebook sau LinkedIn poate adăuga mai multe Pagini deodată, așa că listați-le cu GET /channels?external_ref= și stocați fiecare.
- Răspunsul la un mesaj Messenger sau Instagram dintr-un batch nocturn. După 24 de ore de la ultimul mesaj al persoanei, trimiterea eșuează, așa că răspundeți din handler-ul de evenimente cât timp fereastra este deschisă.
easyCoexistence oferă backend-urilor Node.js și agenților AI acces la clienți pe WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn și alte canale, fiecare prin API-ul său oficial. Conectați conturile cu Partner API, obțineți token-uri proaspete și evenimente semnate și lăsați agenții TypeScript să acționeze prin serverul MCP, cu fiecare conexiune monitorizată 24/7. De la US$ 9 până la US$ 0.75 per conexiune pe lună, scăzând pe măsură ce adăugați conexiuni, cu o perioadă de probă gratuită de 3 zile.
Întrebări frecvente
Am nevoie de un SDK ca să apelez aceste API-uri din Node?
Nu. Partner API și API-urile rețelelor sunt simplu HTTPS, deci fetch-ul global din Node 18 și versiunile ulterioare este suficient. @modelcontextprotocol/client se adaugă doar pentru uneltele MCP, printre care și publicarea pe TikTok.
De ce publicarea pe TikTok trece prin serverul MCP?
TikTok descarcă videoclipuri și fotografii doar de la un domeniu sau un prefix de URL verificat pentru aplicația de dezvoltator, iar aceea este a easyCoexistence. publish_tiktok_post servește fișierul dumneavoastră HTTPS de la acea adresă verificată, deci propriul domeniu nu are nevoie de verificare.
Poate o singură autentificare să conecteze mai multe Pagini de Facebook sau LinkedIn?
Da. Fiecare Pagină, iar pe LinkedIn profilul propriu al membrului, devine propriul canal și propria conexiune. Redirect-ul conține primul channel_id, iar GET /channels?external_ref= le listează pe toate.
Cât costă easyCoexistence pentru Node.js?
De la US$ 9 până la US$ 0.75 per conexiune pe lună, scăzând pe măsură ce adăugați conexiuni, la fel pe fiecare rețea. Partner API și conectorul MCP sunt incluse, fără licențe per utilizator, iar primele 3 zile sunt gratuite.
Continuați să citiți
Conectați primul canal în două minute.
Fără recenzii de platformă de așteptat. Conectați WhatsApp, Instagram, TikTok sau alt canal, apoi cereți AI-ului să publice, să răspundă sau să raporteze și urmăriți-l cum lucrează.
- 3 zile gratuit
- Anulați oricând
- Doar API-uri oficiale
- Monitorizat 24/7
Verificat la