Facebook Reviews Scraper

Facebook Reviews Scraper — Text, Recommendations and Reviewer Data

Facebook Reviews Scraper extracts public review and recommendation posts from any Facebook page — review text, recommendation status, reviewer name and profile link, likes and comment counts, and the page's own published recommend percentage — as clean, structured JSON with one row per review. No Facebook login, no HTML parsing, no CSS selectors to maintain. Add a page URL or handle, set how many reviews you want, and run.

🧭 What is Facebook Reviews Scraper?

Facebook Reviews Scraper is an Apify Actor that collects the public review/recommendation feed of one or more Facebook pages and returns each review as an individual, ready-to-export dataset row. It does not require a Facebook account, login, or session cookie — it reads only what a page publishes publicly. It's built for brand and reputation teams, market researchers, and developers who need Facebook review data in a repeatable, structured feed instead of copy-pasting from the page.

🌐 What Facebook review data is publicly available to scrape?

Facebook exposes review text, recommendation status, reviewer identity, and engagement counts on any page that has recommendations switched on — none of it requires logging in.

Data Category	Publicly Available	Restricted
Review text & recommendation status	Yes, on pages with reviews/recommendations enabled	No — pages that switch reviews off return nothing (a page-owner setting)
Reviewer name, profile link, avatar	Yes, as published on the review	The reviewer's private profile content beyond what they've made public
Review likes & comment counts	Yes, as counts	The comment text itself is not exposed on this surface — count only
Page's overall recommend % and total review count	Yes, when Facebook currently shows a summary on the page	Not shown at all when the page hasn't published one
Reviewer's stable identity	Yes for numeric-ID accounts	Rotating pfbid tokens are not a durable cross-run join key
Private page reviews	—	Always restricted; this Actor never accesses login-gated content

⚠️ Reviews/recommendations being switched off is a page-owner setting, not a limitation of the scraper — the only way to know is to request the page.

Facebook Reviews Scraper only returns publicly visible data — what any visitor sees. Nothing behind a login wall.

📋 What data can I extract with Facebook Reviews Scraper?

Facebook Reviews Scraper returns review identity and text, reviewer identity, engagement metrics, and the page's own published recommendation summary — 21 fields per row plus a nested legacy user object.

Field Name	Description
id	Unique identifier of the review/recommendation post.
type	Row type — always "review".
isChild	Always false — this Actor produces no nested/child rows.
text	Full review text.
date	Review creation date, ISO 8601 (UTC).
url	Direct link to the review post.
facebookUrl	The page URL that was scraped (resolved, /reviews suffix stripped).
inputUrl	The exact value you supplied for this page in inputs.
facebookId	Facebook's internal feedback ID for the review.
postFacebookId	Facebook's internal post ID for the review.
pageName	The page's own display name.
scrapedAt	When this row was collected, ISO 8601 (UTC).
isRecommended	Whether the reviewer recommended the page. true/false, or null when the recommendation sentence couldn't be read reliably — never guessed.
likesCount	Reactions on the review. null when unreadable, never a fabricated 0.
commentsCount	Comment count on the review (count only).
pageRecommendPercent	The page's own published "% recommend" figure, when Facebook shows one.
pageTotalReviewCount	The page's own published total review count, when Facebook shows one.
reviewerName	Reviewer's display name.
reviewerProfileUrl	Link to the reviewer's profile.
reviewerProfilePic	Reviewer's avatar URL, when available.
reviewerIdType	"numeric" when the reviewer's Facebook ID is a stable numeric ID, "pfbid" when it's a rotating token, null when no ID resolved.

Review, page and reviewer identity fields

id, type, isChild, text, date, url, facebookUrl, inputUrl, facebookId, postFacebookId, pageName, scrapedAt

Recommendation and engagement metrics

isRecommended, likesCount, commentsCount, pageRecommendPercent, pageTotalReviewCount, reviewerIdType

Nested user object (kept for backward compatibility)

Every row also carries a user object — { "id", "name", "profileUrl", "profilePic" } — duplicating reviewerName, reviewerProfileUrl, and reviewerProfilePic as a nested structure alongside the flat columns.

