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

⭐ Facebook Reviews Scraper extracts Facebook Page reviews at scale — ratings, comments, dates, reviewer names, reactions & owner replies. 🔎 Export CSV/JSON, schedule runs, and analyze sentiment. 🚀 Ideal for reputation management, CX insights & social proof.

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

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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

A powerful and efficient Apify Actor that scrapes Facebook page reviews at scale. Extract comprehensive review data including user information, ratings, comments, likes, and engagement metrics from any public Facebook page.

### Why Choose Us?

- **🚀 High Performance**: Asynchronous scraping with concurrent processing for maximum speed
- **🛡️ Smart Proxy Management**: Automatic fallback system (no proxy → datacenter → residential) with intelligent retry logic
- **📊 Comprehensive Data**: Extract complete review details including user profiles, engagement metrics, and timestamps
- **🔄 Reliable Pagination**: Automatic cursor-based pagination to collect all available reviews
- **⚡ Production Ready**: Built with error handling, retry logic, and detailed logging for enterprise use
- **📦 Bulk Processing**: Process multiple Facebook pages simultaneously with configurable concurrency

### Key Features

#### ✨ Core Capabilities

- **Bulk Input Support**: Process multiple Facebook pages, usernames, or keywords in a single run
- **Automatic URL Normalization**: Automatically converts usernames and keywords to proper Facebook review URLs
- **Smart Pagination**: Uses Facebook's GraphQL cursor system to fetch all available reviews
- **Data Deduplication**: Automatically filters duplicate reviews based on unique IDs
- **Flexible Sorting**: Sort reviews by newest, oldest, or most relevant (by engagement)
- **Configurable Limits**: Set maximum number of reviews to scrape per page (default: 500)

#### 🔒 Proxy & Anti-Blocking

- **Intelligent Fallback System**: 
  - Stage 1: Starts with no proxy (direct connection)
  - Stage 2: Falls back to datacenter proxy if blocked
  - Stage 3: Falls back to residential proxy with 3 retries
  - Sticky Residential: Once residential proxy is used, it sticks for all remaining requests
- **Detailed Proxy Logging**: Clear visibility into proxy transitions and events
- **Automatic Retry Logic**: Handles empty batches and network errors with configurable retries

#### 📈 Data Extraction

Extracts the following fields for each review:

- **Review Metadata**: Unique ID, Facebook URL, post URL, creation date
- **User Information**: User ID, name, profile URL, profile picture
- **Review Content**: Full review text, recommendation status (recommended/not recommended)
- **Engagement Metrics**: Likes count, comments count
- **Page Information**: Page name, Facebook page URL
- **Technical IDs**: Facebook ID, post Facebook ID

### Input

#### Input Schema

```json
{
  "inputs": [
    "https://www.facebook.com/mrbeast",
    "https://www.facebook.com/tesla",
    "nike"
  ],
  "sortOrder": "newest",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### Input Fields

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| **inputs** | `array` | ✅ Yes | List of Facebook page URLs, usernames, or keywords. Supports multiple formats:<br>• Full URLs: `https://www.facebook.com/mrbeast`<br>• Usernames: `mrbeast`<br>• Keywords: `nike` (requires resolvable page context) |
| **sortOrder** | `string` | ❌ No | Sort reviews by:<br>• `newest` (default)<br>• `oldest`<br>• `most_relevant` (likes + comments) |
| **maxItems** | `integer` | ❌ No | Maximum number of reviews to scrape per page (default: `100`). |
| **proxyConfiguration** | `object` | ❌ No | Proxy settings. Default: `{"useApifyProxy": false}`<br>• If `false`: Starts with no proxy, auto-fallback on blocks<br>• If `true`: Uses Apify proxy groups as specified |

#### Input Examples

**Single Page:**

```json
{
  "inputs": ["https://www.facebook.com/mrbeast"]
}
```

**Multiple Pages:**

```json
{
  "inputs": [
    "https://www.facebook.com/mrbeast",
    "https://www.facebook.com/tesla",
    "nike"
  ]
}
```

**With Proxy:**

