Zaloguj sięRozpocznij bezpłatny okres próbny
easyCoexistence Oficjalne API

Publikuj na Instagramie, TikToku i Facebooku z Node.js jednym API

Dzięki easyCoexistence backend w Node.js lub TypeScript publikuje na Instagramie, Facebooku, TikToku, YouTube i LinkedIn przez oficjalne API każdej sieci. Konta podłączasz raz, przez hostowany link. Jedno wywołanie fetch zwraca świeży token dla każdego zadania w TikToku, YouTube i LinkedIn, a podpisane zdarzenia przekazują komentarze i wiadomości prywatne do Twojej trasy. Agenty zbudowane na TypeScript MCP SDK otrzymują te same konta jako narzędzia.

15 a day

Filmy, które endpoint publikacji TikToka przyjmuje dla każdego konta, w ilości nie większej niż sześć na minutę.

10 min to 30 days

Jak daleko w przód można zaplanować post na stronie na Facebooku z published false i scheduled_publish_time.

x-restli-id

Nagłówek odpowiedzi, który niesie URN nowego posta na LinkedIn, wysyłany ze statusem 201.

5 minutes

Jak szybko TikTok wysyła zdarzenie comment.update po utworzeniu, usunięciu lub zmianie widoczności komentarza.

1 hour

Jak długo link łączenia Partner API pozostaje otwarty, zanim wygaśnie jego sesja.

Jak backend w Node.js łączy konta i pobiera ich tokeny?

Twój backend otwiera sesję łączenia, a właściciel konta kończy proces w przeglądarce. POST do /connect-sessions, z kluczem ec_live_ jako tokenem bearer, kanałem, np. tiktok lub linkedin, redirect_url i external_ref dla Twojego klienta, zwraca url na easycoexistence.com. Tam właściciel loguje się na własnym ekranie zgody sieci i wraca na Twój redirect_url ze status=connected i channel_id. Anulowaną próbę można ponowić z tego samego linku, dopóki nie wygaśnie, czyli godzinę po utworzeniu.

Każde zadanie zaczyna się od GET /channels/{id}?credentials=1. Odpowiedź zawiera token ważny od razu (nie na Instagramie i Facebooku, których tokeny nigdy nie są wydawane) oraz pola, których potrzebuje każda sieć: graph_api_base i account_id_on_meta dla Instagrama i Facebooka, api_base i business_id dla TikToka, channel_id dla YouTube, author_urn i required_headers dla LinkedIn. Podpisane zdarzenia channel.connected, channel.disconnected, channel.removed i channel.suspended, wysyłane na adres zdarzeń ustawiony w panelu, informują Twoją aplikację o zmianach konta.

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;
}

Jak publikować na Instagramie i Facebooku z Node.js?

Instagram publikuje przez kontener. Dla Reela utwórz go z media_type REELS, video_url i caption, odpytuj status_code, aż przyjmie wartość FINISHED, a potem wywołaj media_publish z identyfikatorem kontenera jako creation_id. Meta zaleca odpytywanie mniej więcej raz na minutę i rezygnację po pięciu minutach. ERROR lub EXPIRED oznacza, że kontener nie zostanie opublikowany, a kontener nieopublikowany przez 24 godziny wygasa sam.

Strona na Facebooku dodaje zdjęcie jednym wywołaniem do /{page-id}/photos, z url obrazu i podpisem, a tekst i linki trafiają do /{page-id}/feed. Oba przyjmują published false z scheduled_publish_time, a Meta sama publikuje post o wyznaczonej porze, od 10 minut do 30 dni wcześniej. Token idzie jako nagłówek bearer, wersja Graph API jest już zawarta w graph_api_base, a media muszą leżeć pod publicznym URL, który Meta pobiera.

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
  });
}

Jak publikować na LinkedIn i wysyłać na YouTube z Node.js?

