Conectați-văÎncepeți perioada de probă gratuită
easyCoexistence API-uri oficiale

Facebook Pages API în Python și Node.js: exemple funcționale

Python și Node.js apelează Facebook Pages API prin simple cereri HTTPS către graph.facebook.com/v26.0, cu token-ul de acces al Paginii: POST /{page-id}/feed și /{page-id}/photos publică, /{post-id}/comments citește și răspunde la comentarii, POST /{page-id}/messages răspunde în Messenger, GET /{page-id}/insights citește metricile, iar un HMAC-SHA256 al corpului brut verifică X-Hub-Signature-256 la fiecare webhook.

easyCoexistence oferă unei Pagini conectate aceste sarcini ca instrumente MCP, de la publish_facebook_post și reply_to_comment până la send_social_dm și get_social_insights, redirecționează evenimentele sale semnate cu X-EC-Signature și îi oferă codului propriu ID-ul Paginii și baza API prin get_social_credentials.

caption

Parametrul text al unei fotografii de Pagină; referința Meta la fotografii marchează mesajul ca depreciat acolo.

X-Business-Use-Case-Usage

Antet de răspuns al cărui estimated_time_to_regain_access indică minutele până când apelurile limitate funcționează din nou.

RESPONSE

messaging_type pentru un răspuns la un mesaj primit de Pagină, trimis în fereastra de 24 de ore.

recipient.comment_id

Modul în care un răspuns privat se adresează persoanei care a comentat, prin același endpoint /{page-id}/messages.

Ce au nevoie exemplele înainte să ruleze?

Un ID de Pagină și token-ul de acces al acelei Pagini, citit din /me/accounts cu un token de utilizator de lungă durată, plus Python 3 cu requests sau Node.js 18 sau mai nou, al cărui fetch încorporat nu necesită niciun pachet. Fiecare sarcină are nevoie și de permisiunea sa pe token și de sarcina sa pe Pagină, iar exemplele apelează 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

Cum publicați o postare și o fotografie în Python?

Cu un singur helper pe care îl reutilizează exemplele următoare: graph() adaugă token-ul Paginii, trimite parametrii GET în query string și câmpurile POST ca JSON, așa cum fac exemplele Meta, și transformă obiectul de eroare Meta într-un GraphError care poartă code și error_subcode. Așteaptă și reîncearcă doar codurile temporare și de limitare a ratei, atât timp cât cere X-Business-Use-Case-Usage atunci când acest antet revine, și ridică imediat celelalte.

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

Cum le publicați în Node.js?

Cu același helper în Node.js 18 sau mai nou, salvat ca fișier .mjs ca await de nivel superior să funcționeze, și cu fetch-ul încorporat în locul unei biblioteci client. Apelul pentru fotografie trimite url și caption, câmpul text al edge-ului photos; Meta răspunde cu id-ul fotografiei și cu post_id-ul postării Paginii care conține fotografia, în timp ce apelul pentru feed răspunde doar cu id-ul postării.

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

Cum citiți și răspundeți la comentarii în Python?

Citiți comentariile unei postări cu fields, filter=stream pentru comentarii de toate nivelurile în ordine cronologică și order=reverse_chronological pentru cele mai noi primele, apoi răspundeți ca Pagina trimițând un mesaj către edge-ul comments al comentariului. Token-ul trebuie să aparțină cuiva care poate efectua MODERATE, altfel Meta omite ID-urile comentariilor, iar răspunsul necesită pages_manage_engagement. paging.next duce mai departe în trecut.

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

Cum citiți și răspundeți la comentarii în Node.js?

Aceleași două apeluri, cu obiectul URL care construiește query string-ul: un GET cu fields, filter și order, apoi un POST către /{comment-id}/comments. can_reply_privately, cerut în fields, arată dacă Pagina poate încă trimite persoanei care a comentat un răspuns privat, lucru util de știut înainte de exemplul Messenger de mai jos. Păstrați ID-urile comentariilor la care răspundeți, ca o rulare repetată să nu răspundă de două ori.

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

Cum trimiteți un răspuns Messenger în Python?

POST /{page-id}/messages cu recipient.id setat la ID-ul limitat la Pagină al persoanei, din webhook-ul mesajelor, messaging_type RESPONSE și textul. Exemplul prinde cele două refuzuri care nu merită reîncercate: eroarea 10 cu subcodul 2534022 sau 2018278, când fereastra de 24 de ore s-a închis, și 551, când persoana nu este disponibilă. private_reply() pune recipient.comment_id în locul ID-ului, pentru singurul mesaj pe care un comentariu îl permite în 7 zile.

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

Cum trimiteți un răspuns Messenger în Node.js?

Același corp de cerere în JavaScript, cu recipient, messaging_type și message trimise ca JSON de graph(). Meta răspunde unei trimiteri acceptate cu recipient_id și message_id, de reținut împreună cu conversația. Un răspuns privat conține un link înapoi la comentariul la care răspunde, iar conversația continuă în fereastra standard de 24 de ore, din momentul în care persoana scrie din nou.

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

Cum citiți statisticile Paginii în Python?

GET /{page-id}/insights cu o listă de metrici separate prin virgulă, period=day și o fereastră since și until în secunde UNIX; o singură cerere acoperă până la 90 de zile. Trei dintre aceste metrici au preluat locul altora pe care Meta le-a retras: page_media_view în locul lui page_impressions, page_total_media_view_unique în locul lui page_impressions_unique și page_follows în locul lui page_fans, în timp ce page_post_engagements numără reacțiile, comentariile și distribuirile.

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

