Kirjaudu sisäänAloita ilmainen kokeilu
easyCoexistence Viralliset API:t

Facebook Pages API Pythonissa ja Node.js:ssä: toimivia esimerkkejä

Python ja Node.js kutsuvat Facebook Pages API:a tavallisina HTTPS-pyyntöinä osoitteeseen graph.facebook.com/v26.0 Sivun access tokenilla: POST /{page-id}/feed ja /{page-id}/photos julkaisevat, /{post-id}/comments lukee ja vastaa kommentteihin, POST /{page-id}/messages vastaa Messengerissä, GET /{page-id}/insights lukee mittarit ja HMAC-SHA256 raakarungosta tarkistaa X-Hub-Signature-256:n jokaisessa webhookissa.

easyCoexistence antaa yhdistetylle Sivulle nämä työt MCP-työkaluina, kuten publish_facebook_post, reply_to_comment, send_social_dm ja get_social_insights, välittää tapahtumansa allekirjoitettuina X-EC-Signature-otsikolla ja antaa omalle koodillesi Sivun ID:n ja API-perusosoitteen get_social_credentials-työkalun kautta.

caption

Sivun kuvan text-parametri; Metan photos-viitteessä tämä on merkitty vanhentuneeksi.

X-Business-Use-Case-Usage

Vastauksen otsikko, jonka estimated_time_to_regain_access kertoo minuuttien määrän ennen kuin rajoitetut kutsut toimivat taas.

RESPONSE

messaging_type vastaukselle viestiin, jonka Sivu vastaanotti, lähetettynä 24 tunnin ikkunan sisällä.

recipient.comment_id

Miten yksityisvastaus osoitetaan kommentoijalle samaa /{page-id}/messages-päätepistettä käyttäen.

Mitä esimerkit tarvitsevat ennen ajamista?

Sivun ID:n ja sen access tokenin, jotka luetaan /me/accounts-osoitteesta pitkäikäisellä käyttäjätokenilla, sekä Python 3:n requests-kirjastoineen tai Node.js 18:n tai uudemman, jonka sisäänrakennettu fetch ei vaadi pakettia. Jokainen tehtävä vaatii myös oikeutensa tokenilla ja tehtävänsä Sivulla, ja esimerkit kutsuvat Graph API v26.0:aa:

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

Miten postaus ja kuva julkaistaan Pythonilla?

Yhdellä apufunktiolla, jota myöhemmät esimerkit käyttävät uudelleen: graph() lisää Sivun tokenin, lähettää GET-parametrit kyselymerkkijonossa ja POST-kentät JSON:ina, kuten Metan omat esimerkit tekevät, ja muuttaa Metan virheobjektin GraphErroriksi, jossa on code ja error_subcode. Se odottaa ja yrittää uudelleen vain tilapäiset ja rajoituskoodit sen ajan, minkä X-Business-Use-Case-Usage -otsikko pyytää, kun se palautuu, ja nostaa muut heti.

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

Miten ne julkaistaan Node.js:ssä?

Samalla apufunktiolla Node.js 18:n tai uudemmassa, tallennettuna .mjs-tiedostoksi, jotta ylimmän tason await toimii, ja sisäänrakennetulla fetchillä asiakaskirjaston sijaan. Kuvakutsu lähettää url- ja caption-kentät, joista jälkimmäinen on photos-päätepisteen text-kenttä; Meta vastaa id:llä ja sen kuvan sisältävän Sivun postauksen post_id:llä, kun taas feed-kutsu vastaa vain postauksen id:llä.

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

Miten kommentteja luetaan ja niihin vastataan Pythonilla?

Postauksen kommentit luetaan fields-parametrilla, filter=stream antaa kaikkien tasojen kommentit aikajärjestyksessä ja order=reverse_chronological uusimmat ensin. Sen jälkeen vastataan Sivun nimissä lähettämällä viesti kommentin omaan comments-päätepisteeseen. Tokenin on tultava henkilöltä, joka voi suorittaa MODERATE-toiminnon, muuten Meta jättää kommenttien ID:t pois, ja vastaaminen vaatii pages_manage_engagement-oikeuden. paging.next johtaa kauemmas taaksepäin.

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

Miten kommentteja luetaan ja niihin vastataan Node.js:ssä?

