Prijavite seZapočnite besplatno probno razdoblje
easyCoexistence Službeni API-ji

Objavljujte na Instagramu, TikToku i Facebooku iz Node.js-a jednim API-jem

Uz easyCoexistence, backend u Node.js-u ili TypeScriptu objavljuje na Instagramu, Facebooku, TikToku, YouTubeu i LinkedInu putem službenog API-ja svake mreže. Računi se prijavljuju jednom, kroz poveznicu na našoj stranici; jedan fetch zatim vraća svjež token za svaki posao na TikToku, YouTubeu i LinkedInu, a potpisani događaji komentare i DM-ove dovode do vaše rute. Agenti izgrađeni na TypeScript MCP SDK-u dobivaju iste račune kao alate.

15 a day

Videozapisi koje TikTokov endpoint za objavljivanje prihvaća po računu, najviše šest u minuti.

10 min to 30 days

Koliko unaprijed se objava na Facebook stranici može zakazati s published false i scheduled_publish_time.

x-restli-id

Zaglavlje odgovora koje nosi URN nove LinkedIn objave, poslano sa statusom 201.

5 minutes

Koliko brzo TikTok šalje događaj comment.update nakon što se komentar stvori, obriše ili promijeni mu se vidljivost.

1 hour

Koliko dugo poveznica za povezivanje Partner API-ja ostaje otvorena prije nego joj sesija istekne.

Kako backend u Node.js-u povezuje račune i dobiva njihove tokene?

Vaš backend otvara sesiju povezivanja, a vlasnik računa dovršava postupak u pregledniku. POST na /connect-sessions, s vašim ključem ec_live_ kao bearer tokenom, kanalom poput tiktok ili linkedin, redirect_url i external_ref za vašeg kupca, vraća url na easycoexistence.com. Tamo se vlasnik prijavljuje na zaslonu za suglasnost same mreže i vraća na vaš redirect_url sa status=connected i channel_id. Neuspjeli pokušaj može se ponoviti s iste poveznice do isteka, sat nakon stvaranja.

Svaki posao zatim počinje s GET /channels/{id}?credentials=1. Odgovor sadrži token koji vrijedi odmah (ne na Instagramu i Facebooku, čiji se tokeni nikad ne izdaju) te polja koja svaka mreža traži: graph_api_base i account_id_on_meta na Instagramu i Facebooku, api_base i business_id na TikToku, channel_id na YouTubeu, author_urn i required_headers na LinkedInu. Potpisani događaji channel.connected, channel.disconnected, channel.removed i channel.suspended, poslani na URL za događaje postavljen u vašoj nadzornoj ploči, govore vašoj aplikaciji kada se račun promijeni.

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

Kako iz Node.js-a objavljivati na Instagramu i Facebooku?

Instagram objavljuje preko kontejnera. Za Reel ga stvorite s media_type REELS, video_url i caption, ispitujte status_code dok ne piše FINISHED, zatim pozovite media_publish s ID-jem kontejnera kao creation_id. Meta preporučuje provjeru otprilike jednom u minuti i odustajanje nakon pet minuta. ERROR ili EXPIRED znači da kontejner neće biti objavljen, a onaj neobjavljen 24 sata ističe sam od sebe.

Facebook stranica prima fotografiju jednim pozivom na /{page-id}/photos, s url-om slike i opisom, dok se tekst i poveznice šalju na /{page-id}/feed. Oba prihvaćaju published false sa scheduled_publish_time, a sama Meta objavljuje objavu kada dođe vrijeme, između 10 minuta i 30 dana unaprijed. Token ide kao bearer zaglavlje, verzija Graph API-ja već je u graph_api_base, a medij mora biti na javnom URL-u koji Meta preuzima.

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

Kako iz Node.js-a objavljivati na LinkedInu i učitavati na YouTube?

