Facebook Pages API in Python und Node.js: funktionierende Beispiele
Python und Node.js rufen die Facebook Pages API als einfache HTTPS-Anfragen an graph.facebook.com/v26.0 auf, mit dem Access-Token der Seite: POST /{page-id}/feed und /{page-id}/photos veröffentlichen, /{post-id}/comments liest und beantwortet Kommentare, POST /{page-id}/messages antwortet im Messenger, GET /{page-id}/insights liest Kennzahlen, und ein HMAC-SHA256 des rohen Body prüft X-Hub-Signature-256 bei jedem Webhook.
easyCoexistence stellt einer verbundenen Seite diese Aufgaben als MCP-Tools bereit, von publish_facebook_post und reply_to_comment bis send_social_dm und get_social_insights, leitet ihre Ereignisse signiert mit X-EC-Signature weiter und übergibt Ihrem eigenen Code die Seiten-ID und die API-Basis über get_social_credentials.
Der Parameter text eines Seitenfotos; in Metas Photos-Referenz ist message dort als veraltet markiert.
Antwort-Header, dessen estimated_time_to_regain_access die Minuten angibt, bis gedrosselte Aufrufe wieder funktionieren.
Der messaging_type für eine Antwort auf eine Nachricht, die die Seite erhalten hat, innerhalb des 24-Stunden-Fensters gesendet.
Wie eine private Antwort die Person adressiert, die kommentiert hat, über denselben Endpoint /{page-id}/messages.
Was brauchen die Beispiele, bevor sie laufen?
Eine Seiten-ID und das Access-Token dieser Seite, gelesen aus /me/accounts mit einem langlebigen Nutzer-Token, dazu Python 3 mit requests oder Node.js 18 oder neuer, dessen eingebautes fetch kein Paket braucht. Jede Aufgabe braucht außerdem ihre Berechtigung am Token und ihre Aufgabe auf der Seite, und die Beispiele rufen die Graph API v26.0 auf:
Wie veröffentlicht man einen Beitrag und ein Foto in Python?
Mit einer Hilfsfunktion, die die späteren Beispiele wiederverwenden: graph() fügt das Seiten-Token hinzu, sendet GET-Parameter im Query-String und POST-Felder als JSON, wie es auch Metas eigene Beispiele tun, und wandelt Metas Fehlerobjekt in einen GraphError um, der code und error_subcode enthält. Bei temporären Fehlern und Rate-Limit-Codes wartet graph() und wiederholt den Aufruf, so lange X-Business-Use-Case-Usage es verlangt, sofern dieser Header zurückkommt, und gibt alle übrigen sofort als Fehler weiter.
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"])Wie veröffentlicht man sie in Node.js?
Mit derselben Hilfsfunktion in Node.js 18 oder neuer, als .mjs-Datei gespeichert, damit top-level await funktioniert, und mit dem eingebauten fetch statt einer Client-Bibliothek. Der Foto-Aufruf sendet url und caption, das Feld text am Photos-Edge; Meta antwortet mit der id des Fotos und der post_id des Seitenbeitrags mit dem Foto, während der Feed-Aufruf nur die id des Beitrags zurückgibt.
// 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);Wie liest und beantwortet man Kommentare in Python?
Kommentare eines Beitrags lesen Sie mit fields, filter=stream (Kommentare aller Ebenen in zeitlicher Reihenfolge) und order=reverse_chronological (die neuesten zuerst). Antworten als Seite senden Sie, indem Sie eine Nachricht an die comments-Edge des Kommentars schicken. Das Token muss von jemandem stammen, der MODERATE ausführen darf, sonst lässt Meta die Kommentar-IDs weg, und zum Antworten braucht es pages_manage_engagement. paging.next führt zu älteren Kommentaren.
# 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 backWie liest und beantwortet man Kommentare in Node.js?
Dieselben zwei Aufrufe, wobei das URL-Objekt den Query-String aufbaut: ein GET mit fields, filter und order, dann ein POST an /{comment-id}/comments. can_reply_privately, in fields angefordert, gibt an, ob die Seite dem Kommentierenden noch eine private Antwort senden kann; das lohnt sich zu wissen, bevor das Messenger-Beispiel unten. Speichern Sie die IDs der Kommentare, auf die Sie antworten, damit ein erneuter Lauf nicht doppelt antwortet.
// 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 backWie sendet man eine Messenger-Antwort in Python?
POST /{page-id}/messages mit recipient.id auf die seitenbezogene ID der Person aus dem messages-Webhook, messaging_type RESPONSE und dem text. Das Beispiel fängt die beiden Ablehnungen ab, die keinen Wiederholversuch lohnen: Fehler 10 mit Subcode 2534022 oder 2018278, wenn das 24-Stunden-Fenster geschlossen ist, und 551, wenn die Person nicht erreichbar ist. private_reply() setzt stattdessen recipient.comment_id ein, für die einzige Nachricht, die ein Kommentar innerhalb von 7 Tagen erlaubt.
# 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})Wie sendet man eine Messenger-Antwort in Node.js?
Derselbe Anfrage-Body in JavaScript, mit recipient, messaging_type und message, als JSON von graph() gesendet. Meta antwortet auf einen angenommenen Versand mit recipient_id und message_id; es lohnt sich, beides der Konversation zuzuordnen. Eine private Antwort trägt einen Verweis auf den Kommentar, auf den sie antwortet, und die Konversation läuft im normalen 24-Stunden-Fenster weiter, sobald die Person zurückschreibt.
// 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 },
});
}Wie liest man Seiten-Insights in Python?
GET /{page-id}/insights mit einer kommagetrennten Metrikliste, period=day und einem since- und until-Zeitraum in UNIX-Sekunden; eine Anfrage deckt bis zu 90 Tage ab. Drei dieser Metriken haben Metriken abgelöst, die Meta eingestellt hat: page_media_view ersetzt page_impressions, page_total_media_view_unique ersetzt page_impressions_unique und page_follows ersetzt page_fans. page_post_engagements zählt Reaktionen, Kommentare und Teilen.
# 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"])Wie liest man Seiten-Insights in Node.js?
Derselbe Aufruf, wobei since und until aus Date.now() in Sekunden berechnet werden. Jede Metrik kommt mit Name, Zeitraum und einer values-Liste aus Paaren von value und end_time zurück, eines pro Tag; ist since gesetzt, fällt das erste end_time auf den Tag nach ihm, sodass die Daten dieses Tages enthalten sind. Das Token braucht read_insights und pages_read_engagement, von jemandem mit der Aufgabe 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);
}
}Wie prüft man eine Webhook-Signatur in Python?
Berechnen Sie X-Hub-Signature-256 aus dem rohen Body der Anfrage und dem App Secret neu und vergleichen Sie beide in konstanter Zeit. Meta signiert jeden POST mit einem HMAC-SHA256 der Payload, mit dem App Secret aus den Grundeinstellungen des App Dashboards als Schlüssel, und schreibt ihn nach sha256=. Übergeben Sie den Body als Bytes, vor jedem JSON-Parsing: request.body in Django und await request.body() in FastAPI liefern die Bytes, die Meta signiert hat.
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"))Wie prüft man eine Webhook-Signatur in Node.js?
Dieselbe Prüfung mit node:crypto, das den Body als Buffer braucht: in Express hält express.raw ihn auf dieser Route unverarbeitet. timingSafeEqual wirft bei Eingaben unterschiedlicher Länge einen Fehler, daher läuft die Längenprüfung zuerst. Antworten Sie schnell mit 200 und erledigen Sie die Arbeit danach, denn Meta wiederholt fehlgeschlagene Zustellungen und kann ein Ereignis zweimal senden; die Seite zur Verifizierung behandelt den hub.challenge-Handshake, der jedem Ereignis vorausgeht.
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
// });Welche Fehlercodes soll der Code behandeln?
Die, die Metas Fehlerleitfäden unterscheiden, denn jeder verlangt eine andere Reaktion: ein Wiederholen bei abgelehntem Token oder fehlerhaftem Parameter scheitert nur erneut, während ein gedrosselter Aufruf nach einer Wartezeit gelingt. graph() wiederholt die temporären Fehler- und Rate-Limit-Codes und gibt die übrigen an den Aufrufer zur Behandlung weiter:
Wie führt man dieselben Aufgaben über easyCoexistence aus?
Als MCP-Tools, die Claude, ChatGPT oder Ihr eigener Agent auf einer verbundenen Seite aufruft, wobei das Token bei easyCoexistence bleibt. Seiten-Tokens werden nie herausgegeben, sodass die Beispiele oben mit einem Token aus Ihrer eigenen Meta-App laufen; get_social_credentials liefert die ID der Seite und die Basis-URL der Graph API. Das Tool für jede Aufgabe:
Häufige Fehler
- Seiten-Endpoints mit einem Nutzer-Token aufrufen. Die meisten erwarten das eigene Token der Seite; Aufrufe mit einem Nutzer- oder App-Token zählen gegen diese Rate-Limits statt gegen die der Seite.
- Denselben Text zweimal hintereinander veröffentlichen. Meta lehnt aufeinanderfolgende doppelte Beiträge mit Fehler 506 ab, daher muss ein Job, der erneut läuft, den Inhalt ändern oder den Beitrag überspringen.
- Tägliche eindeutige Betrachter addieren. page_total_media_view_unique zählt eindeutige Betrachter in jedem Zeitraum, daher ergeben die Tageswerte keine Summe für den Monat; fragen Sie stattdessen period days_28 an.
- Das Seiten-Token an einen Browser oder eine App ausliefern. Diese Aufrufe gehören auf einen Server, wo das Token für jeden unerreichbar bleibt, der den Client lesen kann.
US$ 9 bis US$ 0.75 pro Verbindung und Monat, sinkend mit jeder weiteren Verbindung, die ersten 3 Tage als kostenlose Testphase.
Häufig gestellte Fragen
Brauche ich ein SDK, um die Facebook Pages API aufzurufen?
Nein. Die Graph API ist HTTPS mit JSON, daher reichen Anfragen in Python und das in Node.js 18 oder neuer eingebaute fetch, wie die Beispiele auf dieser Seite zeigen.
Kann derselbe Code Beiträge auf mehreren Seiten veröffentlichen?
Ja. /me/accounts liefert für jede Seite ein eigenes Token, daher bewahren Sie je Seite eines auf und übergeben die passende PAGE_ID und PAGE_TOKEN; Aufrufe mit einem Seiten-Token zählen gegen das eigene Rate-Limit dieser Seite.
Woher stammt die PSID für eine Messenger-Antwort?
Aus dem messages-Webhook: sender.id in jedem messaging-Ereignis ist die seitenbezogene ID der Person, eindeutig für diese Person und Seite. Nutzer-IDs aus Facebook Login sind app-bezogen und funktionieren nicht mit der Messenger Platform.
Was kostet easyCoexistence für eine Facebook-Seite?
Jede verbundene Seite zählt als eine Verbindung, mit US$ 9 bis US$ 0.75 pro Verbindung und Monat, je nachdem, wie viele Sie haben; die ersten 3 Tage sind eine kostenlose Testphase, und die MCP-Tools sind inklusive.
Weiterlesen
Verbinden Sie Ihren ersten Kanal in zwei Minuten.
Keine Plattform-Prüfungen, auf die Sie warten müssen. Verbinden Sie WhatsApp, Instagram, TikTok oder einen anderen Kanal, bitten Sie dann Ihre KI, zu posten, zu antworten oder Berichte zu erstellen, und sehen Sie ihr bei der Arbeit zu.
- 3 Tage kostenlos
- Jederzeit kündbar
- Nur offizielle APIs
- Überwacht rund um die Uhr (24/7)
Verifiziert am