Iniciar sessãoIniciar teste gratuito
easyCoexistence APIs oficiais

Publicar no Instagram, TikTok e Facebook a partir de Node.js com uma só API

Com a easyCoexistence, um backend em Node.js ou TypeScript publica no Instagram, Facebook, TikTok, YouTube e LinkedIn através da API oficial de cada rede. As contas iniciam sessão uma única vez através de uma ligação alojada; depois, um único fetch devolve um token novo para cada tarefa no TikTok, no YouTube e no LinkedIn, e os eventos assinados levam os comentários e as mensagens diretas até à sua rota. Os agentes criados com o SDK MCP para TypeScript recebem as mesmas contas como ferramentas.

15 a day

Número de publicações de vídeo que o endpoint de publicação do TikTok aceita por conta, no máximo seis por minuto.

10 min to 30 days

Com quanta antecedência uma publicação numa Página do Facebook pode ser agendada com published false e um scheduled_publish_time.

x-restli-id

O cabeçalho de resposta que transporta o URN de uma nova publicação no LinkedIn, enviado com o estado 201.

5 minutes

Com que rapidez o TikTok dispara um evento comment.update depois de um comentário ser criado, eliminado ou de a sua visibilidade ser alterada.

1 hour

Durante quanto tempo uma ligação da Partner API permanece aberta antes de a sessão expirar.

Como é que um backend em Node.js liga contas e obtém os respetivos tokens?

O seu backend abre uma sessão de ligação, e o titular da conta conclui o processo no navegador. Um pedido POST para /connect-sessions, com a sua chave ec_live_ como token bearer, um canal como tiktok ou linkedin, um redirect_url e um external_ref para o seu cliente, devolve um url em easycoexistence.com. Aí, o titular inicia sessão no ecrã de consentimento da própria rede e regressa ao seu redirect_url com status=connected e um channel_id; uma tentativa cancelada pode ser repetida a partir da mesma ligação até expirar, uma hora depois de ter sido criada.

Cada tarefa começa depois com GET /channels/{id}?credentials=1. A resposta contém um token válido neste momento (não no Instagram nem no Facebook, cujos tokens nunca são entregues), mais os campos que cada rede exige: graph_api_base e account_id_on_meta no Instagram e no Facebook, api_base e business_id no TikTok, channel_id no YouTube, author_urn e required_headers no LinkedIn. Os eventos assinados channel.connected, channel.disconnected, channel.removed e channel.suspended, enviados para o URL de eventos definido no seu painel, informam a sua aplicação sempre que uma conta muda.

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

Como publicar no Instagram e no Facebook a partir de Node.js?

O Instagram publica através de um contentor. Para um Reel, crie-o com media_type REELS, o video_url e a legenda, consulte o seu status_code até indicar FINISHED e depois chame media_publish com o id do contentor como creation_id. A Meta recomenda consultar cerca de uma vez por minuto e desistir ao fim de cinco minutos; ERROR ou EXPIRED significa que o contentor não será publicado, e um contentor que fique por publicar durante 24 horas expira por si só.

Uma Página do Facebook publica uma foto numa só chamada a /{page-id}/photos, com o url da imagem e uma legenda, enquanto o texto e as ligações vão para /{page-id}/feed. Ambas aceitam published false com um scheduled_publish_time, e é a própria Meta que publica a publicação na hora marcada, com uma antecedência de entre 10 minutos e 30 dias. O token segue num cabeçalho bearer, a versão da Graph API já está dentro de graph_api_base, e o ficheiro multimédia tem de estar num URL público que a Meta transfere.

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

Como publicar no LinkedIn e carregar para o YouTube a partir de Node.js?

O LinkedIn exige dois cabeçalhos, para além do token bearer, em cada chamada: LinkedIn-Version, com o valor YYYYMM que a easyCoexistence devolve em required_headers, e X-Restli-Protocol-Version com o valor 2.0.0. Uma publicação é um POST para /rest/posts com o URN do autor, o texto como commentary, visibilidade PUBLIC, o feed principal como distribution e lifecycleState PUBLISHED. O LinkedIn responde com 201 e coloca o URN da nova publicação no cabeçalho x-restli-id, e qualquer URN colocado num caminho de URL tem de ser codificado em URL.

O YouTube exige dois pedidos. Um POST para o endpoint de carregamento com uploadType=resumable e part=snippet,status envia os metadados e devolve o endereço da sessão no cabeçalho Location; um PUT dos bytes do ficheiro para esse endereço devolve o recurso de vídeo com o seu id. Carregar como private com uma data publishAt deixa a publicação a cargo do agendador do próprio YouTube, pelo que nada do seu sistema tem de correr nessa hora.

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

Como receber comentários e mensagens diretas numa rota Node.js?

Cada canal reencaminha para o URL que indicar em PUT /channels/{id}/webhook, e esse pedido devolve o signing_secret do canal uma única vez. Cada entrega é um POST com platform, account_id, external_id e entry, e um cabeçalho X-EC-Signature no formato t=<unix>,v1=<hex>, em que v1 é o HMAC-SHA256 de t, de um ponto e do corpo em bruto. Leia o corpo como texto antes de o interpretar, rejeite um t mais antigo do que cinco minutos e compare com timingSafeEqual.

No Instagram e no Facebook, entry é a entrada de webhook da Meta tal como a Meta a enviou: changes para comentários e menções, messaging para mensagens diretas. No TikTok contém o evento comment.update, que o TikTok dispara até cinco minutos depois de um comentário, com comment_id e video_id como strings, para que o JavaScript não arredonde esses números de 64 bits. Existe uma única tentativa por evento e não há cópia guardada, por isso responda 204 de imediato e processe a partir de uma fila.

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