LinkedIn uz bearer token na svakom pozivu traži još dva zaglavlja: LinkedIn-Version, s vrijednošću YYYYMM koju easyCoexistence vraća u required_headers, te X-Restli-Protocol-Version postavljen na 2.0.0. Objava je POST na /rest/posts s URN-om autora, tekstom kao commentary, vidljivošću PUBLIC, glavnim feedom kao distribution i lifecycleState PUBLISHED. LinkedIn odgovara statusom 201 i stavlja URN nove objave u zaglavlje x-restli-id. Svaki URN stavljen u putanju URL-a mora biti URL-kodiran.

YouTube traži dva zahtjeva. POST na upload endpoint s uploadType=resumable i part=snippet,status šalje metapodatke i u zaglavlju Location vraća adresu sesije. PUT bajtova datoteke na tu adresu vraća resurs videozapisa s njegovim id-jem. Učitavanje kao privatnog videozapisa s datumom publishAt prepušta objavu vlastitom rasporedu YouTubea, pa ništa vaše ne mora raditi u taj sat.

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

Kako u Node.js ruti primati komentare i DM-ove?

Svaki kanal šalje događaje na URL koji zadate pozivom PUT /channels/{id}/webhook, a taj poziv jednom vraća signing_secret kanala. Svaka isporuka je POST s poljima platform, account_id, external_id i entry, te zaglavljem X-EC-Signature oblika t=<unix>,v1=<hex>. Pritom je v1 HMAC-SHA256 od t, točke i sirovog tijela. Tijelo uzmite kao tekst prije parsiranja, odbijte t stariji od pet minuta i uspoređujte s timingSafeEqual.

Za Instagram i Facebook, entry je Metin webhook entry onakav kakav je Meta poslala: changes za komentare i spominjanja, messaging za DM-ove. Za TikTok sadrži događaj comment.update, koji TikTok šalje unutar pet minuta od komentara, s comment_id i video_id kao stringovima da JavaScript ne zaokruži ta 64-bitna broja. Postoji jedan pokušaj po događaju i nema pohranjene kopije, zato odmah odgovorite 204, a obradu radite iz reda čekanja.

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

Kako iz Node.js-a odgovarati na komentare i DM-ove?

Svježim pozivom za vjerodajnice i ID-jevima iz događaja. Na Instagramu i Facebooku odgovor na DM šalje se na /{account-id}/messages, koristeći account_id_on_meta, s ID-jem pošiljatelja kao recipient i unutar 24 sata od njihove zadnje poruke. Stranica dodaje messaging_type RESPONSE, a Instagram dopušta najviše 1.000 bajtova teksta. Komentar dobiva javni odgovor, na /{comment-id}/replies na Instagramu ili /{comment-id}/comments na Facebooku, ili jedan privatni odgovor unutar 7 dana.

Razgovori na TikToku ostaju javni, jer na TikToku nema DM-ova. business/comment/reply/create/, sa zaglavljem Access-Token, business_id, video_id i comment_id, objavljuje odgovor do 1.200 znakova. Čitajte polje code u odgovoru, gdje 0 znači uspjeh, a ne HTTP status. Djelujte samo na comment_action insert s comment_type comment, jer i vaši odgovori stižu kao događaji.

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

Kako objavljivati na TikToku i dati TypeScript agentu ove alate?

Oboje ide preko easyCoexistence MCP servera na https://easycoexistence.com/api/mcp, koji prihvaća samo OAuth 2.1: dinamičku registraciju klijenta, kod za autorizaciju s PKCE-om, pristupne tokene koji traju sat vremena i tokene za osvježavanje. S @modelcontextprotocol/client, službenim TypeScript SDK-om za Node 20 i novije, OAuthClientProvider drži klijenta, tokene i PKCE verifier. Prvo povezivanje šalje korisnika na prijavu i baca UnauthorizedError, a finishAuth s upitom iz povratnog poziva to dovršava.

