Mag-log inMagsimula ng Libreng Trial
easyCoexistence Mga Official API

Facebook Pages API sa Python at Node.js: mga working example

Tumatawag ang Python at Node.js sa Facebook Pages API bilang simpleng HTTPS request sa graph.facebook.com/v26.0 gamit ang access token ng Page: nagpa-publish ang POST /{page-id}/feed at /{page-id}/photos, bumabasa at nagre-reply sa comments ang /{post-id}/comments, nagre-reply sa Messenger ang POST /{page-id}/messages, bumabasa ng metrics ang GET /{page-id}/insights, at sinusuri ng HMAC-SHA256 ng raw body ang X-Hub-Signature-256 sa bawat webhook.

Ibinibigay ng easyCoexistence sa isang naka-connect na Page ang mga trabahong ito bilang MCP tools, mula publish_facebook_post at reply_to_comment hanggang send_social_dm at get_social_insights, ipinapasa ang mga event nito na nilagdaan ng X-EC-Signature, at ibinibigay sa sariling code ninyo ang Page ID at API base sa pamamagitan ng get_social_credentials.

caption

Ang text parameter ng isang Page photo; minamarkahan ito ng photos reference ng Meta bilang deprecated.

X-Business-Use-Case-Usage

Response header na estimated_time_to_regain_access ang nagsasabi ng minuto bago muling gumana ang mga throttled call.

RESPONSE

Ang messaging_type para sa reply sa mensaheng natanggap ng Page, na ipinadala sa loob ng 24-hour window.

recipient.comment_id

Paano tinutugunan ng private reply ang taong nag-comment, sa parehong /{page-id}/messages endpoint.

Ano ang kailangan ng mga halimbawa bago tumakbo?

Page ID at access token ng Page na iyon, na kinukuha mula sa /me/accounts gamit ang long-lived user token, pati Python 3 na may requests, o Node.js 18 pataas, na walang kailangang package dahil built-in ang fetch. Kailangan din ng bawat trabaho ang permission nito sa token at ang task nito sa Page, at tumatawag ang mga halimbawa sa 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

Paano mag-publish ng post at photo sa Python?

Gamit ang isang helper na muling ginagamit ng mga susunod na halimbawa: idinadagdag ng graph() ang Page token, ipinapadala ang GET parameters sa query string at POST fields bilang JSON, gaya ng sariling halimbawa ng Meta, at ginagawang GraphError na may code at error_subcode ang error object ng Meta. Naghihintay at nagre-retry lang ito sa temporary at rate-limit codes, hangga't hinihingi ng X-Business-Use-Case-Usage kapag bumalik ang header na iyon, at agad na itinataas ang iba.

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

Paano sila i-publish sa Node.js?

Gamit ang parehong helper sa Node.js 18 pataas, na sine-save bilang .mjs file para gumana ang top-level await, at ang built-in fetch sa halip na client library. Ang photo call ay nagpapadala ng url at caption, ang text field ng photos edge; sumasagot ang Meta ng id ng photo at post_id ng Page post na naglalaman ng photo, habang ang feed call ay sumasagot ng id ng post lamang.

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

Paano magbasa at mag-reply sa comments sa Python?

Magbasa ng comments ng post gamit ang fields, filter=stream para sa comments sa lahat ng level ayon sa oras, at order=reverse_chronological para sa pinakabago muna, saka mag-reply bilang Page sa pamamagitan ng pagpo-post ng mensahe sa sariling comments edge ng comment. Dapat galing ang token sa taong may MODERATE, kung hindi ay iniiwan ng Meta ang comment IDs, at kailangan ng reply ang pages_manage_engagement. Ang paging.next ang humahantong pa pabalik.

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

Paano magbasa at mag-reply sa comments sa Node.js?

