# Facebook Posts Scraper (`scrapemesh/facebook-posts-scraper`) Actor

Scrape Facebook posts from public pages and profiles with ease 📘📢 Extract post text, dates, reactions, comments, shares, media, and more. Perfect for competitor research, content analysis, audience insights, and trend tracking. Turn Facebook data into actionable insights fast 🚀

- **URL**: https://apify.com/scrapemesh/facebook-posts-scraper.md
- **Developed by:** [ScrapeMesh](https://apify.com/scrapemesh) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 4 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 Posts Scraper

Facebook Posts Scraper is a fast, reliable Facebook post extractor that lets you scrape Facebook posts from public pages and profiles at scale. It discovers the page/profile ID and GraphQL document ID from the live site, then paginates the timeline feed without a browser. Built for marketers, developers, data analysts, and researchers, it helps you turn Facebook feeds into structured data for analysis, reporting, and automation — from quick insights to bulk scrape Facebook posts workflows. 🚀

### What data / output can you get?

| Data field | Description | Example value |
| --- | --- | --- |
| facebookUrl | The input page/profile URL normalized by the actor | https://www.facebook.com/nytimes/ |
| postId | Unique post identifier extracted from feedback context | 123456789012345 |
| pageName | Last path segment of the target URL (page/profile handle) | nytimes |
| url | Direct link to the post (falls back to top-level URL) | https://www.facebook.com/100001234567890/posts/123456789012345 |
| time | Post time in ISO-like string (UTC, millisecond suffix) | 2025-12-31T23:59:59.000Z |
| timestamp | Unix timestamp (seconds) | 1767225599 |
| user | JSON with user/page info: id, name, profileUrl, profilePic | {"id":"100001234567890","name":"The New York Times","profileUrl":"https://www.facebook.com/100001234567890","profilePic":"https://...jpg"} |
| collaborators | JSON array of collaborator objects when present | [] |
| text | Post caption text (may be blank if disabled via input) | “Breaking: …” |
| likes | Reaction count | 10432 |
| comments | Comment count | 512 |
| shares | Share count | 289 |
| topReactionsCount | Total top reactions | 14213 |
| reactionLikeCount | “Like” reactions count | 9800 |
| reactionLoveCount | “Love” reactions count | 341 |
| reactionHahaCount | “Haha” reactions count | 22 |
| reactionCareCount | “Care” reactions count | 15 |
| reactionSadCount | “Sad” reactions count | 6 |
| reactionWowCount | “Wow” reactions count | 21 |
| reactionAngryCount | “Angry” reactions count | 8 |
| media | Array of media attachments with thumbnails, sizes, URLs, OCR captions | [{"thumbnail":"https://...jpg","photo_image":{"uri":"https://...jpg","height":1080,"width":1080},"url":"https://...","id":"987654321"}] |
| feedbackId | Facebook feedback identifier | ZmVlZGJhY2s6MTIzNDU2Nzg5MDEyMzQ1 |
| topLevelUrl | Canonical permalink composed from user ID and postId | https://www.facebook.com/100001234567890/posts/123456789012345 |
| facebookId | Owning profile/page ID | 100001234567890 |
| pageAdLibrary | Page-level object with ID (for Ad Library workflows) | {"id":"100001234567890"} |
| inputUrl | Original input target for easy traceability | https://www.facebook.com/nytimes/ |

Notes:
- Results are saved to the Apify dataset and can be exported as JSON, CSV, or Excel for reporting and BI.
- Bonus metadata includes media thumbnails and optional OCR/accessibility captions when present in the page data.
- This Facebook posts scraping tool provides clean “Facebook posts JSON export” and easy “export Facebook posts to CSV”.

### Key features

- 🌐 No-browser, API-free scraping  
  Fetches Facebook timeline data without a headless browser and without the official API. Ideal for a Facebook posts scraper without API or Chrome extensions.

- 🧭 Smart target discovery  
  Automatically resolves numeric IDs and required GraphQL doc IDs from the live site, then paginates via cursors like the Facebook feed scraper on web.

- 🗓️ Flexible date filters (absolute or relative)  
  Limit results using start/end date fields that accept calendar dates or relative values (e.g., “7 days”, “2 months”), so you only scrape Facebook posts you need.

- 📊 Full engagement breakdown  
  Extracts likes, comments count, shares, total reactions, plus per-type reaction counts (Like, Love, Haha, Care, Sad, Wow, Angry) — perfect for content analysis and trend tracking.

- 🖼️ Rich media metadata  
  Collect media attachments with thumbnails, dimensions, URLs, and OCR/accessibility captions where available — great for download Facebook posts data pipelines.

- 🧱 Sequential, bulk-friendly runs  
  Handles multiple targets in sequence (one page after another) to reduce rate limits, supporting bulk scrape Facebook posts use cases.

- 🛡️ Proxy-first reliability  
  Prefers Apify Residential proxy for higher success rates and falls back to Apify Datacenter proxy or your custom proxy URLs. Built-in retries and backoff for robust crawling.

- 👩‍💻 Developer-friendly on Apify  
  Access results via the Apify Dataset API, integrate with “Facebook posts scraper Python” scripts, and automate downstream workflows.

- 💾 Clean exports for analytics  
  One-click “Facebook posts JSON export” or “export Facebook posts to CSV/Excel” for immediate analysis in your BI stack.

### How to use Facebook Posts Scraper - step by step

1. Sign in to Apify and open the Facebook Posts Scraper actor.
2. Add targets in “Facebook Page URLs or Usernames” (startUrls).  
   - Full URL: https://www.facebook.com/nytimes/  
   - Username: nytimes  
   You can mix URLs and usernames.
3. Set your limit with “Maximum Posts per Page” (maxPosts). Start with 10 for tests and raise for deeper timelines.
4. Apply date filters (optional):  
   - Posts Newer Than (oldestPostDateUnified): absolute date (YYYY-MM-DD) or relative (“7 days”, “2 months”).  
   - Posts Older Than (newestPostDate): absolute date or relative.
5. Content option (optional): toggle “Include Video Transcripts” (includeVideoTranscript).  
   Note: In the current implementation, this flag controls whether the “text” field is retained. If off, the post text is blanked for faster runs.
6. Configure proxies (optional): leave empty to auto-use Apify Residential/Datacenter proxies, or add custom proxy URLs.
7. Start the run. The actor normalizes your targets, resolves IDs, fetches the timeline feed, paginates via cursors, and streams posts to the dataset in real time.
8. Download results from the dataset as JSON, CSV, or Excel — or pull them via the Apify API for your dashboard, ETL, or “Facebook posts crawler” workflows.

Pro Tip: Orchestrate scheduled runs and wire results into your analytics using the Apify API or a “Facebook posts scraper Python” pipeline.

### Use cases

| Use case name | Description |
| --- | --- |
| Competitor research & benchmarking | Track how top pages post and perform. Compare likes, comments count, and reactions to sharpen your content strategy. |
| Editorial & content analysis | Analyze post text, timing, and engagement patterns to guide posting cadence and creative decisions. |
| Audience & trend insights | Monitor reaction mixes and shares to identify emerging topics across public pages and profiles. |
| Reporting & BI pipelines | Export Facebook posts to CSV/JSON/Excel and load into dashboards for campaign performance summaries. |
| Data science & NLP | Build labeled datasets (text, reactions, media) for sentiment and topic modeling with a reliable Facebook posts JSON export. |
| Automation & alerts | Feed this Facebook posts crawler into downstream systems to trigger alerts on spikes in reactions or shares. |

### Why choose Facebook Posts Scraper?

Built for precision, automation, and reliability, this Facebook page posts scraper and Facebook feed scraper delivers production-grade results without a browser.

- ✅ Accurate, structured data with per-reaction counts and clean permalinks
- 🌍 Works on public Facebook pages and profiles, no login or Chrome extension required
- 📈 Scales from quick tests to large timelines with cursor-based pagination
- 👩‍💻 Developer access via Apify Dataset API — ideal for Python and workflow integrations
- 🛡️ Anti-blocking resilience with preferred Residential proxy and fallback logic
- 💰 Cost-effective and time-saving vs. DIY scripts or unstable browser extensions
- 🔌 Plug-and-play exports (CSV, JSON, Excel) for analytics and reporting

In short: a stable, server-side Facebook posts scraper vs. extension-based alternatives that break easily.

### Is it legal / ethical to use Facebook Posts Scraper?

Yes — when done responsibly. This actor targets publicly accessible Facebook content from pages and profiles.

Guidelines to follow:
- Collect only public data and avoid private/restricted content.
- Respect Facebook’s terms and any applicable usage limitations.
- Comply with data protection laws such as GDPR/CCPA in your jurisdiction.
- Use scraped data responsibly (e.g., analysis, research) and consult your legal team for edge cases.

### Input parameters & output format

#### Example input JSON
```json
{
  "startUrls": [
    "https://www.facebook.com/nytimes/",
    "Cristiano"
  ],
  "maxPosts": 25,
  "includeVideoTranscript": false,
  "oldestPostDateUnified": "2024-01-01",
  "newestPostDate": "0 days",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### Parameters

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| startUrls | array | Yes | — | Enter one or more Facebook page targets. Accepts full URLs or usernames; the actor turns usernames into full URLs and scrapes targets sequentially. |
| maxPosts | integer | No | 10 | Limit how many posts to collect per target page. Min 1, Max 10,000. |
| includeVideoTranscript | boolean | No | false | Capture video captions & transcripts (as described in the UI). Note: in the current implementation, this flag controls whether the “text” field is retained (ON) or blanked (OFF). |
| oldestPostDateUnified | string | No | — | Posts Newer Than (Start Date). Accepts absolute (YYYY-MM-DD) or relative values (e.g., “7 days”, “2 months”, “1 year”). |
| newestPostDate | string | No | — | Posts Older Than (End Date). Accepts absolute dates or relative values (e.g., “0” for today). |
| proxyConfiguration | object | No | {"useApifyProxy": false} | Proxy settings. Prefers Apify Residential proxy; falls back to Apify Datacenter; supports custom proxy URLs. |

#### Example output JSON (one item)

```json
{
  "facebookUrl": "https://www.facebook.com/nytimes/",
  "postId": "123456789012345",
  "pageName": "nytimes",
  "url": "https://www.facebook.com/100001234567890/posts/123456789012345",
  "time": "2025-12-31T23:59:59.000Z",
  "timestamp": 1767225599,
  "user": {
    "id": "100001234567890",
    "name": "The New York Times",
    "profileUrl": "https://www.facebook.com/100001234567890",
    "profilePic": "https://example-cdn.fbcdn.net/abc/profile.jpg"
  },
  "collaborators": [],
  "text": "Example caption text for analysis…",
  "likes": 10432,
  "comments": 512,
  "shares": 289,
  "topReactionsCount": 14213,
  "media": [
    {
      "thumbnail": "https://example-cdn.fbcdn.net/abc/photo_thumb.jpg",
      "__typename": "Photo",
      "__isMedia": "Photo",
      "accent_color": "FFFFFFFF",
      "photo_product_tags": [],
      "photo_image": {
        "uri": "https://example-cdn.fbcdn.net/abc/photo.jpg",
        "height": 1080,
        "width": 1080
      },
      "url": "https://www.facebook.com/nytimes/posts/123456789012345",
      "id": "987654321",
      "feedback": {
        "can_viewer_comment": false,
        "id": "ZmVlZGJhY2s6OTg3NjU0MzIx"
      },
      "ocrText": "Example accessibility caption"
    }
  ],
  "feedbackId": "ZmVlZGJhY2s6MTIzNDU2Nzg5MDEyMzQ1",
  "reactionLikeCount": 9800,
  "reactionLoveCount": 341,
  "reactionHahaCount": 22,
  "reactionCareCount": 15,
  "reactionSadCount": 6,
  "reactionWowCount": 21,
  "reactionAngryCount": 8,
  "topLevelUrl": "https://www.facebook.com/100001234567890/posts/123456789012345",
  "facebookId": "100001234567890",
  "pageAdLibrary": {
    "id": "100001234567890"
  },
  "inputUrl": "https://www.facebook.com/nytimes/"
}
```

Notes:

- Fields may be null when unavailable in the original content (e.g., some posts might not expose specific media or timestamps).
- The actor streams items to the dataset as they’re discovered, enabling near-real-time processing.

### FAQ

#### Do I need a Facebook login or official API access?

No. This Facebook posts scraper works without login and without the official API. It uses server-side HTTP requests that mimic the web app to fetch public page/profile timelines.

#### Can it scrape comments text?

No. It captures comments counts (engagement metrics), not full comment text. You’ll receive comments totals per post for analysis.

#### How many posts can I collect per target?

Up to 10,000 per target using the maxPosts parameter. The scraper stops once it reaches your limit for each page or profile.

#### Does it support Facebook profiles as well as pages?

Yes. The actor detects whether a target is a page or a public profile and applies the correct timeline query.

#### Does “Include Video Transcripts” add a separate transcript field?

Not in the current implementation. This flag controls whether the “text” field is retained (ON) or blanked (OFF). There is no separate transcript output field.

#### What export options are available?

All results land in an Apify dataset. You can export Facebook posts to CSV, JSON, or Excel, or pull them via API for downstream pipelines and dashboards.

#### How does the proxy work?

By default, the actor prefers Apify Residential proxy for higher success rates and falls back to Apify Datacenter. You can also supply custom proxy URLs in proxyConfiguration.

#### Can I use this from Python or via an API?

Yes. Use the Apify API to run the actor and fetch datasets, or integrate with “Facebook posts scraper Python” scripts for end-to-end automation.

### Final thoughts

Facebook Posts Scraper is built to reliably turn public Facebook pages and profiles into structured, analysis-ready post data. With engagement breakdowns, smart date filters, resilient proxying, and clean exports, it’s ideal for marketers, analysts, researchers, and developers alike. Use the Apify Dataset API for automation, integrate with your “Facebook posts JSON export” or “export Facebook posts to CSV” workflows, and start extracting smarter insights today. For custom needs, reach out at dev.scraperengine@gmail.com.

# Actor input Schema

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

📌 **Required.** Enter one or more Facebook *page* targets.

• **Full URL:** `https://www.facebook.com/nytimes/` or `https://www.facebook.com/Cristiano/`
• **Username only:** `nytimes`, `Cristiano`, `iamsrk` — the actor will turn these into full URLs.

You can mix URLs and usernames. Each target is scraped in sequence (one page after another) to reduce rate limits. 🔄

## `maxPosts` (type: `integer`):

🎯 **Limit how many posts to collect *per target page*.**

• Minimum: **1** — Maximum: **10,000**.
• Default: **10** — Good for quick tests.
• Increase for deeper timelines (e.g. 50–500). The actor stops once this count is reached for each page. 🛑

## `includeVideoTranscript` (type: `boolean`):

📝 **Capture video captions & transcripts!**

• **ON** ✨ — Extracts closed captions/transcripts from video & reel posts into the output.
• **OFF** — Video posts still appear with metadata, but no transcript text.

Default: **OFF** for faster scraping. Turn **ON** when you need subtitle/caption data. 🎬

## `timeoutMode` (type: `string`):

Choose how per-target timeout is determined. **Auto** scales timeout from requested post count. **Manual** uses your custom timeout value.

## `targetTimeoutSecs` (type: `integer`):

Used only when Timeout Mode is set to **Manual**. The actor will stop a target when this time limit is reached.

## `oldestPostDateUnified` (type: `string`):

⏳ **Only include posts *after* this date.**

• **Absolute:** Pick a calendar date (e.g. `2024-01-01`).
• **Relative:** e.g. `7` days, `2` months, `1` year — counted backward from today.

Leave empty to allow posts from any past date. Combines with "Posts Older Than" for a window. 🗓️

## `newestPostDate` (type: `string`):

🛑 **Only include posts *before* this date.**

• **Absolute:** e.g. `2024-12-31`.
• **Relative:** e.g. `0` for “today” or a number of days/months/years ago.

Use together with "Posts Newer Than" to scrape a precise date range. Leave empty for no end limit. 📆

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

🛡️ **Anti-block & reliability.**

• The actor **prefers Apify Residential proxy** when available for higher success rates.
• If residential isn’t set, it falls back to **Apify Datacenter** proxy.
• You can optionally provide **custom proxy URLs** here as a fallback.

No proxy configuration is required for basic runs; the actor will use Apify proxy when possible. 🔒

## Actor input object example

```json
{
  "startUrls": [
    "iamsrk",
    "https://www.facebook.com/nytimes/"
  ],
  "maxPosts": 10,
  "includeVideoTranscript": false,
  "timeoutMode": "auto",
  "targetTimeoutSecs": 1200,
  "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 = {
    "startUrls": [
        "https://www.facebook.com/nytimes"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

# Run the Actor and wait for it to finish
run = client.actor("scrapemesh/facebook-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": [
    "https://www.facebook.com/nytimes"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapemesh/facebook-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Posts Scraper",
        "description": "Scrape Facebook posts from public pages and profiles with ease 📘📢 Extract post text, dates, reactions, comments, shares, media, and more. Perfect for competitor research, content analysis, audience insights, and trend tracking. Turn Facebook data into actionable insights fast 🚀",
        "version": "0.1",
        "x-build-id": "HmOGvsr7pIF8X2HXI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemesh~facebook-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemesh-facebook-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/scrapemesh~facebook-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapemesh-facebook-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/scrapemesh~facebook-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemesh-facebook-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🔗 Facebook Page URLs or Usernames",
                        "type": "array",
                        "description": "📌 **Required.** Enter one or more Facebook *page* targets.\n\n• **Full URL:** `https://www.facebook.com/nytimes/` or `https://www.facebook.com/Cristiano/`\n• **Username only:** `nytimes`, `Cristiano`, `iamsrk` — the actor will turn these into full URLs.\n\nYou can mix URLs and usernames. Each target is scraped in sequence (one page after another) to reduce rate limits. 🔄",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPosts": {
                        "title": "📊 Maximum Posts per Page",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "🎯 **Limit how many posts to collect *per target page*.**\n\n• Minimum: **1** — Maximum: **10,000**.\n• Default: **10** — Good for quick tests.\n• Increase for deeper timelines (e.g. 50–500). The actor stops once this count is reached for each page. 🛑",
                        "default": 10
                    },
                    "includeVideoTranscript": {
                        "title": "🎥 Include Video Transcripts",
                        "type": "boolean",
                        "description": "📝 **Capture video captions & transcripts!**\n\n• **ON** ✨ — Extracts closed captions/transcripts from video & reel posts into the output.\n• **OFF** — Video posts still appear with metadata, but no transcript text.\n\nDefault: **OFF** for faster scraping. Turn **ON** when you need subtitle/caption data. 🎬",
                        "default": false
                    },
                    "timeoutMode": {
                        "title": "⏱️ Timeout Mode",
                        "enum": [
                            "auto",
                            "manual"
                        ],
                        "type": "string",
                        "description": "Choose how per-target timeout is determined. **Auto** scales timeout from requested post count. **Manual** uses your custom timeout value.",
                        "default": "auto"
                    },
                    "targetTimeoutSecs": {
                        "title": "⏳ Per-Target Timeout (seconds)",
                        "minimum": 60,
                        "maximum": 72000,
                        "type": "integer",
                        "description": "Used only when Timeout Mode is set to **Manual**. The actor will stop a target when this time limit is reached.",
                        "default": 1200
                    },
                    "oldestPostDateUnified": {
                        "title": "📅 Posts Newer Than (Start Date)",
                        "type": "string",
                        "description": "⏳ **Only include posts *after* this date.**\n\n• **Absolute:** Pick a calendar date (e.g. `2024-01-01`).\n• **Relative:** e.g. `7` days, `2` months, `1` year — counted backward from today.\n\nLeave empty to allow posts from any past date. Combines with \"Posts Older Than\" for a window. 🗓️"
                    },
                    "newestPostDate": {
                        "title": "⌛ Posts Older Than (End Date)",
                        "type": "string",
                        "description": "🛑 **Only include posts *before* this date.**\n\n• **Absolute:** e.g. `2024-12-31`.\n• **Relative:** e.g. `0` for “today” or a number of days/months/years ago.\n\nUse together with \"Posts Newer Than\" to scrape a precise date range. Leave empty for no end limit. 📆"
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy Settings",
                        "type": "object",
                        "description": "🛡️ **Anti-block & reliability.**\n\n• The actor **prefers Apify Residential proxy** when available for higher success rates.\n• If residential isn’t set, it falls back to **Apify Datacenter** proxy.\n• You can optionally provide **custom proxy URLs** here as a fallback.\n\nNo proxy configuration is required for basic runs; the actor will use Apify proxy when possible. 🔒"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