🤖 Add-on: Need additional Facebook data?

Pair this with Facebook Event Search Scraper for public event listings on the same pages, or Facebook Video Transcript Extractor if the page also posts video content you want transcribed. Both live in the same Scraper Engine catalog.

🆚 How does Facebook Reviews Scraper differ from the official Facebook API?

Meta's Graph API can return a page's ratings, but only to someone who already administers that page — Facebook Reviews Scraper needs only the page's public URL or handle.

According to Meta's own Graph API reference for the Page ratings edge (developers.facebook.com, checked 2026-08-15), reading a page's ratings requires a page access token requested by a person who can perform CREATE_CONTENT, MANAGE, or MODERATE on that page, plus the pages_read_user_content permission — and "parent Page access tokens cannot be used to get recommendations for child Pages." In other words, the official endpoint is built for a page owner to read their own ratings, not for a third party to read anyone's.

Feature	Facebook Graph API (/ratings)	Facebook Reviews Scraper
Access requirement	Page access token from an admin/moderator of that page, pages_read_user_content permission	Just the page's public URL or handle
Scope	Only pages you (or your app) already administer	Any public page with reviews enabled — including competitors
App review	Requires Meta App Review before pages_read_user_content works in production	No approval process
Output shape	Raw Graph API JSON, aggregate ratings edge	One normalized row per individual review, stable field names
Reviewer-level detail	Aggregate only	Per-review text, reviewer name, profile link, avatar, engagement
Setup time	Register a Meta app, pass App Review, mint and refresh page tokens	Provide a page reference and start the run

Use the Graph API's /ratings edge if you already administer the page and only need your own aggregate rating. Use Facebook Reviews Scraper when you need individual review text and reviewer detail from any public page — including ones you don't manage.

🚀 How to use Facebook Reviews Scraper

Facebook Reviews Scraper runs on the Apify platform — no separate signup or API key beyond your Apify account.

1. Open Facebook Reviews Scraper on the Apify Console.
2. Provide inputs — one or more Facebook page URLs or handles (this is the only required field).
3. Optionally set maxItems (default 10, up to 10,000 per page) and a proxyConfiguration.
4. Click Start to launch the run.
5. Download or stream the results as JSON, CSV, Excel, or the other export formats the Apify dataset supports.

How to scale to bulk review extraction

inputs is an array (editor: stringList) — add as many page URLs or handles as you like and they're all processed in the same run. Internally the Actor works through them concurrently, but caps itself at 3 pages in flight at once (a fixed concurrency limit in the code), so a large batch of pages queues and works through in waves rather than firing every request at once.

💡 What can you do with Facebook review data?

• 🏢 Brand and reputation teams monitoring sentiment use text and isRecommended to track what customers say publicly, without manually reading every post.
• 📊 Analysts benchmarking competitors use pageRecommendPercent and pageTotalReviewCount across multiple pages to compare standing over time.
• 🔬 Researchers studying engagement use likesCount and commentsCount alongside date to see which reviews resonate.
• 🎧 Support and CX teams triage negative feedback by filtering isRecommended: false rows and routing text to the right queue.
• 🤖 AI engineers feed text, isRecommended, and reviewerName into a RAG pipeline or an LLM-based sentiment classifier as clean, pre-structured input — no parsing step needed.

🛡️ How does Facebook Reviews Scraper handle rate limits and blocking?

The Actor makes direct HTTP requests to Facebook's own GraphQL endpoint with browser-matched headers (User-Agent, sec-ch-ua client-hint triplets kept in sync) rather than driving a full headless browser. Concurrency is capped at 3 pages processed simultaneously, and each page's own review feed is paged in batches of 3 — Facebook's own server-side cap on that endpoint, not a choice this Actor makes. proxyConfiguration is honored exactly as given, with no silent escalation to a proxy tier you didn't select.

If a single request to fetch more reviews fails or comes back empty without pagination moving forward, the Actor retries up to 3 times with a short pause before giving up on that page and moving to the next one — a temporary failure on one page never stops the run. The Actor does not solve CAPTCHAs; if a page cannot be resolved at all, it's marked temporarily_unavailable, logged, and skipped.

