Node.js నుండి ఒకే API ద్వారా Instagram, TikTok మరియు Facebookలో పోస్ట్ చేయండి
easyCoexistence తో, Node.js లేదా TypeScript బ్యాకెండ్ ప్రతి నెట్వర్క్ యొక్క అధికారిక API ద్వారా Instagram, Facebook, TikTok, YouTube మరియు LinkedInలో పోస్ట్ చేస్తుంది. ఖాతాలు ఒకసారి హోస్ట్ చేసిన లింక్ ద్వారా సైన్ ఇన్ చేస్తాయి; ప్రతి పనికి ఒక fetch కాల్ TikTok, YouTube మరియు LinkedIn పై తాజా టోకెన్ ఇస్తుంది, మరియు సంతకం చేసిన ఈవెంట్లు కామెంట్లు, DMలను మీ రూట్కు తీసుకువస్తాయి. TypeScript MCP SDK తో నిర్మించిన ఏజెంట్లు అదే ఖాతాలను టూల్స్గా పొందుతాయి.
TikTok పబ్లిషింగ్ ఎండ్పాయింట్ ప్రతి ఖాతాకు అంగీకరించే వీడియో పోస్ట్లు, నిమిషానికి 6 కంటే ఎక్కువ కాకుండా.
published false మరియు scheduled_publish_time తో Facebook Page పోస్ట్ను ఎంత ముందుగా షెడ్యూల్ చేయవచ్చు.
కొత్త LinkedIn పోస్ట్ యొక్క URNను కలిగి ఉండే ప్రతిస్పందన హెడర్, 201 స్టేటస్తో పంపబడుతుంది.
ఒక కామెంట్ సృష్టించబడిన, తొలగించబడిన లేదా దృశ్యమానత మార్చబడిన తర్వాత TikTok comment.update ఈవెంట్ను ఎంత త్వరగా పంపుతుంది.
Partner API కనెక్ట్ లింక్ తన సెషన్ గడువు ముగిసే ముందు ఎంతసేపు తెరిచి ఉంటుంది.
Node.js బ్యాకెండ్ ఖాతాలను ఎలా కనెక్ట్ చేస్తుంది మరియు వాటి టోకెన్లను ఎలా పొందుతుంది?
మీ బ్యాకెండ్ కనెక్ట్ సెషన్ను తెరుస్తుంది, ఖాతా యజమాని బ్రౌజర్లో పూర్తి చేస్తారు. మీ ec_live_ కీని బేరర్ టోకెన్గా ఉపయోగించి /connect-sessions కు POST చేస్తే, tiktok లేదా linkedin వంటి ఛానల్, redirect_url మరియు మీ కస్టమర్ కోసం external_ref తో, easycoexistence.com పై url ఇస్తుంది. అక్కడ యజమాని నెట్వర్క్ స్వంత సమ్మతి స్క్రీన్పై సైన్ ఇన్ చేసి, status=connected మరియు channel_id తో మీ redirect_url కు తిరిగి వస్తారు; రద్దు చేసిన ప్రయత్నాన్ని గడువు ముగిసే వరకు, అంటే సృష్టించిన ఒక గంట తర్వాత వరకు, అదే లింక్ నుండి మళ్ళీ ప్రయత్నించవచ్చు.
ప్రతి పని GET /channels/{id}?credentials=1 తో మొదలవుతుంది. జవాబులో ఇప్పుడు చెల్లుబాటయ్యే టోకెన్ (Instagram మరియు Facebook కు కాదు, వాటి టోకెన్లు ఎప్పుడూ ఇవ్వబడవు) మరియు ప్రతి నెట్వర్క్కు అవసరమైన ఫీల్డ్లు ఉంటాయి: Instagram మరియు Facebookపై graph_api_base మరియు account_id_on_meta, TikTokపై api_base మరియు business_id, YouTubeపై channel_id, LinkedInపై author_urn మరియు required_headers. ఖాతా మారినప్పుడు మీ యాప్కు తెలియజేసే సంతకం చేసిన channel.connected, channel.disconnected, channel.removed మరియు channel.suspended ఈవెంట్లు, మీ డాష్బోర్డ్లో సెట్ చేసిన ఈవెంట్ల URLకు పంపబడతాయి.
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;
}Node.js నుండి Instagram మరియు Facebookలో ఎలా పోస్ట్ చేయాలి?
Instagram ఒక కంటైనర్ ద్వారా ప్రచురిస్తుంది. Reel కోసం, media_type REELS, video_url మరియు క్యాప్షన్తో దాన్ని సృష్టించండి, status_code FINISHED అయ్యే వరకు దాని స్టేటస్ను పోల్ చేయండి, ఆపై కంటైనర్ ఐడిని creation_id గా పెట్టి media_publish కు కాల్ చేయండి. Meta సుమారు ప్రతి నిమిషానికి పోల్ చేయాలని, ఐదు నిమిషాల తర్వాత వదిలేయాలని సిఫార్సు చేస్తుంది; ERROR లేదా EXPIRED అంటే కంటైనర్ ప్రచురించబడదు, మరియు 24 గంటలపాటు ప్రచురించకుండా ఉంటే అది తనంతట తానే గడువు ముగుస్తుంది.
Facebook Pageకి, చిత్రం url మరియు క్యాప్షన్తో /{page-id}/photos కు ఒకే కాల్లో ఫోటో ఇవ్వవచ్చు, అయితే టెక్స్ట్ మరియు లింక్లు /{page-id}/feed కు వెళ్తాయి. రెండూ published false మరియు scheduled_publish_time ను అంగీకరిస్తాయి; ఆ సమయం వచ్చినప్పుడు Meta స్వయంగా పోస్ట్ను ప్రచురిస్తుంది, ఇది 10 నిమిషాల నుండి 30 రోజుల ముందు వరకు ఉంటుంది. టోకెన్ బేరర్ హెడర్గా వెళ్తుంది, Graph API వెర్షన్ ఇప్పటికే graph_api_base లోనే ఉంటుంది, మరియు మీడియా Meta డౌన్లోడ్ చేసే పబ్లిక్ URLలో ఉండాలి.
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
});
}Node.js నుండి LinkedInలో పోస్ట్ చేయడం మరియు YouTubeకు అప్లోడ్ చేయడం ఎలా?
LinkedIn ప్రతి కాల్లో బేరర్ టోకెన్తో పాటు రెండు హెడర్లను కోరుతుంది: LinkedIn-Version, దానిలో easyCoexistence required_headers లో ఇచ్చే YYYYMM విలువ, మరియు X-Restli-Protocol-Version ను 2.0.0 కు సెట్ చేయాలి. పోస్ట్ అంటే రచయిత URN, టెక్స్ట్ను commentary గా, PUBLIC దృశ్యమానత, ప్రధాన ఫీడ్ను distribution గా మరియు lifecycleState PUBLISHED తో /rest/posts కు చేసే POST. LinkedIn 201 తో జవాబిస్తుంది మరియు కొత్త పోస్ట్ URNను x-restli-id హెడర్లో ఉంచుతుంది; URL పాత్లో ఉంచిన ఏ URNనైనా URL-encode చేయాలి.
YouTubeకు రెండు రిక్వెస్ట్లు కావాలి. uploadType=resumable మరియు part=snippet,status తో అప్లోడ్ ఎండ్పాయింట్కు చేసే POST మెటాడేటాను పంపుతుంది మరియు దాని Location హెడర్లో సెషన్ చిరునామాను ఇస్తుంది; ఆ చిరునామాకు ఫైల్ బైట్లను PUT చేస్తే id తో వీడియో రిసోర్స్ను తిరిగి ఇస్తుంది. private గా publishAt తేదీతో అప్లోడ్ చేస్తే ప్రచురణను YouTube సొంత షెడ్యూలర్కు వదిలేస్తుంది, కాబట్టి ఆ సమయంలో మీ వైపు ఏదీ నడవాల్సిన అవసరం లేదు.
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;
}Node.js రూట్లో కామెంట్లు మరియు DMలను ఎలా స్వీకరించాలి?
ప్రతి ఛానల్ మీరు PUT /channels/{id}/webhook తో ఇచ్చే URLకు ఫార్వర్డ్ చేస్తుంది, మరియు ఆ కాల్ ఛానల్ signing_secret ను ఒకసారి తిరిగి ఇస్తుంది. ప్రతి డెలివరీ platform, account_id, external_id మరియు entry తో కూడిన POST; దానితో X-EC-Signature హెడర్ t=<unix>,v1=<hex> ఆకారంలో ఉంటుంది, ఇక్కడ v1 అంటే t, ఒక చుక్క మరియు రా బాడీ యొక్క HMAC-SHA256. పార్స్ చేసే ముందు బాడీని టెక్స్ట్గా తీసుకోండి, ఐదు నిమిషాల కంటే పాతదైన t ను తిరస్కరించండి, మరియు timingSafeEqual తో పోల్చండి.
Instagram మరియు Facebookకు, entry అంటే Meta పంపిన విధంగానే Meta webhook entry: కామెంట్లు మరియు మెన్షన్లకు changes, DMలకు messaging. TikTokకు ఇది comment.update ఈవెంట్ను కలిగి ఉంటుంది, దీన్ని TikTok ఒక కామెంట్ నుండి ఐదు నిమిషాల లోపు ఫైర్ చేస్తుంది; comment_id మరియు video_id స్ట్రింగ్లుగా వస్తాయి, అందువల్ల JavaScript ఆ 64-bit సంఖ్యలను రౌండ్ చేయలేదు. ప్రతి ఈవెంట్కు ఒకే ప్రయత్నం ఉంటుంది మరియు నిల్వ చేసిన కాపీ ఉండదు, కాబట్టి వెంటనే 204 తో జవాబివ్వండి మరియు క్యూ నుండి ప్రాసెస్ చేయండి.
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 });
}Node.js నుండి కామెంట్లు మరియు DMలకు ఎలా రిప్లై ఇవ్వాలి?
తాజా credentials కాల్తో మరియు ఈవెంట్లోని ఐడిలతో. Instagram మరియు Facebookపై, DM రిప్లై /{account-id}/messages కు వెళ్తుంది, account_id_on_meta ఉపయోగించి, పంపినవారి ఐడిని recipient గా పెట్టి, వారి చివరి మెసేజ్ తర్వాత 24 గంటల లోపు; Page కు messaging_type RESPONSE జోడించాలి, మరియు Instagram గరిష్టంగా 1,000 బైట్ల టెక్స్ట్ అనుమతిస్తుంది. కామెంట్కు పబ్లిక్ రిప్లై ఇవ్వవచ్చు, Instagramలో /{comment-id}/replies కు లేదా Facebookలో /{comment-id}/comments కు, లేదా 7 రోజుల లోపు ఒక ప్రైవేట్ రిప్లై.
TikTok సంభాషణలు పబ్లిక్గానే ఉంటాయి, ఎందుకంటే TikTokలో DMలు ఉండవు. business/comment/reply/create/, Access-Token హెడర్, business_id, video_id మరియు comment_id తో, 1,200 అక్షరాల వరకు రిప్లై పోస్ట్ చేస్తుంది. HTTP స్టేటస్ కాకుండా జవాబులోని code ఫీల్డ్ను చూడండి; 0 అంటే విజయం. comment_action insert మరియు comment_type comment ఉన్నవాటిపైనే పని చేయండి, ఎందుకంటే మీ స్వంత రిప్లైలు కూడా ఈవెంట్లుగా వస్తాయి.
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 },
});
}
}
}Node.js నుండి TikTokలో పోస్ట్ చేయడం మరియు TypeScript ఏజెంట్కు ఈ టూల్స్ ఇవ్వడం ఎలా?
రెండూ easyCoexistence యొక్క MCP సర్వర్ ద్వారా వెళ్తాయి: https://easycoexistence.com/api/mcp, ఇది OAuth 2.1 మాత్రమే అంగీకరిస్తుంది: డైనమిక్ క్లయింట్ రిజిస్ట్రేషన్, PKCE తో అథరైజేషన్ కోడ్, ఒక గంట పాటు ఉండే యాక్సెస్ టోకెన్లు మరియు రిఫ్రెష్ టోకెన్లు. Node 20 మరియు ఆ తర్వాతి వెర్షన్ల కోసం అధికారిక TypeScript SDK అయిన @modelcontextprotocol/client తో, OAuthClientProvider క్లయింట్, టోకెన్లు మరియు PKCE వెరిఫైయర్ను ఉంచుతుంది; మొదటి కనెక్ట్ వినియోగదారుని సైన్ ఇన్కు పంపి UnauthorizedError ను విసురుతుంది, మరియు కాల్బ్యాక్ యొక్క query తో finishAuth దాన్ని పూర్తి చేస్తుంది.
TikTok పబ్లిషింగ్ ఇక్కడే ఉంటుంది, ఎందుకంటే TikTok మీడియాను డౌన్లోడ్ చేసేది డెవలపర్ యాప్కు ధృవీకరించబడిన URL ప్రిఫిక్స్ల నుండి మాత్రమే, మరియు ఆ టోకెన్ వెనుక ఉన్న యాప్ మీదే. publish_tiktok_post మీ HTTPS లింక్ను తీసుకుని, easyCoexistence ధృవీకరించబడిన మీడియా రూట్పై సంతకం చేసిన చిరునామాను TikTokకు ఇస్తుంది, మరియు get_tiktok_publish_status ఆ పోస్ట్ను అనుసరిస్తుంది. అదే క్లయింట్ ఖాతా నెట్వర్క్ల అన్ని టూల్స్ను ఏజెంట్కు అందిస్తుంది; ముందు list_social_accounts కాల్ చేయండి, దాని account_id అనేది Partner API యొక్క 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_statusసాధారణ పొరపాట్లు
- పార్స్ చేసిన మరియు తిరిగి సీరియలైజ్ చేసిన JSON పై HMAC లెక్కించడం. సంతకం రా బాడీని బైట్ బైట్గా కవర్ చేస్తుంది, కాబట్టి ముందుగా req.text() కాల్ చేసి తర్వాత పార్స్ చేయండి, లేకపోతే ప్రతి డెలివరీ తనిఖీలో విఫలమవుతుంది.
- TikTok ఐడిలను సంఖ్యలుగా మార్చడం. కామెంట్ మరియు వీడియో ఐడిలు 64-bit, మరియు Number() వాటిని రౌండ్ చేస్తుంది, కాబట్టి రిప్లై ఇచ్చేటప్పుడు లేదా కామెంట్ను వెతికేటప్పుడు ఈవెంట్ తీసుకువచ్చే స్ట్రింగ్లనే ఉంచండి.
- redirect నుండి కేవలం channel_idను ఉంచడం. Facebook లేదా LinkedIn సైన్ ఇన్ ఒకేసారి అనేక Pageలను జోడించవచ్చు, కాబట్టి GET /channels?external_ref= తో వాటిని జాబితా చేసి ప్రతిదాన్ని నిల్వ చేయండి.
- రాత్రివేళ బ్యాచ్ నుండి Messenger లేదా Instagram DMకు రిప్లై ఇవ్వడం. వ్యక్తి చివరి మెసేజ్ నుండి 24 గంటలు దాటితే పంపడం విఫలమవుతుంది, కాబట్టి విండో తెరిచి ఉన్నప్పుడే ఈవెంట్ హ్యాండ్లర్ నుండి రిప్లై ఇవ్వండి.
easyCoexistence Node.js బ్యాకెండ్లు మరియు AI ఏజెంట్లకు WhatsApp, Instagram, Facebook, TikTok, YouTube, LinkedIn మరియు మరిన్ని ఛానళ్లలోని కస్టమర్లను చేరుకునే అవకాశం ఇస్తుంది, ప్రతిదీ అధికారిక API ద్వారా. Partner API తో ఖాతాలను కనెక్ట్ చేయండి, తాజా టోకెన్లు మరియు సంతకం చేసిన ఈవెంట్లు పొందండి, TypeScript ఏజెంట్లు MCP సర్వర్ ద్వారా పని చేయనివ్వండి, ప్రతి కనెక్షన్ 24/7 పర్యవేక్షించబడుతుంది. ఒక్కో కనెక్షన్కు నెలకు US$ 9 నుండి US$ 0.75 వరకు, మీరు కనెక్షన్లు జోడించే కొద్దీ తగ్గుతూ, మొదటి 3 రోజులు ఉచితం.
తరచుగా అడిగే ప్రశ్నలు
Node.js నుండి ఈ APIలను పిలవడానికి నాకు SDK కావాలా?
లేదు. Partner API మరియు నెట్వర్క్ల APIలు సాధారణ HTTPS, కాబట్టి Node 18 మరియు ఆ తర్వాతి వెర్షన్లలోని global fetch వాటిని కవర్ చేస్తుంది. @modelcontextprotocol/client అవసరం MCP టూల్స్ కోసం మాత్రమే, వాటిలో TikTok పబ్లిషింగ్ కూడా ఉంది.
TikTok పబ్లిషింగ్ ఎందుకు MCP సర్వర్ ద్వారా వెళ్తుంది?
TikTok వీడియోలు మరియు ఫోటోలను డెవలపర్ యాప్కు ధృవీకరించబడిన డొమైన్ లేదా URL ప్రిఫిక్స్ నుండి మాత్రమే డౌన్లోడ్ చేస్తుంది, మరియు ఆ యాప్ easyCoexistence దే. publish_tiktok_post మీ HTTPS ఫైల్ను ఆ ధృవీకరించబడిన చిరునామా నుండి అందిస్తుంది, కాబట్టి మీ స్వంత డొమైన్కు ధృవీకరణ అవసరం లేదు.
ఒకే సైన్ ఇన్తో అనేక Facebook లేదా LinkedIn Pages కనెక్ట్ చేయవచ్చా?
అవును. ప్రతి Page, మరియు LinkedInలో సభ్యుని స్వంత ప్రొఫైల్, దానికదే ఒక ఛానల్ మరియు ఒక కనెక్షన్ అవుతుంది. redirectలో మొదటి channel_id వస్తుంది, మరియు GET /channels?external_ref= వాటన్నింటినీ జాబితా చేస్తుంది.
Node.js కోసం easyCoexistence ఎంత ఖర్చు అవుతుంది?
ఒక్కో కనెక్షన్కు నెలకు US$ 9 నుండి US$ 0.75 వరకు, మీరు కనెక్షన్లు జోడించే కొద్దీ తగ్గుతుంది, మరియు ప్రతి నెట్వర్క్కు ఒకే ధర. Partner API మరియు MCP కనెక్టర్ దానితోనే వస్తాయి, సీట్లు అవసరం లేదు, మరియు మొదటి 3 రోజులు ఉచితం.
చదవడం కొనసాగించండి
మీ మొదటి ఛానెల్ను రెండు నిమిషాల్లో కనెక్ట్ చేయండి.
ప్లాట్ఫామ్ సమీక్షల కోసం ఎదురుచూడాల్సిన అవసరం లేదు. WhatsApp, Instagram, TikTok లేదా మరో ఛానెల్ను కనెక్ట్ చేయండి, ఆపై పోస్ట్ చేయమని, ప్రత్యుత్తరం ఇవ్వమని లేదా రిపోర్ట్ ఇవ్వమని మీ AIకి చెప్పండి, అది పని చేయడం చూడండి.
- 3 రోజులు ఉచితం
- ఎప్పుడైనా రద్దు చేయండి
- అధికారిక APIలు మాత్రమే
- 24/7 పర్యవేక్షణ
ధృవీకరించిన తేదీ