EntrarComeçar teste grátis
easyCoexistence APIs oficiais

Publique no Instagram, TikTok e Facebook a partir de Node.js com uma única API

Com o easyCoexistence, um backend em Node.js ou TypeScript publica no Instagram, Facebook, TikTok, YouTube e LinkedIn pela API oficial de cada rede. As contas são conectadas uma vez por um link hospedado; uma única chamada fetch então retorna um token novo para cada tarefa no TikTok, no YouTube e no LinkedIn, e eventos assinados levam comentários e DMs até sua rota. Agentes criados com o SDK MCP em TypeScript recebem as mesmas contas como ferramentas.

15 a day

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

10 min to 30 days

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

x-restli-id

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

5 minutes

Em quanto tempo o TikTok dispara um evento comment.update depois que um comentário é criado, excluído ou tem a visibilidade alterada.

1 hour

Por quanto tempo um link de conexão da Partner API fica aberto antes que a sessão expire.

Como um backend em Node.js conecta contas e obtém seus tokens?

Seu backend abre uma sessão de conexão e o titular da conta conclui no navegador. Um POST para /connect-sessions, com sua chave ec_live_ como bearer token, um canal como tiktok ou linkedin, um redirect_url e um external_ref para seu cliente, retorna uma url em easycoexistence.com. Lá o titular entra na tela de consentimento da própria rede e volta para seu redirect_url com status=connected e um channel_id; uma tentativa cancelada pode ser repetida pelo mesmo link até expirar, uma hora depois de criada.

