Zaloguj sięRozpocznij bezpłatny okres próbny
easyCoexistence Oficjalne API

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.

caption

Parametr text zdjęcia na stronie; w dokumentacji zdjęć Meta parametr message jest tam oznaczony jako przestarzały.

X-Business-Use-Case-Usage

Nagłówek odpowiedzi, którego estimated_time_to_regain_access podaje w minutach, kiedy wywołania z limitem znów zadziałają.

RESPONSE

messaging_type dla odpowiedzi na wiadomość otrzymaną przez stronę, wysłanej w ramach 24-godzinnego okna.

recipient.comment_id

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:

Publish a post or photoPOST /{page-id}/feed and /{page-id}/photos: pages_manage_posts, CREATE_CONTENT
Read and reply to comments/{post-id}/comments and /{comment-id}/comments: pages_manage_engagement, MODERATE
Reply in MessengerPOST /{page-id}/messages: pages_messaging, MESSAGING
Read insightsGET /{page-id}/insights: read_insights, pages_read_engagement, ANALYZE
Check a webhookX-Hub-Signature-256, with the app secret and no token

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.

Python: graph(), then a post and a photo
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: graph(), then a post and a photo
// 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.

Python: read a post's comments and reply to the questions
# 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 back

Jak 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.

Node.js: read a post's comments and reply to the questions
// 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 back

Jak 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.

Python: a Messenger reply and a private reply
# 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.

Node.js: a Messenger reply and a private reply
// 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.

Python: four Page metrics for the last 28 days
# 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.

Node.js: four Page metrics for the last 28 days
// 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.

Python: check X-Hub-Signature-256
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.

Node.js: check X-Hub-Signature-256
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:

190, 102The token was refused, and the subcode says why. A new sign-in is the fix
10, 200 to 299A permission was not granted or was removed. Grant it again
4, 17, 32, 613An app, user or Page rate limit. Stop, wait, then resume gradually
80001Page calls made with a Page token are throttled; the header gives the minutes
368Blocked for policy violations. Wait, and review what was being sent
100An invalid parameter. Fix the request before sending it again
551The person is not available on Messenger. Do not retry
1, 2A temporary issue on Meta's side. Wait and retry

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:

Publishpublish_facebook_post with message, link, image_url or video_url, now or at scheduled_at
Commentslist_social_comments, then reply_to_comment; private set to true sends the one Messenger message
Messengersend_social_dm, with recipient_id set to the sender's ID from the forwarded event
Insightsget_social_insights with metrics and a period, or object_id for one post
Eventsset_social_webhook_destination; each forward carries X-EC-Signature, made with the Page's own secret

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.
Z EasyCoexistence zrobisz to

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