Mag-log inMagsimula ng Libreng Trial
easyCoexistence Mga Official API

Mag-post sa Instagram, TikTok at Facebook mula sa Node.js gamit ang iisang API

Sa easyCoexistence, ang backend na Node.js o TypeScript ay nagpo-post sa Instagram, Facebook, TikTok, YouTube at LinkedIn sa pamamagitan ng opisyal na API ng bawat network. Nagsa-sign in ang mga account nang isang beses sa hosted link; pagkatapos, isang fetch lang ang magbabalik ng bagong token para sa bawat job sa TikTok, YouTube at LinkedIn, at ang mga signed event ang magdadala ng mga comment at DM sa inyong route. Ang mga agent na gawa sa TypeScript MCP SDK ay makakakuha ng parehong account bilang tools.

15 a day

Video post na tinatanggap ng publishing endpoint ng TikTok bawat account, hindi lalampas sa anim kada minuto.

10 min to 30 days

Gaano kalayo sa hinaharap maaaring i-schedule ang Facebook Page post kapag published false at may scheduled_publish_time.

x-restli-id

Response header na may dalang URN ng bagong LinkedIn post, ipinadala na may 201 status.

5 minutes

Gaano kabilis magpapadala ang TikTok ng comment.update event pagkatapos mabuo, mabura, o mapalitan ang visibility ng comment.

1 hour

Gaano katagal bukas ang Partner API connect link bago mag-expire ang session nito.

Paano kumokonekta ang Node.js backend sa mga account at kumukuha ng kanilang token?

Nagbubukas ang inyong backend ng connect session, at tatapusin ng may-ari ng account sa browser. Ang POST sa /connect-sessions, na may inyong ec_live_ key bilang bearer token, channel gaya ng tiktok o linkedin, redirect_url, at external_ref para sa customer ninyo, ay magbabalik ng url sa easycoexistence.com. Doon, mag-si-sign in ang may-ari sa sariling consent screen ng network at babalik sa inyong redirect_url na may status=connected at channel_id; ang cancelled na subok ay puwedeng ulitin mula sa parehong link hanggang mag-expire ito, isang oras matapos itong gawin.

Bawat job ay nagsisimula sa GET /channels/{id}?credentials=1. Ang sagot ay naglalaman ng token na valid na ngayon (hindi sa Instagram at Facebook, na hindi kailanman ibinibigay ang token), kasama ang mga field na kailangan ng bawat network: graph_api_base at account_id_on_meta sa Instagram at Facebook, api_base at business_id sa TikTok, channel_id sa YouTube, author_urn at required_headers sa LinkedIn. Ang mga signed na event na channel.connected, channel.disconnected, channel.removed at channel.suspended, na ipinapadala sa events URL na itinakda ninyo sa dashboard, ang nagsasabi sa app ninyo kapag may nagbago sa account.

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

Paano mag-post sa Instagram at Facebook gamit ang Node.js?

Nagpo-publish ang Instagram sa pamamagitan ng container. Para sa Reel, gumawa nito gamit ang media_type REELS, ang video_url at ang caption, i-poll ang status_code hanggang maging FINISHED, saka tawagin ang media_publish na may container id bilang creation_id. Inirerekomenda ng Meta ang pag-poll nang humigit-kumulang isang beses kada minuto at pagsuko pagkalipas ng limang minuto; ang ERROR o EXPIRED ay nangangahulugang hindi ito mapo-publish, at ang container na hindi nai-publish sa loob ng 24 oras ay kusang mag-e-expire.

Kumukuha ang Facebook Page ng larawan sa isang tawag lang sa /{page-id}/photos, may image url at caption, habang ang text at link ay napupunta sa /{page-id}/feed. Parehong tumatanggap ng published false na may scheduled_publish_time, at ang Meta mismo ang mag-pa-publish ng post kapag dumating ang oras, sa pagitan ng 10 minuto at 30 araw mula ngayon. Ang token ay ipinapadala bilang bearer header, nasa loob na ng graph_api_base ang bersyon ng Graph API, at ang media ay dapat nasa public URL na dina-download ng Meta.

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

Paano mag-post sa LinkedIn at mag-upload sa YouTube gamit ang Node.js?