Cada tarefa então começa com GET /channels/{id}?credentials=1. A resposta traz um token válido agora (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. Eventos assinados channel.connected, channel.disconnected, channel.removed e channel.suspended, enviados para a URL de eventos definida no seu painel, avisam seu app quando 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 por meio de um container. Para um Reel, crie-o com media_type REELS, o video_url e a legenda, consulte seu status_code até aparecer FINISHED e então chame media_publish com o id do container como creation_id. A Meta recomenda consultar cerca de uma vez por minuto e desistir após cinco minutos; ERROR ou EXPIRED significa que o container não será publicado, e um container não publicado por 24 horas expira sozinho.

Uma Página do Facebook recebe uma foto em uma só chamada para /{page-id}/photos, com a url da imagem e uma legenda, enquanto textos e links vão para /{page-id}/feed. Ambos aceitam published false com scheduled_publish_time, e a própria Meta publica a postagem na hora marcada, entre 10 minutos e 30 dias à frente. O token segue como cabeçalho bearer, a versão da Graph API já está dentro de graph_api_base, e a mídia precisa estar em uma URL pública que a Meta baixa.

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 enviar vídeos ao YouTube a partir de Node.js?

O LinkedIn exige dois cabeçalhos além do bearer token em toda chamada: LinkedIn-Version, com o valor YYYYMM que o easyCoexistence devolve em required_headers, e X-Restli-Protocol-Version com 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 201 e coloca o URN da nova publicação no cabeçalho x-restli-id; qualquer URN colocado no caminho de uma URL precisa ser codificado em URL.

O YouTube exige duas requisições. Um POST ao endpoint de upload com uploadType=resumable e part=snippet,status envia os metadados e retorna o endereço da sessão no cabeçalho Location; um PUT dos bytes do arquivo para esse endereço retorna o recurso do vídeo com seu id. Enviar como private com uma data publishAt deixa a publicação com o agendador do próprio YouTube, então nada seu precisa rodar naquele horário.

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 DMs em uma rota Node.js?

Cada canal encaminha para a URL que você informa em PUT /channels/{id}/webhook, e essa chamada devolve o signing_secret do canal uma única vez. Toda 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, um ponto e o corpo bruto. Leia o corpo como texto antes de fazer o parse, rejeite um t com mais de cinco minutos e compare com timingSafeEqual.

No Instagram e no Facebook, entry é a entrada de webhook da Meta exatamente como ela a enviou: changes para comentários e menções, messaging para DMs. No TikTok, ela traz o evento comment.update, que o TikTok dispara em até cinco minutos após um comentário, com comment_id e video_id como strings, para que o JavaScript não arredonde esses números de 64 bits. Há uma única tentativa por evento e nenhuma cópia armazenada, então responda 204 imediatamente 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 DMs a partir de Node.js?

Com uma nova chamada de credentials e os ids do evento. No Instagram e no Facebook, a resposta a uma DM vai para /{account-id}/messages, usando account_id_on_meta, com o id do remetente como recipient e dentro de 24 horas da última mensagem dele; uma Página adiciona messaging_type RESPONSE, e o Instagram aceita 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 em até 7 dias.

As conversas do TikTok permanecem públicas, pois não existem DMs no TikTok. business/comment/reply/create/, com o cabeçalho Access-Token, business_id, video_id e comment_id, publica uma resposta de até 1,200 caracteres. Leia o campo code da resposta, em que 0 significa sucesso, em vez do status HTTP. Aja somente sobre comment_action insert com comment_type comment, pois 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 essas ferramentas?

Ambos passam pelo servidor MCP do easyCoexistence em https://easycoexistence.com/api/mcp, que aceita somente OAuth 2.1: registro 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 de TypeScript para Node 20 ou superior, um OAuthClientProvider guarda o cliente, os tokens e o verificador PKCE; a primeira conexão envia o usuário para entrar e lança UnauthorizedError, e finishAuth com a query string do callback conclui o processo.

A publicação no TikTok fica aqui porque o TikTok baixa mídia somente de prefixos de URL verificados para o app de desenvolvedor por trás do token. publish_tiktok_post recebe seu link HTTPS e entrega ao TikTok um endereço assinado na rota de mídia verificada do easyCoexistence, e get_tiktok_publish_status acompanha a publicação. O mesmo cliente entrega a um agente todas as ferramentas das redes da conta; chame list_social_accounts primeiro, cujo account_id é o channel id 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 já parseado e serializado de novo. A assinatura cobre o corpo bruto byte a byte, então chame req.text() primeiro e faça o parse depois, ou toda entrega falhará na verificação.
  • Converter ids do TikTok em números. Os ids de comentário e vídeo têm 64 bits e Number() os arredonda, então mantenha as strings que o evento traz ao responder ou buscar um comentário.
  • Guardar apenas o channel_id do redirecionamento. Um login no Facebook ou no LinkedIn pode adicionar várias Páginas de uma vez, então liste-as com GET /channels?external_ref= e armazene cada uma.
  • Responder a uma DM do Messenger ou do Instagram em um lote noturno. Fora das 24 horas da última mensagem da pessoa, o envio falha, então responda pelo manipulador do evento enquanto a janela estiver aberta.
Fazendo isso com o EasyCoexistence

O easyCoexistence dá a backends em Node.js e a agentes de IA alcance até os clientes no WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn e mais canais, cada um pela sua API oficial. Conecte contas com a Partner API, obtenha tokens novos e eventos assinados, e deixe agentes em TypeScript agirem pelo servidor MCP, com cada conexão monitorada 24/7. De US$ 9 a US$ 0.75 por conexão por mês, caindo conforme você adiciona conexões, com os primeiros 3 dias grátis.

O easyCoexistence é uma API e um servidor MCP multicanal que conecta agentes de IA, como o Claude e o ChatGPT, ao WhatsApp, Instagram, TikTok, Facebook e mais. No WhatsApp, ele usa o Coexistence: a empresa continua usando o número no app WhatsApp Business enquanto a IA trabalha pela API oficial da Meta.

Perguntas frequentes

Preciso de um SDK para chamar essas APIs a partir do Node?

Não. A Partner API e as APIs das redes são HTTPS simples, então o fetch global do Node 18 ou superior cobre tudo. O @modelcontextprotocol/client entra só para as ferramentas MCP, entre elas a publicação no TikTok.

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

O TikTok baixa vídeos e fotos somente de um domínio ou prefixo de URL verificado para o app de desenvolvedor, e esse app é do easyCoexistence. publish_tiktok_post serve seu arquivo HTTPS a partir desse endereço verificado, então seu domínio próprio não precisa de verificação.

Um único login pode conectar várias Páginas do Facebook ou do LinkedIn?

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

Quanto custa o easyCoexistence para Node.js?

De US$ 9 a US$ 0.75 por conexão por mês, caindo conforme você adiciona conexões, e o mesmo em todas as redes. A Partner API e o conector MCP estão incluídos, sem assentos, e os primeiros 3 dias são grátis.

Continue lendo

Conecte seu primeiro canal em dois minutos.

Sem esperar aprovação das plataformas. Conecte o WhatsApp, o Instagram, o TikTok ou outro canal, peça para a sua IA publicar, responder ou trazer os números, e veja funcionando.

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

Verificado em