```json
{
  "inputs": ["https://www.facebook.com/mrbeast"],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["DATACENTER"]
  }
}
```

### Output

#### Output Format

The actor outputs data in two formats:

1. **Dataset**: Individual review records (one per review)
2. **Key-Value Store**: Aggregated JSON grouped by page name (key: `OUTPUT`)

#### Dataset Output (Individual Reviews)

Each review is stored as a separate record in the dataset:

```json
{
  "facebookUrl": "https://www.facebook.com/mrbeast",
  "id": "UzpfSTYxNTg0MzE3MjA0OTY4OjEyMjEwOTkzMzE4OTE0MzkwNjoxMjIxMDk5MzMxODkxNDM5MDY=",
  "user": {
    "id": "pfbid022DhB36PVT9anEH47J7WQu78JYMNhaEGeHHKAhyPXJVNjusrH3TCierbYBcaA7NTBl",
    "name": "Helen Head",
    "profileUrl": "https://www.facebook.com/people/Helen-Head/pfbid022DhB36PVT9anEH47J7WQu78JYMNhaEGeHHKAhyPXJVNjusrH3TCierbYBcaA7NTBl/",
    "profilePic": null
  },
  "date": "2025-12-23T18:12:27.000Z",
  "url": "https://www.facebook.com/permalink.php?story_fbid=pfbid036zKdeTsZRHzcZspm8CNjzv3jSuSQFmbjNc6h4FPwLvsBmjYU3ibcHqX4HSukzQakl&id=61584317204968",
  "isRecommended": true,
  "text": "I'm at the homeless shelter in Alexandria Virginia Prince William county building and there's a lot of us that are homeless that should have a Christmas maybe someone should help us all out show people love...",
  "likesCount": 1,
  "commentsCount": 0,
  "facebookId": "ZmVlZGJhY2s6MTIyMTA5OTMzMTg5MTQzOTA2",
  "postFacebookId": "122109933189143906",
  "pageName": "MrBeast"
}
```

#### Key-Value Store Output (Aggregated)

Aggregated output grouped by page name:

```json
{
  "MrBeast": [
    {
      "facebookUrl": "https://www.facebook.com/mrbeast",
      "id": "UzpfSTYxNTg0MzE3MjA0OTY4OjEyMjEwOTkzMzE4OTE0MzkwNjoxMjIxMDk5MzMxODkxNDM5MDY=",
      "user": { ... },
      "date": "2025-12-23T18:12:27.000Z",
      ...
    },
    ...
  ],
  "Tesla": [ ... ]
}
```

#### Output Fields

| Field | Type | Description |
|-------|------|-------------|
| **facebookUrl** | `string` | The Facebook page URL where the review was posted |
| **id** | `string` | Unique review identifier (Base64 encoded) |
| **user** | `object` | Reviewer information:<br>• `id`: User's Facebook ID<br>• `name`: User's display name<br>• `profileUrl`: Link to user's profile<br>• `profilePic`: Profile picture URL (may be null) |
| **date** | `string` | Review creation date in ISO 8601 format (UTC) |
| **url** | `string` | Direct link to the review post |
| **isRecommended** | `boolean` | Whether the reviewer recommended the page (`true`/`false`) |
| **text** | `string` | Full text content of the review |
| **likesCount** | `integer` | Number of likes on the review |
| **commentsCount** | `integer` | Number of comments on the review |
| **facebookId** | `string` | Facebook feedback ID |
| **postFacebookId** | `string` | Facebook post ID |
| **pageName** | `string` | Name of the Facebook page being reviewed |

### 🚀 How to Use the Actor (via Apify Console)

1. **Log in to Apify Console**
   - Go to <https://console.apify.com>
   - Sign in or create a free account

2. **Find the Actor**
   - Navigate to the **Actors** section
   - Search for "Facebook Reviews Scraper" or find it in your actor list

3. **Configure Input**
   - Click on the actor to open it
   - In the **Input** tab, enter your configuration:
     - Add Facebook page URLs or usernames in the `inputs` field
     - Optionally configure proxy settings

