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.
Filmy, które endpoint publikacji TikToka przyjmuje dla każdego konta, w ilości nie większej niż sześć na minutę.
Jak daleko w przód można zaplanować post na stronie na Facebooku z published false i scheduled_publish_time.
Nagłówek odpowiedzi, który niesie URN nowego posta na LinkedIn, wysyłany ze statusem 201.
Jak szybko TikTok wysyła zdarzenie comment.update po utworzeniu, usunięciu lub zmianie widoczności komentarza.
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.
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.
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.
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.
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.
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.
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_statusTypowe 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.
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