Publier sur Instagram, TikTok et Facebook depuis Node.js avec une seule API
Avec easyCoexistence, un backend Node.js ou TypeScript publie sur Instagram, Facebook, TikTok, YouTube et LinkedIn via l'API officielle de chaque réseau. Les comptes se connectent une seule fois via un lien hébergé ; un seul fetch renvoie ensuite un token à jour pour chaque tâche sur TikTok, YouTube et LinkedIn, et les événements signés acheminent les commentaires et les messages privés vers votre route. Les agents construits avec le SDK TypeScript MCP accèdent aux mêmes comptes sous forme d'outils.
Vidéos que l'endpoint de publication de TikTok accepte par compte, à six par minute au maximum.
Délai maximal de planification d'une publication sur Page Facebook avec published false et un scheduled_publish_time.
En-tête de réponse qui porte l'URN d'une nouvelle publication LinkedIn, envoyé avec un statut 201.
Délai dans lequel TikTok déclenche un événement comment.update après la création, la suppression ou le changement de visibilité d'un commentaire.
Durée pendant laquelle un lien de connexion de la Partner API reste ouvert avant l'expiration de sa session.
Comment un backend Node.js connecte-t-il les comptes et obtient-il leurs tokens ?
Votre backend ouvre une session de connexion, et le titulaire du compte la termine dans le navigateur. Un POST sur /connect-sessions, avec votre clé ec_live_ comme bearer token, un canal tel que tiktok ou linkedin, un redirect_url et un external_ref pour votre client, renvoie une url sur easycoexistence.com. Là, le titulaire se connecte sur l'écran de consentement du réseau lui-même et revient vers votre redirect_url avec status=connected et un channel_id ; une tentative annulée peut être reprise depuis le même lien jusqu'à son expiration, une heure après sa création.
Chaque tâche démarre ensuite avec GET /channels/{id}?credentials=1. La réponse contient un token valide immédiatement (pas pour Instagram et Facebook, dont les tokens ne sont jamais remis), ainsi que les champs dont chaque réseau a besoin : graph_api_base et account_id_on_meta pour Instagram et Facebook, api_base et business_id pour TikTok, channel_id pour YouTube, author_urn et required_headers pour LinkedIn. Les événements signés channel.connected, channel.disconnected, channel.removed et channel.suspended, envoyés à l'URL d'événements définie dans votre dashboard, indiquent à votre application quand un compte change.
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;
}Comment publier sur Instagram et Facebook depuis Node.js ?
Instagram publie via un conteneur. Pour un Reel, créez-le avec media_type REELS, la video_url et la légende, interrogez son status_code jusqu'à ce qu'il affiche FINISHED, puis appelez media_publish avec l'identifiant du conteneur comme creation_id. Meta recommande d'interroger environ une fois par minute et d'abandonner au bout de cinq minutes ; ERROR ou EXPIRED signifie que le conteneur ne sera pas publié, et un conteneur resté non publié pendant 24 heures expire de lui-même.
Une Page Facebook accepte une photo en un seul appel à /{page-id}/photos, avec l'URL de l'image et une légende, tandis que le texte et les liens vont vers /{page-id}/feed. Les deux acceptent published false avec un scheduled_publish_time, et Meta publie lui-même la publication à l'heure prévue, entre 10 minutes et 30 jours à l'avance. Le token voyage dans un en-tête bearer, la version de l'API Graph figure déjà dans graph_api_base, et le média doit se trouver à une URL publique que Meta télécharge.
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
});
}Comment publier sur LinkedIn et envoyer une vidéo sur YouTube depuis Node.js ?
LinkedIn exige deux en-têtes en plus du bearer token à chaque appel : LinkedIn-Version, avec la valeur YYYYMM que easyCoexistence renvoie dans required_headers, et X-Restli-Protocol-Version défini à 2.0.0. Une publication est un POST sur /rest/posts avec l'URN de l'auteur, le texte dans commentary, une visibilité PUBLIC, le fil principal comme distribution et lifecycleState PUBLISHED. LinkedIn répond 201 et place l'URN de la nouvelle publication dans l'en-tête x-restli-id ; tout URN placé dans un chemin d'URL doit être encodé en URL.
YouTube demande deux requêtes. Un POST sur l'endpoint d'envoi avec uploadType=resumable et part=snippet,status transmet les métadonnées et renvoie l'adresse de session dans son en-tête Location ; un PUT des octets du fichier vers cette adresse renvoie la ressource vidéo avec son id. Un envoi en privé avec une date publishAt confie la publication au planificateur de YouTube, de sorte que rien de votre côté n'a besoin de s'exécuter à cette heure-là.
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;
}Comment recevoir les commentaires et les messages privés dans une route Node.js ?
Chaque canal transmet à l'URL que vous fournissez à PUT /channels/{id}/webhook, et cet appel renvoie le signing_secret du canal une seule fois. Chaque livraison est un POST contenant platform, account_id, external_id et entry, avec un en-tête X-EC-Signature de la forme t=<unix>,v1=<hex>, où v1 est le HMAC-SHA256 de t, d'un point et du corps brut. Lisez le corps comme texte avant de l'analyser, rejetez un t vieux de plus de cinq minutes et comparez avec timingSafeEqual.
Pour Instagram et Facebook, entry est le webhook de Meta tel que Meta l'a envoyé : changes pour les commentaires et les mentions, messaging pour les messages privés. Pour TikTok, il contient l'événement comment.update, que TikTok déclenche dans les cinq minutes suivant un commentaire, avec comment_id et video_id sous forme de chaînes afin que JavaScript n'arrondisse pas ces nombres de 64 bits. Il n'y a qu'une tentative par événement et aucune copie conservée : répondez donc 204 immédiatement, puis traitez depuis une file d'attente.
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 });
}Comment répondre aux commentaires et aux messages privés depuis Node.js ?
Avec un nouvel appel à credentials et les identifiants présents dans l'événement. Sur Instagram et Facebook, une réponse à un message privé part vers /{account-id}/messages, en utilisant account_id_on_meta, avec l'identifiant de l'expéditeur comme recipient, et dans les 24 heures suivant son dernier message ; une Page ajoute messaging_type RESPONSE, et Instagram autorise 1 000 octets de texte au maximum. Un commentaire reçoit une réponse publique, sur /{comment-id}/replies pour Instagram ou /{comment-id}/comments pour Facebook, ou une seule réponse privée dans les 7 jours.
Les conversations TikTok restent publiques, car TikTok n'a pas de messages privés. business/comment/reply/create/, avec l'en-tête Access-Token, business_id, video_id et comment_id, publie une réponse d'au plus 1 200 caractères. Lisez le champ code de la réponse, où 0 signifie succès, plutôt que le statut HTTP. N'agissez que sur comment_action insert avec comment_type comment, car vos propres réponses arrivent aussi sous forme d'événements.
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 },
});
}
}
}Comment publier sur TikTok et donner à un agent TypeScript ces outils ?
Les deux passent par le serveur MCP d'easyCoexistence, à https://easycoexistence.com/api/mcp, qui n'accepte que OAuth 2.1 : enregistrement dynamique du client, code d'autorisation avec PKCE, access tokens valables une heure et refresh tokens. Avec @modelcontextprotocol/client, le SDK TypeScript officiel pour Node 20 et versions ultérieures, un OAuthClientProvider détient le client, les tokens et le verifier PKCE ; la première connexion envoie l'utilisateur vers la page de connexion et lève UnauthorizedError, et finishAuth, appelé avec la query du callback, la termine.
La publication TikTok se fait ici parce que TikTok ne télécharge les médias que depuis des préfixes d'URL vérifiés pour l'application développeur qui détient le token. publish_tiktok_post prend votre lien HTTPS et remet à TikTok une adresse signée sur la route média vérifiée d'easyCoexistence, et get_tiktok_publish_status suit la publication. Le même client remet à un agent tous les outils des réseaux du compte ; appelez d'abord list_social_accounts, dont le account_id est l'identifiant 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_statusErreurs courantes
- Calculer le HMAC sur un JSON analysé puis re-sérialisé. La signature couvre le corps brut octet par octet : appelez donc req.text() avant d'analyser, sinon chaque livraison échoue à la vérification.
- Convertir les identifiants TikTok en nombres. Les identifiants de commentaire et de vidéo sont sur 64 bits et Number() les arrondit : conservez les chaînes que porte l'événement lorsque vous répondez ou recherchez un commentaire.
- Ne garder que le channel_id de la redirection. Une connexion Facebook ou LinkedIn peut ajouter plusieurs Pages d'un coup : listez-les avec GET /channels?external_ref= et enregistrez chacune.
- Répondre à un message Messenger ou Instagram depuis un traitement nocturne par lots. Au-delà de 24 heures après le dernier message de la personne, l'envoi échoue : répondez donc depuis le gestionnaire d'événements pendant que la fenêtre est ouverte.
easyCoexistence donne aux backends Node.js et aux agents IA un accès à leurs clients sur WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn et d'autres canaux, chacun via son API officielle. Connectez les comptes avec la Partner API, obtenez des tokens à jour et des événements signés, et laissez les agents TypeScript agir via le serveur MCP, avec chaque connexion surveillée 24 h/24 et 7 j/7. De US$ 9 à US$ 0,75 par connexion et par mois, dégressif à mesure que vous ajoutez des connexions, avec un essai gratuit de 3 jours.
Questions fréquemment posées
Ai-je besoin d'un SDK pour appeler ces API depuis Node ?
Non. La Partner API et les API des réseaux sont du HTTPS classique, donc le fetch global de Node 18 et versions ultérieures suffit. @modelcontextprotocol/client n'intervient que pour les outils MCP, parmi lesquels la publication TikTok.
Pourquoi la publication TikTok passe-t-elle par le serveur MCP ?
TikTok ne télécharge vidéos et photos que depuis un domaine ou un préfixe d'URL vérifié pour l'application développeur, et cette application est celle d'easyCoexistence. publish_tiktok_post sert votre fichier HTTPS depuis cette adresse vérifiée, de sorte que votre propre domaine n'a besoin d'aucune vérification.
Une même connexion peut-elle relier plusieurs Pages Facebook ou LinkedIn ?
Oui. Chaque Page, et sur LinkedIn le profil personnel du membre, devient son propre canal et sa propre connexion. La redirection transporte le premier channel_id, et GET /channels?external_ref= les liste toutes.
Combien coûte easyCoexistence pour Node.js ?
De US$ 9 à US$ 0,75 par connexion et par mois, dégressif à mesure que vous ajoutez des connexions, au même prix sur chaque réseau. La Partner API et le connecteur MCP sont inclus, sans licence par utilisateur, et un essai gratuit de 3 jours est compris.
Poursuivre la lecture
Connectez votre premier canal en deux minutes.
Aucune validation de plateforme à attendre. Connectez WhatsApp, Instagram, TikTok ou un autre canal, puis demandez à votre IA de publier, de répondre ou de faire un rapport, et regardez-la travailler.
- 3 jours gratuits
- Résiliable à tout moment
- API officielles uniquement
- Supervisé 24/7
Vérifié le