LinkedIn wymaga przy każdym wywołaniu, oprócz tokenu bearer, dwóch nagłówków: LinkedIn-Version z wartością YYYYMM, którą easyCoexistence zwraca w required_headers, oraz X-Restli-Protocol-Version ustawionym na 2.0.0. Post to POST do /rest/posts z URN autora, tekstem jako commentary, widocznością PUBLIC, głównym feedem jako distribution i lifecycleState PUBLISHED. LinkedIn odpowiada kodem 201 i umieszcza URN nowego posta w nagłówku x-restli-id. Każdy URN wstawiany do ścieżki URL musi być zapisany w kodowaniu URL.

YouTube wymaga dwóch żądań. POST do endpointu wysyłania z uploadType=resumable i part=snippet,status przesyła metadane i zwraca adres sesji w nagłówku Location. PUT bajtów pliku pod ten adres zwraca zasób wideo wraz z jego id. Wysyłanie jako prywatne z datą publishAt pozostawia publikację harmonogramowi YouTube, więc nic po Twojej stronie nie musi działać o tej godzinie.

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;
}

Jak odbierać komentarze i wiadomości w trasie Node.js?

Każdy kanał przekazuje zdarzenia pod adres, który podasz w PUT /channels/{id}/webhook. To wywołanie zwraca signing_secret kanału dokładnie raz. Każda dostawa to POST z polami platform, account_id, external_id i entry oraz nagłówkiem X-EC-Signature w formie t=<unix>,v1=<hex>, gdzie v1 to HMAC-SHA256 z t, kropki i surowej treści (raw body). Przed parsowaniem pobierz body jako tekst, odrzuć t starsze niż pięć minut i porównuj przez timingSafeEqual.

Dla Instagrama i Facebooka entry to wpis webhooka Meta w postaci, w jakiej Meta go wysłała: changes dla komentarzy i wzmianek, messaging dla wiadomości prywatnych. Dla TikToka zawiera zdarzenie comment.update, które TikTok wysyła w ciągu pięciu minut od utworzenia komentarza. Pola comment_id i video_id są w nim ciągami znaków, bo JavaScript nie może zaokrąglać tych 64-bitowych liczb. Każde zdarzenie ma jedną próbę dostawy i nie ma zapisanej kopii, więc odpowiedz od razu kodem 204 i przetwarzaj z kolejki.

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 });
}

Jak odpowiadać na komentarze i wiadomości z Node.js?

Świeżym wywołaniem credentials i identyfikatorami z danego zdarzenia. Na Instagramie i Facebooku odpowiedź na wiadomość idzie do /{account-id}/messages, z account_id_on_meta, z id nadawcy jako recipient, w ciągu 24 godzin od jego ostatniej wiadomości. Strona dodaje messaging_type RESPONSE, a Instagram przyjmuje najwyżej 1 000 bajtów tekstu. Komentarz dostaje publiczną odpowiedź pod /{comment-id}/replies na Instagramie lub /{comment-id}/comments na Facebooku, albo jedną prywatną odpowiedź w ciągu 7 dni.

Rozmowy na TikToku pozostają publiczne, bo na TikToku nie ma wiadomości prywatnych. business/comment/reply/create/, z nagłówkiem Access-Token, business_id, video_id i comment_id, publikuje odpowiedź do 1 200 znaków. Sprawdzaj pole code w odpowiedzi, gdzie 0 oznacza sukces, a nie status HTTP. Reaguj tylko na comment_action insert z comment_type comment, bo Twoje własne odpowiedzi też przychodzą jako zdarzenia.

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 },
      });
    }
  }
}

Jak publikować na TikToku i dać agentowi TypeScript te narzędzia?

Oba zadania przechodzą przez serwer MCP easyCoexistence pod https://easycoexistence.com/api/mcp, który przyjmuje wyłącznie OAuth 2.1: dynamiczną rejestrację klienta, kod autoryzacji z PKCE, tokeny dostępu ważne godzinę i tokeny odświeżające. Z @modelcontextprotocol/client, oficjalnym SDK TypeScript dla Node 20 i nowszych, OAuthClientProvider przechowuje klienta, tokeny i weryfikator PKCE. Pierwsze połączenie wysyła użytkownika do logowania i rzuca UnauthorizedError, a finishAuth z query z callbacku je dokańcza.

