# Facebook Pages + Posts Scraper (`trakk/facebook-pages-posts-scraper`) Actor

Scrape Facebook Pages and posts together. Extract Page details, contacts, followers, captions, reactions, comments, shares, photos, videos, reels, links, and engagement data. Supports Page URLs, direct posts, mixed lists, date filters, and optional encrypted cookies.

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

## Pricing

from $4.00 / 1,000 facebook page or post results

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

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

## What's an Apify Actor?

Actors are 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/docs.md):

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

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

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


# README

## Facebook Pages + Posts Scraper

Collect Facebook Page details and posts in one run. Get business contacts, audience numbers, engagement, captions, links, profile and cover images, post photos, videos, and more in structured rows ready for export or automation.

Use public mode without a Facebook account, or add optional encrypted cookies when you need content visible only to your signed-in account.

### 💡 Why this Actor

Most Facebook tools scrape **either** Pages **or** posts. This one returns **both in a single run** — plus the business contacts that lead-generation and outreach teams actually pay for.

- 🔗 **Pages + posts together** — one Page URL returns the Page profile *and* its recent posts, with no second Actor and no manual merging
- 📇 **Contacts built in** — emails, phone numbers, websites, and addresses, ready for a lead list
- 🔓 **No account needed** for public data; add encrypted cookies only when you want signed-in content
- 🎯 **Four focused modes** — full research, contacts-only, posts-only, or single post / photo / video / reel URLs
- 🧹 **Clean, deduplicated rows** that export straight to CSV, Excel, Google Sheets, Make, or Zapier

#### 📸 Sample output

![Facebook Pages + Posts Scraper sample output — real data fields](https://api.apify.com/v2/key-value-stores/sAkX2yFx0oRX6gf6p/records/facebook-pages-posts-scraper-sample)

*A real run's output — exportable to JSON, CSV, or Excel.*

### 🚀 What you can collect

- Facebook Page metadata and business contacts
- Posts from one or many Pages
- Individual posts, photos, videos, reels, and `fb.watch` links
- Profile pictures, cover photos, post images, video URLs, and thumbnails
- Reactions, comments, shares, views, and reaction breakdowns
- Mentions and external links
- Posts filtered by publication date or caption text
- Mixed lists containing both Page and direct post URLs
- Optional raw Facebook JSON for advanced workflows

The Actor deduplicates repeated inputs and post records automatically.

### 🎯 Choose the right mode

| Mode | Best for | Returned rows |
|---|---|---|
| **Pages + Posts** | Complete Page research and mixed URL lists | Page rows and post rows |
| **Page details only** | Lead generation, Page discovery, and contact lists | Page rows only |
| **Posts from Pages** | Content and engagement analysis | Post rows only |
| **Direct post URLs** | Individual posts, photos, videos, reels, or `fb.watch` links | Up to one post row per URL |

**Pages + Posts** is the recommended universal mode. A Page URL can return one Page row plus matching post rows, while a direct content URL returns a post row.

### 📄 Page data

Available Page fields can include:

- Page name, username, Page ID, and Facebook ID
- Page URL and Messenger URL
- Category, description, intro, and additional information
- Followers, following, and likes
- Verified status and confirmed owner
- Email addresses and phone numbers
- Websites and physical addresses
- Rating and rating count
- Profile picture URL and dimensions
- Cover photo URL and dimensions
- Facebook Ad Library URL
- Collection timestamp

### 📝 Post data

Available post fields can include:

- Post ID, URL, type, author, and publication time
- Caption and post text
- Total reactions, comments, shares, and views
- Like, Love, Care, Haha, Wow, Sad, and Angry counts
- Mentioned names and Facebook links
- External links
- Photo URLs
- Video URLs and thumbnails
- Media IDs, types, dimensions, and accessibility text
- Optional raw JSON

Facebook controls which fields are publicly visible. Values that are unavailable for a particular Page or post are omitted instead of being filled with misleading placeholders.

### 📸 Photos and videos

Media extraction covers:

- Page profile pictures
- Page cover photos
- Single-photo posts
- Multi-photo attachments
- Video and reel URLs when exposed
- Video thumbnails
- Available media dimensions and accessibility descriptions

Facebook CDN links may expire later. Download important files soon after collecting them.

### ⚙️ Main input options

| Input | Description |
|---|---|
| `startUrls` | Facebook Page, profile, post, photo, video, reel, or `fb.watch` URLs |
| `scrapeType` | Selects one of the four scraping modes |
| `maxPostsPerPage` | Maximum matching posts collected from each Page |
| `startDate` / `endDate` | Optional publication date range in `YYYY-MM-DD` format |
| `captionText` | Keeps posts whose text contains the supplied phrase |
| `maxItems` | Hard result limit across the whole run |
| `includePageMedia` | Uses available Page photo and video publications when the normal post feed is limited |
| `includeRawJson` | Adds the source JSON as a string for advanced integrations |
| `facebookCookies` | Optional encrypted Facebook session cookies |
| `cookieFormat` | Automatic detection, Cookie header, JSON export, or Netscape format |

The input also contains advanced request and concurrency limits. The defaults are designed for normal runs.

### ✅ Example: Page details and posts

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/NASA/" },
    { "url": "https://www.facebook.com/Meta/" }
  ],
  "scrapeType": "PAGES_AND_POSTS",
  "maxPostsPerPage": 20,
  "maxItems": 100,
  "startDate": "2026-01-01",
  "includePageMedia": true,
  "includeRawJson": false
}
````

