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

The Facebook Posts Scraper extracts public posts from Facebook pages and profiles with engagement metrics, timestamps, and media links. Built for scalable Facebook data scraping, it delivers structured JSON or CSV output for analytics, research, and social media monitoring workflows. 🚀

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

## Pricing

$29.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

The Facebook Posts Scraper is a production-ready Facebook post scraper that extracts public posts from Facebook pages and profiles with clean structure and rich engagement metrics. It solves the pain of manual copy-paste by automating Facebook posts data scraping and returning analysis-ready records for marketers, developers, data analysts, and researchers. Built as a scalable Facebook posts extractor and Facebook posts crawler, it helps you export posts to JSON or CSV for reporting, benchmarking, and monitoring at scale. 🚀

### What data / output can you get?

Below are the exact fields this Facebook page posts scraper pushes to the Apify dataset. You can export results to JSON, CSV, or Excel.

| Data type | Description | Example value |
| --- | --- | --- |
| facebookUrl | The input page/profile URL that was processed | https://www.facebook.com/Cristiano/ |
| postId | Unique post identifier | 1565562734930261 |
| pageName | The page slug (last segment of the URL) | Cristiano |
| url | Direct URL for the post | https://www.facebook.com/Cristiano/posts/pfbid0GwyKMLZ... |
| time | ISO-like timestamp string (UTC) | 2026-02-25T21:52:49.000Z |
| timestamp | Unix timestamp (seconds) | 1772056369 |
| user | Object with owning profile details (id, name, profileUrl, profilePic) | {"id":"100044296486382","name":"Cristiano Ronaldo","profileUrl":"https://www.facebook.com/100044296486382","profilePic":"https://..."} |
| collaborators | Array of collaborators objects when available | [] |
| text | Post caption text (may be empty if not available) | Keep it going! 🟡🔵 |
| likes | Total reaction count | 376348 |
| comments | Total comments count | 10488 |
| shares | Shares count | 1918 |
| topReactionsCount | Total of the top reactions | 7 |
| reactionLikeCount | “Like” reactions count | 275081 |
| reactionLoveCount | “Love” reactions count | 86604 |
| reactionHahaCount | “Haha” reactions count | 439 |
| reactionCareCount | “Care” reactions count | 13953 |
| reactionSadCount | “Sad” reactions count | 22 |
| reactionWowCount | “Wow” reactions count | 231 |
| reactionAngryCount | “Angry” reactions count | 18 |
| media | Array of media objects (thumbnails, dimensions, URLs, optional OCR caption) | [{"thumbnail":null,"__typename":"Photo","photo_image":{"uri":null,"height":null,"width":null},"url":"https://www.facebook.com/Cristiano/posts/pfbid0GwyK...","id":"1565562684930266"}] |
| feedbackId | Internal feedback identifier | ZmVlZGJhY2s6MTU2NTU2MjczNDkzMDI2MQ== |
| topLevelUrl | Canonical permalink using IDs | https://www.facebook.com/100044296486382/posts/1565562734930261 |
| facebookId | Owning profile’s numeric Facebook ID | 100044296486382 |
| pageAdLibrary | Object with page ID useful for Ad Library mapping | {"id":"100044296486382"} |
| inputUrl | Echo of the input target URL | https://www.facebook.com/Cristiano/ |

Notes:
- Media entries include thumbnails, image height/width, and URLs when present.
- Exports are available via the Apify dataset in JSON, CSV, or Excel formats for your analytics workflows.

### Key features

- 🔎 Battle‑tested discovery & pagination  
  Finds page IDs and GraphQL doc IDs from live Facebook, then paginates timeline feeds with cursor-based requests — no browser required.

- 📊 Rich engagement metrics & reactions breakdown  
  Collect likes, comments count, shares, plus a full reactions split (Like, Love, Haha, Care, Sad, Wow, Angry) for deeper analytics.

- 🧹 Clean permalinks & metadata  
  Get normalized post URLs, top-level permalinks, and owning profile data (IDs, names, profile pictures) for reliable joins and tracking.

- ⏱️ Precise date filtering  
  Limit results by “Posts Newer Than” and “Posts Older Than” to capture a precise time window without over-scraping.

- 🌐 Proxy-first reliability  
  Automatically prefers Apify Residential proxy for higher success rates and falls back as needed. Built-in retries and backoff on rate limits.

