Facebook Pages API în Python și Node.js: exemple funcționale
Python și Node.js apelează Facebook Pages API prin simple cereri HTTPS către graph.facebook.com/v26.0, cu token-ul de acces al Paginii: POST /{page-id}/feed și /{page-id}/photos publică, /{post-id}/comments citește și răspunde la comentarii, POST /{page-id}/messages răspunde în Messenger, GET /{page-id}/insights citește metricile, iar un HMAC-SHA256 al corpului brut verifică X-Hub-Signature-256 la fiecare webhook.
easyCoexistence oferă unei Pagini conectate aceste sarcini ca instrumente MCP, de la publish_facebook_post și reply_to_comment până la send_social_dm și get_social_insights, redirecționează evenimentele sale semnate cu X-EC-Signature și îi oferă codului propriu ID-ul Paginii și baza API prin get_social_credentials.
Parametrul text al unei fotografii de Pagină; referința Meta la fotografii marchează mesajul ca depreciat acolo.
Antet de răspuns al cărui estimated_time_to_regain_access indică minutele până când apelurile limitate funcționează din nou.
messaging_type pentru un răspuns la un mesaj primit de Pagină, trimis în fereastra de 24 de ore.
Modul în care un răspuns privat se adresează persoanei care a comentat, prin același endpoint /{page-id}/messages.
Ce au nevoie exemplele înainte să ruleze?
Un ID de Pagină și token-ul de acces al acelei Pagini, citit din /me/accounts cu un token de utilizator de lungă durată, plus Python 3 cu requests sau Node.js 18 sau mai nou, al cărui fetch încorporat nu necesită niciun pachet. Fiecare sarcină are nevoie și de permisiunea sa pe token și de sarcina sa pe Pagină, iar exemplele apelează Graph API v26.0:
Cum publicați o postare și o fotografie în Python?
Cu un singur helper pe care îl reutilizează exemplele următoare: graph() adaugă token-ul Paginii, trimite parametrii GET în query string și câmpurile POST ca JSON, așa cum fac exemplele Meta, și transformă obiectul de eroare Meta într-un GraphError care poartă code și error_subcode. Așteaptă și reîncearcă doar codurile temporare și de limitare a ratei, atât timp cât cere X-Business-Use-Case-Usage atunci când acest antet revine, și ridică imediat celelalte.
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"])Cum le publicați în Node.js?
Cu același helper în Node.js 18 sau mai nou, salvat ca fișier .mjs ca await de nivel superior să funcționeze, și cu fetch-ul încorporat în locul unei biblioteci client. Apelul pentru fotografie trimite url și caption, câmpul text al edge-ului photos; Meta răspunde cu id-ul fotografiei și cu post_id-ul postării Paginii care conține fotografia, în timp ce apelul pentru feed răspunde doar cu id-ul postării.
// 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);Cum citiți și răspundeți la comentarii în Python?
Citiți comentariile unei postări cu fields, filter=stream pentru comentarii de toate nivelurile în ordine cronologică și order=reverse_chronological pentru cele mai noi primele, apoi răspundeți ca Pagina trimițând un mesaj către edge-ul comments al comentariului. Token-ul trebuie să aparțină cuiva care poate efectua MODERATE, altfel Meta omite ID-urile comentariilor, iar răspunsul necesită pages_manage_engagement. paging.next duce mai departe în trecut.
# 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 backCum citiți și răspundeți la comentarii în Node.js?
Aceleași două apeluri, cu obiectul URL care construiește query string-ul: un GET cu fields, filter și order, apoi un POST către /{comment-id}/comments. can_reply_privately, cerut în fields, arată dacă Pagina poate încă trimite persoanei care a comentat un răspuns privat, lucru util de știut înainte de exemplul Messenger de mai jos. Păstrați ID-urile comentariilor la care răspundeți, ca o rulare repetată să nu răspundă de două ori.
// 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 backCum trimiteți un răspuns Messenger în Python?
POST /{page-id}/messages cu recipient.id setat la ID-ul limitat la Pagină al persoanei, din webhook-ul mesajelor, messaging_type RESPONSE și textul. Exemplul prinde cele două refuzuri care nu merită reîncercate: eroarea 10 cu subcodul 2534022 sau 2018278, când fereastra de 24 de ore s-a închis, și 551, când persoana nu este disponibilă. private_reply() pune recipient.comment_id în locul ID-ului, pentru singurul mesaj pe care un comentariu îl permite în 7 zile.
# 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})Cum trimiteți un răspuns Messenger în Node.js?
Același corp de cerere în JavaScript, cu recipient, messaging_type și message trimise ca JSON de graph(). Meta răspunde unei trimiteri acceptate cu recipient_id și message_id, de reținut împreună cu conversația. Un răspuns privat conține un link înapoi la comentariul la care răspunde, iar conversația continuă în fereastra standard de 24 de ore, din momentul în care persoana scrie din nou.
// 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 },
});
}Cum citiți statisticile Paginii în Python?
GET /{page-id}/insights cu o listă de metrici separate prin virgulă, period=day și o fereastră since și until în secunde UNIX; o singură cerere acoperă până la 90 de zile. Trei dintre aceste metrici au preluat locul altora pe care Meta le-a retras: page_media_view în locul lui page_impressions, page_total_media_view_unique în locul lui page_impressions_unique și page_follows în locul lui page_fans, în timp ce page_post_engagements numără reacțiile, comentariile și distribuirile.
# 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"])Cum citiți statisticile Paginii în Node.js?
Același apel, cu since și until calculate din Date.now() în secunde. Fiecare metrică revine cu numele, perioada și o listă values de perechi value și end_time, câte una pe zi; când since este setat, primul end_time cade în ziua următoare, astfel încât datele zilei respective sunt incluse. Token-ul are nevoie de read_insights și pages_read_engagement, de la cineva cu sarcina 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);
}
}Cum verificați semnătura unui webhook în Python?
Recalculați X-Hub-Signature-256 din corpul brut al cererii și secretul aplicației, apoi comparați cele două în timp constant. Meta semnează fiecare POST cu un HMAC-SHA256 al payload-ului, cheia fiind App Secret din setările de bază ale App Dashboard, și îl scrie după sha256=. Transmiteți corpul ca bytes, înainte de orice parsare JSON: request.body în Django și await request.body() în FastAPI dau bytes-ii pe care Meta i-a semnat.
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"))Cum verificați semnătura unui webhook în Node.js?
Aceeași verificare cu node:crypto, care necesită corpul ca Buffer: în Express, express.raw îl păstrează neparsat pe ruta respectivă. timingSafeEqual aruncă o eroare pentru intrări de lungimi diferite, așa că testul de lungime rulează primul. Răspundeți 200 rapid și faceți lucrul după aceea, deoarece Meta reîncearcă livrările eșuate și poate trimite un eveniment de două ori; pagina de verificare descrie strângerea de mână hub.challenge care vine înaintea oricărui eveniment.
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
// });La ce coduri de eroare trebuie să reacționeze codul?
La cele pe care ghidurile de erori Meta le diferențiază, deoarece fiecare cere alt răspuns: reîncercarea unui token refuzat sau a unui parametru greșit eșuează doar din nou, în timp ce un apel limitat reușește după o așteptare. graph() reîncearcă codurile temporare și de limitare a ratei și le ridică pe celelalte pentru ca apelantul să le trateze:
Cum rulați aceleași sarcini prin easyCoexistence?
Ca instrumente MCP pe care Claude, ChatGPT sau propriul agent le apelează pe o Pagină conectată, cu token-ul păstrat de easyCoexistence. Token-urile Paginii nu sunt predate niciodată, așa că exemplele de mai sus rulează cu un token din propria aplicație Meta; get_social_credentials returnează ID-ul Paginii și baza Graph API. Instrumentul fiecărei sarcini:
Greșeli frecvente
- Apelarea endpoint-urilor Paginii cu un token de utilizator. Majoritatea așteaptă token-ul propriu al Paginii, iar apelurile făcute cu un token de utilizator sau de aplicație se numără în aceste limite de rată în loc de cele ale Paginii.
- Publicarea aceluiași text de două ori la rând. Meta refuză postările duplicate consecutive cu eroarea 506, deci o sarcină care se rulează din nou trebuie să varieze conținutul sau să sară peste postare.
- Adunarea vizitatorilor unici zilnici. page_total_media_view_unique numără vizitatorii unici din fiecare perioadă, deci valorile zilnice nu se adună la o lună; cereți în schimb period days_28.
- Trimiterea token-ului Paginii către un browser sau o aplicație. Aceste apeluri aparțin unui server, unde token-ul rămâne inaccesibil oricui poate citi clientul.
De la US$ 9 până la US$ 0.75 pe conexiune pe lună, pe măsură ce adăugați conexiuni scăzând, cu primele 3 zile gratuite.
Întrebări frecvente
Am nevoie de un SDK pentru a apela Facebook Pages API?
Nu. Graph API este HTTPS cu JSON, așa că sunt suficiente cererile în Python și fetch-ul încorporat în Node.js 18 sau mai nou, după cum arată exemplele de pe această pagină.
Același cod poate posta pe mai multe Pagini?
Da. /me/accounts returnează un token separat pentru fiecare Pagină, așa că păstrați câte unul pentru fiecare și transmiteți PAGE_ID și PAGE_TOKEN corespunzătoare; apelurile făcute cu un token de Pagină se numără în limita de rată proprie acelei Pagini.
De unde vine PSID-ul pentru un răspuns Messenger?
Din webhook-ul mesajelor: sender.id din fiecare eveniment de messaging este ID-ul persoanei limitat la Pagină, unic pentru persoana și Pagina respectivă. ID-urile de utilizator din Facebook Login sunt limitate la aplicație și nu funcționează cu Messenger Platform.
Cât costă easyCoexistence pentru o Pagină de Facebook?
Fiecare Pagină conectată contează ca o conexiune, de la US$ 9 până la US$ 0.75 pe conexiune pe lună, în funcție de câte aveți, iar primele 3 zile sunt gratuite; instrumentele MCP vin incluse.
Continuați să citiți
Conectați primul canal în două minute.
Fără recenzii de platformă de așteptat. Conectați WhatsApp, Instagram, TikTok sau alt canal, apoi cereți AI-ului să publice, să răspundă sau să raporteze și urmăriți-l cum lucrează.
- 3 zile gratuit
- Anulați oricând
- Doar API-uri oficiale
- Monitorizat 24/7
Verificat la