### 🎬 Example: direct content URLs

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/watch/?v=1376651124309650" },
    { "url": "https://www.facebook.com/NASA/photos/1583701686458535" }
  ],
  "scrapeType": "DIRECT_POSTS",
  "maxItems": 2
}
```

### 📦 Example Page result

```json
{
  "recordType": "page",
  "pageName": "Example Page",
  "pageId": "123456789",
  "category": "Organization",
  "followers": 1250000,
  "email": "hello@example.com",
  "website": "https://example.com",
  "profilePictureUrl": "https://scontent...fbcdn.net/...",
  "coverPhotoUrl": "https://scontent...fbcdn.net/...",
  "pageUrl": "https://www.facebook.com/example",
  "scrapedAt": "2026-07-23T12:00:00Z"
}
```

### 📝 Example Post result

```json
{
  "recordType": "post",
  "postId": "987654321",
  "pageName": "Example Page",
  "postType": "photo",
  "text": "Post caption",
  "time": "2026-07-20T18:30:00Z",
  "likes": 4821,
  "comments": 193,
  "shares": 88,
  "photoUrls": ["https://scontent...fbcdn.net/..."],
  "mediaWidths": [2048],
  "mediaHeights": [1365],
  "postUrl": "https://www.facebook.com/example/posts/987654321",
  "scrapedAt": "2026-07-23T12:00:01Z"
}
```

### 🗂️ Output and exports

Each saved dataset item is either:

- one `page` result, or
- one `post` result.

The Output tab provides focused views:

- **Pages**
- **Posts**
- **Photos & videos**
- **Contacts**
- **All fields**

Download results as JSON, CSV, Excel, XML, or RSS. You can also send them to Google Sheets, databases, Make, Zapier, webhooks, or your own API integration.

The `OUTPUT` key-value record contains a compact run summary with counts and one of these statuses:

- `completed` — results were collected normally
- `completed_no_data` — the run was valid but no matching rows were visible
- `completed_with_issues` — available rows were saved, while one or more URLs had no accessible data
- `rejected` — invalid input was stopped before any Facebook request

### 💳 Pricing and budget control

The Actor uses pay-per-result pricing shown in the Store pricing panel. A Page row and a post row each count as one result.

Use `maxItems` to set a hard result limit. You can also set Apify's maximum charge for an individual run. The Actor stops saving additional rows when either limit is reached.

Rejected input produces no dataset results and makes no Facebook requests.

### 🔐 Optional cookies

Cookies are not required for public Pages and posts. For content visible only to a signed-in account, the Actor accepts:

- a browser `Cookie` header,
- a JSON browser export, or
- a Netscape `cookies.txt` export.

The input is marked as secret in Apify. Cookie values are never written to the dataset, run summary, or logs. An authenticated session must contain valid `c_user` and `xs` cookies.

For a more stable account session, keep `maxConcurrency` at `1` or `2` and avoid running the same cookies in many simultaneous jobs.

### ❓ Frequently asked questions

#### Why did a valid URL return no row?

The content may be unavailable to logged-out visitors, removed, region-limited, age-limited, or returned without enough structured data. The run summary identifies empty and inaccessible URLs without discarding successful results from the rest of the batch.

#### Why are some columns missing?

Facebook exposes different fields for different Pages and post types. Missing values mean the source did not provide that field.

#### Can I scrape Page URLs and direct posts together?

Yes. Use **Pages + Posts** mode for mixed input lists.

#### Can I collect only contacts?

Use **Page details only**, then open the **Contacts** output view.

#### Can I filter posts?

Yes. Use `startDate`, `endDate`, and `captionText`. Filters apply to post rows, not Page rows.

#### Can I export the results?

Yes. The default dataset supports the standard Apify downloads and integrations, including CSV, Excel, JSON, Google Sheets, Make, Zapier, webhooks, and API access.

# Actor input Schema

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

Add Facebook Page, profile, post, photo, video, reel, or fb.watch URLs. Pages + Posts mode automatically handles mixed URL lists.

## `scrapeType` (type: `string`):

Pages + Posts is the universal default. Focused modes are useful when you need only one record type.

## `maxPostsPerPage` (type: `integer`):

Maximum matching posts saved for each Page URL. Direct post URLs always return at most one post.

## `startDate` (type: `string`):

Optional earliest publication date in YYYY-MM-DD format, for example 2026-01-01.

## `endDate` (type: `string`):

Optional latest publication date in YYYY-MM-DD format.

## `captionText` (type: `string`):

Optional case-insensitive text filter for post captions.

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

Hard run-wide limit across Page and post rows. The Actor stops saving and requesting more data after this limit or the maximum charge is reached.

## `facebookCookies` (type: `string`):

Optional encrypted cookies for content visible to your Facebook account. An authenticated session must include c\_user and xs. Accepts a Cookie header, JSON browser export, or Netscape cookies.txt. Values are never written to logs or results.

## `cookieFormat` (type: `string`):

Automatic detection supports the common export formats. Choose a format only if detection is ambiguous.

## `includeRawJson` (type: `boolean`):

Adds rawJson as a JSON string for advanced integrations. Disabled by default because rows become much larger.

## `includePageMedia` (type: `boolean`):

When Facebook limits timeline pagination, fill the remaining post limit with public photo and video publications from the Page's media tabs.

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

Residential proxy is recommended for reliable Facebook pagination. Cookie mode keeps one account-specific sticky proxy session; avoid changing its country between runs.

## `maxConcurrency` (type: `integer`):

Number of input URLs processed in parallel. Use 1–2 with Facebook cookies to reduce account warnings.

## `requestTimeoutSec` (type: `integer`):

Maximum time for one Facebook request.

## `maxRetries` (type: `integer`):

Attempts after temporary blocks or network errors. Public mode can rotate proxy sessions; cookie mode stays on its account-specific sticky session.

## `maxPaginationPages` (type: `integer`):

Safety limit per Page. The result limit normally stops pagination first.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/NASA/"
    }
  ],
  "scrapeType": "PAGES_AND_POSTS",
  "maxPostsPerPage": 20,
  "captionText": "",
  "maxItems": 500,
  "cookieFormat": "AUTO",
  "includeRawJson": false,
  "includePageMedia": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  },
  "maxConcurrency": 3,
  "requestTimeoutSec": 35,
  "maxRetries": 3,
  "maxPaginationPages": 50
}
```