Kailangan ng LinkedIn ang dalawang header bukod sa bearer token sa bawat tawag: LinkedIn-Version, na may halagang YYYYMM na ibinabalik ng easyCoexistence sa required_headers, at X-Restli-Protocol-Version na nakatakda sa 2.0.0. Ang post ay POST sa /rest/posts na may author URN, ang teksto bilang commentary, PUBLIC na visibility, ang main feed bilang distribution, at lifecycleState na PUBLISHED. Sumasagot ang LinkedIn ng 201 at inilalagay ang URN ng bagong post sa x-restli-id header; anumang URN na ilalagay sa URL path ay dapat naka-URL-encode.

Dalawang request ang kailangan ng YouTube. Ang POST sa upload endpoint na may uploadType=resumable at part=snippet,status ay nagpapadala ng metadata at nagbabalik ng session address sa Location header nito; ang PUT ng bytes ng file sa address na iyon ay nagbabalik ng video resource na may id nito. Kapag ina-upload bilang private na may publishAt na petsa, ang pag-publish ay iniiwan sa scheduler ng YouTube, kaya walang kailangang tumakbo sa inyong panig sa oras na iyon.

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

Paano tumanggap ng comment at DM sa Node.js route?

Ipinapasa ng bawat channel ang mga event sa URL na ibinigay ninyo sa PUT /channels/{id}/webhook, at minsan lang ibinabalik ng tawag na iyon ang signing_secret ng channel. Ang bawat delivery ay POST na may platform, account_id, external_id at entry, kasama ang X-EC-Signature header na may hugis na t=<unix>,v1=<hex>, kung saan ang v1 ay HMAC-SHA256 ng t, isang tuldok, at ng raw body. Kunin muna ang body bilang text bago i-parse, tanggihan ang t na mas luma sa limang minuto, at ikumpara gamit ang timingSafeEqual.

Para sa Instagram at Facebook, ang entry ay ang webhook entry ng Meta gaya ng ipinadala nito: changes para sa comment at mention, messaging para sa DM. Para sa TikTok, nandoon ang comment.update event, na ipinapadala ng TikTok sa loob ng limang minuto mula sa comment, kasama ang comment_id at video_id bilang string para hindi ma-round off ng JavaScript ang 64-bit na numerong iyon. Isang beses lang sinusubukan ang bawat event at walang nakaimbak na kopya, kaya sagutin agad ng 204 at iproseso mula sa queue.

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

Paano sumagot sa comment at DM mula sa Node.js?

Gamit ang bagong tawag sa credentials at ang mga id sa event. Sa Instagram at Facebook, ang DM reply ay napupunta sa /{account-id}/messages, gamit ang account_id_on_meta, na may sender id bilang recipient, at dapat sa loob ng 24 oras mula sa huling mensahe nila; nagdaragdag ang Page ng messaging_type RESPONSE, at hanggang 1,000 bytes ng teksto lang ang pinapayagan ng Instagram. Ang comment ay tumatanggap ng pampublikong reply, sa /{comment-id}/replies sa Instagram o /{comment-id}/comments sa Facebook, o isang private reply sa loob ng 7 araw.

Nananatiling pampubliko ang usapan sa TikTok, dahil walang DM sa TikTok. Ang business/comment/reply/create/, na may Access-Token header, business_id, video_id at comment_id, ay nagpo-post ng reply na hanggang 1,200 characters. Basahin ang code field ng sagot, kung saan ang 0 ay tagumpay, sa halip na HTTP status. Kumilos lamang sa comment_action na insert na may comment_type comment, dahil dumarating din bilang event ang sarili ninyong mga reply.

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

Paano mag-post sa TikTok at bigyan ng TypeScript agent ang mga tool na ito?

Pareho itong dumadaan sa MCP server ng easyCoexistence sa https://easycoexistence.com/api/mcp, na tumatanggap lang ng OAuth 2.1: dynamic client registration, authorization code na may PKCE, access token na tumatagal ng isang oras, at refresh token. Gamit ang @modelcontextprotocol/client, ang opisyal na TypeScript SDK para sa Node 20 pataas, hawak ng OAuthClientProvider ang client, ang mga token at ang PKCE verifier; sa unang connect, ipinapadala ang user para mag-sign in at naghahagis ng UnauthorizedError, at kinukumpleto ito ng finishAuth gamit ang query ng callback.

