Publica en Instagram, TikTok y Facebook desde Node.js con una sola API
Con easyCoexistence, un backend de Node.js o TypeScript publica en Instagram, Facebook, TikTok, YouTube y LinkedIn a través de la API oficial de cada red. Las cuentas se conectan una vez mediante un enlace alojado; un solo fetch devuelve después un token vigente para cada tarea en TikTok, YouTube y LinkedIn, y los eventos firmados llevan los comentarios y los DM a tu ruta. Los agentes creados con el SDK de MCP para TypeScript reciben esas mismas cuentas como herramientas.
Publicaciones de vídeo que el endpoint de publicación de TikTok acepta por cuenta, a no más de seis por minuto.
Hasta cuánto tiempo antes puede programarse una publicación en una página de Facebook con published false y un scheduled_publish_time.
El encabezado de respuesta que lleva el URN de una nueva publicación de LinkedIn, enviado con código de estado 201.
Cuánto tarda TikTok en enviar un evento comment.update tras crear, borrar o cambiar la visibilidad de un comentario.
Cuánto tiempo permanece abierto un enlace de conexión de la Partner API antes de que caduque su sesión.
¿Cómo conecta un backend de Node.js las cuentas y obtiene sus tokens?
Tu backend abre una sesión de conexión y el titular de la cuenta la completa en el navegador. Un POST a /connect-sessions, con tu clave ec_live_ como token bearer, un canal como tiktok o linkedin, un redirect_url y un external_ref para tu cliente, devuelve una url en easycoexistence.com. Allí el titular inicia sesión en la pantalla de consentimiento propia de la red y regresa a tu redirect_url con status=connected y un channel_id. Un intento cancelado puede reintentarse desde el mismo enlace hasta que caduque, una hora después de haberse creado.
Cada tarea comienza luego con GET /channels/{id}?credentials=1. La respuesta incluye un token vigente en ese momento (no en Instagram ni Facebook, cuyos tokens nunca se entregan) más los campos que necesita cada red: graph_api_base y account_id_on_meta en Instagram y Facebook, api_base y business_id en TikTok, channel_id en YouTube, author_urn y required_headers en LinkedIn. Los eventos firmados channel.connected, channel.disconnected, channel.removed y channel.suspended, enviados a la URL de eventos configurada en tu panel, avisan a tu aplicación cuando una cuenta cambia.
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;
}¿Cómo publica en Instagram y Facebook desde Node.js?
Instagram publica a través de un contenedor. Para un Reel, créalo con media_type REELS, el video_url y el caption, consulta su status_code hasta que indique FINISHED y luego llama a media_publish con el id del contenedor como creation_id. Meta recomienda consultar aproximadamente cada minuto y dejar de consultar tras cinco minutos. ERROR o EXPIRED significan que el contenedor no se publicará, y uno que quede sin publicar durante 24 horas caduca por sí solo.
Una página de Facebook sube una foto en una sola llamada a /{page-id}/photos, con la url de la imagen y un pie de foto, mientras que el texto y los enlaces van a /{page-id}/feed. Ambas aceptan published false con un scheduled_publish_time, y Meta publica la entrada por sí misma cuando llega la hora, entre 10 minutos y 30 días después. El token viaja en un encabezado bearer, la versión de la Graph API ya está dentro de graph_api_base, y el contenido multimedia debe estar en una URL pública que Meta descarga.
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
});
}¿Cómo publica en LinkedIn y sube vídeos a YouTube desde Node.js?
LinkedIn requiere dos encabezados además del token bearer en cada llamada: LinkedIn-Version, con el valor YYYYMM que easyCoexistence devuelve en required_headers, y X-Restli-Protocol-Version con el valor 2.0.0. Una publicación es un POST a /rest/posts con el URN del autor, el texto como commentary, visibilidad PUBLIC, el feed principal como distribution y lifecycleState PUBLISHED. LinkedIn responde 201 y coloca el URN de la nueva publicación en el encabezado x-restli-id. Cualquier URN que vaya en la ruta de una URL debe codificarse en URL.
YouTube requiere dos peticiones. Un POST al endpoint de subida con uploadType=resumable y part=snippet,status envía los metadatos y devuelve la dirección de la sesión en su encabezado Location. Un PUT de los bytes del archivo a esa dirección devuelve el recurso del vídeo con su id. Subirlo como private con una fecha publishAt deja la publicación en manos del programador de YouTube, así que nada de tu parte tiene que ejecutarse a esa 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;
}¿Cómo recibe comentarios y DM en una ruta de Node.js?
Cada canal reenvía a la URL que indicas en PUT /channels/{id}/webhook, y esa llamada devuelve una sola vez el signing_secret del canal. Cada entrega es un POST con platform, account_id, external_id y entry, con un encabezado X-EC-Signature de la forma t=<unix>,v1=<hex>, donde v1 es el HMAC-SHA256 de t, un punto y el cuerpo sin procesar. Lee el cuerpo como texto antes de parsearlo, rechaza un t de hace más de cinco minutos y compara con timingSafeEqual.
En Instagram y Facebook, entry es la entrada de webhook de Meta tal como la envió Meta: changes para comentarios y menciones, messaging para DM. En TikTok contiene el evento comment.update, que TikTok emite en un plazo de cinco minutos desde el comentario, con comment_id y video_id como cadenas para que JavaScript no redondee esos números de 64 bits. Hay un solo intento por evento y no se guarda copia, así que responde 204 de inmediato y procesa desde una cola.
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 });
}¿Cómo responde a comentarios y DM desde Node.js?
Con una nueva llamada de credenciales y los ids del evento. En Instagram y Facebook, una respuesta por DM va a /{account-id}/messages, usando account_id_on_meta, con el id del remitente como recipient y dentro de las 24 horas desde su último mensaje. Una página añade messaging_type RESPONSE, e Instagram admite como máximo 1,000 bytes de texto. Un comentario recibe una respuesta pública, en /{comment-id}/replies en Instagram o /{comment-id}/comments en Facebook, o una respuesta privada dentro de los 7 días.
Las conversaciones de TikTok siempre son públicas, porque TikTok no tiene DM. business/comment/reply/create/, con el encabezado Access-Token, business_id, video_id y comment_id, publica una respuesta de hasta 1,200 caracteres. Lee el campo code de la respuesta, donde 0 significa éxito, en lugar del código HTTP. Actúa solo sobre comment_action insert con comment_type comment, porque tus propias respuestas también llegan 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 },
});
}
}
}¿Cómo publica en TikTok y da a un agente TypeScript estas herramientas?
Ambas cosas pasan por el servidor MCP de easyCoexistence en https://easycoexistence.com/api/mcp, que acepta solo OAuth 2.1: registro dinámico de clientes, código de autorización con PKCE, tokens de acceso que duran una hora y tokens de actualización. Con @modelcontextprotocol/client, el SDK oficial de TypeScript para Node 20 y posteriores, un OAuthClientProvider guarda el cliente, los tokens y el verificador PKCE. La primera conexión envía al usuario a iniciar sesión y lanza UnauthorizedError, y finishAuth con los parámetros de la URL de retorno la completa.
La publicación en TikTok está aquí porque TikTok descarga contenido solo desde prefijos de URL verificados para la aplicación de desarrollador detrás del token. publish_tiktok_post toma tu enlace HTTPS y entrega a TikTok una dirección firmada en la ruta verificada de medios de easyCoexistence, y get_tiktok_publish_status sigue la publicación. El mismo cliente entrega a un agente todas las herramientas de las redes de la cuenta. Llama primero a list_social_accounts, cuyo account_id es el id de canal de la 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_statusErrores comunes
- Calcular el HMAC sobre JSON parseado y vuelto a serializar. La firma cubre el cuerpo sin procesar byte a byte, así que llama antes a req.text() y parsea después, o cada entrega fallará la verificación.
- Convertir los ids de TikTok en números. Los ids de comentario y de vídeo son de 64 bits y Number() los redondea, así que conserva las cadenas que trae el evento al responder o buscar un comentario.
- Quedarse solo con el channel_id de la redirección. Un inicio de sesión de Facebook o LinkedIn puede añadir varias páginas a la vez, así que lístalas con GET /channels?external_ref= y guarda cada una.
- Responder a un DM de Messenger o Instagram desde un lote nocturno. Fuera de las 24 horas desde el último mensaje de la persona el envío falla, así que responde desde el manejador del evento mientras la ventana esté abierta.
easyCoexistence da a los backends de Node.js y a los agentes de IA alcance hacia sus clientes en WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn y más canales, cada uno a través de su API oficial. Conecta cuentas con la Partner API, obtén tokens vigentes y eventos firmados, y deja que los agentes TypeScript actúen mediante el servidor MCP, con cada conexión supervisada 24/7. De US$ 9 a US$ 0.75 por conexión al mes, con tarifa decreciente a medida que añades conexiones, y los primeros 3 días son gratis.
Preguntas frecuentes
¿Necesito un SDK para llamar a estas APIs desde Node?
No. La Partner API y las APIs de las redes son HTTPS simple, así que el fetch global de Node 18 y posteriores basta. @modelcontextprotocol/client solo se incorpora para las herramientas MCP, entre ellas la publicación en TikTok.
¿Por qué la publicación en TikTok pasa por el servidor MCP?
TikTok descarga vídeos y fotos solo desde un dominio o prefijo de URL verificado para la aplicación de desarrollador, y esa aplicación es de easyCoexistence. publish_tiktok_post sirve tu archivo HTTPS desde esa dirección verificada, así que tu propio dominio no necesita verificación.
¿Un solo inicio de sesión puede conectar varias páginas de Facebook o de LinkedIn?
Sí. Cada página, y en LinkedIn el perfil propio del miembro, se convierte en su propio canal y su propia conexión. La redirección trae el primer channel_id, y GET /channels?external_ref= las lista todas.
¿Cuánto cuesta easyCoexistence para Node.js?
De US$ 9 a US$ 0.75 por conexión al mes, con tarifa decreciente a medida que añades conexiones, igual en todas las redes. La Partner API y el conector MCP están incluidos, sin asientos, y los primeros 3 días son gratis.
Sigue leyendo
Conecta tu primer canal en dos minutos.
Sin esperar revisiones de las plataformas. Conecta WhatsApp, Instagram, TikTok u otro canal, pídele a tu IA que publique, responda o te haga un informe, y míralo trabajar.
- 3 días gratis
- Cancela cuando quieras
- Solo APIs oficiales
- Monitorizado 24/7
Verificado el