Publikowanie na TikToku działa tutaj, bo TikTok pobiera media wyłącznie spod prefiksów URL zweryfikowanych dla aplikacji developera stojącej za tokenem. publish_tiktok_post przyjmuje Twój link HTTPS i podaje TikTokowi podpisany adres na zweryfikowanej trasie mediów easyCoexistence, a get_tiktok_publish_status śledzi post. Ten sam klient przekazuje agentowi wszystkie narzędzia dla sieci konta. Najpierw wywołaj list_social_accounts, którego account_id to identyfikator kanału z Partner API.

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

Typowe błędy

  • Liczenie HMAC z przetworzonego i ponownie zserializowanego JSON. Podpis obejmuje surową treść bajt po bajcie, więc najpierw wywołaj req.text(), a parsuj potem, bo inaczej każda dostawa nie przejdzie weryfikacji.
  • Zamienianie identyfikatorów TikToka na liczby. Identyfikatory komentarzy i wideo mają 64 bity, a Number() je zaokrągla, więc przy odpowiedzi lub wyszukiwaniu komentarza zachowaj ciągi znaków, które niesie zdarzenie.
  • Zapisywanie tylko channel_id z przekierowania. Logowanie na Facebooka lub LinkedIn może dodać kilka stron naraz, więc wylistuj je przez GET /channels?external_ref= i zapisz każdą z nich.
  • Odpowiadanie na wiadomość z Messengera lub Instagrama z nocnej paczki. Po upływie 24 godzin od ostatniej wiadomości osoby wysyłka się nie uda, więc odpowiadaj z obsługi zdarzenia, dopóki okno jest otwarte.
Z EasyCoexistence zrobisz to

easyCoexistence daje backendom w Node.js i agentom AI dostęp do klientów na WhatsAppie, Instagramie, Facebooku, TikToku, YouTube, LinkedIn i kolejnych kanałach, każdym przez jego oficjalne API. Konta podłączysz przez Partner API, pobierzesz świeże tokeny i podpisane zdarzenia, a agenci TypeScript działają przez serwer MCP. Każde połączenie jest monitorowane całą dobę. Od US$ 9 do US$ 0,75 za połączenie miesięcznie, spadając wraz z dodawaniem połączeń, z pierwszymi 3 dniami za darmo.

Najczęściej zadawane pytania

Czy do wywoływania tych API z Node potrzebuję SDK?

Nie. Partner API oraz API sieci to zwykły HTTPS, więc globalne fetch w Node 18 i nowszych wystarczy. @modelcontextprotocol/client potrzebny jest tylko dla narzędzi MCP, w tym do publikowania na TikToku.

Dlaczego publikowanie na TikToku idzie przez serwer MCP?

TikTok pobiera filmy i zdjęcia wyłącznie z domeny lub prefiksu URL zweryfikowanego dla aplikacji developera, a ta aplikacja należy do easyCoexistence. publish_tiktok_post udostępnia Twój plik HTTPS spod tego zweryfikowanego adresu, więc Twoja własna domena nie wymaga weryfikacji.

Czy jedno logowanie może podłączyć kilka stron na Facebooku lub LinkedIn?

Tak. Każda strona, a na LinkedIn także własny profil członka, staje się osobnym kanałem i osobnym połączeniem. Przekierowanie niesie pierwszy channel_id, a GET /channels?external_ref= wylicza je wszystkie.

Ile kosztuje easyCoexistence dla Node.js?

Od US$ 9 do US$ 0,75 za połączenie miesięcznie, spadając wraz z dodawaniem połączeń, tak samo w każdej sieci. Partner API i konektor MCP są w cenie, bez opłat za użytkowników, a pierwsze 3 dni są bezpłatne.

Czytaj dalej

Połącz pierwszy kanał w dwie minuty.

Bez czekania na weryfikację przez platformy. Połącz WhatsApp, Instagram, TikTok lub inny kanał, a potem poproś swoją AI o opublikowanie posta, odpowiedź lub raport i zobacz, jak działa.

  • 3 dni za darmo
  • Rezygnacja w każdej chwili
  • Tylko oficjalne API
  • Monitorowanie 24/7

Zweryfikowano w