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

📘 Facebook Posts Scraper extracts public posts—text, images, links, timestamps, reactions, comments & #️⃣hashtags—at scale. 🔍 Filter by page, keyword or date. 📊 Export CSV/JSON for social listening, competitor analysis & content research. 🚀 Fast, reliable.

- **URL**: https://apify.com/scrapebase/facebook-posts-scraper.md
- **Developed by:** [ScrapeBase](https://apify.com/scrapebase) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 3 total users, 1 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 production-ready Apify actor that extracts public Facebook posts at scale — including post text, timestamps, links, media, reactions, likes, comments count, and shares — from pages, groups, and profiles. As a Facebook post scraper and Facebook posts extractor, it helps marketers, developers, data analysts, and researchers scrape Facebook page posts and scrape Facebook group posts for social listening, competitor tracking, and content research. Built for reliability and scale, it enables fast Facebook post data extraction without the official API.

### What data / output can you get?

Below are the exact JSON fields the actor saves to the dataset for each post:

| Data field | Description | Example value |
| --- | --- | --- |
| facebookUrl | Source page/profile URL used for scraping | https://www.facebook.com/nytimes/ |
| postId | Unique post identifier | 123456789012345 |
| pageName | Page or profile slug derived from URL | nytimes |
| url | Direct URL to the post (fallback to canonical permalink) | https://www.facebook.com/100044185428261/posts/1397878851694949 |
| time | Post time in ISO format with Z suffix | 2025-01-15T10:41:16.000Z |
| timestamp | Unix timestamp (seconds) | 1736937676 |
| user.id | Owning page/profile ID | 100044185428261 |
| user.name | Page/profile display name (when available) | The New York Times |
| user.profileUrl | Profile URL composed from ID | https://www.facebook.com/100044185428261 |
| user.profilePic | Profile picture URL (when detected) | https://static.xx.fbcdn.net/.../profile.jpg |
| text | Post caption/message text | Major breaking news just in… |
| likes | Total reaction count | 40224 |
| comments | Total comments count | 2279 |
| shares | Total share count | 1484 |
| topReactionsCount | Total count of top reactions | 7 |
| reactionLikeCount | “Like” reactions count | 31200 |
| reactionLoveCount | “Love” reactions count | 6120 |
| reactionHahaCount | “Haha” reactions count | 420 |
| reactionCareCount | “Care” reactions count | 210 |
| reactionSadCount | “Sad” reactions count | 85 |
| reactionWowCount | “Wow” reactions count | 320 |
| reactionAngryCount | “Angry” reactions count | 69 |
| media | Array of media objects (images/attachments) with metadata | [{ "thumbnail": "...", "photo_image": {...}, "ocrText": "..." }] |
| feedbackId | Facebook feedback identifier | ZmVlZGJhY2s6MTM5Nzg3ODg1MTY5NDk0OQ== |
| topLevelUrl | Canonical “/ID/posts/POST_ID” permalink | https://www.facebook.com/100044185428261/posts/1397878851694949 |
| facebookId | Owning page/profile ID (same as user.id) | 100044185428261 |
| pageAdLibrary.id | Page ID for Ad Library lookups | 100044185428261 |
| inputUrl | Original input URL you provided | https://www.facebook.com/nytimes/ |
| collaborators | Collaborator metadata (when present) | [] |

Notes:
- Media entries may include thumbnail, dimensions (photo_image.height/width), URLs, and optional ocrText (accessibility caption) for richer analysis.
- Export the dataset in JSON, CSV, or Excel to build reports, dashboards, or pipelines like a Facebook posts downloader or to export Facebook posts to CSV.

### Key features

- 🔎 GraphQL-powered timeline extraction  
  Robust Facebook page feed scraper that discovers page/profile IDs and GraphQL doc IDs from the live site and paginates with cursors — no browser required.

- 🌐 Pages, groups, and profiles coverage  
  Normalize inputs to scrape Facebook page posts and scrape Facebook group posts in one run. Mix full URLs and usernames; targets run sequentially for reliability.

- 🗓️ Smart date filters  
  Limit results by start and/or end date using oldestPostDateUnified and newestPostDate. Filters are applied during requests and re-checked client-side for precision.

- 💬 Engagement metrics & reaction breakdown  
  Get likes, comments count, shares, topReactionsCount, and per-type fields (Like/Love/Haha/Care/Sad/Wow/Angry) for granular analysis.

- 🖼️ Media metadata with optional OCR captions  
  Collect media thumbnails, dimensions, attachment URLs, and accessibility captions (ocrText) when present to enrich creative analysis.

- 🛡️ Production-grade anti-blocking  
  Prefers Apify Residential proxy when available, falls back to Apify Datacenter or your custom proxy, with retries and exponential backoff.

- 📦 Analysis-ready dataset  
  Clean, consistent JSON that works out of the box for Facebook posts extractor workflows, including “Facebook posts crawler” and “extract Facebook posts for analysis” use cases.

- 👩‍💻 Developer friendly  
  Run via Apify API; integrate with Python, Make, n8n, or your data stack. Build an automated Facebook post scraper tool or Facebook post scraper Python pipeline without the official API.

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

1. Create or log in to your Apify account.  
2. Open the Facebook Posts Scraper actor and click “Input” to configure your run.  
3. Add targets in startUrls:  
   - Full page URL: https://www.facebook.com/nytimes/  
   - Username only: nytimes  
   - Group: groups/mygroup or https://www.facebook.com/groups/mygroup  
4. Set maxPosts to control depth per target (1–10,000; default 10).  
5. Apply date filters (optional):  
   - Posts Newer Than (Start Date): oldestPostDateUnified (absolute like 2024-01-01 or relative like 7 days, 2 months, 1 year).  
   - Posts Older Than (End Date): newestPostDate (absolute like 2024-12-31 or relative like 0 for today).  
6. Configure proxy (optional): The actor prefers Apify Residential proxy, falls back to Apify Datacenter, and supports custom URLs.  
7. Start the run: targets are processed sequentially to reduce rate limits. Progress logs will show per-target counts.  
8. Download results: open the Dataset tab to export JSON, CSV, or Excel, or access via API for automation.

Pro Tip: Chain runs or connect the dataset to your analytics stack to export Facebook posts to CSV and power “Facebook post data extraction” dashboards.

### Use cases

| Use case | Description |
| --- | --- |
| Social listening for marketers | Monitor pages and groups to quantify engagement trends and reactions. Export to CSV for weekly reporting. |
| Competitor content analysis | Benchmark how rivals post, structure captions, and which reactions dominate over time. |
| Editorial research & insights | Curate public posts as a Facebook posts downloader feed for story leads and events. |
| Brand monitoring & PR | Track brand pages for spikes in comments count, shares, and reaction changes. |
| Academic & policy studies | Collect public timelines for longitudinal analysis with a Facebook posts extractor dataset. |
| Data science & NLP | Build labeled corpora from post text, ocrText, and engagement signals for modeling. |
| Automation pipelines | Trigger downstream workflows via API to scrape Facebook page posts at intervals without API credentials. |

### Why choose Facebook Posts Scraper?

Built for precision, automation, and reliability, this Facebook post scraper tool offers:

- ✅ Accurate, structured fields for analysis-ready datasets
- 🌍 Pages, groups, and profiles coverage in a single workflow
- 📈 Scales from small tests to deep timelines (up to 10,000 posts per target)
- 🧰 Developer access via the Apify API for Python and workflow automation
- 🔐 No login required — a Facebook public posts scraper without the official API
- 🛡️ Anti-blocking with residential/datacenter proxies and retry/backoff logic
- ⚙️ Better than ad-hoc extensions — stable, production-grade infrastructure

In short, a dependable Facebook posts crawler that balances coverage, data quality, and operational reliability.

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

Yes — when done responsibly. This actor is designed to extract publicly available information and does not access private or authenticated content. You should:

- Collect only public data and respect platform terms.
- Comply with data protection laws (e.g., GDPR, CCPA) and internal policies.
- Use results for lawful purposes (analysis, research) and avoid misuse.
- Consult your legal team for edge cases and jurisdiction-specific rules.

### Input parameters & output format

Example input
```json
{
  "startUrls": [
    "https://www.facebook.com/nytimes/",
    "Cristiano",
    "groups/mygroup"
  ],
  "maxPosts": 25,
  "includeVideoTranscript": false,
  "oldestPostDateUnified": "7 days",
  "newestPostDate": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Parameter reference

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| startUrls | array | Yes | — | Facebook Page targets as full URLs or usernames. You can mix formats; targets run sequentially to reduce rate limits. |
| maxPosts | integer | No | 10 | Maximum posts to collect per target page (1–10,000). The actor stops when this count is reached per page. |
| includeVideoTranscript | boolean | No | false | Capture video captions & transcripts (when available). When OFF, video posts still appear with metadata. |
| oldestPostDateUnified | string | No | — | Posts Newer Than (Start Date). Absolute (e.g., 2024-01-01) or Relative (e.g., 7 days, 2 months, 1 year). |
| newestPostDate | string | No | — | Posts Older Than (End Date). Absolute (e.g., 2024-12-31) or Relative (e.g., 0 for today). |
| proxyConfiguration | object | No | {"useApifyProxy": false} | Proxy settings. Prefers Apify Residential; falls back to Apify Datacenter; supports custom proxy URLs. |

Example output

```json
{
  "facebookUrl": "https://www.facebook.com/nytimes/",
  "postId": "1397878851694949",
  "pageName": "nytimes",
  "url": "https://www.facebook.com/100044185428261/posts/1397878851694949",
  "time": "2025-01-15T10:41:16.000Z",
  "timestamp": 1736937676,
  "user": {
    "id": "100044185428261",
    "name": "The New York Times",
    "profileUrl": "https://www.facebook.com/100044185428261",
    "profilePic": "https://static.xx.fbcdn.net/rsrc.php/v3/yX/r/profile_pic.jpg"
  },
  "collaborators": [],
  "text": "Major breaking news just in...",
  "likes": 40224,
  "comments": 2279,
  "shares": 1484,
  "topReactionsCount": 7,
  "reactionLikeCount": 31200,
  "reactionLoveCount": 6120,
  "reactionHahaCount": 420,
  "reactionCareCount": 210,
  "reactionSadCount": 85,
  "reactionWowCount": 320,
  "reactionAngryCount": 69,
  "media": [
    {
      "thumbnail": "https://scontent.xx.fbcdn.net/v/t1.6435-9/thumbnail.jpg",
      "__typename": "Photo",
      "__isMedia": "Photo",
      "accent_color": "FFFFFFFF",
      "photo_product_tags": [],
      "photo_image": {
        "uri": "https://scontent.xx.fbcdn.net/v/t1.6435-9/large.jpg",
        "height": 1080,
        "width": 1080
      },
      "url": "https://www.facebook.com/photo/?fbid=1397878851694949",
      "id": "pfbid02abcDEFghijkLmn"
    }
  ],
  "feedbackId": "ZmVlZGJhY2s6MTM5Nzg3ODg1MTY5NDk0OQ==",
  "topLevelUrl": "https://www.facebook.com/100044185428261/posts/1397878851694949",
  "facebookId": "100044185428261",
  "pageAdLibrary": {
    "id": "100044185428261"
  },
  "inputUrl": "https://www.facebook.com/nytimes/"
}
```

Notes:

- The output contains reaction breakdown fields for Like, Love, Haha, Care, Sad, Wow, and Angry.
- Media entries may include ocrText when Facebook provides accessibility captions.

### FAQ

#### Do I need a Facebook login or cookies?

No. The actor works as a Facebook public posts scraper without login. It discovers required IDs from the live site and fetches timeline data over the same endpoints used by the web experience, with robust proxy support.

#### Can it scrape Facebook groups as well as pages?

Yes. You can pass group slugs like groups/mygroup or full /groups/ URLs. The input is normalized so you can scrape Facebook group posts alongside pages and profiles in a single run.

#### Does it extract comments or only comment counts?

It extracts comments count. The dataset includes comments (total count) but does not include full comment threads or bodies.

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

You can set maxPosts from 1 up to 10,000 per target. The scraper paginates the timeline and stops when it reaches your limit for each page or when no further posts are available.

#### Can I export results to CSV or use the data in Python?

Yes. Results are saved to an Apify dataset, which you can download as JSON, CSV, or Excel. You can also access the dataset via the Apify API and integrate with your Python workflows or automation tools.

#### Does it work without the official Facebook API?

Yes. It’s a Facebook post scraper without API credentials or login. It collects publicly available data from Facebook’s web endpoints and handles pagination automatically.

#### How do date filters work?

Use oldestPostDateUnified (start) and newestPostDate (end) to limit scraping to a target window using absolute or relative values. The scraper sends these as request parameters and also applies a client-side check to ensure results match your range.

#### What proxy setup is recommended?

The actor prefers Apify Residential proxy when available for the highest success rates, falls back to Apify Datacenter, and also supports your custom proxy URLs. No proxy configuration is required for basic runs.

### Closing CTA / Final thoughts

Facebook Posts Scraper is built to extract structured, analysis-ready Facebook post data at scale. With date filters, reaction breakdowns, media metadata, and robust proxy handling, it’s ideal for marketers, developers, analysts, and researchers who need to automate Facebook posts downloader workflows and export Facebook posts to CSV or JSON. Integrate via the Apify API or a Facebook post scraper Python pipeline, and start extracting smarter social insights today.

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Posts Scraper",
        "description": "📘 Facebook Posts Scraper extracts public posts—text, images, links, timestamps, reactions, comments & #️⃣hashtags—at scale. 🔍 Filter by page, keyword or date. 📊 Export CSV/JSON for social listening, competitor analysis & content research. 🚀 Fast, reliable.",
        "version": "0.1",
        "x-build-id": "4SrdnxaWylHtjnjVd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapebase~facebook-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapebase-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/scrapebase~facebook-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapebase-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/scrapebase~facebook-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapebase-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