4. **Run the Actor**
   - Click the **Start** button
   - Monitor progress in real-time via the **Log** tab

5. **Monitor Progress**
   - Watch detailed logs showing:
     - Proxy stage transitions
     - Pages being processed
     - Reviews being extracted
     - Batch progress and pagination

6. **Access Results**
   - Once complete, go to the **Dataset** tab to view individual reviews
   - Go to **Key-Value Store** and find the `OUTPUT` key for aggregated results
   - Export data as JSON, CSV, or Excel

7. **Export Results**
   - Click **Export** in the Dataset or Key-Value Store
   - Choose your preferred format (JSON, CSV, Excel, etc.)
   - Download or integrate via API

### Best Use Cases

#### 📊 Business Intelligence & Market Research

- **Competitor Analysis**: Monitor reviews for competitor pages to understand customer sentiment
- **Brand Monitoring**: Track reviews for your own brand pages to measure customer satisfaction
- **Market Research**: Analyze reviews across multiple pages in your industry

#### 💼 Customer Service & Reputation Management

- **Review Aggregation**: Collect all reviews from multiple platforms for centralized analysis
- **Sentiment Analysis**: Extract review text for sentiment analysis and customer feedback processing
- **Response Management**: Identify reviews that need responses based on engagement metrics

#### 📈 Data Analytics & Reporting

- **Trend Analysis**: Track review patterns over time by analyzing dates and engagement
- **Engagement Metrics**: Measure likes and comments to identify most impactful reviews
- **User Behavior**: Analyze reviewer profiles and patterns

#### 🔍 Content & Research

- **Academic Research**: Collect review data for social media research studies
- **Content Creation**: Gather customer testimonials and feedback for marketing materials
- **Product Development**: Extract user feedback to inform product improvements

### Frequently Asked Questions

#### ❓ How many reviews can I scrape per page?

The default limit is **500 reviews per page**, but you can adjust this in the code. The actor will automatically paginate through all available reviews up to your specified limit.

#### ❓ Can I scrape private Facebook pages?

No. This actor only scrapes **publicly available** reviews from Facebook pages. Private pages or pages with restricted access cannot be scraped.

#### ❓ What happens if Facebook blocks my requests?

The actor has an intelligent **3-stage proxy fallback system**:

1. First attempts with no proxy (direct connection)
2. If blocked, automatically switches to datacenter proxy
3. If still blocked, switches to residential proxy with 3 retries
4. Once residential proxy is used, it sticks for all remaining requests

All proxy transitions are logged clearly for transparency.

#### ❓ How long does it take to scrape reviews?

Scraping time depends on:

- Number of pages being processed
- Number of reviews per page
- Network speed and proxy latency
- Facebook's response times

Typically, **100-200 reviews per minute** can be processed. The actor processes multiple pages concurrently for faster results.

#### ❓ Can I scrape reviews from multiple pages at once?

Yes! The actor supports **bulk processing**. Simply add multiple URLs, usernames, or keywords to the `inputs` array. The actor will process them concurrently (up to 3 pages simultaneously by default).

#### ❓ What data format is the output?

Output is available in two formats:

- **Dataset**: Individual review records (one JSON object per review)
- **Key-Value Store**: Aggregated JSON grouped by page name (key: `OUTPUT`)

Both formats can be exported as JSON, CSV, or Excel.

#### ❓ Do I need to configure proxies?

No, proxies are **optional**. By default, the actor starts with no proxy. If Facebook blocks or rejects requests, it automatically falls back to proxies. You can also manually configure proxy settings if needed.

#### ❓ Can I sort the reviews?

Yes! The actor supports sorting by:

- **newest**: Most recent reviews first (default)
- **oldest**: Oldest reviews first
- **most\_relevant**: Highest engagement (likes + comments) first

#### ❓ What if a page has no reviews?

If a page has no reviews or the reviews section is not accessible, the actor will:

- Log a warning message
- Skip that page
- Continue processing other pages
- Return empty results for that page

#### ❓ Is the data real-time?

