Facebook Pages API sa Python at Node.js: mga working example
Tumatawag ang Python at Node.js sa Facebook Pages API bilang simpleng HTTPS request sa graph.facebook.com/v26.0 gamit ang access token ng Page: nagpa-publish ang POST /{page-id}/feed at /{page-id}/photos, bumabasa at nagre-reply sa comments ang /{post-id}/comments, nagre-reply sa Messenger ang POST /{page-id}/messages, bumabasa ng metrics ang GET /{page-id}/insights, at sinusuri ng HMAC-SHA256 ng raw body ang X-Hub-Signature-256 sa bawat webhook.
Ibinibigay ng easyCoexistence sa isang naka-connect na Page ang mga trabahong ito bilang MCP tools, mula publish_facebook_post at reply_to_comment hanggang send_social_dm at get_social_insights, ipinapasa ang mga event nito na nilagdaan ng X-EC-Signature, at ibinibigay sa sariling code ninyo ang Page ID at API base sa pamamagitan ng get_social_credentials.
Ang text parameter ng isang Page photo; minamarkahan ito ng photos reference ng Meta bilang deprecated.
Response header na estimated_time_to_regain_access ang nagsasabi ng minuto bago muling gumana ang mga throttled call.
Ang messaging_type para sa reply sa mensaheng natanggap ng Page, na ipinadala sa loob ng 24-hour window.
Paano tinutugunan ng private reply ang taong nag-comment, sa parehong /{page-id}/messages endpoint.
Ano ang kailangan ng mga halimbawa bago tumakbo?
Page ID at access token ng Page na iyon, na kinukuha mula sa /me/accounts gamit ang long-lived user token, pati Python 3 na may requests, o Node.js 18 pataas, na walang kailangang package dahil built-in ang fetch. Kailangan din ng bawat trabaho ang permission nito sa token at ang task nito sa Page, at tumatawag ang mga halimbawa sa Graph API v26.0:
Paano mag-publish ng post at photo sa Python?
Gamit ang isang helper na muling ginagamit ng mga susunod na halimbawa: idinadagdag ng graph() ang Page token, ipinapadala ang GET parameters sa query string at POST fields bilang JSON, gaya ng sariling halimbawa ng Meta, at ginagawang GraphError na may code at error_subcode ang error object ng Meta. Naghihintay at nagre-retry lang ito sa temporary at rate-limit codes, hangga't hinihingi ng X-Business-Use-Case-Usage kapag bumalik ang header na iyon, at agad na itinataas ang iba.
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"])Paano sila i-publish sa Node.js?
Gamit ang parehong helper sa Node.js 18 pataas, na sine-save bilang .mjs file para gumana ang top-level await, at ang built-in fetch sa halip na client library. Ang photo call ay nagpapadala ng url at caption, ang text field ng photos edge; sumasagot ang Meta ng id ng photo at post_id ng Page post na naglalaman ng photo, habang ang feed call ay sumasagot ng id ng post lamang.
// 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);Paano magbasa at mag-reply sa comments sa Python?
Magbasa ng comments ng post gamit ang fields, filter=stream para sa comments sa lahat ng level ayon sa oras, at order=reverse_chronological para sa pinakabago muna, saka mag-reply bilang Page sa pamamagitan ng pagpo-post ng mensahe sa sariling comments edge ng comment. Dapat galing ang token sa taong may MODERATE, kung hindi ay iniiwan ng Meta ang comment IDs, at kailangan ng reply ang pages_manage_engagement. Ang paging.next ang humahantong pa pabalik.
# 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 backPaano magbasa at mag-reply sa comments sa Node.js?
Ang parehong dalawang call, gamit ang URL object sa pagbuo ng query string: isang GET na may fields, filter at order, saka isang POST sa /{comment-id}/comments. Ang can_reply_privately, na hinihingi sa fields, ang nagsasabi kung maipapadala pa ng Page sa commenter na iyon ang private reply, na mahalagang malaman bago ang Messenger example sa ibaba. Itabi ang IDs ng mga comment na nire-replyan ninyo, para hindi dalawang beses mag-reply kapag inulit ang takbo.
// 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 backPaano magpadala ng Messenger reply sa Python?
POST /{page-id}/messages na may recipient.id na nakatakda sa Page-scoped ID ng tao mula sa webhook ng mensahe, messaging_type na RESPONSE at ang text. Nahuhuli ng halimbawa ang dalawang pagtanggi na hindi na dapat i-retry: error 10 na may subcode 2534022 o 2018278 kapag sarado na ang 24-hour window, at 551 kapag hindi available ang tao. Inilalagay ng private_reply() ang recipient.comment_id sa lugar ng ID, para sa iisang mensaheng pinapayagan ng comment sa loob ng 7 araw.
# 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})Paano magpadala ng Messenger reply sa Node.js?
Ang parehong request body sa JavaScript, na may recipient, messaging_type at message na ipinapadala bilang JSON ng graph(). Sumasagot ang Meta ng recipient_id at message_id sa pagpapadalang tinanggap, na sulit i-save kasama ng conversation. Ang pribadong reply ay may link pabalik sa comment na sinasagot nito, at magpapatuloy ang conversation sa karaniwang 24-hour window kapag sumulat ulit ang tao.
// 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 },
});
}Paano magbasa ng Page insights sa Python?
GET /{page-id}/insights na may listahan ng metric na pinaghihiwalay ng kuwit, period=day, at since at until window sa UNIX seconds; hanggang 90 araw ang saklaw ng isang request. Tatlo sa mga metric na ito ang pumalit sa mga inalis ng Meta: page_media_view mula sa page_impressions, page_total_media_view_unique mula sa page_impressions_unique, at page_follows mula sa page_fans, habang binibilang ng page_post_engagements ang reactions, comments at shares.
# 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"])Paano magbasa ng Page insights sa Node.js?
Ang parehong call, na may since at until na kinukuwenta mula sa Date.now() sa segundo. Bawat metric ay may pangalan, period, at listahan ng values na may value at end_time na pares, isa bawat araw; kapag nakatakda ang since, ang unang end_time ay nasa araw pagkatapos nito, para kasama ang data ng araw na iyon. Kailangan ng token ang read_insights at pages_read_engagement, mula sa taong may ANALYZE task.
// 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);
}
}Paano i-verify ang webhook signature sa Python?
Kuwentahin muli ang X-Hub-Signature-256 mula sa raw request body at sa app secret, saka ihambing ang dalawa sa constant time. Nilalagdaan ng Meta ang bawat POST gamit ang HMAC-SHA256 ng payload, gamit ang App Secret mula sa basic settings ng App Dashboard, at isinusulat ito pagkatapos ng sha256=. Ipasa ang body bilang bytes, bago anumang JSON parsing: ibinibigay ng request.body sa Django at ng await request.body() sa FastAPI ang mismong bytes na nilagdaan ng Meta.
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"))Paano i-verify ang webhook signature sa Node.js?
Ang parehong check gamit ang node:crypto, na nangangailangan ng body bilang Buffer: sa Express, pinapanatili ng express.raw itong hindi na-parse sa route na iyon. Ang timingSafeEqual ay nagtatapon ng error kapag magkaiba ang haba ng input, kaya unang tinitingnan ang haba. Sumagot ng 200 agad at gawin ang trabaho pagkatapos, dahil ni-retry ng Meta ang mga palpak na delivery at maaaring magpadala ng event nang dalawang beses; sakop ng verification page ang hub.challenge handshake na nauuna sa anumang event.
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
// });Aling mga error code ang dapat aksyunan ng code?
Ang mga tinutukoy ng error guides ng Meta, dahil bawat isa ay nangangailangan ng ibang tugon: ang pag-retry sa tinanggihang token o maling parameter ay papalya lang muli, samantalang ang throttled call ay nagtatagumpay pagkatapos ng paghihintay. Nagre-retry ang graph() sa temporary at rate-limit codes at itinataas ang iba para asikasuhin ng tumatawag:
Paano patakbuhin ang parehong trabaho sa pamamagitan ng easyCoexistence?
Bilang MCP tools na tinatawag ng Claude, ChatGPT o sariling agent ninyo sa isang naka-connect na Page, habang hawak ng easyCoexistence ang token. Hindi kailanman ibinibigay ang mga Page token, kaya tumatakbo ang mga halimbawa sa itaas gamit ang token mula sa sarili ninyong Meta app; ibinabalik ng get_social_credentials ang ID ng Page at ang Graph API base. Ang tool ng bawat trabaho:
Mga karaniwang pagkakamali
- Pagtawag sa Page endpoints gamit ang user token. Karamihan sa mga ito ay umaasa sa sariling token ng Page, at ang mga call na gawa sa user o app token ay binibilang sa rate limit na iyon sa halip na sa Page.
- Pag-publish ng parehong text nang sunod-sunod. Tinatanggihan ng Meta ang magkasunod na magkaparehong post gamit ang error 506, kaya ang trabahong inuulit ay dapat mag-iba ng nilalaman o laktawan ang post.
- Pagdaragdag ng araw-araw na unique viewers. Binibilang ng page_total_media_view_unique ang mga unique viewer sa bawat period, kaya hindi nagsasama-sama ang araw-araw na value sa isang buwan; humingi ng period na days_28 sa halip.
- Pagpapadala ng Page token sa browser o app. Dapat nasa server ang mga call na ito, kung saan nananatiling wala sa abot ng sinumang makababasa ng client ang token.
Mula US$ 9 hanggang US$ 0.75 kada koneksyon kada buwan, bumababa habang dumarami ang koneksyon, at libre ang unang 3 araw.
Mga madalas itanong
Kailangan ko ba ng SDK para tawagin ang Facebook Pages API?
Hindi. HTTPS na may JSON ang Graph API, kaya sapat na ang request sa Python at ang fetch na built-in sa Node.js 18 pataas, gaya ng ipinapakita ng mga halimbawa sa pahinang ito.
Maaari bang mag-post ang parehong code sa maraming Page?
Oo. Nagbabalik ang /me/accounts ng hiwalay na token para sa bawat Page, kaya magtabi ng isa bawat Page at ipasa ang kaukulang PAGE_ID at PAGE_TOKEN; ang mga call gamit ang Page token ay binibilang sa sariling rate limit ng Page na iyon.
Saan galing ang PSID para sa Messenger reply?
Sa webhook ng mensahe: ang sender.id sa bawat event ng webhook ay ang Page-scoped ID ng tao, natatangi sa taong iyon at Page. Ang User ID mula sa Facebook Login ay app-scoped at hindi gumagana sa Messenger Platform.
Magkano ang easyCoexistence para sa isang Facebook Page?
Bawat naka-connect na Page ay binibilang bilang isang koneksyon, sa US$ 9 hanggang US$ 0.75 kada koneksyon kada buwan depende sa dami ng mayroon kayo, at libre ang unang 3 araw; kasama na ang MCP tools.
Magpatuloy sa pagbabasa
I-connect ang inyong unang channel sa loob ng dalawang minuto.
Walang review ng platform na hihintayin. I-connect ang WhatsApp, Instagram, TikTok o iba pang channel, pagkatapos ay utusan ang inyong AI na mag-post, mag-reply o gumawa ng report, at panoorin itong gumana.
- 3 araw na libre
- Mag-cancel anumang oras
- Official API lang
- Minomonitor 24/7
Na-verify noong