# Actor output Schema

## `pages` (type: `string`):

No description

## `posts` (type: `string`):

No description

## `media` (type: `string`):

No description

## `contacts` (type: `string`):

No description

## `all` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.facebook.com/NASA/"
        }
    ],
    "scrapeType": "PAGES_AND_POSTS",
    "maxPostsPerPage": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("trakk/facebook-pages-posts-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.facebook.com/NASA/" }],
    "scrapeType": "PAGES_AND_POSTS",
    "maxPostsPerPage": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("trakk/facebook-pages-posts-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.facebook.com/NASA/"
    }
  ],
  "scrapeType": "PAGES_AND_POSTS",
  "maxPostsPerPage": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call trakk/facebook-pages-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Pages + Posts Scraper",
        "description": "Scrape Facebook Pages and posts together. Extract Page details, contacts, followers, captions, reactions, comments, shares, photos, videos, reels, links, and engagement data. Supports Page URLs, direct posts, mixed lists, date filters, and optional encrypted cookies.",
        "version": "0.1",
        "x-build-id": "5mLEaTSoftLdY0Qj8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trakk~facebook-pages-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trakk-facebook-pages-posts-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/trakk~facebook-pages-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-trakk-facebook-pages-posts-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/trakk~facebook-pages-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-trakk-facebook-pages-posts-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",
                "properties": {
                    "startUrls": {
                        "title": "🔗 Facebook URLs",
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Add Facebook Page, profile, post, photo, video, reel, or fb.watch URLs. Pages + Posts mode automatically handles mixed URL lists.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "scrapeType": {
                        "title": "🎯 What to scrape",
                        "enum": [
                            "PAGES_AND_POSTS",
                            "PAGES_ONLY",
                            "POSTS_ONLY",
                            "DIRECT_POSTS"
                        ],
                        "type": "string",
                        "description": "Pages + Posts is the universal default. Focused modes are useful when you need only one record type.",
                        "default": "PAGES_AND_POSTS"
                    },
                    "maxPostsPerPage": {
                        "title": "📝 Maximum posts per Page",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum matching posts saved for each Page URL. Direct post URLs always return at most one post.",
                        "default": 20
                    },
                    "startDate": {
                        "title": "From date",
                        "pattern": "^$|^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional earliest publication date in YYYY-MM-DD format, for example 2026-01-01."
                    },
                    "endDate": {
                        "title": "To date",
                        "pattern": "^$|^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional latest publication date in YYYY-MM-DD format."
                    },
                    "captionText": {
                        "title": "Caption contains",
                        "maxLength": 500,
                        "type": "string",
                        "description": "Optional case-insensitive text filter for post captions.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "💯 Maximum total results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Hard run-wide limit across Page and post rows. The Actor stops saving and requesting more data after this limit or the maximum charge is reached.",
                        "default": 500
                    },
                    "facebookCookies": {
                        "title": "🔐 Facebook cookies (optional)",
                        "type": "string",
                        "description": "Optional encrypted cookies for content visible to your Facebook account. An authenticated session must include c_user and xs. Accepts a Cookie header, JSON browser export, or Netscape cookies.txt. Values are never written to logs or results."
                    },
                    "cookieFormat": {
                        "title": "Cookie format",
                        "enum": [
                            "AUTO",
                            "HEADER",
                            "JSON",
                            "NETSCAPE"
                        ],
                        "type": "string",
                        "description": "Automatic detection supports the common export formats. Choose a format only if detection is ambiguous.",
                        "default": "AUTO"
                    },
                    "includeRawJson": {
                        "title": "Include raw Facebook JSON",
                        "type": "boolean",
                        "description": "Adds rawJson as a JSON string for advanced integrations. Disabled by default because rows become much larger.",
                        "default": false
                    },
                    "includePageMedia": {
                        "title": "📸 Include Page photo & video fallback",
                        "type": "boolean",
                        "description": "When Facebook limits timeline pagination, fill the remaining post limit with public photo and video publications from the Page's media tabs.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxy is recommended for reliable Facebook pagination. Cookie mode keeps one account-specific sticky proxy session; avoid changing its country between runs.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of input URLs processed in parallel. Use 1–2 with Facebook cookies to reduce account warnings.",
                        "default": 3
                    },
                    "requestTimeoutSec": {
                        "title": "Request timeout",
                        "minimum": 10,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Maximum time for one Facebook request.",
                        "default": 35
                    },
                    "maxRetries": {
                        "title": "Request retries",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Attempts after temporary blocks or network errors. Public mode can rotate proxy sessions; cookie mode stays on its account-specific sticky session.",
                        "default": 3
                    },
                    "maxPaginationPages": {
                        "title": "Maximum pagination requests",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Safety limit per Page. The result limit normally stops pagination first.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```