Facebook Pages API w Pythonie i Node.js: działające przykłady
Python i Node.js wywołują Facebook Pages API jako zwykłe żądania HTTPS do graph.facebook.com/v26.0, z tokenem dostępu strony: POST /{page-id}/feed i /{page-id}/photos publikują, /{post-id}/comments odczytuje i odpowiada na komentarze, POST /{page-id}/messages odpowiada w Messengerze, GET /{page-id}/insights odczytuje metryki, a HMAC-SHA256 surowego ciała sprawdza X-Hub-Signature-256 w każdym webhooku.
easyCoexistence udostępnia podłączonej stronie te zadania jako narzędzia MCP, od publish_facebook_post i reply_to_comment po send_social_dm i get_social_insights, przekazuje jej zdarzenia podpisane X-EC-Signature i oddaje własnemu kodowi ID strony i bazę API przez get_social_credentials.
Parametr text zdjęcia na stronie; w dokumentacji zdjęć Meta parametr message jest tam oznaczony jako przestarzały.
Nagłówek odpowiedzi, którego estimated_time_to_regain_access podaje w minutach, kiedy wywołania z limitem znów zadziałają.
messaging_type dla odpowiedzi na wiadomość otrzymaną przez stronę, wysłanej w ramach 24-godzinnego okna.
Jak odpowiedź prywatna trafia do osoby, która skomentowała, przez ten sam endpoint /{page-id}/messages.
Czego przykłady potrzebują, zanim zaczną działać?
Identyfikatora strony i tokenu dostępu tej strony, odczytanego z /me/accounts za pomocą tokenu użytkownika o długim czasie życia, oraz Pythona 3 z biblioteką requests albo Node.js w wersji 18 lub nowszej, którego wbudowany fetch nie wymaga pakietu. Każde zadanie wymaga też swojego uprawnienia w tokenie i swojego zadania na stronie, a przykłady wywołują Graph API v26.0:
Jak publikować post i zdjęcie w Pythonie?
Za pomocą jednej funkcji pomocniczej, której użyją kolejne przykłady: graph() dodaje token strony, wysyła parametry GET w query stringu, a pola POST jako JSON, tak jak robią to własne przykłady Meta, i zamienia obiekt błędu Meta na GraphError z polami code i error_subcode. Czeka i ponawia tylko kody tymczasowe i kody limitów, przez tyle czasu, ile wskaże nagłówek X-Business-Use-Case-Usage, gdy wraca, a resztę zgłasza od razu.
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"])Jak publikować je w Node.js?
Tą samą funkcją pomocniczą w Node.js 18 lub nowszym, zapisaną jako plik .mjs, aby działał top-level await, oraz wbudowanym fetch zamiast biblioteki klienta. Wywołanie zdjęcia wysyła url i caption, czyli pole text edge'a photos; Meta odpowiada identyfikatorem zdjęcia id i post_id posta strony, który zawiera zdjęcie, a wywołanie feed odpowiada samym id posta.
// 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);Jak czytać i odpowiadać na komentarze w Pythonie?
Komentarze posta odczytuje się przez fields, filter=stream dla komentarzy na wszystkich poziomach w kolejności czasowej oraz order=reverse_chronological dla najnowszych jako pierwszych, a odpowiada jako strona, wysyłając wiadomość do krawędzi comments danego komentarza. Token musi pochodzić od kogoś, kto może wykonać MODERATE, bo inaczej Meta pomija identyfikatory komentarzy, a odpowiedź wymaga pages_manage_engagement. paging.next prowadzi dalej wstecz.
# 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 backJak czytać i odpowiadać na komentarze w Node.js?
Te same dwa wywołania, a obiekt URL składa query string: GET z fields, filter i order, potem POST do /{comment-id}/comments. can_reply_privately, pobrane w fields, mówi, czy strona może jeszcze wysłać temu komentującemu odpowiedź prywatną, co warto wiedzieć przed przykładem Messengera poniżej. Zapisz identyfikatory komentarzy, na które odpowiedziałeś, aby ponowne uruchomienie nie odpowiedziało dwa razy.
// 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 backJak wysłać odpowiedź w Messengerze w Pythonie?
POST /{page-id}/messages z recipient.id ustawionym na identyfikator osoby w zakresie strony, pobrany z messages webhooka, messaging_type RESPONSE i tekstem. Przykład wychwytuje dwa odrzucenia, których nie warto ponawiać: błąd 10 z podkodem 2534022 lub 2018278, gdy 24-godzinne okno się zamknęło, oraz 551, gdy osoba jest niedostępna. private_reply() wstawia zamiast identyfikatora recipient.comment_id, dla jedynej wiadomości, jaką komentarz pozwala wysłać w ciągu 7 dni.
# 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})Jak wysłać odpowiedź w Messengerze w Node.js?
To samo ciało żądania w JavaScripcie, z recipient, messaging_type i message wysyłanymi jako JSON przez graph(). Meta odpowiada na przyjęte wysłanie polami recipient_id i message_id, które warto zapisać przy rozmowie. Odpowiedź prywatna zawiera link do komentarza, na który odpowiada, a rozmowa toczy się dalej w standardowym 24-godzinnym oknie, gdy osoba napisze ponownie.
// 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 },
});
}Jak czytać statystyki strony w Pythonie?
GET /{page-id}/insights z listą metryk oddzieloną przecinkami, period=day oraz oknem since i until w sekundach UNIX; jedno żądanie obejmuje do 90 dni. Trzy z nich zastąpiły wycofane metryki Meta: page_media_view zamiast page_impressions, page_total_media_view_unique zamiast page_impressions_unique i page_follows zamiast page_fans, a page_post_engagements liczy reakcje, komentarze i udostępnienia.
# 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"])Jak czytać statystyki strony w Node.js?
To samo wywołanie, z since i until liczonymi z Date.now() w sekundach. Każda metryka wraca z nazwą, okresem i listą values z parami value i end_time, po jednej na dzień; przy ustawionym since pierwszy end_time przypada na dzień po nim, więc dane tego dnia są uwzględnione. Token potrzebuje read_insights i pages_read_engagement, od kogoś z zadaniem 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);
}
}Jak zweryfikować podpis webhooka w Pythonie?
Przelicz X-Hub-Signature-256 z surowego ciała żądania i sekretu aplikacji, a następnie porównaj oba w stałym czasie. Meta podpisuje każdy POST HMAC-SHA256 treści żądania, kluczem App Secret z podstawowych ustawień App Dashboard, i zapisuje go po sha256=. Przekaż ciało jako bajty, przed jakimkolwiek parsowaniem JSON: request.body w Django i await request.body() w FastAPI dają bajty, które podpisała 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"))Jak zweryfikować podpis webhooka w Node.js?
Ta sama kontrola z node:crypto, która potrzebuje ciała jako Buffer: w Express express.raw zachowuje je nieparsowane na tej trasie. timingSafeEqual rzuca wyjątek dla danych o różnej długości, więc najpierw działa test długości. Odpowiedz 200 szybko, a pracę wykonaj później, bo Meta ponawia nieudane dostarczenia i może wysłać zdarzenie dwa razy; strona weryfikacji opisuje uścisk hub.challenge, który poprzedza każde zdarzenie.
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
// });Na które kody błędów powinien reagować kod?
Na te, które przewodniki Meta po błędach rozróżniają, bo każdy wymaga innej reakcji: ponawianie odrzuconego tokenu albo złego parametru tylko znowu zawiedzie, podczas gdy wywołanie z limitem uda się po czekaniu. graph() ponawia kody tymczasowe i kody limitów, a pozostałe zgłasza wywołującemu do obsługi:
Jak uruchomić te same zadania przez easyCoexistence?
Jako narzędzia MCP, które Claude, ChatGPT lub własny agent wywołuje na podłączonej stronie, przy czym token trzyma easyCoexistence. Tokeny strony nie są nigdy wydawane, więc przykłady powyżej działają na tokenie z Twojej własnej aplikacji Meta; get_social_credentials zwraca identyfikator strony i bazę Graph API. Narzędzie każdego zadania:
Typowe błędy
- Wywoływanie endpointów strony tokenem użytkownika. Większość z nich oczekuje własnego tokenu strony, a wywołania z tokenem użytkownika lub aplikacji liczą się do tych limitów zamiast do limitów strony.
- Publikowanie tego samego tekstu dwa razy z rzędu. Meta odrzuca kolejne identyczne posty kodem błędu 506, więc zadanie uruchamiane ponownie musi zmienić treść albo pominąć post.
- Sumowanie dziennych unikalnych widzów. page_total_media_view_unique liczy unikalnych widzów w każdym okresie, więc wartości dzienne nie sumują się do miesiąca; zamiast tego poproś o period days_28.
- Wysyłanie tokenu strony do przeglądarki lub aplikacji. Te wywołania należą na serwer, gdzie token pozostaje poza zasięgiem każdego, kto może odczytać klienta.
Od US$ 9 do US$ 0,75 za połączenie miesięcznie, spadając wraz z liczbą połączeń, a pierwsze 3 dni bezpłatnie.
Najczęściej zadawane pytania
Czy do wywołania Facebook Pages API potrzebuję SDK?
Nie. Graph API to HTTPS z JSON-em, więc żądania w Pythonie i fetch wbudowany w Node.js 18 lub nowszy wystarczają, jak pokazują przykłady na tej stronie.
Czy ten sam kod może publikować na kilku stronach?
Tak. /me/accounts zwraca osobny token dla każdej strony, więc trzymaj jeden na stronę i przekazuj pasujące PAGE_ID i PAGE_TOKEN; wywołania z tokenem strony liczą się do jej własnego limitu.
Skąd bierze się PSID do odpowiedzi w Messengerze?
Z messages webhooka: sender.id w każdym zdarzeniu messaging to identyfikator osoby w zakresie strony, unikalny dla tej osoby i strony. Identyfikatory użytkowników z Facebook Login są w zakresie aplikacji i nie działają z Messenger Platform.
Ile kosztuje easyCoexistence dla strony na Facebooku?
Każda podłączona strona liczy się jako jedno połączenie, po US$ 9 do US$ 0,75 za połączenie miesięcznie, zależnie od liczby połączeń, a pierwsze 3 dni są bezpłatne; narzędzia MCP są w cenie.
Czytaj dalej
Połącz pierwszy kanał w dwie minuty.
Bez czekania na weryfikację przez platformy. Połącz WhatsApp, Instagram, TikTok lub inny kanał, a potem poproś swoją AI o opublikowanie posta, odpowiedź lub raport i zobacz, jak działa.
- 3 dni za darmo
- Rezygnacja w każdej chwili
- Tylko oficjalne API
- Monitorowanie 24/7
Zweryfikowano w