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.
Publicações de vídeo que o endpoint de publicação do TikTok aceita por conta, com no máximo seis por minuto.
Com quanta antecedência uma publicação em Página do Facebook pode ser agendada com published false e scheduled_publish_time.
O cabeçalho de resposta que traz o URN de uma nova publicação no LinkedIn, enviado com status 201.
Em quanto tempo o TikTok dispara um evento comment.update depois que um comentário é criado, excluído ou tem a visibilidade alterada.
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.
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.
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.
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.
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.
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.
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_statusErros 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.
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