# Facebook Page Reviews Scraper — Newest Reviews & Rating (`foxlabs/facebook-page-reviews-scraper`) Actor

The newest reviews a visitor is shown for public Facebook business Pages (six per Page, measured) and each Page's recommendation rate and review count as a row of its own: recommends or not, text, exact time, author (or a code), reactions, photos. Many Pages a run, for reputation watching. No login.

- **URL**: https://apify.com/foxlabs/facebook-page-reviews-scraper.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 reviews

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Facebook Page Reviews Scraper — Newest Reviews & Rating 🚀

**foXLabs Facebook series:** [Page Posts](https://apify.com/foxlabs/facebook-page-posts-scraper) · [Page Profile](https://apify.com/foxlabs/facebook-page-profile-scraper) · [Post Comments](https://apify.com/foxlabs/facebook-post-comments-scraper) · [Page Videos](https://apify.com/foxlabs/facebook-page-videos-scraper) · [Page Events](https://apify.com/foxlabs/facebook-page-events-scraper)

🎉 The newest reviews of public Facebook business Pages, exactly as Facebook shows them to a signed-out visitor — **whether the reviewer recommends the Page, the text, exact time, author (or a code), reactions, comments, photos** — plus the Page's **recommendation rate and review count** as a row of its own. Many Pages a run. No login, no cookies, no account of anyone. Built for watching reputation week after week.

**Read this first:** Facebook shows a signed-out visitor only a Page's newest reviews — six per Page, measured on a Page with 119,567 reviews — and its overall rate. This Actor delivers exactly that, and says so instead of pretending to reach the archive.

### 🔍 What is the Facebook Page Reviews Scraper — and when should you use it?

Give this Actor public Facebook business Pages and it returns their newest reviews plus the Page's recommendation rate — clean rows for reputation monitoring across many Pages.

**Use it when you need:** to watch reputation (rate + newest reviews) across many Pages on a schedule; the latest customer sentiment on a competitor; or recommendation-only / does-not-recommend slices.

**Use something else when:** you need posts → [Page Posts](https://apify.com/foxlabs/facebook-page-posts-scraper); the Page's contact record → [Page Profile](https://apify.com/foxlabs/facebook-page-profile-scraper); comments on a post → [Post Comments](https://apify.com/foxlabs/facebook-post-comments-scraper).

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for this Actor by name: `foxlabs/facebook-page-reviews-scraper`. An agent can discover it, run it and read the dataset over MCP.

**Real-time Standby API.** This Actor ships a Standby endpoint so an agent can fetch a Page's newest reviews and rating on demand — `GET /reviews?page=metmuseum&maxReviews=10&authors=0`, billed with the same events.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```
I want public Facebook Page reviews using the Apify Actor
`foxlabs/facebook-page-reviews-scraper`.

Input: `pages` is a list of business Pages; `includeRating` adds the Page's overall rate row;
`recommendation` filters all/recommends/does-not-recommend; `hideAuthors` returns codes instead
of names. Each review row has isRecommended, text, createdAt, author and reactions.

Start with:
{ "pages": ["metmuseum"], "maxReviewsPerPage": 10 }

Ask me which Pages to watch, run the Actor, then summarise the reviews and rating.
```

The machine-readable API, MCP config and OpenAPI definition live at `apify.com/foxlabs/facebook-page-reviews-scraper.md`.

### 📋 Overview

Everything you need to monitor public Facebook Page reputation — newest reviews plus the overall rate — in one Actor, with no login, cookies or account.

**Why teams pick this Actor:**

- ✅ **Rate + reviews** — the Page's recommendation percentage and count, and each newest review.
- 🔁 **Reputation watching** — schedule the same Pages to build history over time.
- 🕵️ **Author privacy** — `hideAuthors` returns a stable code instead of a name.
- 🎯 **Honest about the limit** — a signed-out visitor sees ~6 reviews; the Actor says so, never fakes the archive.
- 💰 **Pay only for results** — `review`/`rating` events per row; status rows and unreadable Pages free.
- 🤖 **Agent-ready** — MCP + a real-time Standby API.

### ✨ Features

- ⭐ **Recommendation + text** — `isRecommended`, title, text, exact time.
- 📊 **Rating row** — "100% recommend (119,567 reviews)" with its two numbers (`includeRating`).
- 🙈 **Author codes** — `hideAuthors` replaces names/ids/URLs with a stable `u_…` code.
- 🧹 **Filter** — all / recommends / does-not-recommend.
- 📦 **Clean export** — deduplicated camelCase rows, ready for CSV/Excel/JSON.

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~facebook-page-reviews-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"pages": ["metmuseum"], "maxReviewsPerPage": 10}'
```

### 🚀 Getting Started (3 steps)

1. **Choose business Pages** — one per line: name, `@handle`, numeric id or URL.
2. **Tune it** — keep `includeRating` on; set a `recommendation` filter; turn on `hideAuthors` for privacy.
3. **Run and export** — get a clean dataset as JSON, CSV or Excel.

### 📥 Input

| Field | Default | What it does |
|---|---|---|
| `pages` | — | One Page per line. Business Pages with a Reviews tab; others get a free status row. |
| `maxReviewsPerPage` | 50 | Reviews per Page (a visitor is shown six at most, see above). |
| `maxReviews` | 100000 | Review rows in the whole run. |
| `recommendation` | `all` | `all`, `recommends`, or `does-not-recommend`. |
| `includeRating` | true | The Page's rate and review count as a row of its own (billed as `rating`). |
| `hideAuthors`, `authorCodeKey` | false | Replace reviewers' names/ids/URLs with codes; a shared key gives the same person the same code. |
| `proxyConfiguration` | residential Apify Proxy | Nothing to change for normal use. |

### 📤 Output

One row per review (`type: "review"`), plus one per Page (`type: "rating"`) with `includeRating`. A value Facebook does not give is `null`.

| Field | What it is |
|---|---|
| `reviewId`, `url` | the review's id and address |
| `isRecommended`, `title` | whether the reviewer recommends the Page, and the title Facebook shows |
| `text`, `createdAt` | the review's text and when it was written (UTC) |
| `author`, `authorId`, `authorUrl` | who wrote it — or a stable code with `hideAuthors` |
| `reactions`, `commentCount`, `images` | reactions, comments and photos the review carries |
| `pageId`, `pageName`, `pageUrl` | the Page |
| `ratingText`, `ratingPercent`, `reviewCount` | on the rating row |
| `position`, `input`, `type`, `error` | place in the list; input line; row type / free status row |

```json
{ "type": "rating", "pageName": "The Metropolitan Museum of Art, New York", "ratingText": "100% recommend (119,567 reviews)", "ratingPercent": 100, "reviewCount": 119567, "input": "metmuseum" }
{ "type": "review", "reviewId": "29009148878689253", "isRecommended": true, "title": "Alyssa Lema recommends The Metropolitan Museum of Art.", "text": "I managed to catch the very end of the Van Gogh…", "createdAt": "2026-10-01T13:38:11.000Z", "author": "Alyssa Lema", "position": 1, "input": "metmuseum" }
```

### 💼 Use cases

**1. Reputation monitoring** — track rate and newest reviews across many Pages weekly.
*Input:* your Pages, scheduled. *Output:* rating rows + newest reviews. *Use:* spot sentiment shifts early.

**2. Competitor sentiment** — read what customers say about a rival.
*Input:* the competitor's Page. *Output:* recent recommendations + text. *Use:* learn their praise and complaints.

**3. Privacy-safe exports** — reviews without exposing reviewer identities.
*Input:* Pages, `hideAuthors` on. *Output:* reviews with stable author codes. *Use:* analyse sentiment within policy.

### 🔗 Integration

**JavaScript / Node.js**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/facebook-page-reviews-scraper').call({
  pages: ['metmuseum'], maxReviewsPerPage: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('foxlabs/facebook-page-reviews-scraper').call(
    run_input={'pages': ['metmuseum'], 'maxReviewsPerPage': 10}
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)
```

Written for `apify-client` 3 for Python, where `call()` returns a run object; with version 1 or 2 it returns a dict — write `run['defaultDatasetId']` there.

**Automation (n8n / Zapier / Make):** schedule → HTTP request to the Actor API with your `pages` → handle the JSON dataset → push to a sheet, CRM or dashboard.

### 📊 Pricing

Pay per event: **`review`** per delivered review row, **`rating`** per delivered rating row. The prices are on the Pricing tab. Nothing else is charged: no start fee, nothing for a status row, nothing for a review the filter left out, nothing for a Page that could not be read.

### ❓ FAQ

**How many reviews can I get per Page?** Six — that's all Facebook shows a signed-out visitor, even on a Page with 119,567 reviews. The older archive needs a login, which this Actor does not use. For reputation watching, run the same Pages on a schedule.

**Are there star ratings?** No — Facebook reviews are recommendations (yes/no), plus the Page's overall percentage.

**Can I hide reviewer names?** Yes — `hideAuthors` returns a stable code instead of the name/id/URL.

**Why does a Page return a status row?** It has no Reviews tab (not a business Page), doesn't exist, or is signed-in only — free, not charged.

**Can I export to CSV / Excel / JSON?** Yes — directly from the Apify dataset.

### 🐛 Troubleshooting

- **Only six reviews** — expected; it's the signed-out visitor's limit. Schedule recurring runs to keep collecting the newest.
- **A Page returns a status row** — no Reviews tab, no such Page, or signed-in only (free).
- **The Page's replies to reviews** aren't shown to a visitor, so they're not in the rows.

**How it reads Facebook:** opens the Reviews tab as a signed-out visitor (it carries the rate and three reviews) and asks Facebook's own feed query for the rest, using the page's tokens. Residential Apify Proxy by default (Facebook serves public Pages to residential only); rate-limited exits dropped and replaced. Every run starts with a one-call check and ends with a clear message if Facebook's queries changed.

### ⚠️ Trademark

Independent, third-party tool. Not affiliated with, endorsed by or connected to Meta Platforms, Inc. "Facebook" and related marks belong to their owners and are used here for identification only.

### ⚖️ Is it legal to scrape this data?

It reads only what Facebook shows a signed-out visitor. Reviews carry the names of people who wrote them publicly; personal data is protected by the GDPR and similar laws, so only collect and process it with a legitimate basis — or turn on `hideAuthors`. The Actor does not log in, use anyone's account or cookies, or solve CAPTCHAs. See Apify's blog post on the legality of web scraping.

### 🤝 Support & contact

- 🌐 **Website:** [data.foxlabs.com.tr](https://data.foxlabs.com.tr)
- 📧 **Email:** info@foxlabs.com.tr
- 🐛 **Issues:** open a ticket in the Actor's **Issues** tab — include the run id; the run's `SOURCE_REPORT` record holds what was asked and why the run stopped.
- 🧰 **More clean data actors:** [Fox Labs on Apify](https://apify.com/foxlabs)

### Changelog

#### 0.1.0 — 2026-10-11 — first release

- The newest reviews (recommendations) of public Facebook business Pages as a signed-out visitor sees them — the Reviews tab's three plus Facebook's feed query (six per Page in all) — and the Page's recommendation rate and review count as a row of its own (`includeRating`).
- Every review row: recommendation, title, text, exact time, author (name/id/URL — or a stable code with `hideAuthors`), reactions, comment count, photos, the review's address, the Page's record.
- A recommendation filter that leaves reviews out without charging. Free status rows for lines that bring nothing; restarted runs continue without duplicates. Standby mode prepared; published in batch mode.

# Changelog

This Actor's version history is a separate document: https://apify.com/foxlabs/facebook-page-reviews-scraper/changelog.md

# Actor input Schema

## `pages` (type: `array`):

One Page per line: a name (metmuseum), @name, a numeric id, or an address (https://www.facebook.com/metmuseum). Business Pages with a Reviews tab; a Page without one gets a free status row that says so. A Page written twice is read once.

## `maxReviewsPerPage` (type: `integer`):

How many reviews to deliver for each Page, newest first. Facebook hands the Reviews tab out three at a time.

## `maxReviews` (type: `integer`):

The run stops when this many review rows have been delivered. You are charged only for delivered rows.

## `recommendation` (type: `string`):

All reviews, only those that recommend the Page, or only those that do not. Reviews left out are not charged.

## `includeRating` (type: `boolean`):

One row of type "rating" per Page with its recommendation rate and review count, as Facebook shows them (billed as a rating event). Off: review rows only.

## `hideAuthors` (type: `boolean`):

Each reviewer's name, id and address are replaced by a code that is the same for the same person. Use it when you do not need who wrote what.

## `authorCodeKey` (type: `string`):

With "Replace reviewers' names with codes": runs that share this key give the same person the same code. Leave empty for the Actor's own key.

## `proxyConfiguration` (type: `object`):

Nothing to change for normal use: the Actor reads Facebook through Apify Proxy residential addresses, the only kind Facebook serves its public Pages to (measured: residential 25 of 25 requests, datacenter 0 — sent to the login page). Set a proxy here to send every request through it instead.

## Actor input object example

```json
{
  "pages": [
    "metmuseum"
  ],
  "maxReviewsPerPage": 20,
  "maxReviews": 100000,
  "recommendation": "all",
  "includeRating": true,
  "hideAuthors": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "pages": [
        "metmuseum"
    ],
    "maxReviewsPerPage": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/facebook-page-reviews-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "pages": ["metmuseum"],
    "maxReviewsPerPage": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/facebook-page-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "pages": [
    "metmuseum"
  ],
  "maxReviewsPerPage": 20
}' |
apify call foxlabs/facebook-page-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,foxlabs/facebook-page-reviews-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/NHQeWPIbRtr7tjh2l/builds/D4eiVGSZYbti8kC4K/openapi.json