InloggenGratis proefperiode starten
easyCoexistence Officiële API's

Facebook Pages API in Python en Node.js: werkende voorbeelden

Python en Node.js roepen de Facebook Pages API aan als gewone HTTPS-verzoeken naar graph.facebook.com/v26.0 met het toegangstoken van de Pagina: POST /{page-id}/feed en /{page-id}/photos publiceren, /{post-id}/comments leest en beantwoordt reacties, POST /{page-id}/messages antwoordt in Messenger, GET /{page-id}/insights leest statistieken, en een HMAC-SHA256 van de ruwe body controleert X-Hub-Signature-256 bij elke webhook.

easyCoexistence geeft een verbonden Pagina deze taken als MCP-tools, van publish_facebook_post en reply_to_comment tot send_social_dm en get_social_insights, stuurt de events door die het ondertekent met X-EC-Signature, en geeft je eigen code de Pagina-ID en API-basis via get_social_credentials.

caption

De text-parameter van een Pagina-foto; in Meta's referentie voor photos is message daar als verouderd gemarkeerd.

X-Business-Use-Case-Usage

Antwoordheader waarvan estimated_time_to_regain_access aangeeft na hoeveel minuten beperkte aanroepen weer werken.

RESPONSE

De messaging_type voor een antwoord op een bericht dat de Pagina ontving, verstuurd binnen het 24-uursvenster.

recipient.comment_id

Hoe een privé-antwoord de persoon aanspreekt die heeft gereageerd, via hetzelfde /{page-id}/messages-endpoint.

Wat hebben de voorbeelden nodig voordat ze draaien?

Een Page ID en het toegangstoken van die Pagina, uit /me/accounts opgehaald met een langlevend gebruikerstoken, plus Python 3 met requests, of Node.js 18 of later, waarvan de ingebouwde fetch geen pakket nodig heeft. Elke taak heeft ook zijn machtiging op het token en zijn taak op de Pagina nodig, en de voorbeelden roepen Graph API v26.0 aan:

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

Hoe publiceer je een post en een foto in Python?

Met één helper die de latere voorbeelden hergebruiken: graph() voegt het Pagina-token toe, stuurt GET-parameters in de querystring en POST-velden als JSON, zoals Meta's eigen voorbeelden doen, en zet het foutobject van Meta om in een GraphError met code en error_subcode. Hij wacht en probeert opnieuw alleen bij de tijdelijke en snelheidslimietcodes, zo lang als X-Business-Use-Case-Usage aangeeft wanneer die header terugkomt, en gooit de overige meteen als fout op.

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"])

Hoe publiceer je ze in Node.js?

Met dezelfde helper in Node.js 18 of later, opgeslagen als .mjs-bestand zodat top-level await werkt, en de ingebouwde fetch in plaats van een clientbibliotheek. De fotoaanroep stuurt url en caption, het text-veld van de photos-edge; Meta antwoordt met de id van de foto en de post_id van de Pagina-post die de foto bevat, terwijl de feed-aanroep alleen de id van de post teruggeeft.

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);

Hoe lees en beantwoord je reacties in Python?

Lees de reacties van een post met fields, filter=stream voor reacties op alle niveaus in tijdsvolgorde en order=reverse_chronological voor de nieuwste eerst, en antwoord dan als de Pagina door een bericht te plaatsen op de eigen comments-edge van de reactie. Het token moet van iemand komen die MODERATE kan uitvoeren, anders laat Meta de reactie-ID's weg, en antwoorden vereist pages_manage_engagement. paging.next leidt verder terug in de tijd.

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

Hoe lees en beantwoord je reacties in Node.js?

Dezelfde twee aanroepen, met het URL-object dat de querystring opbouwt: een GET met fields, filter en order, daarna een POST naar /{comment-id}/comments. can_reply_privately, opgevraagd in fields, geeft aan of de Pagina die persoon nog een privé-antwoord kan sturen, wat je wilt weten voordat het Messenger-voorbeeld hieronder. Bewaar de ID's van de reacties die je beantwoordt, zodat een herhaalde run niet twee keer antwoordt.

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

Hoe stuur je een Messenger-antwoord in Python?

POST /{page-id}/messages met recipient.id ingesteld op de Pagina-gebonden ID van de persoon uit de messages-webhook, messaging_type RESPONSE en de text. Het voorbeeld vangt de twee weigeringen op die het niet waard zijn om opnieuw te proberen: fout 10 met subcode 2534022 of 2018278 wanneer het venster van 24 uur is gesloten, en 551 wanneer de persoon niet beschikbaar is. private_reply() zet recipient.comment_id in plaats van de ID, voor het ene bericht dat een reactie binnen 7 dagen toestaat.

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})

Hoe stuur je een Messenger-antwoord in Node.js?

Dezelfde verzoekbody in JavaScript, met recipient, messaging_type en message als JSON verstuurd door graph(). Meta antwoordt op een verzending die het accepteert met recipient_id en message_id, die je bij het gesprek opslaat. Een privé-antwoord bevat een link terug naar de reactie waarop het antwoordt, en het gesprek loopt door in het standaardvenster van 24 uur zodra de persoon terugschrijft.

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 },
  });
}

Hoe lees je Pagina-inzichten in Python?

