Se connecterCommencer l’essai gratuit
easyCoexistence API officielles

Facebook Pages API en Python et Node.js : exemples concrets

Python et Node.js appellent l'API Facebook Pages par de simples requêtes HTTPS vers graph.facebook.com/v26.0 avec le token d'accès de la Page : POST /{page-id}/feed et /{page-id}/photos publient, /{post-id}/comments lit et répond aux commentaires, POST /{page-id}/messages répond dans Messenger, GET /{page-id}/insights lit les métriques, et un HMAC-SHA256 du corps brut vérifie X-Hub-Signature-256 à chaque webhook.

easyCoexistence donne à une Page connectée ces tâches sous forme d'outils MCP (publish_facebook_post, reply_to_comment, send_social_dm, get_social_insights), transmet ses événements signés avec X-EC-Signature, et remet à votre propre code l'ID de la Page et la base de l'API via get_social_credentials.

caption

Le paramètre text d'une photo de Page ; la référence des photos de Meta marque message comme obsolète à cet endroit.

X-Business-Use-Case-Usage

En-tête de réponse dont estimated_time_to_regain_access indique les minutes avant que les appels limités ne repartent.

RESPONSE

Le messaging_type d'une réponse à un message reçu par la Page, envoyée dans la fenêtre de 24 heures.

recipient.comment_id

Comment une réponse privée désigne la personne qui a commenté, via le même endpoint /{page-id}/messages.

De quoi les exemples ont-ils besoin avant de s'exécuter ?

Un Page ID et le token d'accès de cette Page, lu depuis /me/accounts avec un token utilisateur longue durée, plus Python 3 avec requests, ou Node.js 18 ou ultérieur, dont le fetch intégré n'exige aucun paquet. Chaque tâche demande aussi sa permission sur le token et son rôle sur la Page, et les exemples appellent l'API Graph 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

Comment publier un post et une photo en Python ?

Avec une seule fonction d'aide que les exemples suivants réutilisent : graph() ajoute le token de la Page, envoie les paramètres GET dans la chaîne de requête et les champs POST en JSON, comme le font les exemples de Meta, et transforme l'objet d'erreur de Meta en GraphError portant code et error_subcode. Elle attend et réessaie uniquement les codes temporaires et de limitation de débit, aussi longtemps que X-Business-Use-Case-Usage l'indique quand cet en-tête revient, et lève les autres immédiatement.

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

Comment les publier en Node.js ?

Avec la même fonction d'aide en Node.js 18 ou ultérieur, enregistrée dans un fichier .mjs pour que le await de niveau supérieur fonctionne, et le fetch intégré à la place d'une bibliothèque cliente. L'appel photo envoie url et caption, le champ text de l'edge photos ; Meta répond avec l'id de la photo et le post_id de la publication de la Page qui porte la photo, tandis que l'appel feed ne répond que par l'id de la publication.

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

Comment lire et répondre aux commentaires en Python ?

Lire les commentaires d'une publication avec fields, filter=stream pour les commentaires de tous niveaux par ordre chronologique et order=reverse_chronological pour les plus récents d'abord, puis répondre au nom de la Page en publiant un message sur l'edge comments du commentaire. Le token doit provenir de quelqu'un pouvant exécuter MODERATE, sinon Meta omet les ID de commentaires, et répondre exige pages_manage_engagement. paging.next remonte plus loin dans le temps.

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

Comment lire et répondre aux commentaires en Node.js ?

Les mêmes deux appels, l'objet URL construisant la chaîne de requête : un GET avec fields, filter et order, puis un POST vers /{comment-id}/comments. can_reply_privately, demandé dans fields, indique si la Page peut encore envoyer une réponse privée à cette personne, ce qu'il est utile de savoir avant l'exemple Messenger ci-dessous. Conservez les ID des commentaires auxquels vous répondez, pour qu'une relance ne réponde pas deux fois.

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

Comment envoyer une réponse Messenger en Python ?

POST /{page-id}/messages avec recipient.id défini sur l'ID de portée Page de la personne, issu du webhook de messages, messaging_type à RESPONSE et le texte. L'exemple intercepte les deux refus qui ne méritent pas de nouvel essai : l'erreur 10 avec le sous-code 2534022 ou 2018278 lorsque la fenêtre de 24 heures est fermée, et 551 lorsque la personne n'est pas disponible. private_reply() place recipient.comment_id à la place de l'ID, pour le message unique qu'un commentaire autorise dans les 7 jours.

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

Comment envoyer une réponse Messenger en Node.js ?

Le même corps de requête en JavaScript, avec recipient, messaging_type et message envoyés en JSON par graph(). Meta répond à un envoi accepté avec recipient_id et message_id, à conserver avec la conversation. Une réponse privée contient un lien vers le commentaire auquel elle répond, et la conversation se poursuit dans la fenêtre standard de 24 heures dès que la personne répond.

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

Comment lire les insights d'une Page en Python ?

