# Facebook Reviews Scraper (`scrapesmith/fb-reviews-scraper`) Actor

🔥$0.80/1000 results🔥Extract reviews and recommendations from any Facebook page. Get reviewer name, rating, recommendation status, text, date, likes, comments, and business replies. JSON/CSV/Excel. API, MCP, webhook, AI-agent ready.

- **URL**: https://apify.com/scrapesmith/fb-reviews-scraper.md
- **Developed by:** [Scrape Smith](https://apify.com/scrapesmith) (community)
- **Categories:** Social media, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 results

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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Reviews Scraper

Extract every review, rating, and recommendation from any public Facebook Page — reviewer details, star rating, recommendation status, review text, likes, comments, and the business's own replies — delivered as clean, ready-to-use JSON, CSV, or Excel.

No login, no setup, no configuration. Paste a Page URL (or just the username) and get structured review data back in seconds.

### Why use this scraper

- **Most complete field set on the market** — reviewer profile, recommendation flag, likes, comments, reply text, and more. Nothing else on Apify returns this much per review.
- **Runs on a fraction of the compute other Facebook review scrapers need** — which means faster queueing, lower cost per run, and results that land quicker.
- **Zero setup.** No Facebook login, no API keys, no cookies to paste in — just the Page URL.
- **Built for automation.** Clean JSON output that drops straight into n8n, Make, Zapier, LangChain, or any AI agent / MCP pipeline.
- **Multiple pages in one run**, fully concurrent — scrape a competitor set or an entire brand portfolio in a single job.
- **Handles both positive recommendations and negative reviews**, with full pagination so you're not capped at the first page Facebook shows you.

### Input

| Field | Type | Description |
|---|---|---|
| `pageUrls` | array of strings | Facebook Page URLs to pull reviews from, e.g. `https://www.facebook.com/cocacola` |
| `usernames` | array of strings | Alternative to full URLs — just the Page username, e.g. `cocacola` |
| `maxItems` | integer | Maximum total reviews to collect across all pages (default: 500) |
| `maxReviewsPerPage` | integer | Cap on reviews per individual page. `0` = no per-page cap |
| `proxyConfiguration` | object | Optional — only needed in rare edge cases |

You can mix `pageUrls` and `usernames` in the same run.

### Output example

```json
{
  "reviewId": "1234567890123456",
  "reviewerName": "Jane Doe",
  "reviewerId": "100000123456789",
  "reviewerAvatar": "https://scontent.xx.fbcdn.net/v/....jpg",
  "rating": 5,
  "isRecommended": true,
  "text": "Great service and super fast delivery. Would recommend to anyone!",
  "date": "2026-05-14T10:32:00.000Z",
  "likesCount": 12,
  "commentsCount": 3,
  "url": "https://www.facebook.com/cocacola/posts/1234567890123456",
  "tags": [],
  "hasReply": true,
  "replyText": "Thank you so much for your kind words, Jane!",
  "pageName": "Coca-Cola",
  "pageUrl": "https://www.facebook.com/cocacola",
  "scrapedAt": "2026-07-26T08:12:41.000Z"
}
````

### Every field, explained

| Field | Description |
|---|---|
| `reviewId` | Unique ID of the review/recommendation |
| `reviewerName` | Name of the person who left the review |
| `reviewerId` | Facebook user ID of the reviewer |
| `reviewerAvatar` | URL of the reviewer's profile picture |
| `rating` | 1–5 star rating (recommendations map to 5 or 1) |
| `isRecommended` | `true` if the reviewer recommends the page, `false` if not |
| `text` | Full text of the review |
| `date` | Date/time the review was posted (ISO 8601) |
| `likesCount` | Number of likes/reactions on the review |
| `commentsCount` | Number of comments on the review |
| `url` | Direct link to the review |
| `tags` | Any tags attached to the review |
| `hasReply` | Whether the business replied |
| `replyText` | The business's reply text, if any |
| `pageName` | Name of the Facebook Page reviewed |
| `pageUrl` | URL of the Facebook Page |
| `scrapedAt` | Timestamp of when the data was collected |

### Use cases

- **Reputation monitoring** — track new reviews and ratings for your own Page in real time.
- **Competitor analysis** — see what customers say about competitor businesses, and how (or if) they reply.
- **Lead generation** — find businesses with poor review-response rates and pitch your reputation-management service.
- **Sentiment & NLP pipelines** — feed review text straight into a classifier, LLM summarizer, or dashboard.
- **Customer service audits** — measure reply rate and reply speed across a portfolio of Pages.
- **Market research** — aggregate ratings and recommendation rates across an entire industry vertical.

### API, MCP & integrations

This actor runs on the Apify platform and works with:

- **Apify API & client libraries** (Python, JavaScript) for programmatic runs
- **Webhooks** for real-time notifications when a run finishes
- **MCP (Model Context Protocol)** so AI agents — including Claude, ChatGPT, and custom LLM agents — can call this scraper as a tool
- **n8n, Make, and Zapier** integrations for no-code automation
- **Scheduled runs** to monitor a Page's reviews on a recurring basis

Export results as JSON, CSV, Excel, or push directly to Google Sheets.

### FAQ

**Do I need a Facebook account or login?**
No. This scraper works entirely on public Page data — no login, no cookies, no account required.

**Can I scrape multiple Pages in one run?**
Yes — add as many `pageUrls` or `usernames` as you like; they're processed together in the same run.

**Does it get every review, or just the first page?**
It paginates through all available reviews for each Page, up to the limit you set in `maxItems`.

**What if a Page has no reviews enabled?**
The run completes cleanly and simply returns zero results for that Page — no errors.

**How fresh is the data?**
Every run scrapes live, current data directly from Facebook at the time you run it.

# Actor input Schema

## `pageUrls` (type: `array`):

Facebook page URLs to scrape reviews from. Example: https://www.facebook.com/cocacola

## `usernames` (type: `array`):

Facebook page usernames (without URL). Example: cocacola

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

The main limit. Maximum number of reviews to collect PER Facebook page, not in total -- each page URL gets its own independent budget. Example: 5 page URLs with this set to 100 will collect up to 500 reviews (100 per page). 0 = no per-page limit (only the global safety cap below still applies).

## Actor input object example

```json
{
  "pageUrls": [
    "https://www.facebook.com/KFC"
  ],
  "maxReviewsPerPage": 100
}
```

# 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 = {
    "pageUrls": [
        "https://www.facebook.com/KFC"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesmith/fb-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 = { "pageUrls": ["https://www.facebook.com/KFC"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapesmith/fb-reviews-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 '{
  "pageUrls": [
    "https://www.facebook.com/KFC"
  ]
}' |
apify call scrapesmith/fb-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapesmith/fb-reviews-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Reviews Scraper",
        "description": "🔥$0.80/1000 results🔥Extract reviews and recommendations from any Facebook page. Get reviewer name, rating, recommendation status, text, date, likes, comments, and business replies. JSON/CSV/Excel. API, MCP, webhook, AI-agent ready.",
        "version": "0.1",
        "x-build-id": "LygxvRa6lNQ40AQgg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~fb-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-fb-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapesmith~fb-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-fb-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapesmith~fb-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-fb-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "pageUrls"
                ],
                "properties": {
                    "pageUrls": {
                        "title": "Page URLs",
                        "type": "array",
                        "description": "Facebook page URLs to scrape reviews from. Example: https://www.facebook.com/cocacola",
                        "items": {
                            "type": "string"
                        }
                    },
                    "usernames": {
                        "title": "Usernames",
                        "type": "array",
                        "description": "Facebook page usernames (without URL). Example: cocacola",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerPage": {
                        "title": "Max reviews per page",
                        "minimum": 0,
                        "type": "integer",
                        "description": "The main limit. Maximum number of reviews to collect PER Facebook page, not in total -- each page URL gets its own independent budget. Example: 5 page URLs with this set to 100 will collect up to 500 reviews (100 per page). 0 = no per-page limit (only the global safety cap below still applies).",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```