# Facebook Review Scraper (`scrapers-hub/facebook-review-scraper`) Actor

📣 Facebook Review Scraper efficiently collects customer reviews from Facebook for deeper insights. ✅ Perfect for brand monitoring, market research, and reputation analytics. 🔎 Save time, boost decisions—without manual scraping hassles.

- **URL**: https://apify.com/scrapers-hub/facebook-review-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Social media, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 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.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Review Scraper 💬

Facebook Review Scraper is an Apify actor that collects public reviews from a Facebook page’s Reviews section. This Facebook reviews scraper tool helps marketers, analysts, and researchers extract reviews from Facebook pages at scale — no manual copy-paste. As a Facebook page reviews extractor and Facebook review data extractor, it pulls clean, structured review data so you can analyze sentiment, monitor testimonials, and automate Facebook review collection across your workflows.

### Why choose Facebook Review Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ Public page reviews scraping | Scrape Facebook business page reviews from the public Reviews section — no login required, simple automation. |
| ✅ Structured output | Get consistent fields (name, message, story_url, story_id, profile_pic) ready for analysis or dashboards. |
| ✅ Pagination handling | Built-in cursor pagination to keep fetching more reviews until your limit is reached. |
| ✅ Max review limit control | Use maxReviews to cap volume per run and keep costs predictable. |
| ✅ Dataset-first storage | Results go straight to Apify Dataset — export Facebook reviews to CSV, JSON, or Excel in a click. |
| ✅ Proxy input support | Accepts proxyConfiguration (e.g., useApifyProxy). The actor logs when Apify Proxy is enabled. |

### Key features

- 🚀 Public Reviews focus: Targets the Reviews section of public Facebook pages to extract reviews from Facebook pages reliably.
- 📦 Structured fields: Captures reviewer name, review text, profile picture URL, story URL, and story ID for easy processing.
- 🔄 Pagination aware: Uses Facebook cursors under the hood to continue fetching multiple pages of reviews when available.
- 🎯 Volume control: Set maxReviews to control how many results you collect in a run.
- 💾 Dataset output: Saves results to the default Apify dataset so you can download Facebook page reviews and integrate downstream.
- 🌐 Proxy input logging: Accepts proxyConfiguration; when useApifyProxy is true, the actor logs that Apify Proxy is enabled (requests use direct connection by default).

### Input

Provide input via an input.json file. Example structure:

```json
{
  "startUrl": "https://www.facebook.com/buladiradda/reviews",
  "maxReviews": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

Input fields

| Field | Required | Description |
| --- | --- | --- |
| startUrl | Yes | The Facebook Page Reviews URL to crawl (e.g., https://www.facebook.com/<page>/reviews). |
| maxReviews | No | Maximum number of reviews to scrape. If omitted, defaults to 100. |
| proxyConfiguration | No | Proxy settings. If useApifyProxy is true, the actor logs that Apify Proxy is enabled; requests use direct connection by default. |

### Output

After execution, the actor saves each review to the default Apify dataset in JSON format.

Sample output item

```json
{
  "name": "Julia Odan",
  "profile_pic": "https://scontent-itm1-1.xx.fbcdn.net/v/t39.30808-1/447503218_1421351475235900_1276580829558666368_n.jpg?stp=c0.128.768.768a_cp0_dst-jpg_s50x50_tt6&_nc_cat=100&ccb=1-7&_nc_sid=e99d92&_nc_ohc=tb3gMBl1nZ4Q7kNvwHMkcRR&_nc_oc=AdnbtWHkJecxad6HPguRsNhJVh9ftY5PVIUMvVAI-1g3IZDWWdcj4WucYO2TxYyuF5Y&_nc_zt=24&_nc_ht=scontent-itm1-1.xx&_nc_gid=fXOTY82o1VPchmrLVtteLg&oh=00_AfgvvWN2o7VZh2TnnY5kZ0_lWB6y8cs8_KJIoCETdya-cw&oe=693251AB",
  "message": "Rubbish product from a misogynistic company.",
  "story_id": "UzpfSTEwMDAyMDgzMTgyMzg1MjoxMTg5NTQyMDg4NDE2ODQxOjExODk1NDIwODg0MTY4NDE=",
  "story_url": "https://web.facebook.com/jyn.odan.3/posts/pfbid0FbBNhkzZArg9AYASawZNhDuYAfPaErwHgFGZm7ZTaCn2dZs7Q9ys2UMkG7ejLJ6tl"
}
```

Output fields

| Field | Type | Description |
| --- | --- | --- |
| name | string | Reviewer’s display name. |
| message | string | The review content text. |
| story\_url | string | Direct link to the review post/story. |
| story\_id | string | Facebook internal story ID. |
| profile\_pic | string | Reviewer’s profile picture URL. |

You can export results directly from the dataset in CSV, JSON, or Excel — perfect for a Facebook reviews export tool workflow or sending to Google Sheets.

### How to use Facebook Review Scraper (via Apify Console)

1. Open Apify Console\
   Go to https://console.apify.com and log in to your account.

2. Find the actor\
   Search for “Facebook Review Scraper” and open the actor page.

3. Configure your input
   - Paste the Facebook Reviews URL into startUrl (e.g., https://www.facebook.com/buladiradda/reviews).
   - Set maxReviews to limit how many reviews you collect (default is 100).
   - Optional: In proxyConfiguration, you can enable useApifyProxy. The actor will log when Apify Proxy is enabled; it uses direct requests by default.

4. Start the run\
   Click Start to begin scraping. The actor resolves the page, identifies the feed query, and handles pagination automatically.

5. Monitor progress\
   Watch the run logs to see page-by-page progress and review counts as the Facebook review crawler works through the feed.

6. Access and export results\
   When complete, open the default dataset to view your items (name, message, story\_url, story\_id, profile\_pic). Export to JSON, CSV, or Excel to download Facebook page reviews and plug into your tools.

No coding required — get structured Facebook recommendations and reviews in minutes.

### Advanced features & SEO optimization

- 🔎 Public Reviews targeting: Engineered to scrape Facebook recommendations from a page’s Reviews feed with structured fields.
- 💾 Dataset-first pipeline: Optimized for workflows that download Facebook page reviews and export Facebook reviews to CSV or JSON.
- 📣 Detailed run logging: Logs target URL, maxReviews, pagination progress, and proxy flag status for clarity and troubleshooting.
- 🌐 Proxy input awareness: Accepts proxyConfiguration and logs when Apify Proxy is enabled (direct connections by default) for transparent operation.
- 🧰 Automation-ready: Pairs well with Apify scheduling and the Dataset API for a Facebook reviews scraping software alternative to building your own scripts.

### Best use cases

- 📣 Marketing – testimonial harvesting: Collect public quotes to fuel landing pages, social proof, and creatives with a Facebook business reviews scraper.
- 🛡️ Brand monitoring – feedback tracking: Aggregate recent comments to track sentiment trends across Facebook page ratings and reviews.
- 🔬 Product research – voice of customer: Analyze recurring themes directly from unstructured review text.
- 🏁 Competitive analysis – benchmarking: Compare public feedback across business pages to understand positioning and gaps.
- 📊 Data analytics – trend analysis: Build time-based datasets of review messages for dashboards and analysis.
- 🧩 Automation pipelines – API alternative: Use the Apify dataset as a simple way to scrape Facebook recommendations and feed ETL flows.

### Technical specifications

- Supported Input Formats
  - ✅ Facebook Page Reviews URL: https://www.facebook.com/<page>/reviews (startUrl)

- Proxy Support
  - ✅ Accepts proxyConfiguration with useApifyProxy
  - ℹ️ When useApifyProxy is true, the actor logs that Apify Proxy is enabled; requests use direct connection by default.

- Dataset Structure
  - ✅ Each item contains: name, message, story\_url, story\_id, profile\_pic

- Limitations
  - ❌ Does not log in or access private pages
  - ❌ Output is limited to the extracted fields listed above
  - ❗ One startUrl per run; to process multiple pages, queue multiple runs

### FAQ

#### Do I need to log in to scrape Facebook reviews?

No. The actor targets public Facebook page Reviews sections and does not require login. If a page requires authentication or is blocked, data may not be accessible.

#### How many reviews can I scrape per run?

You control this with maxReviews. The actor paginates the Reviews feed until it reaches your limit or no more reviews are available.

#### What fields does the scraper extract?

Each item includes name, message, story\_url, story\_id, and profile\_pic from public content.

#### Can I export the results to CSV or Google Sheets?

Yes. Open the run’s default dataset and export to CSV, JSON, or Excel. You can then import the CSV into Google Sheets or BI tools.

#### Should I use a proxy?

You can pass proxyConfiguration with useApifyProxy. The actor logs when Apify Proxy is enabled; however, it uses direct requests by default.

#### Does it scrape star ratings or private data?

No. It extracts the reviewer name, review text, profile picture, story link, and story ID from public content only.

#### Can it scrape multiple Facebook pages in one run?

The input takes a single startUrl per run. To scrape multiple pages, queue multiple runs via the Apify platform.

#### Is this a Facebook reviews API alternative?

For public data, yes. Use this Facebook reviews export tool and the Apify Dataset API to automate review collection without building your own integration.

### Support & feature requests

- 💡 Feature requests: Want bulk multi-URL input, additional metadata, or custom export presets? Share your ideas via the Apify platform’s run comments and feedback tools.
- 🛟 Help & support: Use Apify’s support resources and documentation to troubleshoot runs, exports, and integrations.

Your feedback helps improve Facebook Review Scraper for everyone.

### Closing CTA / Final thoughts

*Get clean, structured reviews with Facebook Review Scraper — fast, reliable, and ready for export to your favorite tools.*\
*Start a run today and turn public Facebook recommendations into actionable insights at scale.*

### Disclaimer

These scrapers collect information only from publicly accessible sources. They do not access private profiles, authenticated data, or password‑protected pages. It is the user’s responsibility to comply with applicable laws (e.g., GDPR/CCPA) and Facebook’s terms of service. Always use this tool responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

## `startUrl` (type: `string`):

The URL of the Facebook page reviews section (e.g., https://www.facebook.com/buladiradda/reviews)

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

Maximum number of reviews to scrape.

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

Select proxies to validly scrape Facebook.

## Actor input object example

```json
{
  "startUrl": "https://www.facebook.com/buladiradda/reviews",
  "maxReviews": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "startUrl": "https://www.facebook.com/buladiradda/reviews"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/facebook-review-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 = { "startUrl": "https://www.facebook.com/buladiradda/reviews" }

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/facebook-review-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 '{
  "startUrl": "https://www.facebook.com/buladiradda/reviews"
}' |
apify call scrapers-hub/facebook-review-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Review Scraper",
        "description": "📣 Facebook Review Scraper efficiently collects customer reviews from Facebook for deeper insights. ✅ Perfect for brand monitoring, market research, and reputation analytics. 🔎 Save time, boost decisions—without manual scraping hassles.",
        "version": "1.0",
        "x-build-id": "VxyF0YS2Qr0vZrIJw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapers-hub~facebook-review-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapers-hub-facebook-review-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/scrapers-hub~facebook-review-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapers-hub-facebook-review-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/scrapers-hub~facebook-review-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapers-hub-facebook-review-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": [
                    "startUrl"
                ],
                "properties": {
                    "startUrl": {
                        "title": "Facebook Page Reviews URL",
                        "type": "string",
                        "description": "The URL of the Facebook page reviews section (e.g., https://www.facebook.com/buladiradda/reviews)"
                    },
                    "maxReviews": {
                        "title": "Max Reviews",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Select proxies to validly scrape Facebook.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
