# Facebook Page Recommendations Scraper (`automation-lab/facebook-page-recommendations-scraper`) Actor

Extract public Facebook Page recommendations and review summary data for reputation monitoring.

- **URL**: https://apify.com/automation-lab/facebook-page-recommendations-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Facebook Page Recommendations Scraper

Extract anonymous public recommendation records from Facebook Page **Reviews** tabs.

Provide one or more public Page URLs and receive normalized records containing the reviewer, recommendation decision, text, displayed time, public post URL, engagement counts when visible, and Page-level reputation summary.

The Actor is designed for recurring reputation monitoring. It does not ask for Facebook credentials, cookies, or private account access.

### What does Facebook Page Recommendations Scraper do?

The Actor opens each supplied public Facebook Page in Chromium and reads recommendation cards that Facebook exposes to logged-out visitors.

It:

- normalizes Page and `/reviews` URLs;
- extracts individual public recommendation records;
- attaches the Page recommendation percentage and review count to every record;
- follows public recommendation post permalinks when Facebook exposes them;
- removes duplicate records by permalink or a stable content hash;
- stops at your global `maxItems` limit;
- fails clearly when no useful public records are visible.

It does not scrape private profiles, authenticate as a user, or accept account cookies.

### Who is it for?

#### Reputation-management agencies

Track fresh customer experiences across client Pages and load normalized records into reporting pipelines.

#### Multi-location and franchise brands

Snapshot Page reputation metrics and recommendation text for selected brand or location Pages.

#### Social-listening teams

Combine public Facebook recommendations with review feeds from other channels for triage or sentiment analysis.

#### Researchers

Collect reproducible public observations with source URLs and scrape timestamps.

### Why use this Actor?

- **Public-only workflow:** no private Facebook session is required or accepted.
- **Record-level output:** this is not only a Page metadata scraper.
- **Page context included:** each row carries the recommendation percentage and Page review count.
- **Explicit failures:** login-only, unavailable, challenged, and zero-public-record pages do not silently become successful empty datasets.
- **Bounded browser work:** scrolling and result volume have strict limits.
- **Pipeline-ready:** use JSON, CSV, Excel, API, webhooks, Make, Zapier, or MCP.

### What data can you extract?

| Field | Meaning |
| --- | --- |
| `reviewId` | Facebook post ID when visible, otherwise a stable record hash |
| `reviewUrl` | Public recommendation post permalink, or `null` |
| `reviewerName` | Public display name |
| `reviewerProfileUrl` | Public profile URL when Facebook exposes one, otherwise `null` |
| `recommends` | `true` for recommends and `false` for does not recommend |
| `text` | Recommendation text |
| `timestampText` | Timestamp exactly as displayed, such as `1h` |
| `publishedAt` | Absolute time when available; currently `null` for relative-only public cards |
| `reactionsCount` | Visible reaction count, or `null` |
| `commentsCount` | Visible comment count, or `null` |
| `pageName` | Facebook Page name |
| `pageUrl` | Canonical Page URL |
| `reviewsUrl` | Canonical Reviews tab URL |
| `recommendationPercent` | Visible Page recommendation percentage, or `null` |
| `reviewCount` | Visible Page review count, or `null` |
| `followersText` | Public follower summary, or `null` |
| `sourceUrl` | Normalized input URL processed for this record |
| `scrapedAt` | UTC collection timestamp |

### How to scrape Facebook Page recommendations

1. Open the Actor on Apify.
2. Add one or more canonical public Facebook Page URLs.
3. Choose the maximum number of recommendations.
4. Keep the default scroll settings for a normal snapshot.
5. Click **Start**.
6. Open the default dataset to download JSON, CSV, Excel, XML, or RSS.