The actor scrapes reviews as they appear on Facebook at the time of execution. It does not provide real-time updates - you need to run the actor periodically to get the latest reviews.

### Support and Feedback

💬 **For custom solutions or feature requests**, contact us at: **dev.scraperengine@gmail.com**

We're always looking to improve! If you encounter any issues or have suggestions, please reach out.

### Cautions

⚠️ **Important Legal and Ethical Considerations:**

- **Public Data Only**: This actor collects data only from **publicly available** Facebook pages. No private accounts or password-protected content is accessed.

- **Terms of Service**: Ensure your use of this actor complies with:
  - Facebook's Terms of Service
  - Apify's Terms of Service
  - Applicable data protection laws (GDPR, CCPA, etc.)

- **Rate Limiting**: The actor includes built-in delays and rate limiting to be respectful to Facebook's servers. Do not modify these settings to avoid potential blocks.

- **Data Usage**: You are responsible for:
  - Ensuring legal compliance with data collection and usage
  - Respecting user privacy
  - Complying with spam laws and data protection regulations
  - Obtaining necessary permissions for data processing

- **No Guarantees**: Facebook may change their structure or implement anti-scraping measures at any time. The actor is provided "as-is" without warranties.

- **Ethical Use**: Use this tool responsibly and ethically. Do not use scraped data for:
  - Spam or unsolicited communications
  - Harassment or stalking
  - Violation of user privacy
  - Any illegal activities

***

**Built with ❤️ for the Apify community**

# Actor input Schema

## `inputs` (type: `array`):

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📝 Add Facebook page links or short usernames—one per line
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

✅ Examples
• 🔗 https://www.facebook.com/yourfavouritebrand
• 👤 just the handle, e.g. yourfavouritebrand

💡 Tip: use the exact page you care about so results line up with your research goals.

🚀 Each entry is processed in order—batch a whole watchlist in one run!

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

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🎚️ Choose your collection size (1 → 10,000)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📈 Higher = more history & richer analytics
⚡ Lower = faster runs when you only need a fresh sample

🎯 Default 100 hits the sweet spot for most dashboards.

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

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🛡️ Optional Apify Proxy for steadier access
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

🏠 Leave off for the simplest setup
✨ Turn on when you want extra resilience for demanding pages

🔧 Pick the proxy mode that matches your workspace policy—no technical deep-dive required here.

## Actor input object example

```json
{
  "inputs": [
    "https://www.facebook.com/mrbeast"
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

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

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapeengine/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 extracts Facebook Page reviews at scale — ratings, comments, dates, reviewer names, reactions & owner replies. 🔎 Export CSV/JSON, schedule runs, and analyze sentiment. 🚀 Ideal for reputation management, CX insights & social proof.",
        "version": "0.1",
        "x-build-id": "QiSeGIfaMsQwnqggT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeengine~facebook-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeengine-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/scrapeengine~facebook-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeengine-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/scrapeengine~facebook-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeengine-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": [
                    "inputs"
                ],
                "properties": {
                    "inputs": {
                        "title": "🔗 Pages to collect reviews from",
                        "type": "array",
                        "description": "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n📝 Add Facebook page links or short usernames—one per line\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n✅ Examples\n  • 🔗 https://www.facebook.com/yourfavouritebrand\n  • 👤 just the handle, e.g. yourfavouritebrand\n\n💡 Tip: use the exact page you care about so results line up with your research goals.\n\n🚀 Each entry is processed in order—batch a whole watchlist in one run!",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "📊 How many reviews per page?",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n🎚️ Choose your collection size (1 → 10,000)\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n📈 Higher = more history & richer analytics\n⚡ Lower = faster runs when you only need a fresh sample\n\n🎯 Default 100 hits the sweet spot for most dashboards.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy (optional)",
                        "type": "object",
                        "description": "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n🛡️ Optional Apify Proxy for steadier access\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n🏠 Leave off for the simplest setup\n✨ Turn on when you want extra resilience for demanding pages\n\n🔧 Pick the proxy mode that matches your workspace policy—no technical deep-dive required here.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
