InloggenGratis proefperiode starten
easyCoexistence Officiële API's

Posten naar Instagram, TikTok en Facebook vanuit Node.js met één API

Met easyCoexistence publiceert een Node.js- of TypeScript-backend via de officiële API van elk netwerk op Instagram, Facebook, TikTok, YouTube en LinkedIn. Accounts koppel je één keer via een gehoste link; daarna levert één fetch per taak een vers token op TikTok, YouTube en LinkedIn, en ondertekende events brengen reacties en DM's naar je route. Agents die op de TypeScript MCP SDK zijn gebouwd, krijgen dezelfde accounts als tools.

15 a day

Videoposts die het publicatie-endpoint van TikTok per account accepteert, tot maximaal zes per minuut.

10 min to 30 days

Hoe ver vooruit een Facebook Page-post ingepland kan worden met published false en een scheduled_publish_time.

x-restli-id

De antwoordheader met de URN van een nieuwe LinkedIn-post, verstuurd met status 201.

5 minutes

Hoe snel TikTok een comment.update-event verstuurt nadat een reactie is aangemaakt, verwijderd of de zichtbaarheid ervan is gewijzigd.

1 hour

Hoe lang een connect-link van de Partner API open blijft voordat de sessie verloopt.

Hoe verbindt een Node.js-backend accounts en haalt het hun tokens op?

Je backend opent een connect-sessie en de accounteigenaar rondt het af in de browser. Een POST naar /connect-sessions, met je ec_live_-sleutel als bearer-token, een kanaal zoals tiktok of linkedin, een redirect_url en een external_ref voor je klant, geeft een url terug op easycoexistence.com. Daar meldt de eigenaar zich aan op het toestemmingsscherm van het netwerk zelf en keert terug naar je redirect_url met status=connected en een channel_id; een afgebroken poging kan vanaf dezelfde link opnieuw worden gestart tot die verloopt, een uur na aanmaak.

Elke taak begint daarna met GET /channels/{id}?credentials=1. Het antwoord bevat een token dat nu geldig is (niet bij Instagram en Facebook, waarvan de tokens nooit worden uitgegeven), plus de velden die elk netwerk nodig heeft: graph_api_base en account_id_on_meta bij Instagram en Facebook, api_base en business_id bij TikTok, channel_id bij YouTube, author_urn en required_headers bij LinkedIn. Ondertekende channel.connected-, channel.disconnected-, channel.removed- en channel.suspended-events, verstuurd naar de events-URL die je in het dashboard instelt, laten je app weten wanneer een account verandert.

A connect link and per-job credentials with fetch
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;
}

Hoe post je vanuit Node.js naar Instagram en Facebook?

Instagram publiceert via een container. Voor een Reel maak je die aan met media_type REELS, de video_url en de caption, vraag je de status_code op tot die FINISHED aangeeft, en roep je media_publish aan met het container-id als creation_id. Meta raadt aan ongeveer elke minuut op te vragen en na vijf minuten op te geven; ERROR of EXPIRED betekent dat de container niet wordt gepubliceerd, en een container die 24 uur onpubliceerd blijft, verloopt vanzelf.

Een Facebook Page krijgt een foto in één aanroep naar /{page-id}/photos, met de afbeeldings-URL en het bijschrift, terwijl tekst en links naar /{page-id}/feed gaan. Beide accepteren published false met een scheduled_publish_time, en Meta publiceert de post zelf op dat moment, tussen 10 minuten en 30 dagen vooruit. Het token reist als bearer-header, de Graph API-versie zit al in graph_api_base, en de media moet op een openbare URL staan die Meta downloadt.

Publish a Reel and schedule a Page photo
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
  });
}

Hoe post je vanuit Node.js naar LinkedIn en upload je naar YouTube?