A simple input is:

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/McDonalds/reviews" }
  ],
  "maxItems": 20,
  "maxScrolls": 4,
  "scrollWaitMillis": 1500
}
```

### Input parameters

#### `startUrls`

Required array of public canonical Facebook Page URLs. URLs may end at the Page slug or include `/reviews`; the Actor normalizes both forms.

Supported:

```text
https://www.facebook.com/McDonalds
https://www.facebook.com/McDonalds/reviews
```

Private URLs, `profile.php` identifiers, non-Facebook hosts, and non-HTTPS URLs are rejected.

#### `maxItems`

Maximum records across all Pages. Allowed range: 1–500. Default: 20.

#### `maxScrolls`

Maximum bounded scroll attempts per Page. Allowed range: 0–20. Default: 4. Use `0` for only initially rendered records.

#### `scrollWaitMillis`

Wait after a scroll so newly exposed public cards can render. Allowed range: 500–5,000 milliseconds. Default: 1,500.

### Output example

This abbreviated record reflects current public output from the McDonald's Page:

```json
{
  "reviewId": "pfbid07FWg4sbEUozz8zWukPsvzJ2wNeTBxVj2rEn94UcnMugtbrbpJNGVtPAr4cHbAR7fl",
  "reviewUrl": "https://www.facebook.com/alii.aliss.7/posts/pfbid07FWg4sbEUozz8zWukPsvzJ2wNeTBxVj2rEn94UcnMugtbrbpJNGVtPAr4cHbAR7fl",
  "reviewerName": "Alexandra Ionescu",
  "reviewerProfileUrl": null,
  "recommends": false,
  "text": "Personal necalificat care nu își respectă clienții !\nTerrible delivery service",
  "timestampText": "1h",
  "publishedAt": null,
  "reactionsCount": null,
  "commentsCount": null,
  "pageName": "McDonald's",
  "pageUrl": "https://www.facebook.com/McDonalds",
  "reviewsUrl": "https://www.facebook.com/McDonalds/reviews",
  "recommendationPercent": 32,
  "reviewCount": 37834,
  "followersText": "82M followers",
  "sourceUrl": "https://www.facebook.com/McDonalds/reviews",
  "scrapedAt": "2026-07-27T04:40:45.109Z"
}
```

Relative timestamps and counts change on Facebook. Treat this as a field-shape example, not a promise that the same recommendation remains first.

### How much does it cost to scrape Facebook Page recommendations?

Pay per event pricing has two parts on the FREE tier:

- **$0.005 per Actor start**;
- **$0.000041071 per successfully emitted recommendation**.

There is no recommendation charge for a Page that produces no dataset record. Platform usage limits still apply. Higher Apify pricing tiers receive lower per-recommendation prices.

Examples at FREE-tier event prices:

| Useful output | Event price |
| --- | ---: |
| 1 recommendation | $0.005041071 |
| 10 recommendations | $0.00541071 |
| 100 recommendations | $0.00910710 |

Actual availability and runtime vary because Facebook controls anonymous delivery.

### Monitoring workflow examples

#### Daily reputation snapshot

Schedule the Actor daily, set a webhook on successful runs, and upsert rows by `reviewId` in your warehouse.

#### Multi-location review triage

Supply several location Pages, filter new rows where `recommends` is `false`, and route them to a customer-experience queue.

#### Cross-channel analysis

Export recommendation text and Page summary fields to BigQuery, Snowflake, Google Sheets, or a sentiment-classification workflow.

### Tips for reliable results

- Use canonical Page slugs rather than shared or shortened links.
- Start with a small `maxItems` while validating a Page.
- Keep `maxScrolls` conservative; logged-out Facebook often exposes only a small public sample.
- Schedule snapshots rather than expecting a complete historical archive from one anonymous visit.
- Deduplicate downstream by `reviewId`.
- Preserve `scrapedAt` and `sourceUrl` for auditability.

### Limitations and failure behavior

Facebook decides which recommendation cards are available to logged-out visitors. Availability varies by Page, country, time, and Facebook experiments.

The Actor does not promise every historical review. It only emits records visible on the public anonymous surface during the run.

A run fails rather than returning a misleading empty success when all requested Pages are unavailable, challenged, login-only, or expose zero public recommendation records.

If at least one Page succeeds, valid rows are preserved and individual Page failures are logged as warnings.

Images, videos, and fonts are blocked because they are unnecessary for textual recommendation extraction.

### Use the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~facebook-page-recommendations-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://www.facebook.com/McDonalds/reviews"}],"maxItems":10}'
```

To wait and retrieve dataset items:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~facebook-page-recommendations-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://www.facebook.com/McDonalds/reviews"}],"maxItems":10}'
```

### Use the Apify API with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/facebook-page-recommendations-scraper').call({
  startUrls: [{ url: 'https://www.facebook.com/McDonalds/reviews' }],
  maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/facebook-page-recommendations-scraper").call(run_input={
    "startUrls": [{"url": "https://www.facebook.com/McDonalds/reviews"}],
    "maxItems": 10,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use Facebook recommendations through MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/facebook-page-recommendations-scraper"
```