GET /{page-id}/insights avec une liste de métriques séparées par des virgules, period=day et une fenêtre since et until en secondes UNIX ; une seule requête couvre jusqu'à 90 jours. Trois de ces métriques ont remplacé d'anciennes métriques retirées par Meta : page_media_view remplace page_impressions, page_total_media_view_unique remplace page_impressions_unique et page_follows remplace page_fans, tandis que page_post_engagements compte les réactions, les commentaires et les partages.

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

Comment lire les insights d'une Page en Node.js ?

Le même appel, avec since et until calculés à partir de Date.now() en secondes. Chaque métrique revient avec son nom, sa période et une liste values de paires value et end_time, une par jour ; avec since défini, le premier end_time tombe le jour suivant, de sorte que les données de ce jour sont incluses. Le token a besoin de read_insights et pages_read_engagement, obtenus par quelqu'un qui détient la tâche 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);
  }
}

Comment vérifier la signature d'un webhook en Python ?

Recalculez X-Hub-Signature-256 à partir du corps brut de la requête et de l'App Secret, puis comparez les deux valeurs en temps constant. Meta signe chaque POST avec un HMAC-SHA256 du payload, calculé avec l'App Secret affiché dans les paramètres de base du dashboard de l'application, et l'écrit après sha256=. Passez le corps en octets, avant tout parsing JSON : request.body dans Django et await request.body() dans FastAPI donnent les octets que Meta a signés.

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

Comment vérifier la signature d'un webhook en Node.js ?

La même vérification avec node:crypto, qui exige le corps sous forme de Buffer : dans Express, express.raw le garde non analysé sur cette route. timingSafeEqual lève une erreur pour des entrées de longueurs différentes, donc le test de longueur passe en premier. Répondez 200 rapidement et faites le travail ensuite, car Meta relance les envois en échec et peut envoyer un événement deux fois ; la page de vérification traite de la poignée de main hub.challenge qui précède tout événement.

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

Quels codes d'erreur le code doit-il traiter ?

Ceux que les guides d'erreurs de Meta distinguent, car chacun appelle une réponse différente : relancer un token refusé ou un paramètre incorrect n'échoue qu'à nouveau, tandis qu'un appel limité réussit après une attente. graph() relance les codes temporaires et de limitation de débit et lève les autres pour que l'appelant les gère :

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

Comment exécuter les mêmes tâches via easyCoexistence ?

Sous forme d'outils MCP que Claude, ChatGPT ou votre propre agent appellent sur une Page connectée, le token restant détenu par easyCoexistence. Les tokens de Page ne sont jamais communiqués : les exemples ci-dessus fonctionnent donc avec un token issu de votre propre app Meta ; get_social_credentials renvoie l'ID de la Page et la base de l'API Graph. L'outil de chaque tâche :

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

Erreurs courantes

  • Appeler les endpoints de la Page avec un token utilisateur. La plupart attendent le token propre à la Page, et les appels faits avec un token utilisateur ou d'application comptent sur ces limites de débit au lieu de celles de la Page.
  • Publier deux fois de suite le même texte. Meta refuse les publications en double consécutives avec l'erreur 506, donc une tâche relancée doit varier le contenu ou sauter la publication.
  • Additionner les visiteurs uniques quotidiens. page_total_media_view_unique compte les visiteurs uniques de chaque période, donc les valeurs journalières ne s'additionnent pas pour un mois ; demandez plutôt period days_28.
  • Envoyer le token de la Page à un navigateur ou à une application. Ces appels doivent se faire côté serveur, où le token reste hors de portée de quiconque peut lire le client.
Faire cela avec EasyCoexistence

De US$ 9 à US$ 0,75 par connexion et par mois, dégressif à mesure que vous ajoutez des connexions, avec les 3 premiers jours d'essai offerts.

Questions fréquemment posées

Faut-il un SDK pour appeler l'API Facebook Pages ?

Non. L'API Graph repose sur HTTPS avec du JSON, donc des requêtes en Python et le fetch intégré à Node.js 18 ou ultérieur suffisent, comme le montrent les exemples de cette page.

Le même code peut-il publier sur plusieurs Pages ?

Oui. /me/accounts renvoie un token distinct pour chaque Page ; gardez-en un par Page et passez le PAGE_ID et le PAGE_TOKEN correspondants. Les appels faits avec un token de Page comptent sur la limite de débit propre à cette Page.

D'où vient le PSID d'une réponse Messenger ?

Du webhook de messages : sender.id dans chaque événement messaging est l'ID de portée Page de la personne, unique à cette personne et à cette Page. Les ID utilisateur issus de Facebook Login sont de portée application et ne fonctionnent pas avec la Messenger Platform.

Combien coûte easyCoexistence pour une Page Facebook ?

Chaque Page connectée compte pour une connexion, de US$ 9 à US$ 0,75 par connexion et par mois selon le nombre de connexions, et les 3 premiers jours d'essai sont offerts ; les outils MCP sont inclus.

Poursuivre la lecture

Connectez votre premier canal en deux minutes.

Aucune validation de plateforme à attendre. Connectez WhatsApp, Instagram, TikTok ou un autre canal, puis demandez à votre IA de publier, de répondre ou de faire un rapport, et regardez-la travailler.

  • 3 jours gratuits
  • Résiliable à tout moment
  • API officielles uniquement
  • Supervisé 24/7

Vérifié le