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.
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.
Com quanta antecedência uma publicação numa Página do Facebook pode ser agendada com published false e um scheduled_publish_time.
O cabeçalho de resposta que transporta o URN de uma nova publicação no LinkedIn, enviado com o estado 201.
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.
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.
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.
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.
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.
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.
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.
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 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.
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