Use the same HTTP server configuration in **Claude Desktop**, **Cursor**, or **VS Code** MCP settings:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/facebook-page-recommendations-scraper"
    }
  }
}
```

Example prompts:

- “Collect up to 20 public recommendations from this Facebook Page and summarize recurring complaints.”
- “Compare public recommendation percentages across these three brand Pages.”
- “Return only new negative recommendations not present in this list of review IDs.”

### Integrations

Use Apify webhooks to start downstream processing when a run succeeds. The default dataset works with Make, Zapier, Google Sheets, Slack, cloud storage, and database integrations.

For recurring monitoring, schedule runs in Apify Console and retain `reviewId` in the destination system for incremental processing.

### Responsible use and legality

Scrape only public information and follow applicable laws, contracts, and Facebook terms. Do not use the output for harassment, discrimination, identity profiling, or attempts to access private accounts.

Reviewer names and profile links can be personal data. Establish a lawful purpose, collect only what you need, secure the output, honor deletion obligations, and apply appropriate retention limits.

This Actor is an independent automation tool and is not affiliated with or endorsed by Meta or Facebook.

### Troubleshooting

#### Why did the run say no public recommendation records were found?

The Page may not have a public Reviews tab, Facebook may be showing a login-only surface, the Page may be unavailable, or anonymous visibility may have changed. Confirm the canonical Page URL in a logged-out browser and retry later if the condition is temporary.

#### Why did I receive fewer rows than `maxItems`?

`maxItems` is a ceiling, not a guarantee. Logged-out Facebook frequently exposes a bounded public sample, and scrolling does not guarantee more records.

#### Why are engagement counts or profile URLs null?

Facebook does not show every field on every anonymous card. Nullable fields remain `null` rather than being guessed.

#### Can I provide my Facebook login or cookies?

No. The Actor intentionally supports public anonymous data only and has no credential input.

### FAQ

#### Does the Actor scrape Facebook star ratings?

Facebook Page recommendations are generally expressed as recommends/does not recommend plus a Page recommendation percentage. The Actor reports those public fields; it does not invent star ratings.

#### Can I scrape multiple Pages?

Yes. Add up to 50 Page URLs. `maxItems` applies across the complete run.

#### Does it return old recommendations?

Only when Facebook exposes them to the anonymous rendered surface during the run. Use scheduled snapshots for ongoing monitoring.

#### Is each Page summary a separate charged row?

No. Page summary fields are attached to each recommendation. Only emitted recommendation records have the `recommendation` event charge.

### Related automation-lab Actors

For broader public Facebook Page metadata rather than individual recommendation rows, use [Facebook Pages Scraper](https://apify.com/automation-lab/facebook-pages-scraper).

Combine Page recommendations with other review-channel Actors in the automation-lab portfolio when your workflow needs cross-source reputation monitoring.

# Actor input Schema

## `startUrls` (type: `array`):

Public canonical Facebook Page URLs, with or without /reviews. Profile.php links and private content are not supported.

## `maxItems` (type: `integer`):

Maximum number of recommendation records emitted across all supplied Pages.

## `maxScrolls` (type: `integer`):

Bounded attempts to load additional public recommendations. Use 0 for only the initially rendered records.

## `scrollWaitMillis` (type: `integer`):

Delay for Facebook to render additional public records after a scroll.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/McDonalds/reviews"
    }
  ],
  "maxItems": 20,
  "maxScrolls": 4,
  "scrollWaitMillis": 1500
}
```

# Actor output Schema

## `overview` (type: `string`):

Default dataset containing one normalized row per public Facebook Page recommendation.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.facebook.com/McDonalds/reviews"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/facebook-page-recommendations-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 = {
    "startUrls": [{ "url": "https://www.facebook.com/McDonalds/reviews" }],
    "maxItems": 20,
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.facebook.com/McDonalds/reviews"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/facebook-page-recommendations-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/facebook-page-recommendations-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/160KOururRFJdqUcJ/builds/bOpv8bofqjZMMl6Cg/openapi.json