⬇️ Input

Parameter	Required	Type	Description	Example Value
inputs	Yes	array of strings	One or more Facebook page links or handles, one per entry. Examples: https://www.facebook.com/yourfavouritebrand or yourfavouritebrand. Only public pages that have reviews/recommendations enabled will return rows.	["https://www.facebook.com/mrbeast"]
maxItems	No	integer	Maximum number of reviews to collect for each page (1–10,000). Default 10.	50
proxyConfiguration	No	object	Optional Apify Proxy configuration. Leave off for the simplest setup.	{"useApifyProxy": false}

Example input

{
  "inputs": [
    "https://www.facebook.com/mrbeast",
    "dominos"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

⬆️ Output

Every result is typed, normalized JSON with the same field names on every row — export straight to CSV, Excel, JSON, or feed it directly into another tool. Every dataset row is a real, collected review; the Actor pushes no separate accounting or error rows to the dataset.

Example output

{
  "id": "UzpfSTYxNTg0MzE3MjA0OTY4OjEyMjEwOTkzMzE4OTE0MzkwNjoxMjIxMDk5MzMxODkxNDM5MDY=",
  "type": "review",
  "isChild": false,
  "facebookUrl": "https://www.facebook.com/mrbeast",
  "inputUrl": "https://www.facebook.com/mrbeast",
  "user": {
    "id": "100004512398765",
    "name": "Jordan Ellis",
    "profileUrl": "https://www.facebook.com/jordan.ellis.94",
    "profilePic": "https://scontent.xx.fbcdn.net/v/t39.30808-1/example_profile.jpg"
  },
  "reviewerName": "Jordan Ellis",
  "reviewerProfileUrl": "https://www.facebook.com/jordan.ellis.94",
  "reviewerProfilePic": "https://scontent.xx.fbcdn.net/v/t39.30808-1/example_profile.jpg",
  "reviewerIdType": "numeric",
  "date": "2026-07-14T09:32:11.000Z",
  "url": "https://www.facebook.com/permalink.php?story_fbid=pfbid02exampleStoryId&id=61584317204968",
  "isRecommended": true,
  "text": "Great customer service and the product arrived earlier than expected. Would order again.",
  "likesCount": 4,
  "commentsCount": 1,
  "facebookId": "ZmVlZGJhY2s6MTIyMTA5OTMzMTg5MTQzOTA2",
  "postFacebookId": "122109933189143906",
  "pageName": "MrBeast",
  "pageRecommendPercent": 96,
  "pageTotalReviewCount": 5190,
  "scrapedAt": "2026-08-15T10:04:22.000Z"
}

⚙️ How does it work?

Facebook Reviews Scraper fetches the page's public reviews surface over HTTP with browser-matched headers, then reads two things already embedded in that one page load: a first batch of reviews and a pagination cursor buried in Facebook's own @defer chunks, plus the GraphQL doc_id needed to ask for more. It then pages through Facebook's internal GraphQL endpoint using that cursor until it reaches your maxItems limit or the feed runs out. Whether a page reference resolves to a real page with reviews on, a real page with reviews switched off, or no page at all is decided from page content markers, not the HTTP status code alone — Facebook can answer 200 for all three. Only publicly visible data is returned, and the output schema stays stable regardless of Facebook UI changes.

🔌 Integrations

Facebook Reviews Scraper runs on Apify, so it works with anything that can call the Apify API or use the apify-client SDK.

Calling Facebook Reviews Scraper programmatically

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run = client.actor("<YOUR_USERNAME>/facebook-reviews-scraper").call(run_input={
    "inputs": ["https://www.facebook.com/mrbeast"],
    "maxItems": 50,
})

for review in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(review["reviewerName"], review["isRecommended"])

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request.

No-code tools (n8n, Make, LangChain)

In n8n, point the HTTP Request node at the Actor's run-sync endpoint with your input JSON as the body. In Make, use the Apify app's "Run an Actor and Get Dataset Items" module and map inputs/maxItems from your scenario. In LangChain, wrap the run with Apify's dataset loader to pull text and isRecommended straight into a document store for retrieval.

⚖️ Is it legal to scrape Facebook reviews?

Scraping publicly available data is generally lawful; what you can lawfully do with it depends on what that data contains and where your users are. Facebook Reviews Scraper returns only publicly visible reviews — nothing behind a login. Because a review row includes personal data about an identifiable person (reviewerName, reviewerProfileUrl, reviewerProfilePic), storing or processing it falls under data-protection regimes like GDPR (EU) and CCPA (California) if your users or subjects are covered by them — you need a lawful basis for storing and using it, and reasonable limits on retention. Consult legal counsel if your use case involves bulk storage of personal data.

❓ Frequently asked questions

What Facebook review fields does Facebook Reviews Scraper return?

The core fields are text, isRecommended, reviewerName, date, and likesCount — see the full field table above for all 21 fields plus the nested user object.

Does Facebook Reviews Scraper require a Facebook account or login?

No. The Actor fetches the page's public reviews surface directly with browser-matched HTTP headers — no login, cookies, or session are used at any point.

How many reviews can I extract in one run?

Set maxItems per page — from 1 up to 10,000 — and add as many pages as you like to inputs in the same run. Concurrency is capped at 3 pages processed at once internally.

What happens if a page has reviews disabled or doesn't exist?

The Actor tells these apart from page content, not the HTTP status code: a page with no reviews feed and no recommendation summary returns zero rows and is logged as reviews_disabled if the page itself resolved, or page_not_found if it didn't. Either way it logs a warning and moves on to the next page in your inputs list — it never fabricates rows for a page it couldn't read.

Can I scrape multiple Facebook pages at once?

Yes — add multiple entries to inputs and they're all collected in the same run, processed concurrently up to 3 pages at a time.

Does Facebook Reviews Scraper work with Claude, ChatGPT, and other AI agent tools?

Yes, as an HTTP endpoint. It's callable by any agent framework that can call the Apify API — pass inputs and maxItems as the run input and read the resulting dataset.

How does Facebook Reviews Scraper compare to other Facebook review scrapers?

No third-party comparison data was verified for this listing as of 2026-08-15. What's verifiable from the source: isRecommended, likesCount, and commentsCount are returned as null rather than a guessed value whenever they can't be reliably read, and a page's status (reviews_available, reviews_disabled, page_not_found, temporarily_unavailable) is decided from page content rather than the HTTP status code alone, so a nonexistent handle and a real page with reviews switched off aren't confused with each other.

Does Facebook Reviews Scraper return data in a format LLMs can use directly?

Yes. Typed, normalized JSON with consistent field names across runs — no HTML parsing or selectors needed. Pass it directly to an LLM, index it into a vector store, or feed it to an agent tool.

What happens when Facebook changes its layout or anti-bot system?

The Actor is maintained and the output schema is designed to stay stable across Facebook UI changes. No specific update turnaround time is published.

Can I use Facebook Reviews Scraper without managing proxies or browser infrastructure?

Yes. The Actor makes its own HTTP requests directly — it doesn't require you to run a browser. proxyConfiguration is entirely optional; leave it off and the Actor runs without one.

Which Facebook review fields work best for AI training data and RAG indexing?

For RAG, index text as the primary passage, with reviewerName, date, and isRecommended as metadata. For training or scoring data, isRecommended, likesCount, commentsCount, pageRecommendPercent, and pageTotalReviewCount are the fields with the most consistent structure across records, returned as typed primitives (booleans and integers, not strings).

🔗 Related scrapers

Scraper Name	What it extracts
Facebook Event Search Scraper	Public Facebook event listings
Facebook Video Transcript Extractor	Transcripts from Facebook video posts
Airbnb Review Scraper	Public guest reviews from Airbnb listings
Walmart Reviews Scraper	Public product reviews from Walmart
Udemy Course Reviews Scraper	Public course reviews from Udemy

💬 Your feedback

Found a bug or missing a field? Let us know through the Issues tab on the Actor's Apify Console page or by messaging Scraper Engine support — reports like these are how the field list and edge-case handling keep improving.