Cum citiți statisticile Paginii în Node.js?

Același apel, cu since și until calculate din Date.now() în secunde. Fiecare metrică revine cu numele, perioada și o listă values de perechi value și end_time, câte una pe zi; când since este setat, primul end_time cade în ziua următoare, astfel încât datele zilei respective sunt incluse. Token-ul are nevoie de read_insights și pages_read_engagement, de la cineva cu sarcina 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);
  }
}

Cum verificați semnătura unui webhook în Python?

Recalculați X-Hub-Signature-256 din corpul brut al cererii și secretul aplicației, apoi comparați cele două în timp constant. Meta semnează fiecare POST cu un HMAC-SHA256 al payload-ului, cheia fiind App Secret din setările de bază ale App Dashboard, și îl scrie după sha256=. Transmiteți corpul ca bytes, înainte de orice parsare JSON: request.body în Django și await request.body() în FastAPI dau bytes-ii pe care Meta i-a semnat.

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

Cum verificați semnătura unui webhook în Node.js?

Aceeași verificare cu node:crypto, care necesită corpul ca Buffer: în Express, express.raw îl păstrează neparsat pe ruta respectivă. timingSafeEqual aruncă o eroare pentru intrări de lungimi diferite, așa că testul de lungime rulează primul. Răspundeți 200 rapid și faceți lucrul după aceea, deoarece Meta reîncearcă livrările eșuate și poate trimite un eveniment de două ori; pagina de verificare descrie strângerea de mână hub.challenge care vine înaintea oricărui eveniment.

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

La ce coduri de eroare trebuie să reacționeze codul?

La cele pe care ghidurile de erori Meta le diferențiază, deoarece fiecare cere alt răspuns: reîncercarea unui token refuzat sau a unui parametru greșit eșuează doar din nou, în timp ce un apel limitat reușește după o așteptare. graph() reîncearcă codurile temporare și de limitare a ratei și le ridică pe celelalte pentru ca apelantul să le trateze:

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

Cum rulați aceleași sarcini prin easyCoexistence?

Ca instrumente MCP pe care Claude, ChatGPT sau propriul agent le apelează pe o Pagină conectată, cu token-ul păstrat de easyCoexistence. Token-urile Paginii nu sunt predate niciodată, așa că exemplele de mai sus rulează cu un token din propria aplicație Meta; get_social_credentials returnează ID-ul Paginii și baza Graph API. Instrumentul fiecărei sarcini:

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

Greșeli frecvente

  • Apelarea endpoint-urilor Paginii cu un token de utilizator. Majoritatea așteaptă token-ul propriu al Paginii, iar apelurile făcute cu un token de utilizator sau de aplicație se numără în aceste limite de rată în loc de cele ale Paginii.
  • Publicarea aceluiași text de două ori la rând. Meta refuză postările duplicate consecutive cu eroarea 506, deci o sarcină care se rulează din nou trebuie să varieze conținutul sau să sară peste postare.
  • Adunarea vizitatorilor unici zilnici. page_total_media_view_unique numără vizitatorii unici din fiecare perioadă, deci valorile zilnice nu se adună la o lună; cereți în schimb period days_28.
  • Trimiterea token-ului Paginii către un browser sau o aplicație. Aceste apeluri aparțin unui server, unde token-ul rămâne inaccesibil oricui poate citi clientul.
Faceți acest lucru cu EasyCoexistence

De la US$ 9 până la US$ 0.75 pe conexiune pe lună, pe măsură ce adăugați conexiuni scăzând, cu primele 3 zile gratuite.

Întrebări frecvente

Am nevoie de un SDK pentru a apela Facebook Pages API?

Nu. Graph API este HTTPS cu JSON, așa că sunt suficiente cererile în Python și fetch-ul încorporat în Node.js 18 sau mai nou, după cum arată exemplele de pe această pagină.

Același cod poate posta pe mai multe Pagini?

Da. /me/accounts returnează un token separat pentru fiecare Pagină, așa că păstrați câte unul pentru fiecare și transmiteți PAGE_ID și PAGE_TOKEN corespunzătoare; apelurile făcute cu un token de Pagină se numără în limita de rată proprie acelei Pagini.

De unde vine PSID-ul pentru un răspuns Messenger?

Din webhook-ul mesajelor: sender.id din fiecare eveniment de messaging este ID-ul persoanei limitat la Pagină, unic pentru persoana și Pagina respectivă. ID-urile de utilizator din Facebook Login sunt limitate la aplicație și nu funcționează cu Messenger Platform.

Cât costă easyCoexistence pentru o Pagină de Facebook?

Fiecare Pagină conectată contează ca o conexiune, de la US$ 9 până la US$ 0.75 pe conexiune pe lună, în funcție de câte aveți, iar primele 3 zile sunt gratuite; instrumentele MCP vin incluse.

Continuați să citiți

Conectați primul canal în două minute.

Fără recenzii de platformă de așteptat. Conectați WhatsApp, Instagram, TikTok sau alt canal, apoi cereți AI-ului să publice, să răspundă sau să raporteze și urmăriți-l cum lucrează.

  • 3 zile gratuit
  • Anulați oricând
  • Doar API-uri oficiale
  • Monitorizat 24/7

Verificat la