Mit einer API aus Node.js auf Instagram, TikTok und Facebook posten
Mit easyCoexistence posten ein Node.js- oder TypeScript-Backend über die offizielle API jedes Netzwerks auf Instagram, Facebook, TikTok, YouTube und LinkedIn. Konten melden sich einmal über einen gehosteten Verbindungslink an; ein einziger fetch-Aufruf liefert danach für jeden Auftrag bei TikTok, YouTube und LinkedIn ein frisches Token, und signierte Ereignisse bringen Kommentare und Direktnachrichten an Ihre Route. Agenten auf Basis des TypeScript-MCP-SDK erhalten dieselben Konten als Tools.
Der Publishing-Endpoint von TikTok nimmt Videobeiträge je Konto an, höchstens sechs pro Minute.
Wie weit im Voraus ein Facebook-Seitenbeitrag mit published false und scheduled_publish_time geplant werden kann.
Der Antwort-Header, der die URN eines neuen LinkedIn-Beitrags trägt, gesendet mit Status 201.
Wie schnell TikTok ein comment.update-Ereignis auslöst, nachdem ein Kommentar erstellt, gelöscht oder in seiner Sichtbarkeit geändert wurde.
Wie lange ein Verbindungslink der Partner API geöffnet bleibt, bevor seine Sitzung abläuft.
Wie verbindet ein Node.js-Backend Konten und holt deren Token?
Ihr Backend öffnet eine Verbindungssitzung, und der Kontoinhaber schließt sie im Browser ab. Ein POST an /connect-sessions mit Ihrem ec_live_-Schlüssel als Bearer-Token, einem Kanal wie tiktok oder linkedin, einer redirect_url und einer external_ref für Ihren Kunden liefert eine url auf easycoexistence.com. Dort meldet sich der Inhaber auf dem eigenen Zustimmungsbildschirm des Netzwerks an und kehrt mit status=connected und einer channel_id zu Ihrer redirect_url zurück. Ein abgebrochener Versuch lässt sich über denselben Link wiederholen, bis er abläuft, eine Stunde nach seiner Erstellung.
Jeder Auftrag beginnt dann mit GET /channels/{id}?credentials=1. Die Antwort enthält ein Token, das jetzt gültig ist (nicht bei Instagram und Facebook, deren Token nie herausgegeben werden), sowie die Felder, die jedes Netzwerk braucht: graph_api_base und account_id_on_meta bei Instagram und Facebook, api_base und business_id bei TikTok, channel_id bei YouTube, author_urn und required_headers bei LinkedIn. Signierte Ereignisse channel.connected, channel.disconnected, channel.removed und channel.suspended, gesendet an die im Dashboard hinterlegte Ereignis-URL, teilen Ihrer App mit, wann sich ein Konto ändert.
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;
}Wie posten Sie aus Node.js auf Instagram und Facebook?
Instagram veröffentlicht über einen Container. Für ein Reel legen Sie ihn mit media_type REELS, video_url und caption an, fragen status_code ab, bis dort FINISHED steht, und rufen dann media_publish mit der Container-ID als creation_id auf. Meta empfiehlt, etwa einmal pro Minute abzufragen, und nach fünf Minuten aufzugeben; ERROR oder EXPIRED bedeutet, dass der Container nicht veröffentlicht wird, und ein Container, der 24 Stunden unveröffentlicht bleibt, läuft von selbst ab.
Eine Facebook-Seite nimmt ein Foto in einem Aufruf an /{page-id}/photos entgegen, mit der Bild-url und einer Bildunterschrift, während Text und Links an /{page-id}/feed gehen. Beide akzeptieren published false mit einer scheduled_publish_time, und Meta selbst veröffentlicht den Beitrag zum festgelegten Zeitpunkt, zwischen 10 Minuten und 30 Tagen im Voraus. Das Token wird als Bearer-Header übermittelt, die Graph-API-Version steckt bereits in graph_api_base, und die Medien müssen unter einer öffentlichen URL liegen, die Meta herunterlädt.
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
});
}Wie posten Sie auf LinkedIn und laden auf YouTube hoch, aus Node.js?
LinkedIn verlangt bei jedem Aufruf neben dem Bearer-Token zwei Header: LinkedIn-Version mit dem YYYYMM-Wert, den easyCoexistence in required_headers zurückgibt, und X-Restli-Protocol-Version mit 2.0.0. Ein Beitrag ist ein POST an /rest/posts mit der Autoren-URN, dem Text als commentary, der Sichtbarkeit PUBLIC, dem Hauptfeed als distribution und lifecycleState PUBLISHED. LinkedIn antwortet mit 201 und legt die URN des neuen Beitrags in den Header x-restli-id; jede URN, die in einem URL-Pfad steht, muss URL-kodiert sein.
YouTube braucht zwei Anfragen. Ein POST an den Upload-Endpoint mit uploadType=resumable und part=snippet,status sendet die Metadaten und liefert die Sitzungsadresse im Header Location zurück; ein PUT der Dateibytes an diese Adresse liefert die Video-Ressource mit ihrer id. Wird das Video als privat mit einem publishAt-Datum hochgeladen, übernimmt der eigene Scheduler von YouTube die Veröffentlichung, sodass zu dieser Uhrzeit nichts bei Ihnen laufen muss.
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;
}Wie empfangen Sie Kommentare und Direktnachrichten in einer Node.js-Route?
Jeder Kanal leitet an die URL weiter, die Sie bei PUT /channels/{id}/webhook angeben; dieser Aufruf liefert das signing_secret des Kanals genau einmal zurück. Jede Zustellung ist ein POST mit platform, account_id, external_id und entry sowie einem Header X-EC-Signature der Form t=<unix>,v1=<hex>, wobei v1 der HMAC-SHA256 aus t, einem Punkt und dem rohen Body ist. Lesen Sie den Body als Text, bevor Sie ihn parsen, weisen Sie ein t ab, das älter als fünf Minuten ist, und vergleichen Sie mit timingSafeEqual.
Bei Instagram und Facebook ist entry der Webhook-Eintrag von Meta, so wie Meta ihn gesendet hat: changes für Kommentare und Erwähnungen, messaging für Direktnachrichten. Bei TikTok enthält er das Ereignis comment.update, das TikTok innerhalb von fünf Minuten nach einem Kommentar auslöst, mit comment_id und video_id als Strings, damit JavaScript diese 64-Bit-Zahlen nicht rundet. Es gibt pro Ereignis genau einen Zustellversuch und keine gespeicherte Kopie, also antworten Sie sofort mit 204 und verarbeiten aus einer Warteschlange.
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 });
}Wie antworten Sie aus Node.js auf Kommentare und Direktnachrichten?
Mit einem frischen credentials-Aufruf und den IDs aus dem Ereignis. Bei Instagram und Facebook geht eine Antwort auf eine Direktnachricht an /{account-id}/messages, mit account_id_on_meta, der ID des Absenders als recipient und innerhalb von 24 Stunden nach dessen letzter Nachricht; eine Seite fügt messaging_type RESPONSE hinzu, und Instagram erlaubt höchstens 1,000 Byte Text. Ein Kommentar erhält eine öffentliche Antwort, unter /{comment-id}/replies auf Instagram oder /{comment-id}/comments auf Facebook, oder eine einzige private Antwort innerhalb von 7 Tagen.
TikTok-Unterhaltungen bleiben öffentlich, denn auf TikTok gibt es keine Direktnachrichten. business/comment/reply/create/ mit dem Header Access-Token, business_id, video_id und comment_id veröffentlicht eine Antwort von bis zu 1,200 Zeichen. Werten Sie das Feld code der Antwort aus, wobei 0 Erfolg bedeutet, und nicht den HTTP-Status. Handeln Sie nur bei comment_action insert mit comment_type comment, denn Ihre eigenen Antworten kommen ebenfalls als Ereignisse an.
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 },
});
}
}
}Wie posten Sie auf TikTok und geben einem TypeScript-Agenten diese Tools?
Beides läuft über den MCP-Server von easyCoexistence unter https://easycoexistence.com/api/mcp, der nur OAuth 2.1 akzeptiert: dynamische Client-Registrierung, ein Autorisierungscode mit PKCE, Zugriffs-Token mit einer Stunde Gültigkeit und Refresh-Token. Mit @modelcontextprotocol/client, dem offiziellen TypeScript-SDK für Node 20 und neuer, hält ein OAuthClientProvider den Client, die Token und den PKCE-Verifier; die erste Verbindung schickt den Nutzer zur Anmeldung und wirft UnauthorizedError, und finishAuth mit dem Query-Teil des Callbacks schließt sie ab.
TikTok-Veröffentlichung läuft hier, weil TikTok Medien nur von URL-Präfixen herunterlädt, die für die Entwickler-App hinter dem Token verifiziert sind. publish_tiktok_post nimmt Ihren HTTPS-Link entgegen und gibt TikTok eine signierte Adresse auf der verifizierten Medienroute von easyCoexistence, und get_tiktok_publish_status verfolgt den Beitrag. Derselbe Client übergibt einem Agenten alle Tools für die Netzwerke des Kontos; rufen Sie zuerst list_social_accounts auf, dessen account_id die Kanal-ID der Partner API ist.
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_statusHäufige Fehler
- HMAC über geparstes und erneut serialisiertes JSON berechnen. Die Signatur deckt den rohen Body Byte für Byte ab; rufen Sie daher zuerst req.text() auf und parsen Sie danach, sonst scheitert jede Zustellung an der Prüfung.
- TikTok-IDs in Zahlen umwandeln. Kommentar- und Video-IDs sind 64-Bit-Werte, und Number() rundet sie, also behalten Sie die Strings aus dem Ereignis, wenn Sie antworten oder einen Kommentar nachschlagen.
- Nur die channel_id aus der Weiterleitung speichern. Eine Anmeldung bei Facebook oder LinkedIn kann mehrere Seiten auf einmal hinzufügen, also listen Sie sie mit GET /channels?external_ref= auf und speichern jede einzeln.
- Eine Messenger- oder Instagram-Direktnachricht aus einem nächtlichen Stapellauf beantworten. Außerhalb von 24 Stunden nach der letzten Nachricht der Person schlägt der Versand fehl, also antworten Sie aus dem Ereignis-Handler, solange das Zeitfenster offen ist.
easyCoexistence gibt Node.js-Backends und KI-Agenten Zugang zu Kunden auf WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn und weiteren Kanälen, jeweils über deren offizielle API. Verbinden Sie Konten mit der Partner API, holen Sie frische Token und signierte Ereignisse, und lassen Sie TypeScript-Agenten über den MCP-Server handeln, wobei jede Verbindung rund um die Uhr überwacht wird. US$ 9 bis US$ 0.75 pro Verbindung und Monat, sinkend mit jeder weiteren Verbindung, die ersten 3 Tage sind eine kostenlose Testphase.
Häufig gestellte Fragen
Brauche ich ein SDK, um diese APIs aus Node aufzurufen?
Nein. Die Partner API und die APIs der Netzwerke sind einfaches HTTPS, daher reicht das globale fetch in Node 18 und neuer. @modelcontextprotocol/client wird nur für die MCP-Tools benötigt, darunter die TikTok-Veröffentlichung.
Warum läuft die TikTok-Veröffentlichung über den MCP-Server?
TikTok lädt Videos und Fotos nur von einer Domain oder einem URL-Präfix herunter, das für die Entwickler-App verifiziert ist, und diese App gehört easyCoexistence. publish_tiktok_post stellt Ihre HTTPS-Datei über diese verifizierte Adresse bereit, sodass Ihre eigene Domain keine Verifizierung braucht.
Kann eine Anmeldung mehrere Facebook- oder LinkedIn-Seiten verbinden?
Ja. Jede Seite und bei LinkedIn das eigene Profil des Mitglieds wird zu einem eigenen Kanal und einer eigenen Verbindung. Die Weiterleitung enthält die erste channel_id, und GET /channels?external_ref= listet alle auf.
Was kostet easyCoexistence für Node.js?
US$ 9 bis US$ 0.75 pro Verbindung und Monat, sinkend mit jeder weiteren Verbindung, auf jedem Netzwerk gleich. Die Partner API und der MCP-Connector sind inklusive, ohne Sitze, und die ersten 3 Tage sind eine kostenlose Testphase.
Weiterlesen
Verbinden Sie Ihren ersten Kanal in zwei Minuten.
Keine Plattform-Prüfungen, auf die Sie warten müssen. Verbinden Sie WhatsApp, Instagram, TikTok oder einen anderen Kanal, bitten Sie dann Ihre KI, zu posten, zu antworten oder Berichte zu erstellen, und sehen Sie ihr bei der Arbeit zu.
- 3 Tage kostenlos
- Jederzeit kündbar
- Nur offizielle APIs
- Überwacht rund um die Uhr (24/7)
Verifiziert am