Python மற்றும் Node.js இல் Facebook Pages API: வேலை செய்யும் எடுத்துக்காட்டுகள்
Python மற்றும் Node.js, Page-இன் அணுகல் டோக்கனுடன் graph.facebook.com/v26.0க்கு வெறும் HTTPS கோரிக்கைகளாக Facebook Pages API-ஐ அழைக்கின்றன: POST /{page-id}/feed மற்றும் /{page-id}/photos வெளியிடுகின்றன, /{post-id}/comments கருத்துகளைப் படித்து அவற்றுக்குப் பதிலளிக்கிறது, POST /{page-id}/messages Messenger-இல் பதிலளிக்கிறது, GET /{page-id}/insights அளவீடுகளைப் படிக்கிறது, மேலும் ஒவ்வொரு வெப்ஹூக்கிலும் X-Hub-Signature-256-ஐ, மூல உள்ளடக்கத்தின் HMAC-SHA256 உடன் சரிபார்க்கிறது.
easyCoexistence இணைக்கப்பட்ட Page-க்கு இந்தப் பணிகளை MCP கருவிகளாக வழங்குகிறது, publish_facebook_post மற்றும் reply_to_comment முதல் send_social_dm மற்றும் get_social_insights வரை, அதன் நிகழ்வுகளை X-EC-Signature உடன் கையொப்பமிட்டு அனுப்புகிறது, மேலும் get_social_credentials வழியாக உங்கள் சொந்த குறியீட்டுக்கு Page ID-யும் API அடிப்படை முகவரியும் தருகிறது.
Page புகைப்படத்தின் text parameter; Meta-வின் photos reference இங்கே மெசேஜ் நிறுத்தப்பட்டதாகக் குறிக்கிறது.
estimated_time_to_regain_access கொடுக்கும் பதில் ஹெடர்; வரம்பு அடைந்த அழைப்புகள் மீண்டும் வேலை செய்ய எத்தனை நிமிடங்கள் ஆகும் என்பதை அது காட்டுகிறது.
Page பெற்ற மெசேஜுக்குப் பதிலளிக்கும்போது messaging_type; 24 மணி நேர சாளரத்துக்குள் அனுப்பப்படுகிறது.
கருத்து தெரிவித்த நபரை தனிப்பட்ட பதில் எப்படி முகவரியிடுகிறது, அதே /{page-id}/messages எண்ட்பாயிண்ட் வழியாக.
எடுத்துக்காட்டுகள் இயங்குவதற்கு முன் என்ன தேவை?
Page ID மற்றும் அந்த Page-இன் அணுகல் டோக்கன், நீண்டகால பயனர் டோக்கனுடன் /me/accounts-இலிருந்து படிக்கப்பட்டது, அத்துடன் requests நூலகத்துடன் Python 3, அல்லது Node.js 18 அல்லது அதற்குப் பிந்தைய பதிப்பு; அதன் உள்ளமைந்த fetch-க்கு எந்த பேக்கேஜ்-உம் தேவையில்லை. ஒவ்வொரு பணிக்கும் டோக்கனில் அதன் அனுமதியும் Page-இல் அதன் பணியும் தேவை; எடுத்துக்காட்டுகள் Graph API v26.0-ஐ அழைக்கின்றன:
Python-இல் இடுகையையும் புகைப்படத்தையும் எப்படி வெளியிடுவது?
பின்வரும் எடுத்துக்காட்டுகள் மீண்டும் பயன்படுத்தும் ஒரு உதவி செயல்பாட்டுடன்: graph() Page டோக்கனைச் சேர்க்கிறது, GET அளவுருக்களை வினவல் சரத்தில் அனுப்புகிறது, POST புலங்களை Meta-வின் சொந்த எடுத்துக்காட்டுகளைப் போல JSON-ஆக அனுப்புகிறது, மேலும் Meta-வின் பிழை ஆப்ஜெக்ட்டை code மற்றும் error_subcode கொண்ட GraphError-ஆக மாற்றுகிறது. தற்காலிக மற்றும் விகித வரம்பு குறியீடுகளுக்கு மட்டுமே காத்திருந்து மீண்டும் முயற்சிக்கிறது; அந்த ஹெடர் திரும்பி வரும்போது X-Business-Use-Case-Usage கேட்கும் நேரம் வரை காத்திருக்கிறது, மற்றவற்றை உடனடியாக எழுப்புகிறது.
import json, os, time
import requests
GRAPH = "https://graph.facebook.com/v26.0"
PAGE_ID = os.environ["PAGE_ID"]
PAGE_TOKEN = os.environ["PAGE_TOKEN"] # the Page's own token, from /me/accounts
RETRY = {1, 2, 4, 17, 32, 613, 80001} # temporary or rate limited
class GraphError(Exception):
def __init__(self, err):
super().__init__(err.get("message"))
self.code, self.subcode = err.get("code"), err.get("error_subcode")
def wait_seconds(response, attempt):
usage = json.loads(response.headers.get("x-business-use-case-usage", "{}"))
minutes = [u.get("estimated_time_to_regain_access", 0) for v in usage.values() for u in v]
return max([60 * m for m in minutes] + [30 * 2 ** attempt])
def graph(method, path, retries=3, **fields):
fields["access_token"] = PAGE_TOKEN
send = {"params": fields} if method == "GET" else {"json": fields}
for attempt in range(retries + 1):
response = requests.request(method, f"{GRAPH}/{path}", timeout=30, **send)
body = response.json()
if "error" not in body:
return body
err = GraphError(body["error"])
if err.code not in RETRY or attempt == retries:
raise err
time.sleep(wait_seconds(response, attempt))
post = graph("POST", f"{PAGE_ID}/feed", message="Open until 11pm this Friday.")
photo = graph("POST", f"{PAGE_ID}/photos",
url="https://example.com/menu.jpg", caption="This week's menu")
print(post["id"], photo["post_id"])Node.js-இல் அவற்றை எப்படி வெளியிடுவது?
அதே உதவி செயல்பாடு Node.js 18 அல்லது அதற்குப் பிந்தைய பதிப்பில், top-level await வேலை செய்யும் வகையில் .mjs கோப்பாகச் சேமிக்கப்பட்டு, கிளையன்ட் லைப்ரரிக்குப் பதிலாக உள்ளமைந்த fetch உடன். புகைப்பட அழைப்பு url மற்றும் caption-ஐ அனுப்புகிறது, அவை photos எட்ஜின் text புலம்; Meta புகைப்பட ID மற்றும் புகைப்படம் உள்ள Page இடுகையின் post_id-ஐத் திருப்பித் தருகிறது, feed அழைப்பு இடுகையின் ID-ஐ மட்டும் தருகிறது.
// Node.js 18 or later, saved as an .mjs file: fetch and top-level await are built in.
const GRAPH = "https://graph.facebook.com/v26.0";
const { PAGE_ID, PAGE_TOKEN } = process.env; // the Page's own token, from /me/accounts
const RETRY = new Set([1, 2, 4, 17, 32, 613, 80001]); // temporary or rate limited
class GraphError extends Error {
constructor(err) {
super(err.message);
this.code = err.code;
this.subcode = err.error_subcode;
}
}
function waitMs(response, attempt) {
const usage = JSON.parse(response.headers.get("x-business-use-case-usage") ?? "{}");
const minutes = Object.values(usage).flat().map((u) => u.estimated_time_to_regain_access ?? 0);
return Math.max(30_000 * 2 ** attempt, ...minutes.map((m) => m * 60_000));
}
async function graph(method, path, fields = {}, retries = 3) {
const url = new URL(`${GRAPH}/${path}`);
const init = { method };
const all = { ...fields, access_token: PAGE_TOKEN };
if (method === "GET") {
for (const [key, value] of Object.entries(all)) url.searchParams.set(key, String(value));
} else {
init.headers = { "Content-Type": "application/json" };
init.body = JSON.stringify(all);
}
for (let attempt = 0; ; attempt++) {
const response = await fetch(url, init);
const body = await response.json();
if (!body.error) return body;
if (!RETRY.has(body.error.code) || attempt === retries) throw new GraphError(body.error);
await new Promise((done) => setTimeout(done, waitMs(response, attempt)));
}
}
const post = await graph("POST", `${PAGE_ID}/feed`, { message: "Open until 11pm this Friday." });
const photo = await graph("POST", `${PAGE_ID}/photos`, {
url: "https://example.com/menu.jpg",
caption: "This week's menu",
});
console.log(post.id, photo.post_id);Python-இல் கருத்துகளைப் படித்து அவற்றுக்குப் பதிலளிப்பது எப்படி?
ஒரு இடுகையின் கருத்துகளை fields-உடன் படியுங்கள், எல்லா நிலைகளின் கருத்துகளுக்கும் filter=stream என்றும், புதியவை முதலில் வரும் வகையில் order=reverse_chronological என்றும் அமையுங்கள்; பின்னர் கருத்தின் சொந்த comments எட்ஜுக்கு மெசேஜ் அனுப்புவதன் மூலம் Page-ஆகப் பதிலளியுங்கள். MODERATE பணி செய்யக்கூடியவரிடமிருந்து டோக்கன் வர வேண்டும், இல்லையெனில் Meta கருத்து ID-களை விட்டுவிடும்; பதிலளிக்க pages_manage_engagement தேவை. paging.next மேலும் பின்னோக்கிச் செல்லும் பக்கத்திற்கு இட்டுச் செல்கிறது.
# graph() as in the first example
post_id = post["id"] # {page-id}_{post-id}, as the publish call returned it
page = graph("GET", f"{post_id}/comments", fields="id,message,created_time,can_reply_privately",
filter="stream", order="reverse_chronological", limit=50)
for comment in page["data"]:
if "?" in comment.get("message", ""):
graph("POST", f"{comment['id']}/comments",
message="Thanks for asking! Our hours are on the Page.")
older = page.get("paging", {}).get("next") # follow it to read further backNode.js-இல் கருத்துகளைப் படித்து அவற்றுக்குப் பதிலளிப்பது எப்படி?
அதே இரண்டு அழைப்புகள், query string-ஐ URL ஆப்ஜெக்ட் உருவாக்குகிறது: fields, filter மற்றும் order உடன் GET, பின்னர் /{comment-id}/comments-க்கு POST. fields-இல் கோரப்பட்ட can_reply_privately, கருத்து தெரிவித்தவருக்கு இன்னும் தனிப்பட்ட பதில் அனுப்ப Page-ஆல் முடியுமா என்பதைச் சொல்கிறது; கீழே உள்ள Messenger எடுத்துக்காட்டுக்கு முன் அதை அறிவது பயனுள்ளது. நீங்கள் பதிலளித்த கருத்துகளின் ID-களைச் சேமித்து வையுங்கள், மீண்டும் இயக்கினால் இரண்டு முறை பதிலளிக்காமல் இருக்க.
// graph() as in the first example
const postId = post.id; // {page-id}_{post-id}, as the publish call returned it
const page = await graph("GET", `${postId}/comments`, {
fields: "id,message,created_time,can_reply_privately",
filter: "stream",
order: "reverse_chronological",
limit: 50,
});
for (const comment of page.data) {
if ((comment.message ?? "").includes("?")) {
await graph("POST", `${comment.id}/comments`, {
message: "Thanks for asking! Our hours are on the Page.",
});
}
}
const older = page.paging?.next; // follow it to read further backPython-இல் Messenger பதிலை எப்படி அனுப்புவது?
POST /{page-id}/messages, recipient.id-ஐ messages வெப்ஹூக்கிலிருந்து நபரின் Page-scoped ID-க்கு அமைத்து, messaging_type RESPONSE மற்றும் text உடன். மீண்டும் முயற்சிக்கத் தகாத இரண்டு மறுப்புகளை எடுத்துக்காட்டு பிடிக்கிறது: 24 மணி நேர சாளரம் முடிந்தபோது 2534022 அல்லது 2018278 subcode உடன் பிழை 10, மற்றும் நபர் கிடைக்காதபோது 551. private_reply() ID-க்குப் பதில் recipient.comment_id-ஐ வைக்கிறது, ஒரு கருத்துக்கு 7 நாட்களுக்குள் அனுமதிக்கப்படும் ஒரே மெசேஜுக்காக.
# graph(), GraphError and PAGE_ID as in the first example
def reply(psid, text):
"""psid: sender.id from the messages webhook, within 24 hours of the person's message."""
try:
return graph("POST", f"{PAGE_ID}/messages", recipient={"id": psid},
messaging_type="RESPONSE", message={"text": text})
except GraphError as e:
if (e.code == 10 and e.subcode in (2534022, 2018278)) or e.code == 551:
return None # the window has closed, or the person is unavailable: no retry
raise
def private_reply(comment_id, text):
"""One Messenger message to the person who commented, within 7 days of the comment."""
return graph("POST", f"{PAGE_ID}/messages", recipient={"comment_id": comment_id},
message={"text": text})Node.js-இல் Messenger பதிலை எப்படி அனுப்புவது?
அதே கோரிக்கை உள்ளடக்கம், JavaScript-இல்: recipient, messaging_type மற்றும் message, graph() JSON-ஆக அனுப்புகிறது. Meta ஏற்றுக்கொண்ட அனுப்புதலுக்கு recipient_id மற்றும் message_id திருப்பித் தருகிறது, அவற்றை உரையாடலுடன் சேமித்து வையுங்கள். தனிப்பட்ட பதில் அது பதிலளிக்கும் கருத்துடன் மீண்டும் இணைப்பைக் கொண்டிருக்கும்; நபர் மீண்டும் எழுதியதும் உரையாடல் வழக்கமான 24 மணி நேர சாளரத்தில் தொடரும்.
// graph(), GraphError and PAGE_ID as in the first example
async function reply(psid, text) {
// psid: sender.id from the messages webhook, within 24 hours of the person's message
try {
return await graph("POST", `${PAGE_ID}/messages`, {
recipient: { id: psid },
messaging_type: "RESPONSE",
message: { text },
});
} catch (e) {
const closed =
e instanceof GraphError && ((e.code === 10 && [2534022, 2018278].includes(e.subcode)) || e.code === 551);
if (closed) return null; // the window has closed, or the person is unavailable: no retry
throw e;
}
}
function privateReply(commentId, text) {
// one Messenger message to the person who commented, within 7 days of the comment
return graph("POST", `${PAGE_ID}/messages`, {
recipient: { comment_id: commentId },
message: { text },
});
}Python-இல் Page insights-ஐ எப்படி படிப்பது?
GET /{page-id}/insights, கமாவால் பிரிக்கப்பட்ட அளவீட்டுப் பட்டியல், period=day, மற்றும் UNIX வினாடிகளில் since மற்றும் until சாளரத்துடன்; ஒரு கோரிக்கை 90 நாட்கள் வரை உள்ளடக்கும். Meta நீக்கிய அளவீடுகளில் மூன்று இடம்பெயர்ந்துள்ளன: page_impressions-க்குப் பதிலாக page_media_view, page_impressions_unique-க்குப் பதிலாக page_total_media_view_unique, page_fans-க்குப் பதிலாக page_follows; அதே நேரத்தில் page_post_engagements எதிர்வினைகள், கருத்துகள் மற்றும் பகிர்வுகளை எண்ணுகிறது.
# graph() and PAGE_ID as in the first example
until = int(time.time())
since = until - 28 * 86400 # one request can cover up to 90 days
metrics = "page_media_view,page_total_media_view_unique,page_post_engagements,page_follows"
data = graph("GET", f"{PAGE_ID}/insights", metric=metrics, period="day", since=since, until=until)
for metric in data["data"]:
for point in metric["values"]:
print(metric["name"], point["end_time"][:10], point["value"])Node.js-இல் Page insights-ஐ எப்படி படிப்பது?
அதே அழைப்பு, since மற்றும் until Date.now() இலிருந்து வினாடிகளில் கணக்கிடப்பட்டு. ஒவ்வொரு அளவீடும் அதன் பெயர், period மற்றும் value மற்றும் end_time இணைகளின் values பட்டியலுடன் திரும்புகிறது, ஒரு நாளுக்கு ஒன்று; since அமைக்கப்பட்டிருந்தால், முதல் end_time அதன் அடுத்த நாளில் விழுகிறது, அதனால் அந்த நாளின் தரவு சேர்க்கப்படுகிறது. டோக்கனுக்கு read_insights மற்றும் pages_read_engagement தேவை, ANALYZE பணி உள்ளவரிடமிருந்து.
// graph() and PAGE_ID as in the first example
const until = Math.floor(Date.now() / 1000);
const since = until - 28 * 86400; // one request can cover up to 90 days
const data = await graph("GET", `${PAGE_ID}/insights`, {
metric: "page_media_view,page_total_media_view_unique,page_post_engagements,page_follows",
period: "day",
since,
until,
});
for (const metric of data.data) {
for (const point of metric.values) {
console.log(metric.name, point.end_time.slice(0, 10), point.value);
}
}Python-இல் வெப்ஹூக் கையொப்பத்தை எப்படி சரிபார்ப்பது?
மூல கோரிக்கை உள்ளடக்கம் மற்றும் ஆப் ரகசியத்திலிருந்து X-Hub-Signature-256-ஐ மீண்டும் கணக்கிட்டு, இரண்டையும் நிலையான நேரத்தில் ஒப்பிடுங்கள். Meta ஒவ்வொரு POST-ஐயும் பேலோட்டின் HMAC-SHA256 உடன் கையொப்பமிடுகிறது, App Dashboard-இன் basic settings-இல் உள்ள App Secret-ஐ சாவியாகக் கொண்டு, அதை sha256= என்பதன் பின்னால் எழுதுகிறது. உள்ளடக்கத்தை JSON பகுப்பாய்வுக்கு முன், bytes-ஆக அனுப்புங்கள்: Django-இல் request.body மற்றும் FastAPI-இல் await request.body() இரண்டும் Meta கையொப்பமிட்ட bytes-ஐத் தருகின்றன.
import hashlib, hmac, os
APP_SECRET = os.environ["APP_SECRET"].encode() # App Dashboard, Settings, Basic
def signed_by_meta(raw_body: bytes, header: str) -> bool:
"""raw_body: the request body exactly as received. header: X-Hub-Signature-256."""
expected = "sha256=" + hmac.new(APP_SECRET, raw_body, hashlib.sha256).hexdigest()
return hmac.compare_digest(expected.encode(), (header or "").encode())
# Django: signed_by_meta(request.body, request.headers.get("X-Hub-Signature-256"))
# FastAPI: signed_by_meta(await request.body(), request.headers.get("X-Hub-Signature-256"))Node.js-இல் வெப்ஹூக் கையொப்பத்தை எப்படி சரிபார்ப்பது?
அதே சரிபார்ப்பு node:crypto உடன், உள்ளடக்கம் Buffer-ஆக இருக்க வேண்டும்: Express-இல் express.raw அந்த route-இல் அதைப் பகுக்காமல் வைத்திருக்கும். timingSafeEqual வெவ்வேறு நீளமுள்ள உள்ளீடுகளில் பிழை எறியும், அதனால் நீள சோதனை முதலில் நடக்க வேண்டும். 200 பதிலை விரைவாக அனுப்புங்கள், வேலையைப் பின்னர் செய்யுங்கள்; Meta தோல்வியடைந்த டெலிவரிகளை மீண்டும் முயற்சிக்கிறது, ஒரு நிகழ்வை இரண்டு முறை அனுப்பலாம். hub.challenge கைகுலுக்கல் பற்றி சரிபார்ப்புப் பக்கம் விளக்குகிறது, அது எந்த நிகழ்வுக்கு முன்பும் வருகிறது.
import crypto from "node:crypto";
const APP_SECRET = process.env.APP_SECRET; // App Dashboard, Settings, Basic
function signedByMeta(rawBody, header = "") {
// rawBody: a Buffer holding the request body exactly as received. header: X-Hub-Signature-256
const digest = crypto.createHmac("sha256", APP_SECRET).update(rawBody).digest("hex");
const expected = Buffer.from(`sha256=${digest}`);
const given = Buffer.from(header);
return given.length === expected.length && crypto.timingSafeEqual(given, expected);
}
// Express: app.post("/webhook", express.raw({ type: "application/json" }), (req, res) => {
// if (!signedByMeta(req.body, req.get("X-Hub-Signature-256"))) return res.sendStatus(401);
// res.sendStatus(200); // then work on JSON.parse(req.body) after answering
// });எந்தப் பிழை குறியீடுகளின் மீது குறியீடு செயல்பட வேண்டும்?
Meta-வின் பிழை வழிகாட்டிகள் வேறுபடுத்தும் குறியீடுகள், ஏனெனில் ஒவ்வொன்றுக்கும் வேறு பதில் தேவை: நிராகரிக்கப்பட்ட டோக்கன் அல்லது தவறான அளவுருவை மீண்டும் முயற்சிப்பது மீண்டும் தோல்வியடையும் மட்டுமே, ஆனால் வரம்பு அடைந்த அழைப்பு காத்திருப்புக்குப் பிறகு வெற்றிபெறும். graph() தற்காலிக மற்றும் விகித வரம்பு குறியீடுகளை மீண்டும் முயற்சிக்கிறது, மற்றவற்றை அழைப்பாளர் கையாள எழுப்புகிறது:
அதே பணிகளை easyCoexistence வழியாக எப்படி இயக்குவது?
இணைக்கப்பட்ட Page-இல் Claude, ChatGPT அல்லது உங்கள் சொந்த ஏஜென்ட் அழைக்கும் MCP கருவிகளாக, டோக்கன் easyCoexistence-இன் வசம் இருக்கும். Page டோக்கன்கள் ஒருபோதும் வழங்கப்படுவதில்லை, அதனால் மேலே உள்ள எடுத்துக்காட்டுகள் உங்கள் சொந்த Meta ஆப்பின் டோக்கனில் இயங்குகின்றன; get_social_credentials Page-இன் ID மற்றும் Graph API அடிப்படை URL-ஐத் தருகிறது. ஒவ்வொரு பணியின் கருவி:
பொதுவான தவறுகள்
- Page எண்ட்பாயிண்ட்களை பயனர் டோக்கனுடன் அழைப்பது. அவற்றில் பெரும்பாலானவை Page-இன் சொந்த டோக்கனை எதிர்பார்க்கின்றன; பயனர் அல்லது ஆப் டோக்கனுடன் செய்யப்படும் அழைப்புகள் Page-இன் விகித வரம்புகளுக்குப் பதிலாக அந்த வரம்புகளுக்கு எதிராக எண்ணப்படுகின்றன.
- ஒரே உரையை தொடர்ச்சியாக இருமுறை இடுவது. Meta தொடர்ச்சியான நகல் இடுகைகளை பிழை 506 உடன் மறுக்கிறது, அதனால் மீண்டும் இயங்கும் பணி உள்ளடக்கத்தை மாற்ற வேண்டும் அல்லது இடுகையைத் தவிர்க்க வேண்டும்.
- தினசரி தனித்துவ பார்வையாளர்களைக் கூட்டுவது. page_total_media_view_unique ஒவ்வொரு காலகட்டத்திலும் தனித்துவ பார்வையாளர்களை எண்ணுகிறது, அதனால் தினசரி மதிப்புகள் ஒரு மாதமாகக் கூடாது; அதற்குப் பதிலாக period days_28 கேளுங்கள்.
- Page டோக்கனை உலாவிக்கோ அல்லது ஆப்புக்கோ அனுப்புவது. இந்த அழைப்புகள் சர்வரில் இருக்க வேண்டும், அங்கு கிளையண்டைப் படிக்கக்கூடிய எவரும் டோக்கனை அணுக முடியாது.
ஒரு இணைப்புக்கு மாதத்துக்கு US$ 9 முதல் US$ 0.75 வரை, இணைப்புகளைச் சேர்க்கச் சேர்க்கக் குறைகிறது, முதல் 3 நாட்கள் இலவசம்.
அடிக்கடி கேட்கப்படும் கேள்விகள்
Facebook Pages API-ஐ அழைக்க எனக்கு SDK தேவையா?
இல்லை. Graph API என்பது JSON உடன் HTTPS; அதனால் Python-இல் கோரிக்கைகளும் Node.js 18 அல்லது அதற்குப் பிந்தையதில் உள்ளமைந்த fetch-உம் போதும், இந்தப் பக்கத்தின் எடுத்துக்காட்டுகள் காட்டுவது போல.
அதே குறியீடு பல Page-களில் இடுக முடியுமா?
ஆம். /me/accounts ஒவ்வொரு Page-க்கும் தனி டோக்கனைத் தருகிறது, அதனால் ஒவ்வொன்றுக்கும் ஒன்றை வைத்து, பொருந்தும் PAGE_ID மற்றும் PAGE_TOKEN-ஐ அனுப்புங்கள்; Page டோக்கனுடன் செய்யப்படும் அழைப்புகள் அந்த Page-இன் சொந்த விகித வரம்புக்கு எதிராக எண்ணப்படுகின்றன.
Messenger பதிலுக்கான PSID எங்கிருந்து வருகிறது?
messages வெப்ஹூக்கிலிருந்து: ஒவ்வொரு messaging நிகழ்விலும் sender.id என்பது நபரின் Page-scoped ID, அந்த நபருக்கும் Page-க்கும் தனித்துவமானது. Facebook Login-இன் பயனர் ID-கள் ஆப்-scoped, அவை Messenger Platform உடன் வேலை செய்யாது.
easyCoexistence ஒரு Facebook Page-க்கு எவ்வளவு செலவாகும்?
இணைக்கப்பட்ட ஒவ்வொரு Page-உம் ஒரு இணைப்பாக எண்ணப்படுகிறது; உங்களிடம் எத்தனை இருக்கின்றன என்பதைப் பொறுத்து ஒரு இணைப்புக்கு மாதத்துக்கு US$ 9 முதல் US$ 0.75 வரை, முதல் 3 நாட்கள் இலவசம்; MCP கருவிகள் அதனுடன் வருகின்றன.
தொடர்ந்து படிக்கவும்
உங்கள் முதல் சேனலை இரண்டு நிமிடங்களில் இணையுங்கள்.
காத்திருக்க வேண்டிய தளச் மதிப்பாய்வுகள் எதுவும் இல்லை. WhatsApp, Instagram, TikTok அல்லது வேறொரு சேனலை இணையுங்கள். பிறகு போஸ்ட் செய்ய, பதிலளிக்க அல்லது ரிப்போர்ட் தர உங்கள் AI-யிடம் கேளுங்கள், அது செயல்படுவதைப் பாருங்கள்.
- 3 நாட்கள் இலவசம்
- எப்போது வேண்டுமானாலும் ரத்து செய்யலாம்
- அதிகாரப்பூர்வ API-கள் மட்டுமே
- 24/7 கண்காணிப்பு
இதில் சரிபார்க்கப்பட்டது: