లాగిన్ చేయండిఉచిత ట్రయల్ ప్రారంభించండి
easyCoexistence అధికారిక APIలు

Python మరియు Node.js లో Facebook Pages API: పని చేసే ఉదాహరణలు

Python మరియు Node.js, Facebook Pages API ను graph.facebook.com/v26.0 కు సాధారణ HTTPS అభ్యర్థనలుగా పంపుతాయి, Page యొక్క access టోకెన్‌తో: POST /{page-id}/feed మరియు /{page-id}/photos పోస్ట్ చేస్తాయి, /{post-id}/comments కామెంట్‌లను చదివి వాటికి సమాధానమిస్తాయి, POST /{page-id}/messages Messenger లో సమాధానమిస్తుంది, GET /{page-id}/insights మెట్రిక్స్ చదువుతుంది, మరియు ప్రతి webhook పై X-Hub-Signature-256 ను raw బాడీ యొక్క HMAC-SHA256 తో తనిఖీ చేస్తాయి.

easyCoexistence కనెక్ట్ చేయబడిన Pageకు ఈ పనులను MCP టూల్స్‌గా ఇస్తుంది, publish_facebook_post నుండి reply_to_comment మరియు send_social_dm నుండి get_social_insights వరకు, దాని ఈవెంట్‌లను X-EC-Signature తో సంతకం చేసి ఫార్వర్డ్ చేస్తుంది, మరియు మీ స్వంత కోడ్‌కు get_social_credentials ద్వారా Page ID మరియు API బేస్ ఇస్తుంది.

caption

Page ఫోటో యొక్క text పరామితి; Meta యొక్క photos రిఫరెన్స్ అక్కడ మెసేజ్ ను వాడుకలో లేనిదిగా గుర్తిస్తుంది.

X-Business-Use-Case-Usage

estimated_time_to_regain_access ఇచ్చే response హెడర్; పరిమితి దాటిన కాల్స్ మళ్లీ పని చేయడానికి ఎన్ని నిమిషాలు పడుతుందో అది చెబుతుంది.

RESPONSE

Page అందుకున్న మెసేజ్‌కు సమాధానం కోసం messaging_type, 24-గంటల విండోలో పంపబడుతుంది.

recipient.comment_id

కామెంట్ చేసిన వ్యక్తికి ప్రైవేట్ రిప్లై ఎలా చిరునామా ఇస్తుంది, అదే /{page-id}/messages ఎండ్‌పాయింట్ ద్వారా.

ఉదాహరణలు రన్ కావడానికి ముందు ఏమి కావాలి?

Page ID మరియు ఆ Page యొక్క access టోకెన్, long-lived user టోకెన్‌తో /me/accounts నుండి చదవబడినవి, అలాగే Python 3 మరియు requests, లేదా Node.js 18 లేదా తరువాతి వెర్షన్, దీని అంతర్నిర్మిత fetch కు ఏ ప్యాకేజీ అవసరం లేదు. ప్రతి పనికి కూడా టోకెన్‌పై దాని permission, మరియు Page పై దాని టాస్క్ కావాలి; ఉదాహరణలు 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

Python లో పోస్ట్ మరియు ఫోటో ఎలా ప్రచురించాలి?

తర్వాతి ఉదాహరణలు ఉపయోగించే ఒక హెల్పర్‌తో: graph() Page టోకెన్‌ను జోడిస్తుంది, GET పారామితులను query string లో, POST ఫీల్డ్‌లను Meta యొక్క స్వంత ఉదాహరణల వలె JSON గా పంపుతుంది, మరియు Meta యొక్క లోపం ఆబ్జెక్ట్‌ను code మరియు error_subcode కలిగిన GraphError గా మారుస్తుంది. తాత్కాలిక మరియు రేట్-లిమిట్ కోడ్‌లకు మాత్రమే వేచి ఉండి మళ్లీ ప్రయత్నిస్తుంది, X-Business-Use-Case-Usage ఆ హెడర్ తిరిగి వచ్చినప్పుడు కోరినంత సేపు, మిగిలినవాటిని వెంటనే raise చేస్తుంది.

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

Node.js లో వాటిని ఎలా ప్రచురించాలి?

అదే హెల్పర్‌తో Node.js 18 లేదా తరువాతి వెర్షన్‌లో, .mjs ఫైల్‌గా సేవ్ చేయబడింది, తద్వారా top-level await పని చేస్తుంది, మరియు క్లయింట్ లైబ్రరీకి బదులు అంతర్నిర్మిత fetch. ఫోటో కాల్ url మరియు caption ను పంపుతుంది, photos edge యొక్క text ఫీల్డ్; Meta దానికి ఫోటో యొక్క id తో, ఫోటోను కలిగి ఉన్న Page పోస్ట్ యొక్క post_id తో సమాధానమిస్తుంది, అయితే feed కాల్ పోస్ట్ యొక్క id మాత్రమే ఇస్తుంది.

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

Python లో కామెంట్‌లను ఎలా చదివి వాటికి సమాధానమివ్వాలి?

ఒక పోస్ట్ యొక్క కామెంట్‌లను fields తో చదవండి, అన్ని స్థాయిల కామెంట్‌ల కోసం filter=stream మరియు కొత్తవి మొదట కోసం order=reverse_chronological తో, తర్వాత కామెంట్ యొక్క స్వంత comments edge కు మెసేజ్ పోస్ట్ చేసి Page గా సమాధానమివ్వండి. టోకెన్ MODERATE చేయగల వ్యక్తి నుండి రావాలి, లేకపోతే Meta కామెంట్ IDలను వదిలేస్తుంది, మరియు సమాధానమివ్వడానికి pages_manage_engagement కావాలి. paging.next మరింత వెనక్కి తీసుకువెళ్తుంది.

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

Node.js లో కామెంట్‌లను ఎలా చదివి వాటికి సమాధానమివ్వాలి?

అవే రెండు కాల్స్, query string ను URL object నిర్మిస్తుంది: fields, filter మరియు order తో GET, తర్వాత /{comment-id}/comments కు POST. fields లో అభ్యర్థించిన can_reply_privately, Page ఆ కామెంట్ చేసిన వ్యక్తికి ఇంకా ప్రైవేట్ రిప్లై పంపగలదో లేదో చెబుతుంది; క్రింది Messenger ఉదాహరణకు ముందు ఇది తెలుసుకోవడం విలువైనది. మీరు సమాధానమిచ్చిన కామెంట్‌ల IDలను ఉంచండి, తద్వారా మళ్లీ రన్ చేసినప్పుడు రెండుసార్లు సమాధానమివ్వదు.

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

Python లో Messenger సమాధానం ఎలా పంపాలి?

POST /{page-id}/messages, recipient.id ను మెసేజ్ webhook నుండి వచ్చిన వ్యక్తి యొక్క Page-scoped ID కు సెట్ చేసి, messaging_type RESPONSE మరియు text తో. ఉదాహరణ మళ్లీ ప్రయత్నించకూడని రెండు తిరస్కరణలను పట్టుకుంటుంది: 24-గంటల విండో మూసివేసినప్పుడు subcode 2534022 లేదా 2018278 తో ఎర్రర్ కోడ్ 10, మరియు ఆ వ్యక్తి అందుబాటులో లేనప్పుడు 551. private_reply() ID స్థానంలో recipient.comment_id ఉంచుతుంది, కామెంట్ 7 రోజుల్లో అనుమతించే ఒకే మెసేజ్ కోసం.

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

Node.js లో Messenger సమాధానం ఎలా పంపాలి?

అదే request బాడీ JavaScript లో, recipient, messaging_type మరియు message లను graph() JSON గా పంపుతుంది. Meta అంగీకరించిన పంపకానికి recipient_id మరియు message_id తో సమాధానమిస్తుంది, వాటిని సంభాషణతో నిల్వ చేయడం విలువైనది. ప్రైవేట్ రిప్లైలో అది సమాధానమిస్తున్న కామెంట్‌కు లింక్ ఉంటుంది, మరియు ఆ వ్యక్తి తిరిగి రాసిన తర్వాత సంభాషణ ప్రామాణిక 24-గంటల విండోలో కొనసాగుతుంది.

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

Python లో Page insights ఎలా చదవాలి?

comma తో వేరు చేసిన మెట్రిక్ జాబితాతో GET /{page-id}/insights, period=day, మరియు UNIX సెకన్లలో since మరియు until విండో; ఒక request 90 రోజుల వరకు కవర్ చేస్తుంది. ఈ మెట్రిక్స్‌లో మూడు, Meta తొలగించిన వాటి స్థానంలో వచ్చాయి: page_impressions నుండి page_media_view, page_impressions_unique నుండి page_total_media_view_unique, మరియు page_fans నుండి page_follows, అయితే page_post_engagements రియాక్షన్‌లు, కామెంట్‌లు మరియు షేర్‌లను లెక్కిస్తుంది.

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

Node.js లో Page insights ఎలా చదవాలి?

అదే కాల్, since మరియు until ను Date.now() నుండి సెకన్లలో లెక్కించి. ప్రతి మెట్రిక్ దాని పేరు, period మరియు value మరియు end_time జంటల values జాబితాతో వస్తుంది, రోజుకు ఒకటి; since సెట్ చేసినప్పుడు, మొదటి end_time ఆ రోజు తర్వాతి రోజున వస్తుంది, తద్వారా ఆ రోజు డేటా చేర్చబడుతుంది. టోకెన్‌కు read_insights మరియు pages_read_engagement కావాలి, 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);
  }
}

Python లో webhook సంతకాన్ని ఎలా ధృవీకరించాలి?

raw అభ్యర్థన బాడీ మరియు app secret నుండి X-Hub-Signature-256 ను తిరిగి లెక్కించి, రెండింటిని constant time లో పోల్చండి. Meta ప్రతి POST ను payload యొక్క HMAC-SHA256 తో సంతకం చేస్తుంది, App Dashboard యొక్క basic settings లోని App Secret తో కీ చేయబడింది, మరియు దాన్ని sha256= తర్వాత వ్రాస్తుంది. బాడీని JSON పార్స్ చేయడానికి ముందు bytes గా ఇవ్వండి: Django లో request.body మరియు FastAPI లో await request.body() రెండూ Meta సంతకం చేసిన bytes ను ఇస్తాయి.

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

Node.js లో webhook సంతకాన్ని ఎలా ధృవీకరించాలి?

అదే తనిఖీ node:crypto తో, అది బాడీని Buffer గా కోరుతుంది: Express లో express.raw ఆ route లో దాన్ని పార్స్ చేయకుండా ఉంచుతుంది. timingSafeEqual వేరు వేరు పొడవుల ఇన్‌పుట్‌లపై లోపం విసురుతుంది, కాబట్టి పొడవు పరీక్ష మొదట నడుస్తుంది. 200 తో త్వరగా స్పందించండి మరియు పని తర్వాత చేయండి, ఎందుకంటే Meta విఫలమైన డెలివరీలను మళ్లీ పంపుతుంది మరియు ఒక ఈవెంట్‌ను రెండుసార్లు పంపవచ్చు; ధృవీకరణ పేజీ ఏ ఈవెంట్ కంటే ముందు వచ్చే hub.challenge హ్యాండ్‌షేక్‌ను వివరిస్తుంది.

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

కోడ్ ఏ ఎర్రర్ కోడ్‌లకు వేరుగా స్పందించాలి?

Meta యొక్క ఎర్రర్ గైడ్‌లు వేరు చేసే కోడ్‌లు, ఎందుకంటే ప్రతిదానికి వేరే స్పందన అవసరం: తిరస్కరించబడిన టోకెన్ లేదా చెడ్డ పరామితిని మళ్లీ ప్రయత్నించడం మళ్లీ విఫలమవుతుంది మాత్రమే, పరిమితి దాటిన కాల్ మాత్రం కొంత సేపు వేచి ఉన్న తర్వాత విజయవంతమవుతుంది. graph() తాత్కాలిక మరియు రేట్-లిమిట్ కోడ్‌లను మళ్లీ ప్రయత్నిస్తుంది, మిగిలిన వాటిని కాలర్ నిర్వహించడానికి raise చేస్తుంది:

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

easyCoexistence ద్వారా అవే పనులను ఎలా నడపాలి?

కనెక్ట్ చేయబడిన Page పై Claude, ChatGPT లేదా మీ స్వంత ఏజెంట్ కాల్ చేసే MCP టూల్స్‌గా, టోకెన్ easyCoexistence వద్ద ఉంచబడుతుంది. Page టోకెన్‌లు ఎప్పుడూ ఇవ్వబడవు, కాబట్టి పై ఉదాహరణలు మీ స్వంత Meta యాప్ టోకెన్‌తో నడుస్తాయి; get_social_credentials Page యొక్క ID మరియు Graph API base ను ఇస్తుంది. ప్రతి పని యొక్క టూల్:

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

సాధారణ పొరపాట్లు

  • Page ఎండ్‌పాయింట్‌లను యూజర్ టోకెన్‌తో కాల్ చేయడం. చాలావాటికి Page యొక్క స్వంత టోకెన్ కావాలి, మరియు యూజర్ లేదా app టోకెన్‌తో చేసిన కాల్స్ Page యొక్క పరిమితికి బదులు ఆ రేట్ లిమిట్‌లపై లెక్కించబడతాయి.
  • అదే టెక్స్ట్‌ను వరుసగా రెండుసార్లు ప్రచురించడం. Meta వరుస డూప్లికేట్ పోస్ట్‌లను ఎర్రర్ కోడ్ 506 తో తిరస్కరిస్తుంది, కాబట్టి మళ్లీ రన్ అయ్యే పని కంటెంట్‌ను మార్చాలి లేదా పోస్ట్‌ను దాటవేయాలి.
  • రోజువారీ unique viewers ను కూడటం. page_total_media_view_unique ప్రతి period లో unique viewers ను లెక్కిస్తుంది, కాబట్టి రోజువారీ విలువలు నెలగా కూడవు; బదులుగా period days_28 అడగండి.
  • Page టోకెన్‌ను బ్రౌజర్ లేదా యాప్‌కు పంపడం. ఈ కాల్స్ సర్వర్‌లో ఉండాలి, అక్కడ క్లయింట్ చదవగల ఎవరికైనా టోకెన్ అందకుండా ఉంటుంది.
EasyCoexistenceతో దీన్ని చేయడం

ప్రతి కనెక్షన్‌కు నెలకు US$ 9 నుండి US$ 0.75 వరకు, కనెక్షన్‌లు పెరిగినకొద్దీ తగ్గుతూ, మొదటి 3 రోజులు ఉచితం.

తరచుగా అడిగే ప్రశ్నలు

Facebook Pages API కాల్ చేయడానికి నాకు SDK కావాలా?

లేదు. Graph API JSON తో కూడిన HTTPS, కాబట్టి ఈ పేజీలోని ఉదాహరణలు చూపినట్లు Python లో requests మరియు Node.js 18 లేదా తరువాతి వెర్షన్‌లో అంతర్నిర్మిత fetch సరిపోతాయి.

అదే కోడ్ అనేక Pageలకు పోస్ట్ చేయగలదా?

అవును. /me/accounts ప్రతి Pageకు వేరే టోకెన్ ఇస్తుంది, కాబట్టి ప్రతి Pageకు ఒకటి ఉంచి సరిపోలే PAGE_ID మరియు PAGE_TOKEN ఇవ్వండి; Page టోకెన్‌తో చేసిన కాల్స్ ఆ Page యొక్క స్వంత రేట్ లిమిట్‌పై లెక్కించబడతాయి.

Messenger సమాధానానికి PSID ఎక్కడి నుండి వస్తుంది?

మెసేజ్ webhook నుండి: ప్రతి messaging ఈవెంట్‌లో sender.id ఆ వ్యక్తి యొక్క Page-scoped ID, ఆ వ్యక్తికి మరియు Pageకు మాత్రమే ప్రత్యేకమైనది. Facebook Login నుండి వచ్చే user IDలు app-scoped, అవి Messenger Platform తో పనిచేయవు.

Facebook Page కోసం easyCoexistence ఎంత ఖర్చు?

కనెక్ట్ చేయబడిన ప్రతి Page ఒక కనెక్షన్‌గా లెక్కించబడుతుంది, మీ దగ్గర ఎన్ని ఉన్నాయో బట్టి కనెక్షన్‌కు నెలకు US$ 9 నుండి US$ 0.75 వరకు, మరియు మొదటి 3 రోజులు ఉచితం; MCP టూల్స్ దానితో వస్తాయి.

చదవడం కొనసాగించండి

Facebook Pages API గైడ్ 2026: యాప్ నుండి మొదటి పోస్ట్ వరకు2026 కోసం Facebook Pages API మార్గం: Meta యాప్, Facebook Login for Business, అనుమతులు, Page టోకెన్, మొదటి పోస్ట్, Messenger, వెబ్‌హుక్‌లు.Facebook వెబ్‌హుక్ ధృవీకరణ: hub.challenge మరియు X-Hub-Signature-256Facebook వెబ్‌హుక్ ధృవీకరణ: hub.verify_token సరిపోలితే hub.challenge తిరిగి ఇవ్వండి; ప్రతి ఈవెంట్ సంతకాన్ని యాప్ సీక్రెట్‌తో తనిఖీ చేయండి.2026లో Facebook Page Insights మెట్రిక్స్: ఏవి పనిచేస్తాయి మరియు Meta ఏవి తొలగించింది2026 చివరి నాటికి ఏ Facebook Page Insights మెట్రిక్స్ పనిచేస్తాయి, Meta ఏవి తేదీలతో తొలగించింది: page_impressions, page_fans, రీచ్ మెట్రిక్స్.2026లో Messenger మెసేజ్‌ల ట్యాగ్‌లు: 24 గంటల విండో తర్వాత Facebook పేజీ ఏమి పంపగలదు2026లో Facebook పేజీ Messenger 24 గంటల విండో తర్వాత ఏమి పంపగలదో: HUMAN_AGENT, CUSTOMER_FEEDBACK, నిలిపివేసిన మూడు ట్యాగ్‌లు, ప్రత్యామ్నాయాలు.Facebook Page API కనెక్షన్ ఎందుకు పనిచేయడం ఆగిపోతుంది, దాన్ని ఎలా పనిచేస్తూ ఉంచాలిFacebook Page టోకెన్ లేదా వెబ్‌హుక్ ఆగిపోవడానికి కారణాలు, ప్రతి కారణం చూపే లోపం, ముందుగానే గుర్తించే మార్గం, Page ను మళ్లీ కనెక్ట్ చేసే విధానం.Facebook Graph API మార్పులు 2026: ఏవి పనిచేయడం ఆగిపోయాయి, ఏం చేయాలి2026 Facebook Graph API మార్పులు, కొత్తవి ముందు: v26.0, తొలగించిన వెర్షన్లు, ప్రోటోకాల్ మార్పులు, నిలిపివేసిన మెట్రిక్స్ మరియు ప్రతి పరిష్కారం.

మీ మొదటి ఛానెల్‌ను రెండు నిమిషాల్లో కనెక్ట్ చేయండి.

ప్లాట్‌ఫామ్ సమీక్షల కోసం ఎదురుచూడాల్సిన అవసరం లేదు. WhatsApp, Instagram, TikTok లేదా మరో ఛానెల్‌ను కనెక్ట్ చేయండి, ఆపై పోస్ట్ చేయమని, ప్రత్యుత్తరం ఇవ్వమని లేదా రిపోర్ట్ ఇవ్వమని మీ AIకి చెప్పండి, అది పని చేయడం చూడండి.

  • 3 రోజులు ఉచితం
  • ఎప్పుడైనా రద్దు చేయండి
  • అధికారిక APIలు మాత్రమే
  • 24/7 పర్యవేక్షణ

ధృవీకరించిన తేదీ