Ang parehong dalawang call, gamit ang URL object sa pagbuo ng query string: isang GET na may fields, filter at order, saka isang POST sa /{comment-id}/comments. Ang can_reply_privately, na hinihingi sa fields, ang nagsasabi kung maipapadala pa ng Page sa commenter na iyon ang private reply, na mahalagang malaman bago ang Messenger example sa ibaba. Itabi ang IDs ng mga comment na nire-replyan ninyo, para hindi dalawang beses mag-reply kapag inulit ang takbo.

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

Paano magpadala ng Messenger reply sa Python?

POST /{page-id}/messages na may recipient.id na nakatakda sa Page-scoped ID ng tao mula sa webhook ng mensahe, messaging_type na RESPONSE at ang text. Nahuhuli ng halimbawa ang dalawang pagtanggi na hindi na dapat i-retry: error 10 na may subcode 2534022 o 2018278 kapag sarado na ang 24-hour window, at 551 kapag hindi available ang tao. Inilalagay ng private_reply() ang recipient.comment_id sa lugar ng ID, para sa iisang mensaheng pinapayagan ng comment sa loob ng 7 araw.

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

Paano magpadala ng Messenger reply sa Node.js?

Ang parehong request body sa JavaScript, na may recipient, messaging_type at message na ipinapadala bilang JSON ng graph(). Sumasagot ang Meta ng recipient_id at message_id sa pagpapadalang tinanggap, na sulit i-save kasama ng conversation. Ang pribadong reply ay may link pabalik sa comment na sinasagot nito, at magpapatuloy ang conversation sa karaniwang 24-hour window kapag sumulat ulit ang tao.

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

Paano magbasa ng Page insights sa Python?

GET /{page-id}/insights na may listahan ng metric na pinaghihiwalay ng kuwit, period=day, at since at until window sa UNIX seconds; hanggang 90 araw ang saklaw ng isang request. Tatlo sa mga metric na ito ang pumalit sa mga inalis ng Meta: page_media_view mula sa page_impressions, page_total_media_view_unique mula sa page_impressions_unique, at page_follows mula sa page_fans, habang binibilang ng page_post_engagements ang reactions, comments at shares.

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

Paano magbasa ng Page insights sa Node.js?

Ang parehong call, na may since at until na kinukuwenta mula sa Date.now() sa segundo. Bawat metric ay may pangalan, period, at listahan ng values na may value at end_time na pares, isa bawat araw; kapag nakatakda ang since, ang unang end_time ay nasa araw pagkatapos nito, para kasama ang data ng araw na iyon. Kailangan ng token ang read_insights at pages_read_engagement, mula sa taong may ANALYZE task.

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

Paano i-verify ang webhook signature sa Python?

Kuwentahin muli ang X-Hub-Signature-256 mula sa raw request body at sa app secret, saka ihambing ang dalawa sa constant time. Nilalagdaan ng Meta ang bawat POST gamit ang HMAC-SHA256 ng payload, gamit ang App Secret mula sa basic settings ng App Dashboard, at isinusulat ito pagkatapos ng sha256=. Ipasa ang body bilang bytes, bago anumang JSON parsing: ibinibigay ng request.body sa Django at ng await request.body() sa FastAPI ang mismong bytes na nilagdaan ng 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"))

Paano i-verify ang webhook signature sa Node.js?

Ang parehong check gamit ang node:crypto, na nangangailangan ng body bilang Buffer: sa Express, pinapanatili ng express.raw itong hindi na-parse sa route na iyon. Ang timingSafeEqual ay nagtatapon ng error kapag magkaiba ang haba ng input, kaya unang tinitingnan ang haba. Sumagot ng 200 agad at gawin ang trabaho pagkatapos, dahil ni-retry ng Meta ang mga palpak na delivery at maaaring magpadala ng event nang dalawang beses; sakop ng verification page ang hub.challenge handshake na nauuna sa anumang event.

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

Aling mga error code ang dapat aksyunan ng code?