- 📦 Structured exports for BI & automation  
  Export Facebook posts to CSV, JSON, or Excel. Ideal for dashboards, ETL, and pipelines built on the Apify platform.

- 🧰 Developer-friendly & scalable  
  Runs on Apify infrastructure with dataset outputs ready for API consumption and integration into internal tools or make.com/n8n workflows.

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

1. Create or log in to your Apify account.  
2. Open the Facebook Posts Scraper in the Apify Store.  
3. Add targets in startUrls: paste full Facebook page/profile URLs (e.g., https://www.facebook.com/nytimes/) or usernames (e.g., nytimes).  
4. (Optional) Set date filters using “Posts Newer Than (Start Date)” and/or “Posts Older Than (End Date)” to focus your range.  
5. Adjust “Maximum Posts per Page” (maxPosts) to control depth per target (default is 10).  
6. (Optional) Configure Proxy Settings or leave defaults to let the actor prefer Apify Residential proxy automatically.  
7. Click Run and monitor progress in the logs.  
8. When finished, open the run’s Dataset and export results to JSON, CSV, or Excel.

Pro tip: Chain this Facebook posts scraping tool with the Apify API or automation platforms to feed dashboards, alerts, or enrichment workflows.

### Use cases

| Use case name | Description |
| --- | --- |
| Market research & trend analysis | Aggregate public Facebook page posts to analyze content themes, reaction splits, and engagement over time for category insights. |
| Competitor content benchmarking | Track competitor pages to compare top reactions, comment counts, and share velocity for content strategy decisions. |
| Social media monitoring & reporting | Build automated reports by exporting Facebook posts to CSV/JSON and updating BI dashboards on a set cadence. |
| Academic & policy research | Collect structured timelines for studies on public communication patterns, topics, and audience response. |
| Data enrichment for analytics | Enrich internal datasets with post URLs, timestamps, and reaction metrics to power modeling and forecasting. |
| Automated ETL & API pipelines | Use Apify datasets and APIs to stream Facebook public posts data into warehouses and downstream systems. |

### Why choose Facebook Posts Scraper?

This Facebook posts scraping tool prioritizes precision, reliability, and scale — everything you need for analytics-grade social data.

- 🎯 Accurate, structured fields for seamless joins and analysis  
- 🌍 Works on public pages and profiles without a browser session  
- 📈 Built for scale on Apify infrastructure with resilient pagination  
- 🧑‍💻 Developer-ready outputs for API consumption and pipelines  
- 🛡️ Anti-blocking with proxy preference, retries, and backoff baked-in  
- 💸 Export-friendly for BI teams (JSON, CSV, Excel) without extra tooling  
- 🔄 Better than brittle browser extensions — fewer moving parts, more stability

In short: a production-grade Facebook post metadata scraper that’s robust, automation-friendly, and designed for repeatable workflows.

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

Yes — when used responsibly. This Facebook public posts scraper is designed to collect publicly available data from Facebook pages and profiles. You should:
- Scrape only public content you’re allowed to access.
- Comply with applicable laws and regulations (e.g., GDPR, CCPA).
- Review and respect Facebook’s terms of service.
- Avoid collecting or using data in ways that violate privacy or platform rules.  
For edge cases, consult your legal team to ensure compliant use.

### Input parameters & output format

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

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| startUrls | array | Yes | — | Required. Enter one or more Facebook page targets. Accepts full URLs (e.g., https://www.facebook.com/nytimes/) or usernames (e.g., nytimes). Targets are processed sequentially. |
| maxPosts | integer | No | 10 | Limit how many posts to collect per target page. Minimum 1, maximum 10,000. The actor stops once this count is reached for each page. |
| includeVideoTranscript | boolean | No | false | Capture video captions & transcripts toggle. When ON per schema description, transcripts are considered; when OFF, video posts include metadata only. |
| 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 | — | Proxy Settings. Prefers Apify Residential proxy when available; falls back to other options. You can provide custom proxy URLs as a fallback. |

#### Example JSON output

```json
{
  "facebookUrl": "https://www.facebook.com/Cristiano/",
  "postId": "1565562734930261",
  "pageName": "Cristiano",
  "url": "https://www.facebook.com/Cristiano/posts/pfbid0GwyKMLZF7Xaeww3dGoWzFdymFizBw8iCH4Rnhsw9gX6NEJp9L7mzTJyxo9Ah8VZdl",
  "time": "2026-02-25T21:52:49.000Z",
  "timestamp": 1772056369,
  "user": {
    "id": "100044296486382",
    "name": "Cristiano Ronaldo",
    "profileUrl": "https://www.facebook.com/100044296486382",
    "profilePic": "https://scontent.fyvr2-1.fna.fbcdn.net/v/t39.30808-1/448474001_1102716254548247_2613997786866384047_n.jpg"
  },
  "collaborators": [],
  "text": "Keep it going! 🟡🔵",
  "likes": 376348,
  "comments": 10488,
  "shares": 1918,
  "topReactionsCount": 7,
  "media": [
    {
      "thumbnail": null,
      "__typename": "Photo",
      "__isMedia": "Photo",
      "accent_color": "FFFFFFFF",
      "photo_product_tags": [],
      "photo_image": {
        "uri": null,
        "height": null,
        "width": null
      },
      "url": "https://www.facebook.com/Cristiano/posts/pfbid0GwyKMLZF7Xaeww3dGoWzFdymFizBw8iCH4Rnhsw9gX6NEJp9L7mzTJyxo9Ah8VZdl",
      "id": "1565562684930266"
    }
  ],
  "feedbackId": "ZmVlZGJhY2s6MTU2NTU2MjczNDkzMDI2MQ==",
  "reactionLikeCount": 275081,
  "reactionLoveCount": 86604,
  "reactionHahaCount": 439,
  "reactionCareCount": 13953,
  "reactionSadCount": 22,
  "reactionWowCount": 231,
  "reactionAngryCount": 18,
  "topLevelUrl": "https://www.facebook.com/100044296486382/posts/1565562734930261",
  "facebookId": "100044296486382",
  "pageAdLibrary": {
    "id": "100044296486382"
  },
  "inputUrl": "https://www.facebook.com/Cristiano/"
}
```

Notes:

- The scraper returns counts for comments and reactions; it does not extract individual comment text.
- Field availability can vary per post depending on Facebook’s public data.

### FAQ

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

No. The Facebook Posts Scraper targets publicly available pages and profiles and operates without a browser session. It discovers the required IDs from the live site and uses GraphQL requests with cursor-based pagination.

#### Can it scrape Facebook group posts?

It normalizes targets that include “/groups/” or group-style identifiers and will attempt to fetch public timelines accordingly. Results depend on what Facebook exposes publicly for that group.

#### What types of data does it return?

It returns post metadata and engagement metrics including postId, url, time/timestamp, text, likes, comments count, shares, topReactionsCount, full reactions breakdown, media details, and clean permalinks. See the Output section for the full JSON fields.

#### How do I limit posts by date?

Use the “Posts Newer Than (Start Date)” and/or “Posts Older Than (End Date)” inputs. Both support absolute dates (YYYY-MM-DD) and relative values like “7 days” or “2 months” to filter the timeline.

#### How many posts can I scrape per page?

Set maxPosts to control depth per target. The allowed range is 1 to 10,000, with a default of 10.

#### Does it download comments or just counts?

It outputs comments counts only, not individual comment text or threads. You’ll still get overall engagement metrics for analysis.

#### What export formats are supported?

You can export the dataset to JSON, CSV, or Excel directly from Apify, making it easy to feed BI tools and pipelines.

#### What about proxies and reliability?

The actor prefers Apify Residential proxies automatically for better success rates and includes retries and backoff for transient errors or rate limits. You can also provide custom proxy URLs if needed.

### Closing CTA / Final thoughts

Facebook Posts Scraper is built to extract structured, analytics-ready public Facebook posts at scale. It delivers clean URLs, timestamps, reaction breakdowns, and media metadata — all exportable to CSV, JSON, or Excel for marketers, developers, analysts, and researchers. Use it to scrape Facebook page posts reliably, power dashboards, or automate pipelines with the Apify API. Start extracting smarter with a scalable Facebook posts scraping tool that’s production‑ready and workflow‑friendly.

# 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("scrapapi/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("scrapapi/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 scrapapi/facebook-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Posts Scraper",
        "description": "The Facebook Posts Scraper extracts public posts from Facebook pages and profiles with engagement metrics, timestamps, and media links. Built for scalable Facebook data scraping, it delivers structured JSON or CSV output for analytics, research, and social media monitoring workflows. 🚀",
        "version": "0.1",
        "x-build-id": "r4ca5g5XyryDxkOGp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~facebook-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-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/scrapapi~facebook-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-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/scrapapi~facebook-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