LinkedIn vraagt bij elke aanroep naast het bearer-token om twee headers: LinkedIn-Version, met de YYYYMM-waarde die easyCoexistence teruggeeft in required_headers, en X-Restli-Protocol-Version met 2.0.0. Een post is een POST naar /rest/posts met de author-URN, de tekst als commentary, PUBLIC-zichtbaarheid, de hoofdfeed als distribution en lifecycleState PUBLISHED. LinkedIn antwoordt met 201 en zet de URN van de nieuwe post in de header x-restli-id, en een URN in een URL-pad moet URL-gecodeerd zijn.

YouTube heeft twee verzoeken nodig. Een POST naar het upload-endpoint met uploadType=resumable en part=snippet,status stuurt de metadata en geeft het sessieadres terug in de Location-header; een PUT van de bytes van het bestand naar dat adres geeft de videoresource terug met zijn id. Uploaden als private met een publishAt-datum laat het publiceren over aan de eigen planner van YouTube, zodat niets van jou op dat uur hoeft te draaien.

Publish on LinkedIn and schedule a YouTube upload
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;
}

Hoe ontvang je reacties en DM's in een Node.js-route?

Elk kanaal stuurt door naar de URL die je meegeeft aan PUT /channels/{id}/webhook, en die aanroep geeft het signing_secret van het kanaal één keer terug. Elke levering is een POST met platform, account_id, external_id en entry, met een X-EC-Signature-header in de vorm t=<unix>,v1=<hex>, waarbij v1 de HMAC-SHA256 is van t, een punt en de ruwe body. Lees de body eerst als tekst voordat je hem parseert, weiger een t die ouder is dan vijf minuten en vergelijk met timingSafeEqual.

Bij Instagram en Facebook is entry de webhook-entry van Meta zoals Meta die stuurde: changes voor reacties en vermeldingen, messaging voor DM's. Bij TikTok bevat hij het comment.update-event, dat TikTok binnen vijf minuten na een reactie verstuurt, met comment_id en video_id als strings, zodat JavaScript die 64-bitsgetallen niet kan afronden. Er is één poging per event en geen opgeslagen kopie, dus beantwoord direct met 204 en verwerk vanuit een wachtrij.

Turn on forwarding and verify X-EC-Signature in a route handler
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 });
}

Hoe reageer je vanuit Node.js op reacties en DM's?

Met een nieuwe credentials-aanroep en de id's uit het event. Bij Instagram en Facebook gaat een DM-antwoord naar /{account-id}/messages, met account_id_on_meta, met het id van de afzender als recipient en binnen 24 uur na diens laatste bericht; een Page voegt messaging_type RESPONSE toe, en Instagram staat maximaal 1.000 bytes tekst toe. Een reactie krijgt een openbaar antwoord, op /{comment-id}/replies bij Instagram of /{comment-id}/comments bij Facebook, of één privé-antwoord binnen 7 dagen.

Gesprekken op TikTok blijven openbaar, want er zijn geen DM's op TikTok. business/comment/reply/create/, met de header Access-Token, business_id, video_id en comment_id, plaatst een antwoord van maximaal 1.200 tekens. Lees het code-veld van het antwoord, waarbij 0 succes betekent, in plaats van de HTTP-status. Reageer alleen op comment_action insert met comment_type comment, want je eigen antwoorden komen ook als events binnen.

Reply to a TikTok comment and a Messenger DM
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 },
      });
    }
  }
}

Hoe post je naar TikTok en geef je een TypeScript-agent deze tools?

Beide lopen via de MCP-server van easyCoexistence op https://easycoexistence.com/api/mcp, die alleen OAuth 2.1 accepteert: dynamische clientregistratie, een autorisatiecode met PKCE, toegangstokens die een uur geldig zijn en refreshtokens. Met @modelcontextprotocol/client, de officiële TypeScript SDK voor Node 20 en nieuwer, houdt een OAuthClientProvider de client, de tokens en de PKCE-verifier bij; de eerste verbinding stuurt de gebruiker naar de aanmelding en gooit UnauthorizedError, en finishAuth met de querystring van de callback voltooit die.