GET /{page-id}/insights met een kommagescheiden lijst van metrics, period=day en een since- en until-venster in UNIX-seconden; één verzoek dekt maximaal 90 dagen. Drie van deze metrics vervingen metrics die Meta heeft uitgefaseerd: page_media_view vervangt page_impressions, page_total_media_view_unique vervangt page_impressions_unique en page_follows vervangt page_fans, terwijl page_post_engagements likes, reacties en shares telt.

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"])

Hoe lees je Pagina-inzichten in Node.js?

Dezelfde aanroep, met since en until berekend uit Date.now() in seconden. Elke metric komt terug met zijn naam, zijn period en een lijst values van value- en end_time-paren, één per dag; als since is ingesteld, valt de eerste end_time op de dag erna, zodat de data van die dag is inbegrepen. Het token heeft read_insights en pages_read_engagement nodig, van iemand met de taak 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);
  }
}

Hoe verifieer je een webhook-handtekening in Python?

Bereken X-Hub-Signature-256 opnieuw uit de ruwe verzoekbody en het app-geheim, en vergelijk de twee in constante tijd. Meta ondertekent elke POST met een HMAC-SHA256 van de payload, met als sleutel het App Secret uit de basisinstellingen van het App Dashboard, en zet die achter sha256=. Geef de body als bytes door, vóór het JSON-parsen: request.body in Django en await request.body() in FastAPI geven beide de bytes die Meta heeft ondertekend.

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"))

Hoe verifieer je een webhook-handtekening in Node.js?

Dezelfde controle met node:crypto, die de body als Buffer nodig heeft: in Express houdt express.raw hem op die route ongeparsed. timingSafeEqual gooit een fout bij invoer met verschillende lengtes, dus de lengtetest gaat eerst. Antwoord snel met 200 en doe het werk daarna, want Meta probeert mislukte leveringen opnieuw en kan een event twee keer sturen; de verificatiepagina behandelt de hub.challenge-handshake die vóór elk event komt.

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
// });

Op welke foutcodes moet de code reageren?

Die welke de foutgidsen van Meta onderscheiden, omdat elk een andere reactie vraagt: een geweigerd token of een slechte parameter opnieuw proberen mislukt alleen weer, terwijl een beperkte aanroep na een wachttijd slaagt. graph() probeert de tijdelijke en snelheidslimietcodes opnieuw en gooit de andere op voor de aanroeper om af te handelen:

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

Hoe voer je dezelfde taken uit via easyCoexistence?

Als MCP-tools die Claude, ChatGPT of je eigen agent aanroept op een verbonden Pagina, met het token bewaard door easyCoexistence. Tokens van de Pagina worden nooit verstrekt, dus de voorbeelden hierboven draaien met een token van je eigen Meta-app; get_social_credentials geeft het ID van de Pagina en de Graph API-basis terug. De tool per taak:

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

Veelgemaakte fouten

  • Pagina-eindpunten aanroepen met een gebruikerstoken. De meeste verwachten het eigen token van de Pagina, en aanroepen met een gebruikers- of app-token tellen mee op die snelheidslimieten in plaats van op die van de Pagina.
  • Dezelfde tekst twee keer achter elkaar publiceren. Meta weigert opeenvolgende dubbele posts met fout 506, dus een taak die opnieuw draait moet de inhoud variëren of de post overslaan.
  • Dagelijkse unieke kijkers optellen. page_total_media_view_unique telt unieke kijkers per periode, dus dagwaarden tellen niet op tot een maand; vraag in plaats daarvan period days_28 aan.
  • De Pagina-token naar een browser of app sturen. Deze aanroepen horen op een server, waar het token buiten bereik blijft van wie de client kan lezen.
Dit doen met EasyCoexistence

US$ 9 tot US$ 0.75 per verbinding per maand, dalend naarmate je meer verbindingen toevoegt, met de eerste 3 dagen gratis.

Veelgestelde vragen

Heb ik een SDK nodig om de Facebook Pages API aan te roepen?

Nee. De Graph API is HTTPS met JSON, dus verzoeken in Python en de fetch die is ingebouwd in Node.js 18 of later volstaan, zoals de voorbeelden op deze pagina laten zien.

Kan dezelfde code naar meerdere Pagina's posten?

Ja. /me/accounts geeft voor elke Pagina een apart token terug, dus houd er één per Pagina bij en geef de bijbehorende PAGE_ID en PAGE_TOKEN door; aanroepen met een Pagina-token tellen mee op de eigen snelheidslimiet van die Pagina.

Waar komt de PSID voor een Messenger-antwoord vandaan?

Uit de messages-webhook: sender.id in elk messaging-event is de Pagina-gebonden ID van de persoon, uniek voor die persoon en Pagina. Gebruikers-ID's uit Facebook Login zijn app-gebonden en werken niet met het Messenger Platform.

Hoeveel kost easyCoexistence voor een Facebook-pagina?

Elke verbonden Pagina telt als één verbinding, tegen US$ 9 tot US$ 0.75 per verbinding per maand, afhankelijk van hoeveel je er hebt, en de eerste 3 dagen zijn gratis; de MCP-tools zitten erbij.

Lees verder

Koppel je eerste kanaal in twee minuten.

Geen platformbeoordelingen om op te wachten. Verbind WhatsApp, Instagram, TikTok of een ander kanaal, vraag je AI om te posten, te reageren of een rapport te maken, en zie het aan het werk.

  • 3 dagen gratis
  • Op elk moment opzegbaar
  • Alleen officiële API's
  • 24/7 bewaakt

Geverifieerd op