Como responder a comentários e mensagens diretas a partir de Node.js?

Com uma nova chamada de credenciais e os ids do evento. No Instagram e no Facebook, a resposta a uma mensagem direta vai para /{account-id}/messages, usando account_id_on_meta, com o id do remetente como recipient e dentro de 24 horas desde a última mensagem dessa pessoa; uma Página acrescenta messaging_type RESPONSE, e o Instagram permite no máximo 1 000 bytes de texto. Um comentário recebe uma resposta pública, em /{comment-id}/replies no Instagram ou /{comment-id}/comments no Facebook, ou uma única resposta privada no prazo de 7 dias.

As conversas no TikTok ficam sempre públicas, porque não existem mensagens diretas no TikTok. business/comment/reply/create/, com o cabeçalho Access-Token, business_id, video_id e comment_id, publica uma resposta com até 1 200 caracteres. Leia o campo code da resposta, em que 0 significa sucesso, e não o estado HTTP. Atue apenas sobre comment_action insert com comment_type comment, porque as suas próprias respostas também chegam como eventos.

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

Como publicar no TikTok e dar a um agente TypeScript estas ferramentas?

Ambos passam pelo servidor MCP da easyCoexistence em https://easycoexistence.com/api/mcp, que aceita apenas OAuth 2.1: registo dinâmico de cliente, código de autorização com PKCE, tokens de acesso que duram uma hora e tokens de atualização. Com @modelcontextprotocol/client, o SDK oficial para TypeScript em Node 20 ou posterior, um OAuthClientProvider guarda o cliente, os tokens e o verificador PKCE; a primeira ligação envia o utilizador para iniciar sessão e lança UnauthorizedError, e finishAuth com os parâmetros de consulta do retorno de chamada conclui o processo.

A publicação no TikTok faz-se aqui porque o TikTok só transfere ficheiros multimédia a partir de prefixos de URL verificados para a aplicação de programador por detrás do token. publish_tiktok_post recebe o seu link HTTPS e entrega ao TikTok um endereço assinado na rota de multimédia verificada da easyCoexistence, e get_tiktok_publish_status acompanha a publicação. O mesmo cliente entrega ao agente todas as ferramentas das redes da conta; chame primeiro list_social_accounts, cujo account_id é o id do canal da 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

Erros comuns

  • Calcular o HMAC sobre JSON analisado e serializado de novo. A assinatura cobre o corpo em bruto byte a byte, por isso chame primeiro req.text() e analise depois, ou todas as entregas falham a verificação.
  • Converter ids do TikTok em números. Os ids de comentário e de vídeo têm 64 bits e Number() arredonda-os, por isso mantenha as strings que o evento traz ao responder ou procurar um comentário.
  • Manter apenas o channel_id do redirecionamento. Um início de sessão no Facebook ou no LinkedIn pode adicionar várias Páginas de uma só vez, por isso liste-as com GET /channels?external_ref= e guarde cada uma.
  • Responder a uma mensagem do Messenger ou do Instagram a partir de um lote noturno. Fora das 24 horas desde a última mensagem da pessoa, o envio falha, por isso responda a partir do manipulador de eventos enquanto a janela estiver aberta.
Fazer isto com a EasyCoexistence

A easyCoexistence permite a backends em Node.js e a agentes de IA chegar aos seus clientes no WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn e mais canais, cada um através da respetiva API oficial. Ligue contas com a Partner API, obtenha tokens novos e eventos assinados, e deixe os agentes TypeScript atuar através do servidor MCP, com cada ligação monitorizada 24/7. De US$ 9 até US$ 0.75 por ligação por mês, a descer à medida que acrescenta ligações, com os primeiros 3 dias grátis.

Perguntas frequentes

Preciso de um SDK para chamar estas APIs a partir de Node?

Não. A Partner API e as APIs das redes são HTTPS simples, por isso o fetch global do Node 18 e versões posteriores basta. O @modelcontextprotocol/client só entra para as ferramentas MCP, entre as quais a publicação no TikTok.

Porque é que a publicação no TikTok passa pelo servidor MCP?

O TikTok transfere vídeos e fotografias apenas a partir de um domínio ou prefixo de URL verificado para a aplicação de programador, e essa aplicação é da easyCoexistence. publish_tiktok_post serve o seu ficheiro HTTPS a partir desse endereço verificado, por isso o seu próprio domínio não precisa de verificação.

Um único início de sessão pode ligar várias Páginas do Facebook ou do LinkedIn?

Sim. Cada Página, e no LinkedIn o perfil do próprio membro, torna-se um canal próprio e uma ligação própria. O redirecionamento traz o primeiro channel_id, e GET /channels?external_ref= lista todos.

Quanto custa a easyCoexistence para Node.js?

De US$ 9 até US$ 0.75 por ligação por mês, a descer à medida que acrescenta ligações, e o mesmo em todas as redes. A Partner API e o conector MCP estão incluídos, sem licenças por utilizador, e os primeiros 3 dias são grátis.

Continue a ler

Ligue o seu primeiro canal em dois minutos.

Sem revisões de plataformas para esperar. Ligue o WhatsApp, o Instagram, o TikTok ou outro canal, peça depois à sua IA que publique, responda ou faça um relatório, e veja-a trabalhar.

  • 3 dias grátis
  • Cancele quando quiser
  • Só APIs oficiais
  • Monitorizado 24/7

Verificado em