Het TikTok-publiceren zit hier omdat TikTok media alleen downloadt van URL-prefixen die voor de developer-app achter het token zijn geverifieerd. publish_tiktok_post neemt je HTTPS-link en geeft TikTok een ondertekend adres op de geverifieerde mediaroute van easyCoexistence, en get_tiktok_publish_status volgt de post. Dezelfde client levert een agent elke tool voor de netwerken van het account; roep eerst list_social_accounts aan, waarvan de account_id het channel-id van de Partner API is.

Sign in over OAuth and publish to TikTok with the MCP client
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

Veelgemaakte fouten

  • De HMAC berekenen over geparseerde en opnieuw geserialiseerde JSON. De handtekening dekt de ruwe body byte voor byte, dus roep eerst req.text() aan en parseer daarna, anders faalt elke levering de controle.
  • TikTok-id's omzetten naar getallen. Reactie- en video-id's zijn 64-bits en Number() rondt ze af, dus bewaar de strings die het event bevat wanneer je antwoordt of een reactie opzoekt.
  • Alleen de channel_id uit de redirect bewaren. Een aanmelding via Facebook of LinkedIn kan meerdere Pages tegelijk toevoegen, dus toon ze met GET /channels?external_ref= en sla elk op.
  • Een Messenger- of Instagram-DM beantwoorden vanuit een nachtelijke batch. Buiten 24 uur na het laatste bericht van de persoon mislukt de verzending, dus antwoord vanuit de event-handler zolang het venster open is.
Dit doen met EasyCoexistence

easyCoexistence geeft Node.js-backends en AI-agents bereik tot klanten op WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn en meer kanalen, elk via de officiële API. Koppel accounts met de Partner API, haal verse tokens en ondertekende events op, en laat TypeScript-agents handelen via de MCP-server, met elke verbinding 24/7 gemonitord. US$ 9 tot US$ 0,75 per verbinding per maand, dalend naarmate je meer verbindingen toevoegt, met de eerste 3 dagen gratis.

Veelgestelde vragen

Heb ik een SDK nodig om deze API's vanuit Node aan te roepen?

Nee. De Partner API en de API's van de netwerken zijn gewone HTTPS, dus de globale fetch in Node 18 en nieuwer is voldoende. @modelcontextprotocol/client komt er alleen bij voor de MCP-tools, waaronder TikTok-publiceren.

Waarom gaat TikTok-publiceren via de MCP-server?

TikTok downloadt video's en foto's alleen van een domein of URL-prefix die voor de developer-app is geverifieerd, en die app is van easyCoexistence. publish_tiktok_post serveert je HTTPS-bestand vanaf dat geverifieerde adres, dus je eigen domein hoeft niet geverifieerd te worden.

Kan één aanmelding meerdere Facebook- of LinkedIn-Pages verbinden?

Ja. Elke Page, en bij LinkedIn het eigen profiel van het lid, wordt een eigen kanaal en een eigen verbinding. De redirect bevat de eerste channel_id, en GET /channels?external_ref= toont ze allemaal.

Hoeveel kost easyCoexistence voor Node.js?

US$ 9 tot US$ 0,75 per verbinding per maand, dalend naarmate je meer verbindingen toevoegt, en hetzelfde op elk netwerk. De Partner API en de MCP-connector zijn erbij inbegrepen, zonder seats, en de eerste 3 dagen zijn gratis.

Lees verder

Koppel je eerste kanaal in twee minuten.

Geen platformbeoordelingen om op te wachten. Verbind WhatsApp, Instagram, TikTok of een ander kanaal, vraag je AI om te posten, te reageren of een rapport te maken, en zie het aan het werk.

  • 3 dagen gratis
  • Op elk moment opzegbaar
  • Alleen officiële API's
  • 24/7 bewaakt

Geverifieerd op