Ang mga tinutukoy ng error guides ng Meta, dahil bawat isa ay nangangailangan ng ibang tugon: ang pag-retry sa tinanggihang token o maling parameter ay papalya lang muli, samantalang ang throttled call ay nagtatagumpay pagkatapos ng paghihintay. Nagre-retry ang graph() sa temporary at rate-limit codes at itinataas ang iba para asikasuhin ng tumatawag:

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

Paano patakbuhin ang parehong trabaho sa pamamagitan ng easyCoexistence?

Bilang MCP tools na tinatawag ng Claude, ChatGPT o sariling agent ninyo sa isang naka-connect na Page, habang hawak ng easyCoexistence ang token. Hindi kailanman ibinibigay ang mga Page token, kaya tumatakbo ang mga halimbawa sa itaas gamit ang token mula sa sarili ninyong Meta app; ibinabalik ng get_social_credentials ang ID ng Page at ang Graph API base. Ang tool ng bawat trabaho:

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

Mga karaniwang pagkakamali

  • Pagtawag sa Page endpoints gamit ang user token. Karamihan sa mga ito ay umaasa sa sariling token ng Page, at ang mga call na gawa sa user o app token ay binibilang sa rate limit na iyon sa halip na sa Page.
  • Pag-publish ng parehong text nang sunod-sunod. Tinatanggihan ng Meta ang magkasunod na magkaparehong post gamit ang error 506, kaya ang trabahong inuulit ay dapat mag-iba ng nilalaman o laktawan ang post.
  • Pagdaragdag ng araw-araw na unique viewers. Binibilang ng page_total_media_view_unique ang mga unique viewer sa bawat period, kaya hindi nagsasama-sama ang araw-araw na value sa isang buwan; humingi ng period na days_28 sa halip.
  • Pagpapadala ng Page token sa browser o app. Dapat nasa server ang mga call na ito, kung saan nananatiling wala sa abot ng sinumang makababasa ng client ang token.
Ginagawa ito gamit ang EasyCoexistence

Mula US$ 9 hanggang US$ 0.75 kada koneksyon kada buwan, bumababa habang dumarami ang koneksyon, at libre ang unang 3 araw.

Mga madalas itanong

Kailangan ko ba ng SDK para tawagin ang Facebook Pages API?

Hindi. HTTPS na may JSON ang Graph API, kaya sapat na ang request sa Python at ang fetch na built-in sa Node.js 18 pataas, gaya ng ipinapakita ng mga halimbawa sa pahinang ito.

Maaari bang mag-post ang parehong code sa maraming Page?

Oo. Nagbabalik ang /me/accounts ng hiwalay na token para sa bawat Page, kaya magtabi ng isa bawat Page at ipasa ang kaukulang PAGE_ID at PAGE_TOKEN; ang mga call gamit ang Page token ay binibilang sa sariling rate limit ng Page na iyon.

Saan galing ang PSID para sa Messenger reply?

Sa webhook ng mensahe: ang sender.id sa bawat event ng webhook ay ang Page-scoped ID ng tao, natatangi sa taong iyon at Page. Ang User ID mula sa Facebook Login ay app-scoped at hindi gumagana sa Messenger Platform.

Magkano ang easyCoexistence para sa isang Facebook Page?

Bawat naka-connect na Page ay binibilang bilang isang koneksyon, sa US$ 9 hanggang US$ 0.75 kada koneksyon kada buwan depende sa dami ng mayroon kayo, at libre ang unang 3 araw; kasama na ang MCP tools.

Magpatuloy sa pagbabasa

I-connect ang inyong unang channel sa loob ng dalawang minuto.

Walang review ng platform na hihintayin. I-connect ang WhatsApp, Instagram, TikTok o iba pang channel, pagkatapos ay utusan ang inyong AI na mag-post, mag-reply o gumawa ng report, at panoorin itong gumana.

  • 3 araw na libre
  • Mag-cancel anumang oras
  • Official API lang
  • Minomonitor 24/7

Na-verify noong