Objavljivanje na TikToku je ovdje jer TikTok preuzima medije samo s URL prefiksa provjerenih za razvojnu aplikaciju iza tokena. publish_tiktok_post uzima vašu HTTPS poveznicu i TikToku daje potpisanu adresu na provjerenoj medijskoj ruti easyCoexistencea, a get_tiktok_publish_status prati objavu. Isti klijent agentu predaje svaki alat za mreže računa. Prvo pozovite list_social_accounts, čiji account_id je channel_id iz Partner API-ja.

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

Uobičajene pogreške

  • Računanje HMAC-a nad parsiranim i ponovno serijaliziranim JSON-om. Potpis pokriva sirovo tijelo bajt po bajt, zato prvo pozovite req.text(), pa tek onda parsirajte, inače svaka isporuka propada provjeru.
  • Pretvaranje TikTok ID-jeva u brojeve. ID-jevi komentara i videozapisa su 64-bitni, a Number() ih zaokružuje, pa zadržite stringove koje događaj nosi kad odgovarate ili tražite komentar.
  • Zadržavanje samo channel_id iz preusmjeravanja. Prijava na Facebooku ili LinkedInu može odjednom dodati više stranica, zato ih izlistajte s GET /channels?external_ref= i spremite svaku.
  • Odgovaranje na Messenger ili Instagram DM iz noćne skupne obrade. Nakon 24 sata od zadnje poruke osobe slanje ne uspijeva, pa odgovarajte iz handlera događaja dok je prozor otvoren.
Radite ovo uz EasyCoexistence

easyCoexistence daje backendima u Node.js-u i AI agentima doseg do kupaca na WhatsAppu, Instagramu, Facebooku, TikToku, YouTubeu, LinkedInu i još kanala, svaki preko službenog API-ja. Račune povezujete putem Partner API-ja, dobivate svježe tokene i potpisane događaje, a TypeScript agenti djeluju kroz MCP server, pri čemu se svaka veza prati 24/7. Od US$ 9 do US$ 0,75 po vezi mjesečno, uz sniženje kako dodajete veze, te besplatno probno razdoblje od prva 3 dana.

Često postavljana pitanja

Trebam li SDK za pozivanje ovih API-ja iz Node-a?

Ne. Partner API i API-ji mreža su obični HTTPS, pa ih pokriva globalni fetch u Node 18 i novijima. @modelcontextprotocol/client dolazi samo za MCP alate, među kojima je i objavljivanje na TikToku.

Zašto objavljivanje na TikToku ide preko MCP servera?

TikTok preuzima videozapise i fotografije samo s domene ili URL prefiksa provjerenog za razvojnu aplikaciju, a ta aplikacija je easyCoexistenceova. publish_tiktok_post poslužuje vašu HTTPS datoteku s te provjerene adrese, pa vaša vlastita domena ne treba provjeru.

Može li jedna prijava povezati više Facebook ili LinkedIn stranica?

Može. Svaka stranica, a na LinkedInu i vlastiti profil člana, postaje zaseban kanal i zasebna veza. Preusmjeravanje nosi prvi channel_id, a GET /channels?external_ref= ih izlistava sve.

Koliko košta easyCoexistence za Node.js?

Od US$ 9 do US$ 0,75 po vezi mjesečno, uz sniženje kako dodajete veze, i isto na svakoj mreži. Partner API i MCP konektor dolaze uz to, bez naplate po korisniku, a prva 3 dana su besplatna.

Nastavite čitati

Povežite svoj prvi kanal u dvije minute.

Bez čekanja na provjere platformi. Povežite WhatsApp, Instagram, TikTok ili drugi kanal, zatim zamolite svoju umjetnu inteligenciju da objavi, odgovori ili izradi izvješće i gledajte kako radi.

  • 3 dana besplatno
  • Otkažite bilo kada
  • Samo službeni API-ji
  • Nadzor 24/7

Provjereno na