Samat kaksi kutsua, ja kyselymerkkijonon rakentaa URL-olio: GET fields-, filter- ja order-parametreilla, sitten POST osoitteeseen /{comment-id}/comments. can_reply_privately, joka pyydetään fields-kentässä, kertoo voiko Sivu vielä lähettää kommentoijalle yksityisvastauksen, mikä kannattaa tietää ennen alla olevaa Messenger-esimerkkiä. Tallenna vastattujen kommenttien ID:t, jotta uudelleenajo ei vastaa kahdesti.

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

Miten Messenger-vastaus lähetetään Pythonilla?

POST /{page-id}/messages, jossa recipient.id on henkilön Sivukohtainen ID messages-webhookista, messaging_type on RESPONSE ja teksti. Esimerkki ottaa kiinni kaksi virhettä, joita ei kannata yrittää uudelleen: virhe 10 alikoodilla 2534022 tai 2018278, kun 24 tunnin ikkuna on sulkeutunut, ja 551, kun henkilö ei ole tavoitettavissa. private_reply() käyttää recipient.comment_id:tä ID:n sijasta yhden viestin lähettämiseen, jonka kommentti sallii 7 päivän sisällä.

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

Miten Messenger-vastaus lähetetään Node.js:ssä?

Sama pyynnön runko JavaScriptissä: recipient, messaging_type ja message lähetetään JSON-muodossa graph()-funktiolla. Metan hyväksymä lähetys vastaa recipient_id:llä ja message_id:llä, jotka kannattaa tallentaa keskusteluun. Yksityisvastaus sisältää linkin kommenttiin, jota se vastaa, ja keskustelu jatkuu tavallisessa 24 tunnin ikkunassa, kun henkilö kirjoittaa takaisin.

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

Miten Sivun tilastot luetaan Pythonilla?

GET /{page-id}/insights, jossa on pilkuilla erotettu mittarilista, period=day sekä since- ja until-ikkuna UNIX-sekunteina; yksi pyyntö kattaa enintään 90 päivää. Kolme mittaria on korvannut Metan poistamat: page_media_view (korvaa page_impressions), page_total_media_view_unique (korvaa page_impressions_unique) ja page_follows (korvaa page_fans), kun taas page_post_engagements laskee reaktiot, kommentit ja jakamiset.

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

Miten Sivun tilastot luetaan Node.js:ssä?

Sama kutsu, jossa since ja until lasketaan sekunneiksi Date.now()-kutsusta. Jokainen mittari palautuu nimellään, jaksollaan ja values-listana, jossa on value- ja end_time-parit, yksi päivää kohden; kun since on asetettu, ensimmäinen end_time osuu sitä seuraavalle päivälle, jotta kyseisen päivän data sisältyy. Tokenilla on oltava read_insights- ja pages_read_engagement-oikeudet henkilöltä, jolla on ANALYZE-tehtävä.

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

Miten webhookin allekirjoitus tarkistetaan Pythonilla?

Lasketaan uudelleen X-Hub-Signature-256 raakarungosta ja sovelluksen salaisuudesta, ja verrataan kahta arvoa vakioaikaisesti. Meta allekirjoittaa jokaisen POST-pyynnön rungon HMAC-SHA256:lla, avaimena Sovelluksen hallintapaneelin perusasetuksista löytyvä App Secret, ja kirjoittaa sen sha256=-etuliitteen perään. Anna runko tavuina ennen JSON-jäsennystä: request.body Djangossa ja await request.body() FastAPI:ssa antavat tavut, jotka Meta allekirjoitti.

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

Miten webhookin allekirjoitus tarkistetaan Node.js:ssä?

Sama tarkistus node:crypto-moduulilla, joka tarvitsee rungon Buffer-oliona: Expressissä express.raw pitää rungon jäsentämättömänä kyseisellä reitillä. timingSafeEqual heittää virheen eri pituisille syötteille, joten pituustarkistus tehdään ensin. Vastaa nopeasti koodilla 200 ja tee työ jälkikäteen, koska Meta yrittää epäonnistuneet toimitukset uudelleen ja voi lähettää tapahtuman kahdesti; vahvistussivu kattaa hub.challenge-kättelyn, joka tulee ennen tapahtumia.

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

Mihin virhekoodeihin koodin pitää reagoida?

Niihin, jotka Metan virheohjeet erottavat toisistaan, koska jokainen vaatii erilaisen vastauksen: hylätyn tokenin tai virheellisen parametrin uudelleenyritys epäonnistuu vain uudestaan, kun taas rajoitettu kutsu onnistuu odotuksen jälkeen. graph() yrittää uudelleen tilapäiset ja rajoituskoodit ja nostaa muut kutsujan käsiteltäväksi:

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

Miten samat työt ajetaan easyCoexistencen kautta?

MCP-työkaluina, joita Claude, ChatGPT tai oma agenttisi kutsuu yhdistetyllä Sivulla, ja token pysyy easyCoexistencen hallussa. Sivun tokeneita ei koskaan luovuteta, joten yllä olevat esimerkit toimivat oman Meta-sovelluksesi tokenilla; get_social_credentials palauttaa Sivun ID:n ja Graph API -perusosoitteen. Jokaisen työn työkalu:

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

Yleiset virheet

  • Sivun päätepisteiden kutsuminen käyttäjätokenilla. Useimmat niistä odottavat Sivun omaa tokenia, ja käyttäjä- tai sovellustokenilla tehdyt kutsut kuluttavat näiden rajoitusten kiintiötä Sivun sijaan.
  • Saman tekstin julkaiseminen kahdesti peräkkäin. Meta hylkää peräkkäiset samat postaukset virheellä 506, joten uudelleen ajettavan työn on vaihdettava sisältöä tai ohitettava postaus.
  • Päivittäisten uniikkien katselijoiden yhteen laskeminen. page_total_media_view_unique laskee uniikit katselijat kullakin jaksolla, joten päiväarvot eivät summaudu kuukaudeksi; pyydä sen sijaan period days_28.
  • Sivun tokenin lähettäminen selaimeen tai sovellukseen. Nämä kutsut kuuluvat palvelimelle, jonne token ei ulotu kenellekään, joka voi lukea asiakasohjelmaa.
Näin teet tämän EasyCoexistencen avulla

US$ 9:stä US$ 0,75:een per yhteys kuukaudessa, kun yhteyksiä on enemmän; ensimmäiset 3 päivää ovat ilmaista kokeilua.

Usein kysytyt kysymykset

Tarvitsenko SDK:ta Facebook Pages API:n kutsumiseen?

Ei. Graph API toimii HTTPS-yhteydellä ja JSON-muodossa, joten Pythonin pyynnöt ja Node.js 18:n tai uudemman sisäänrakennettu fetch riittävät, kuten tämän sivun esimerkit näyttävät.

Voiko sama koodi julkaista useille Sivuille?

Kyllä. /me/accounts palauttaa erillisen tokenin jokaiselle Sivulle, joten pidä yksi jokaiselle Sivulle ja anna vastaavat PAGE_ID ja PAGE_TOKEN. Sivun tokenilla tehdyt kutsut kuluttavat sen oman Sivun rajoituskiintiön.

Mistä Messenger-vastauksen PSID tulee?

Messages-webhookista: jokaisen messaging-tapahtuman sender.id on henkilön Sivukohtainen ID, joka on yksilöllinen kyseiselle henkilölle ja Sivulle. Facebook Login -käyttäjä-ID:t ovat sovelluskohtaisia eivätkä toimi Messenger Platformin kanssa.

Paljonko easyCoexistence maksaa Facebook-sivulle?

Jokainen yhdistetty Sivu lasketaan yhdeksi yhteydeksi, hintaan US$ 9:stä US$ 0,75:een per yhteys kuukaudessa riippuen siitä, kuinka monta niitä on, ja ensimmäiset 3 päivää ovat ilmaista kokeilua; MCP-työkalut tulevat mukana.

Lue lisää

Yhdistä ensimmäinen kanavasi kahdessa minuutissa.

Ei alustojen tarkastuksia odotettavana. Yhdistä WhatsApp, Instagram, TikTok tai jokin muu kanava, pyydä sitten tekoälyäsi julkaisemaan, vastaamaan tai raportoimaan ja seuraa, kun se hoitaa homman.

  • 3 päivää ilmaiseksi
  • Peruuta milloin tahansa
  • Vain viralliset API:t
  • Valvottu 24/7

Vahvistettu