Nandito ang TikTok publishing dahil dina-download lang ng TikTok ang media mula sa mga URL prefix na na-verify para sa developer app sa likod ng token. Kinukuha ng publish_tiktok_post ang inyong HTTPS link at binibigyan ang TikTok ng naka-sign na address sa verified media route ng easyCoexistence, at sinusundan ng get_tiktok_publish_status ang post. Ang parehong client ay nagbibigay sa agent ng bawat tool para sa mga network ng account; tawagin muna ang list_social_accounts, na ang account_id ay ang channel id ng 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

Mga karaniwang pagkakamali

  • Pagkalkula ng HMAC sa parsed at muling na-serialize na JSON. Ang signature ay sumasaklaw sa raw body, byte sa byte, kaya tawagin muna ang req.text() at saka i-parse, o babagsak ang bawat delivery sa check.
  • Pag-convert ng TikTok id sa numero. Ang comment at video id ay 64-bit at niroround ng Number(), kaya panatilihin ang mga string na dala ng event kapag sumasagot o naghahanap ng comment.
  • Pag-iimbak lang ng channel_id mula sa redirect. Maaaring magdagdag ng ilang Page nang sabay ang sign-in sa Facebook o LinkedIn, kaya ilista ang mga ito gamit ang GET /channels?external_ref= at i-store ang bawat isa.
  • Pagsagot sa Messenger o Instagram DM mula sa nightly batch. Kapag lampas na sa 24 oras mula sa huling mensahe ng tao, babagsak ang pagpapadala, kaya sumagot mula sa event handler habang bukas pa ang window.
Ginagawa ito gamit ang EasyCoexistence

Binibigyan ng easyCoexistence ang mga backend ng Node.js at AI agent ng abot sa mga customer sa WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn at iba pang channel, bawat isa sa pamamagitan ng opisyal nitong API. Ikonekta ang mga account gamit ang Partner API, kumuha ng bagong token at signed na event, at hayaang kumilos ang mga TypeScript agent sa pamamagitan ng MCP server, habang binabantayan ang bawat koneksyon 24/7. US$ 9 hanggang US$ 0.75 kada koneksyon kada buwan, bumababa habang dumarami ang mga koneksyon, at libre ang unang 3 araw.

Mga madalas itanong

Kailangan ko ba ng SDK para tawagin ang mga API na ito mula sa Node?

Hindi. Ang Partner API at ang API ng mga network ay plain HTTPS, kaya sapat na ang global fetch sa Node 18 pataas. Ang @modelcontextprotocol/client ay kailangan lang para sa MCP tools, kasama ang TikTok publishing.

Bakit dumadaan sa MCP server ang TikTok publishing?

Dina-download lang ng TikTok ang mga video at larawan mula sa domain o URL prefix na na-verify para sa developer app, at app ng easyCoexistence ang app na iyon. Inihahain ng publish_tiktok_post ang HTTPS file ninyo mula sa na-verify na address, kaya hindi na kailangan ng sariling domain ng verification.

Puwede bang ikonekta ng isang sign-in ang ilang Facebook o LinkedIn Page?

Oo. Ang bawat Page, at sa LinkedIn ang sariling profile ng miyembro, ay nagiging sariling channel at sariling koneksyon. Dala ng redirect ang unang channel_id, at inililista ng GET /channels?external_ref= ang lahat ng ito.

Magkano ang easyCoexistence para sa Node.js?

US$ 9 hanggang US$ 0.75 kada koneksyon kada buwan, bumababa habang dumarami ang koneksyon, at pareho ito sa lahat ng network. Kasama ang Partner API at ang MCP connector, walang seat, at libre ang unang 3 araw.

Magpatuloy sa pagbabasa

I-connect ang inyong unang channel sa loob ng dalawang minuto.

Walang review ng platform na hihintayin. I-connect ang WhatsApp, Instagram, TikTok o iba pang channel, pagkatapos ay utusan ang inyong AI na mag-post, mag-reply o gumawa ng report, at panoorin itong gumana.

  • 3 araw na libre
  • Mag-cancel anumang oras
  • Official API lang
  • Minomonitor 24/7

Na-verify noong