Julkaise Instagramiin, TikTokiin ja Facebookiin Node.js:stä yhdellä API:lla
easyCoexistencen avulla Node.js- tai TypeScript-taustajärjestelmäsi julkaisee Instagramiin, Facebookiin, TikTokiin, YouTubeen ja LinkedIniin kunkin verkon virallisen API:n kautta. Tilit yhdistetään kerran isännöidyn linkin kautta. Yksi fetch-kutsu palauttaa jokaiselle työlle tuoreen tokenin TikTokille, YouTubelle ja LinkedInille, ja allekirjoitetut tapahtumat tuovat kommentit ja yksityisviestit reitillesi. Agentit, jotka on rakennettu TypeScript MCP SDK:lla, saavat samat tilit työkaluina.
Videojulkaisut, joita TikTokin julkaisupäätepiste hyväksyy tilikohtaisesti, enintään kuusi minuutissa.
Kuinka kauas tulevaisuuteen Facebook-sivun julkaisu voidaan ajastaa, kun published on false ja scheduled_publish_time on annettu.
Vastausotsake, joka kantaa uuden LinkedIn-julkaisun URN-tunnuksen, kun vastaus tulee 201-tilalla.
Kuinka nopeasti TikTok lähettää comment.update-tapahtuman kommentin luomisen, poistamisen tai näkyvyyden muuttamisen jälkeen.
Kuinka kauan Partner API -yhdistämislinkki pysyy auki ennen kuin sen istunto vanhenee.
Miten Node.js-taustajärjestelmä yhdistää tilit ja hakee niiden tokenit?
Taustajärjestelmäsi avaa yhdistämisistunnon, ja tilin omistaja viimeistelee yhdistämisen selaimessa. POST-pyyntö osoitteeseen /connect-sessions, bearer-tokenina ec_live_-avaimesi, kanava kuten tiktok tai linkedin, redirect_url ja asiakkaasi external_ref palauttaa kentässä url linkin osoitteeseen easycoexistence.com. Siellä omistaja kirjautuu verkon omalla suostumusnäytöllä ja palaa redirect_url-osoitteeseesi kentät status=connected ja channel_id mukanaan. Keskeytynyt yritys voidaan tehdä uudelleen samasta linkistä, kunnes linkki vanhenee tunnin kuluttua sen luomisesta.
Jokainen työ alkaa sitten kutsulla GET /channels/{id}?credentials=1. Vastaus sisältää tokenin, joka on voimassa juuri nyt (ei Instagramissa ja Facebookissa, joiden tokeneita ei koskaan anneta ulos), sekä kunkin verkon tarvitsemat kentät: graph_api_base ja account_id_on_meta Instagramissa ja Facebookissa, api_base ja business_id TikTokissa, channel_id YouTubessa, author_urn ja required_headers LinkedInissä. Allekirjoitetut tapahtumat channel.connected, channel.disconnected, channel.removed ja channel.suspended lähetetään hallintapaneelissasi asetettuun tapahtumien URL-osoitteeseen, ja ne kertovat sovelluksellesi, kun tili muuttuu.
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;
}Miten julkaiset Instagramiin ja Facebookiin Node.js:stä?
Instagram julkaisee kontin kautta. Reelille luot kontin media_type-arvolla REELS, video_url-osoitteella ja kuvatekstillä, kyselet sen status_code-kenttää, kunnes se on FINISHED, ja kutsut sitten media_publish-päätepistettä, jonka creation_id on kontin tunnus. Meta suosittelee kyselyä noin minuutin välein ja luovuttamista viiden minuutin jälkeen. ERROR tai EXPIRED tarkoittaa, että kontti ei julkaise, ja julkaisematta jäänyt kontti vanhenee itsestään 24 tunnin kuluttua.
Facebook-sivu lähettää kuvan yhdellä kutsulla osoitteeseen /{page-id}/photos, url-kentän ja kuvatekstin kanssa, kun taas teksti ja linkit menevät osoitteeseen /{page-id}/feed. Molemmat hyväksyvät published-arvon false ja scheduled_publish_time-kentän, ja Meta julkaisee postauksen itse oikeaan aikaan, 10 minuutista 30 päivään eteenpäin. Token kulkee bearer-otsakkeessa, Graph API -versio on jo osana graph_api_base-kenttää, ja median on oltava julkisessa URL-osoitteessa, jonka Meta lataa.
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
});
}Miten julkaiset LinkedInissä ja lataat YouTubeen Node.js:stä?
LinkedIn vaatii bearer-tokenin lisäksi kaksi otsaketta jokaiseen kutsuun: LinkedIn-Version, jonka arvo on YYYYMM-muodossa ja jonka easyCoexistence palauttaa kentässä required_headers, sekä X-Restli-Protocol-Version arvolla 2.0.0. Julkaisu on POST-pyyntö osoitteeseen /rest/posts, jossa ovat tekijän URN, teksti commentary-kentässä, PUBLIC-näkyvyys, pääsyöte distribution-kentässä ja lifecycleState-arvo PUBLISHED. LinkedIn vastaa 201-tilalla ja kirjoittaa uuden julkaisun URN:n x-restli-id-otsakkeeseen. Polkuun laitettu URN on aina URL-koodattava.
YouTubeen lataus vaatii kaksi pyyntöä. POST-pyyntö latauspäätepisteeseen, jossa on uploadType=resumable ja part=snippet,status, lähettää metatiedot ja palauttaa istunto-osoitteen Location-otsakkeessa. Tiedoston tavut lähetetään PUT-pyynnöllä tuohon osoitteeseen, ja vastauksena tulee videoresurssi tunnuksineen. Kun lataat yksityisenä ja asetat publishAt-päivämäärän, YouTuben oma ajastin hoitaa julkaisun, joten mikään koodistasi ei tarvitse olla käynnissä sinä hetkenä.
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;
}Miten vastaanotat kommentit ja yksityisviestit Node.js-reitillä?
Jokainen kanava lähettää tapahtumat URL-osoitteeseen, jonka annat kutsulla PUT /channels/{id}/webhook. Tämä kutsu palauttaa kanavan signing_secret-avaimen vain kerran. Jokainen toimitus on POST-pyyntö, jossa ovat platform, account_id, external_id ja entry sekä X-EC-Signature-otsake muodossa t=<unix>,v1=<hex>. v1 on HMAC-SHA256 merkkijonosta t, pisteestä ja raakarungosta. Lue runko tekstinä ennen jäsentämistä, hylkää t, joka on vanhempi kuin viisi minuuttia, ja vertaa timingSafeEqual-funktiolla.
Instagramissa ja Facebookissa entry on Metan webhook-merkintä sellaisenaan kuin Meta sen lähetti: changes kommenteille ja maininnoille, messaging yksityisviesteille. TikTokissa se sisältää comment.update-tapahtuman, jonka TikTok lähettää viiden minuutin sisällä kommentin tekemisestä. Mukana ovat comment_id ja video_id merkkijonoina, jotta JavaScript ei pyöristä 64-bittisiä lukuja. Tapahtumasta tehdään yksi yritys eikä tallennettua kopiota, joten vastaa heti tilalla 204 ja käsittele tapahtuma jonosta.
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 });
}Miten vastaat kommentteihin ja yksityisviesteihin Node.js:stä?
Tuoreella credentials-kutsulla ja tapahtuman tunnuksilla. Instagramissa ja Facebookissa yksityisviestivastaus menee osoitteeseen /{account-id}/messages käyttäen account_id_on_meta-kenttää, vastaanottajana lähettäjän tunnus, ja enintään 24 tunnin sisällä hänen viimeisestä viestistään. Facebook-sivu lisää messaging_type-arvon RESPONSE, ja Instagram sallii enintään 1 000 tavua tekstiä. Kommenttiin voi vastata julkisesti osoitteessa /{comment-id}/replies Instagramissa tai /{comment-id}/comments Facebookissa, tai kerran yksityisesti 7 päivän sisällä.
TikTok-keskustelut pysyvät julkisina, sillä TikTokissa ei ole yksityisviestejä. business/comment/reply/create/-pyyntö, jossa ovat Access-Token-otsake, business_id, video_id ja comment_id, lähettää enintään 1 200 merkin vastauksen. Lue vastauksen code-kenttä, jossa 0 tarkoittaa onnistumista, eikä HTTP-tilaa. Toimi vain tapahtumilla, joiden comment_action on insert ja comment_type on comment, koska myös omat vastauksesi saapuvat tapahtumina.
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 },
});
}
}
}Miten julkaiset TikTokiin ja annat TypeScript-agentille nämä työkalut?
Molemmat kulkevat easyCoexistencen MCP-palvelimen kautta osoitteessa https://easycoexistence.com/api/mcp. Palvelin hyväksyy vain OAuth 2.1:n: dynaamisen asiakasrekisteröinnin, valtuutuskoodin PKCE:llä, tunnin voimassa olevat käyttötokenit ja päivitystokenit. Virallisella TypeScript-SDK:lla @modelcontextprotocol/client Node 20:stä alkaen OAuthClientProvider pitää sisällään asiakkaan, tokenit ja PKCE-varmisteen. Ensimmäinen yhdistäminen ohjaa käyttäjän kirjautumaan ja heittää UnauthorizedError-virheen. finishAuth viimeistelee yhdistämisen, kun sille annetaan takaisinkutsun kyselymerkkijono.
TikTok-julkaisu on täällä, koska TikTok lataa mediaa vain sellaisista URL-etuliitteistä, jotka on vahvistettu tokenin taustalla olevalle kehittäjäsovellukselle. publish_tiktok_post ottaa HTTPS-linkkisi ja antaa TikTokille allekirjoitetun osoitteen easyCoexistencen vahvistetussa mediareitissä, ja get_tiktok_publish_status seuraa julkaisua. Sama asiakas antaa agentille kaikki tilin verkkojen työkalut. Kutsu ensin list_social_accounts, jonka account_id on Partner API:n channel_id.
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_statusYleiset virheet
- HMAC:n laskeminen jäsennetystä ja uudelleen sarjoitetusta JSON-datasta. Allekirjoitus kattaa raakarungon tavu tavulta, joten kutsu ensin req.text() ja jäsennä vasta sen jälkeen, muuten jokainen toimitus epäonnistuu tarkistuksessa.
- TikTok-tunnusten muuttaminen numeroiksi. Kommentti- ja videotunnukset ovat 64-bittisiä, ja Number() pyöristää ne, joten säilytä tapahtuman mukana tulevat merkkijonot, kun vastaat tai haet kommenttia.
- Pelkän channel_id-tunnuksen säilyttäminen uudelleenohjauksesta. Facebook- tai LinkedIn-kirjautuminen voi lisätä useita sivuja kerralla, joten listaa ne kutsulla GET /channels?external_ref= ja tallenna jokainen.
- Messenger- tai Instagram-yksityisviestiin vastaaminen yöajon erässä. 24 tunnin ikkunan ulkopuolella lähetys epäonnistuu, joten vastaa tapahtumankäsittelijästä, kun ikkuna on auki.
easyCoexistence antaa Node.js-taustajärjestelmille ja tekoälyagenteille yhteyden asiakkaisiin WhatsAppissa, Instagramissa, Facebookissa, TikTokissa, YouTubessa, LinkedInissä ja useammissa kanavissa, kukin virallisen API:nsa kautta. Yhdistä tilit Partner API:lla, hae tuoreet tokenit ja allekirjoitetut tapahtumat ja anna TypeScript-agenttien toimia MCP-palvelimen kautta. Jokainen yhteys on 24/7 valvonnassa. US$ 9:stä US$ 0,75:een yhteydeltä kuukaudessa, hinta laskee yhteyksien määrän kasvaessa, ja ensimmäiset 3 päivää ovat ilmaista kokeilua.
Usein kysytyt kysymykset
Tarvitsenko SDK:n näiden API:en kutsumiseen Node.js:stä?
Ei. Partner API ja verkkojen omat API:t ovat tavallista HTTPS:ää, joten Node 18:sta alkaen saatavilla oleva globaali fetch riittää niihin. @modelcontextprotocol/client tarvitaan vain MCP-työkaluihin, joihin kuuluu myös TikTok-julkaisu.
Miksi TikTok-julkaisu kulkee MCP-palvelimen kautta?
TikTok lataa videot ja kuvat vain domainista tai URL-etuliitteestä, joka on vahvistettu kehittäjäsovellukselle, ja tuo sovellus on easyCoexistencen. publish_tiktok_post tarjoaa HTTPS-tiedostosi tuosta vahvistetusta osoitteesta, joten oma domainisi ei tarvitse vahvistusta.
Voiko yksi kirjautuminen yhdistää useita Facebook- tai LinkedIn-sivuja?
Kyllä. Jokainen sivu ja LinkedInissä jäsenen oma profiili muodostaa oman kanavansa ja oman yhteytensä. Uudelleenohjaus kantaa ensimmäisen channel_id-tunnuksen, ja GET /channels?external_ref= listaa ne kaikki.
Paljonko easyCoexistence maksaa Node.js-käyttöön?
US$ 9:stä US$ 0,75:een yhteydeltä kuukaudessa, hinta laskee yhteyksien määrän kasvaessa, ja hinta on sama jokaisessa verkossa. Partner API ja MCP-liitin kuuluvat mukaan ilman käyttäjälisenssejä, ja ensimmäiset 3 päivää ovat ilmaista kokeilua.
Lue lisää
Yhdistä ensimmäinen kanavasi kahdessa minuutissa.
Ei alustojen tarkastuksia odotettavana. Yhdistä WhatsApp, Instagram, TikTok tai jokin muu kanava, pyydä sitten tekoälyäsi julkaisemaan, vastaamaan tai raportoimaan ja seuraa, kun se hoitaa homman.
- 3 päivää ilmaiseksi
- Peruuta milloin tahansa
- Vain viralliset API:t
- Valvottu 24/7
Vahvistettu