# Facebook Reviews Scraper (`maximedupre/facebook-reviews-scraper`) Actor

Facebook reviews scraper for public Facebook Page recommendations. Add Page URLs, reviews URLs, handles, or numeric Page IDs to export reviews, recommendation status, engagement, media, and comments.

- **URL**: https://apify.com/maximedupre/facebook-reviews-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 85.7% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 recommendations

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 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 Reviews Scraper

This Facebook reviews scraper collects public Facebook Page recommendations from [Facebook](https://www.facebook.com/) and saves them as clean dataset rows. Use it as a Facebook reviews extractor for reputation monitoring, local business research, customer feedback analysis, or exporting Facebook page reviews without asking users for Facebook cookies.

Facebook now labels most Page reviews as recommendations, so this actor returns `recommended`, `not_recommended`, or `unknown` instead of inventing star ratings. Rows are returned newest first for each Facebook Page and can include reviewer details, recommendation text, recommendation URLs, timestamps, engagement counts, media, top-level comments, and optional comment replies.

### What this actor does

- Scrapes public Facebook Page reviews and recommendations.
- Accepts Facebook Page URLs, reviews URLs, handles, and numeric Page IDs.
- Returns one dataset row per Facebook recommendation.
- Includes top-level comments by default.
- Can include direct replies to returned comments when enabled.
- Keeps recommendation rows newest first for each Page.
- Works without user-provided Facebook login, cookies, or account credentials.

This actor is focused on Facebook Page recommendations. It does not scrape personal profiles, groups, Marketplace listings, posts outside the Page reviews surface, or private content.

### What data you get

Each recommendation row can include:

- Recommendation ID and public URL
- Review or recommendation text
- Creation time
- Recommendation status: `recommended`, `not_recommended`, or `unknown`
- Legacy rating when Facebook exposes one
- Page identity: Page ID, handle, Page name, Page URL, and reviews URL
- Reviewer profile information when public
- Facebook tags attached to the recommendation
- Engagement counts, including reactions, comments, replies, shares, and reaction breakdown
- Attached media such as photos or videos when available
- Top-level comments and optional replies

Example output:

```json
{
	"id": "recommendation-1",
	"url": "https://www.facebook.com/example/posts/recommendation-1",
	"text": "Loved the lunch service.",
	"createdAt": "2026-05-11T12:56:47.000Z",
	"recommendationStatus": "recommended",
	"legacyRating": null,
	"target": {
		"pageId": "123456789",
		"handle": "examplecafe",
		"pageName": "Example Cafe",
		"pageUrl": "https://www.facebook.com/examplecafe",
		"reviewsUrl": "https://www.facebook.com/examplecafe/reviews"
	},
	"comments": []
}
````

### How to run the Facebook review scraper

1. Add one or more Facebook Pages in the **Facebook Page targets** field.
2. Use a handle such as `portosbakery`, a Page URL such as `https://www.facebook.com/portosbakery`, a reviews URL, or a numeric Page ID.
3. Choose the maximum number of recommendations to collect.
4. Leave comments enabled if you want the most useful default export.
5. Enable replies only when you also need replies under returned comments.

The starter input is intentionally small so you can test the actor quickly before running a larger Facebook recommendations scraper job.

### Input

| Field | Description |
|---|---|
| `targets` | Facebook Page handles, Page URLs, reviews URLs, or numeric Page IDs. |
| `maxRecommendations` | Maximum recommendation rows across the whole run. |
| `maxRecommendationsPerTarget` | Maximum recommendation rows for each Facebook Page. |
| `includeComments` | Include visible top-level comments attached to each recommendation. |
| `commentsLimit` | Maximum comments per recommendation. |
| `maxComments` | Maximum comments across the run. |
| `includeReplies` | Include direct replies to returned comments. Replies require comments. |
| `repliesLimit` | Maximum replies per returned comment. |
| `maxReplies` | Maximum replies across the run. |

### Output

The dataset is designed for analysis rather than raw Facebook internals. Related values are grouped into objects such as `target`, `reviewer`, `engagement`, `media`, and `comments`, so exports are easier to use in spreadsheets, APIs, databases, and automations.

### Pricing

This actor uses pay-per-event pricing. You are charged for recommendation rows saved to the dataset. Comments are included in the recommendation row output when enabled, and replies are included when you enable reply collection.

### FAQ

#### Is this a Facebook reviews extractor or a Facebook recommendations scraper?

Both phrases describe the same Page surface for this actor. Facebook commonly calls Page reviews "recommendations", while many users still search for Facebook reviews, Facebook review scraper, or Facebook page reviews.

#### Does this actor return star ratings?

Usually no. Facebook recommendations generally expose a recommendation status instead of star ratings. The `legacyRating` field is included for compatibility and is `null` unless Facebook exposes a legacy rating.

#### Can I scrape private Facebook reviews?

No. The actor only collects public recommendation data available from Facebook Page review surfaces.

#### Can I use full Facebook URLs?

Yes. You can use full Page URLs, reviews URLs, short handles, or numeric Page IDs.

### Legal and responsible use

Use this actor only for lawful purposes and follow Facebook's terms and applicable privacy, data protection, and platform rules. The actor returns public data only, but you are responsible for how you store, process, and use exported data.

### Support

If a public Facebook Page does not return recommendations, check that the Page has a public reviews or recommendations surface and that your input points to the Page rather than a group, profile, post, or Marketplace listing. If the issue continues, open an issue with the target format you used and the run ID.

# Actor input Schema

## `targets` (type: `array`):

Add one Facebook Page URL, reviews URL, handle, or numeric Page ID per row. Personal profiles, groups, Marketplace, posts, and non-Facebook URLs are not supported.

## `maxRecommendations` (type: `integer`):

Maximum number of Facebook review or recommendation rows across the whole run.

## `maxRecommendationsPerTarget` (type: `integer`):

Maximum number of Facebook review or recommendation rows to return for each target Page.

## `includeComments` (type: `boolean`):

Include visible top-level comments attached directly to each Facebook recommendation.

## `commentsLimit` (type: `integer`):

Maximum number of top-level comments to include for each Facebook recommendation when comments are enabled.

## `maxComments` (type: `integer`):

Maximum number of top-level comments to include across the whole run when comments are enabled.

## `includeReplies` (type: `boolean`):

Include direct replies to returned top-level comments. Replies require comments to be enabled.

## `repliesLimit` (type: `integer`):

Maximum number of direct replies to include for each returned top-level comment when replies are enabled.

## `maxReplies` (type: `integer`):

Maximum number of direct replies to include across the whole run when replies are enabled.

## Actor input object example

```json
{
  "targets": [
    "portosbakery"
  ],
  "maxRecommendations": 50,
  "maxRecommendationsPerTarget": 50,
  "includeComments": true,
  "commentsLimit": 3,
  "maxComments": 100,
  "includeReplies": false,
  "repliesLimit": 5,
  "maxReplies": 100
}
```

# Actor output Schema

## `results` (type: `string`):

Facebook reviews and recommendations dataset rows

# 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 = {
    "targets": [
        "portosbakery"
    ],
    "maxRecommendations": 50,
    "maxRecommendationsPerTarget": 50,
    "commentsLimit": 3,
    "maxComments": 100,
    "repliesLimit": 5,
    "maxReplies": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/facebook-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 = {
    "targets": ["portosbakery"],
    "maxRecommendations": 50,
    "maxRecommendationsPerTarget": 50,
    "commentsLimit": 3,
    "maxComments": 100,
    "repliesLimit": 5,
    "maxReplies": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/facebook-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 '{
  "targets": [
    "portosbakery"
  ],
  "maxRecommendations": 50,
  "maxRecommendationsPerTarget": 50,
  "commentsLimit": 3,
  "maxComments": 100,
  "repliesLimit": 5,
  "maxReplies": 100
}' |
apify call maximedupre/facebook-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Reviews Scraper",
        "description": "Facebook reviews scraper for public Facebook Page recommendations. Add Page URLs, reviews URLs, handles, or numeric Page IDs to export reviews, recommendation status, engagement, media, and comments.",
        "version": "0.0",
        "x-build-id": "CMAqulAhpHdIvoqxx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~facebook-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-facebook-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/maximedupre~facebook-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-facebook-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/maximedupre~facebook-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-facebook-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": [
                    "targets",
                    "maxRecommendations",
                    "maxRecommendationsPerTarget",
                    "includeComments",
                    "commentsLimit",
                    "maxComments",
                    "includeReplies",
                    "repliesLimit",
                    "maxReplies"
                ],
                "properties": {
                    "targets": {
                        "title": "Facebook Page targets",
                        "minItems": 1,
                        "type": "array",
                        "description": "Add one Facebook Page URL, reviews URL, handle, or numeric Page ID per row. Personal profiles, groups, Marketplace, posts, and non-Facebook URLs are not supported.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxRecommendations": {
                        "title": "Maximum recommendations",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of Facebook review or recommendation rows across the whole run.",
                        "default": 50
                    },
                    "maxRecommendationsPerTarget": {
                        "title": "Maximum recommendations per Page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of Facebook review or recommendation rows to return for each target Page.",
                        "default": 50
                    },
                    "includeComments": {
                        "title": "Include top-level comments",
                        "type": "boolean",
                        "description": "Include visible top-level comments attached directly to each Facebook recommendation.",
                        "default": true
                    },
                    "commentsLimit": {
                        "title": "Comments per recommendation",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of top-level comments to include for each Facebook recommendation when comments are enabled.",
                        "default": 3
                    },
                    "maxComments": {
                        "title": "Maximum comments",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of top-level comments to include across the whole run when comments are enabled.",
                        "default": 100
                    },
                    "includeReplies": {
                        "title": "Include replies",
                        "type": "boolean",
                        "description": "Include direct replies to returned top-level comments. Replies require comments to be enabled.",
                        "default": false
                    },
                    "repliesLimit": {
                        "title": "Replies per comment",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of direct replies to include for each returned top-level comment when replies are enabled.",
                        "default": 5
                    },
                    "maxReplies": {
                        "title": "Maximum replies",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of direct replies to include across the whole run when replies are enabled.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
