# Facebook Comments & Conversation Scraper (`qaseemiqbal/facebook-comments-conversation-scraper`) Actor

Extract public Facebook comments and replies from posts, photos, videos, and reels. Get clean datasets with comment text, author details, timestamps, engagement counts, and thread fields for social listening, research, reporting, and AI workflows.

- **URL**: https://apify.com/qaseemiqbal/facebook-comments-conversation-scraper.md
- **Developed by:** [Muhammad Qaseem Iqbal](https://apify.com/qaseemiqbal) (community)
- **Categories:** Social media, AI
- **Stats:** 2 total users, 0 monthly users, 88.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 comments

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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 Comments & Conversation Scraper

Extract comments from public Facebook posts, photos, videos, and reels. Paste one or more Facebook URLs, choose how many results you want, and get a clean dataset with comment text, author details, timestamps, post information, and conversation fields.

This Actor is useful for social listening, campaign monitoring, content research, community analysis, reporting, and AI workflows that need Facebook comment data in a structured format.

### What This Actor Does

- Scrapes publicly visible Facebook comments from post-like URLs
- Includes replies and nested replies when they are visible and can be loaded
- Lets you choose comment sorting: most relevant, newest, or all/unfiltered
- Filters comments by date
- Saves author name, profile ID, profile URL, and profile picture when visible
- Saves comment IDs, parent comment IDs, root comment IDs, and thread depth
- Removes duplicate comments caused by retries or repeated page loading
- Exports results to Apify Dataset for JSON, CSV, Excel, XML, HTML, and API use
- Saves a run summary with counts, warnings, skipped URLs, and errors
- Can also save a nested thread tree for conversation analysis

### What Data Can You Extract?

| Data | Description |
| --- | --- |
| Post URL | Original input URL and normalized Facebook URL |
| Post details | Post ID, canonical post URL, and visible post text/title where available |
| Comment text | The visible text of each comment or reply |
| Comment links | Comment ID and direct comment URL where Facebook provides them |
| Author details | Public author name, profile ID, profile URL, and profile picture where visible |
| Dates | Normalized comment timestamp when available |
| Engagement counts | Visible likes, reactions, and reply counts where available |
| Thread structure | Parent comment ID, root comment ID, and depth in the conversation |
| Diagnostics | Sort order, extraction method, status, scrape time, and dedupe key |

Some fields can be empty if Facebook does not show that information to the running browser session.

### How To Use It

1. Open the Actor on Apify.
2. Paste one or more public Facebook post, photo, video, or reel URLs.
3. Set the maximum number of results you want.
4. Choose whether to include replies.
5. Choose the comment sorting option.
6. Add a date filter if you only need comments from a specific time period.
7. Click "Start".
8. Download the results from the Dataset tab, or use them through the Apify API.

### Input

The only required input is at least one Facebook URL.

| Setting | What It Means |
| --- | --- |
| `startUrls` | Facebook post, photo, video, or reel URLs to scrape |
| `maxItems` | Maximum total number of comments and replies to save across the whole run |
| `maxCommentsPerPost` | Maximum number of top-level comments to save per Facebook URL |
| `includeReplies` | Turn reply scraping on or off |
| `maxRepliesPerComment` | Maximum number of replies to save for each top-level comment |
| `maxThreadDepth` | `0` for comments only, `1` for replies, `2` for nested replies |
| `sortOrder` | `MOST_RELEVANT`, `RECENT_ACTIVITY`, or `ALL_COMMENTS` |
| `onlyCommentsNewerThan` | Optional lower date filter, such as `2026-06-01` or `7 days` |
| `onlyCommentsOlderThan` | Optional upper date filter, such as `2026-06-10` or `2 months` |
| `outputMode` | Save only flat records, or also save nested thread trees |
| `proxyConfiguration` | Proxy settings for more stable Facebook scraping |

Example input:

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/somepage/posts/example"
    }
  ],
  "maxItems": 1000,
  "maxCommentsPerPost": 500,
  "includeReplies": true,
  "maxRepliesPerComment": 50,
  "maxThreadDepth": 2,
  "sortOrder": "RECENT_ACTIVITY",
  "onlyCommentsNewerThan": "7 days",
  "outputMode": "FLAT_AND_THREADS"
}
````

Date filters accept:

- Calendar dates, for example `2026-06-01`
- ISO timestamps, for example `2026-06-01T12:00:00Z`
- Relative values, for example `1 day`, `2 months`, `3 years`, or `1 hour`

When `onlyCommentsNewerThan` is set, the Actor automatically uses newest-first loading so recent comments are found earlier.

### Output

Each Dataset item represents one comment or reply.

```json
{
  "recordType": "comment",
  "inputUrl": "https://www.facebook.com/somepage/posts/example",
  "facebookUrl": "https://www.facebook.com/somepage/posts/example",
  "canonicalPostUrl": "https://www.facebook.com/somepage/posts/example",
  "postId": "example",
  "postTitle": "Example public post text",
  "commentId": "883254471472572",
  "parentCommentId": null,
  "rootCommentId": "883254471472572",
  "commentUrl": "https://www.facebook.com/somepage/posts/example?comment_id=883254471472572",
  "text": "Example public comment text",
  "date": "2026-06-05T04:06:45.000Z",
  "timestampAccuracy": "exact",
  "profileName": "Example User",
  "profileId": "100000000000000",
  "profileUrl": "https://www.facebook.com/example.user",
  "profilePicture": "https://...",
  "likesCount": 0,
  "reactionsCount": 0,
  "repliesCount": 0,
  "threadingDepth": 0,
  "sortOrder": "RECENT_ACTIVITY",
  "postStatus": "OK",
  "extractionMethod": "embedded-json",
  "dedupeKey": "facebook:example:883254471472572",
  "scrapedAt": "2026-06-12T12:00:00.000Z",
  "runId": "..."
}
```

The Actor also saves helpful files to the default key-value store:

| File | What It Contains |
| --- | --- |
| `run-summary.json` | Saved counts, skipped counts, per-post statuses, warnings, and errors |
| `threads.json` | Optional nested conversation tree when `outputMode` is `FLAT_AND_THREADS` |
| Debug snapshots | Optional HTML and screenshot files for failed pages when enabled |

### Comments, Replies, And Threads

Facebook comments can have replies, and replies can sometimes have another level of nested replies. This Actor stores every visible item as a separate Dataset record so the data is easy to export.

To rebuild conversations later, use:

- `commentId` for the current comment or reply
- `parentCommentId` for the direct parent reply/comment
- `rootCommentId` for the top-level comment that started the thread
- `threadingDepth` to understand whether the item is a comment, reply, or nested reply

Set `outputMode` to `FLAT_AND_THREADS` if you also want a ready-made nested `threads.json` file.

### How Many Comments Can It Scrape?

The number of results depends on what Facebook shows publicly for your URL. A small post may only return a few comments. A large public post can return many more, up to the limits you set.

Results can be lower than the number shown on Facebook because Facebook counters may include private comments, hidden comments, replies, deleted comments, or comments only visible to logged-in users or certain regions. The best way to estimate coverage is to run a small test with your actual URLs.

### Popular Use Cases

- Track audience feedback on public Facebook posts
- Monitor brand, product, or campaign conversations
- Collect comments for sentiment analysis
- Research public reactions to news, creators, events, or communities
- Build dashboards in BI tools or spreadsheets
- Send public comment data into AI and LLM workflows
- Audit high-engagement posts and identify common questions or complaints

### Export And Integrations

You can download results from Apify as JSON, JSONL, CSV, Excel, XML, or HTML. You can also connect the Actor to:

- Apify API
- Apify SDKs for JavaScript and Python
- Webhooks
- Schedules and saved tasks
- Make, Zapier, Google Sheets, Slack, Airbyte, and other Apify integrations
- AI workflows through Apify MCP or API-based automation

For long-running jobs, webhooks are usually better than waiting for a run synchronously. Use run-finished events to process the Dataset after the scrape completes.

### Tips For Better Results

- Use direct public Facebook post, photo, video, or reel URLs.
- Start with a small `maxItems` value to test the URL before running a large scrape.
- Enable `includeReplies` if you want conversation context, not just top-level comments.
- Use `RECENT_ACTIVITY` when recent comments matter most.
- Use date filters when you only need a specific time period.
- Use reliable proxies. Apify Proxy with residential proxies is recommended for Facebook.
- Lower concurrency if you see access restrictions or unstable runs.
- Check `run-summary.json` after each run to understand skipped URLs, warnings, and failures.

### Public Data And Responsible Use

This Actor only extracts information visible to the running browser session. It cannot access private Facebook comments, hidden comments, closed groups, private messages, account-only data, or content behind permissions the session does not have.

You are responsible for how you use scraped data. Make sure your use case follows applicable laws, platform terms, privacy rules, and any internal compliance requirements.

### FAQ

#### Can it scrape private Facebook comments?

No. It only works with comments that are publicly visible to the browser session.

#### Can it scrape replies?

Yes, when replies are visible and Facebook allows them to be loaded. Enable `includeReplies` and set `maxThreadDepth` to `1` or `2`.

#### Why did I get fewer comments than Facebook shows?

Facebook's visible counter may include private, hidden, deleted, restricted, or reply comments. The Actor can only save comments it can actually see and load.

#### Why are some fields empty?

Facebook does not always show every field. For example, profile pictures, profile IDs, timestamps, likes, or reply counts may be missing or hidden for some comments.

#### Can I filter comments by date?

Yes. Use `onlyCommentsNewerThan`, `onlyCommentsOlderThan`, or both. You can enter dates such as `2026-06-01` or relative values such as `7 days`.

#### Which sorting options are available?

The Actor supports `MOST_RELEVANT`, `RECENT_ACTIVITY`, and `ALL_COMMENTS`. Date filtering automatically switches to newest-first loading where needed.

#### Do I need proxies?

Proxies are strongly recommended for Facebook scraping. Apify Proxy with residential proxies usually gives more stable results than datacenter IPs.

#### Can I use the results in another app?

Yes. Results are saved to an Apify Dataset, so you can download them, call them through the API, connect them to webhooks, or send them to automation tools.

### Troubleshooting

| Problem | Likely Cause | What To Try |
| --- | --- | --- |
| No comments returned | The post is private, unavailable, restricted, or has no visible public comments | Test with a clearly public Facebook page post |
| Fewer comments than expected | Facebook counters include comments the Actor cannot see | Enable replies and check `run-summary.json` |
| Replies are missing | Replies are hidden, not loaded, or disabled by input settings | Enable `includeReplies` and increase `maxThreadDepth` |
| Run is slow | Large post, many replies, high limits, or proxy instability | Lower limits, reduce concurrency, or improve proxy quality |
| Access restricted | Facebook limited the browser session, region, or IP | Use high-quality residential proxies and lower concurrency |
| Date filter misses records | Facebook did not load older/newer records, or timestamps are not visible | Use ISO dates and run with newest-first sorting |

# Actor input Schema

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

Facebook post, photo, video, or reel URLs to scrape.

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

Maximum number of total comment/reply records to save across all input URLs.

## `maxCommentsPerPost` (type: `integer`):

Maximum top-level comments to extract from each Facebook URL.

## `includeReplies` (type: `boolean`):

Expand and save replies to top-level comments.

## `maxRepliesPerComment` (type: `integer`):

Maximum replies to extract for each top-level comment.

## `maxThreadDepth` (type: `integer`):

0 = top-level comments only, 1 = comments and replies, 2 = comments, replies, and nested replies.

## `sortOrder` (type: `string`):

Order in which comments are loaded. Date filtering automatically uses newest-first sorting.

## `onlyCommentsNewerThan` (type: `string`):

Optional date filter. Use YYYY-MM-DD, ISO timestamp, or relative values like '1 day', '2 months', '3 years', or '1 hour'.

## `onlyCommentsOlderThan` (type: `string`):

Optional upper date bound. Use YYYY-MM-DD, ISO timestamp, or a relative date.

## `includePostMetadata` (type: `boolean`):

Include post title/text, post ID, canonical URL, and source URL fields where visible.

## `includeAuthorProfile` (type: `boolean`):

Include public author name, profile ID, and profile URL where visible.

## `includeProfilePicture` (type: `boolean`):

Include public profile picture URL where visible.

## `includeAdLibraryStatus` (type: `boolean`):

Attempt to include page Ad Library activity status when available.

## `outputMode` (type: `string`):

Save flat dataset only, or also save nested thread trees to the key-value store.

## `deduplicate` (type: `boolean`):

Avoid saving duplicate comment records caused by repeated pagination or retries.

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

Select proxies for stable scraping. Apify Proxy with residential proxies is recommended for Facebook.

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

Maximum number of browser pages processed in parallel.

## `maxRequestsPerMinute` (type: `integer`):

Rate limit for crawler requests.

## `maxRequestRetries` (type: `integer`):

Maximum retries for failed requests before marking the URL as failed.

## `debugMode` (type: `boolean`):

Enable verbose logs and extra diagnostics.

## `saveHtmlSnapshots` (type: `boolean`):

Save HTML and screenshots for failed pages to the key-value store.

## `failOnPostError` (type: `boolean`):

If enabled, the Actor fails when any input URL fails. Otherwise, failed URLs are reported in the summary.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/humansofnewyork/posts/example"
    }
  ],
  "maxItems": 1000,
  "maxCommentsPerPost": 500,
  "includeReplies": true,
  "maxRepliesPerComment": 50,
  "maxThreadDepth": 2,
  "sortOrder": "MOST_RELEVANT",
  "includePostMetadata": true,
  "includeAuthorProfile": true,
  "includeProfilePicture": true,
  "includeAdLibraryStatus": false,
  "outputMode": "FLAT",
  "deduplicate": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 3,
  "maxRequestsPerMinute": 60,
  "maxRequestRetries": 3,
  "debugMode": false,
  "saveHtmlSnapshots": false,
  "failOnPostError": false
}
```

# Actor output Schema

## `comments` (type: `string`):

No description

## `threadTree` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

## `debugArtifacts` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.facebook.com/humansofnewyork/posts/example"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.facebook.com/humansofnewyork/posts/example" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.facebook.com/humansofnewyork/posts/example"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call qaseemiqbal/facebook-comments-conversation-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Comments & Conversation Scraper",
        "description": "Extract public Facebook comments and replies from posts, photos, videos, and reels. Get clean datasets with comment text, author details, timestamps, engagement counts, and thread fields for social listening, research, reporting, and AI workflows.",
        "version": "0.1",
        "x-build-id": "ixnDMYvTok1HMs8No"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/qaseemiqbal~facebook-comments-conversation-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-qaseemiqbal-facebook-comments-conversation-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/qaseemiqbal~facebook-comments-conversation-scraper/runs": {
            "post": {
                "operationId": "runs-sync-qaseemiqbal-facebook-comments-conversation-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/qaseemiqbal~facebook-comments-conversation-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-qaseemiqbal-facebook-comments-conversation-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 post URLs",
                        "minItems": 1,
                        "type": "array",
                        "description": "Facebook post, photo, video, or reel URLs to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "additionalProperties": true,
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL",
                                    "description": "Facebook post, photo, video, or reel URL.",
                                    "pattern": "^(https?://)?((www|m|mobile|web)\\.)?(facebook\\.com|fb\\.watch)/.+"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of total comment/reply records to save across all input URLs.",
                        "default": 1000
                    },
                    "maxCommentsPerPost": {
                        "title": "Maximum top-level comments per post",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum top-level comments to extract from each Facebook URL.",
                        "default": 500
                    },
                    "includeReplies": {
                        "title": "Include replies",
                        "type": "boolean",
                        "description": "Expand and save replies to top-level comments.",
                        "default": true
                    },
                    "maxRepliesPerComment": {
                        "title": "Maximum replies per comment",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum replies to extract for each top-level comment.",
                        "default": 50
                    },
                    "maxThreadDepth": {
                        "title": "Maximum thread depth",
                        "minimum": 0,
                        "maximum": 2,
                        "type": "integer",
                        "description": "0 = top-level comments only, 1 = comments and replies, 2 = comments, replies, and nested replies.",
                        "default": 2
                    },
                    "sortOrder": {
                        "title": "Comment sorting",
                        "enum": [
                            "MOST_RELEVANT",
                            "RECENT_ACTIVITY",
                            "ALL_COMMENTS"
                        ],
                        "type": "string",
                        "description": "Order in which comments are loaded. Date filtering automatically uses newest-first sorting.",
                        "default": "MOST_RELEVANT"
                    },
                    "onlyCommentsNewerThan": {
                        "title": "Only comments newer than",
                        "pattern": "^(\\d{4}-\\d{2}-\\d{2}|\\d{4}-\\d{2}-\\d{2}T.*Z?|\\d+\\s*(minute|minutes|hour|hours|day|days|week|weeks|month|months|year|years))$",
                        "type": "string",
                        "description": "Optional date filter. Use YYYY-MM-DD, ISO timestamp, or relative values like '1 day', '2 months', '3 years', or '1 hour'."
                    },
                    "onlyCommentsOlderThan": {
                        "title": "Only comments older than",
                        "pattern": "^(\\d{4}-\\d{2}-\\d{2}|\\d{4}-\\d{2}-\\d{2}T.*Z?|\\d+\\s*(minute|minutes|hour|hours|day|days|week|weeks|month|months|year|years))$",
                        "type": "string",
                        "description": "Optional upper date bound. Use YYYY-MM-DD, ISO timestamp, or a relative date."
                    },
                    "includePostMetadata": {
                        "title": "Include post metadata",
                        "type": "boolean",
                        "description": "Include post title/text, post ID, canonical URL, and source URL fields where visible.",
                        "default": true
                    },
                    "includeAuthorProfile": {
                        "title": "Include author profile metadata",
                        "type": "boolean",
                        "description": "Include public author name, profile ID, and profile URL where visible.",
                        "default": true
                    },
                    "includeProfilePicture": {
                        "title": "Include profile picture URL",
                        "type": "boolean",
                        "description": "Include public profile picture URL where visible.",
                        "default": true
                    },
                    "includeAdLibraryStatus": {
                        "title": "Include page Ad Library status",
                        "type": "boolean",
                        "description": "Attempt to include page Ad Library activity status when available.",
                        "default": false
                    },
                    "outputMode": {
                        "title": "Output mode",
                        "enum": [
                            "FLAT",
                            "FLAT_AND_THREADS"
                        ],
                        "type": "string",
                        "description": "Save flat dataset only, or also save nested thread trees to the key-value store.",
                        "default": "FLAT"
                    },
                    "deduplicate": {
                        "title": "Deduplicate comments",
                        "type": "boolean",
                        "description": "Avoid saving duplicate comment records caused by repeated pagination or retries.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies for stable scraping. Apify Proxy with residential proxies is recommended for Facebook."
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of browser pages processed in parallel.",
                        "default": 3
                    },
                    "maxRequestsPerMinute": {
                        "title": "Maximum requests per minute",
                        "minimum": 1,
                        "maximum": 600,
                        "type": "integer",
                        "description": "Rate limit for crawler requests.",
                        "default": 60
                    },
                    "maxRequestRetries": {
                        "title": "Maximum request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum retries for failed requests before marking the URL as failed.",
                        "default": 3
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Enable verbose logs and extra diagnostics.",
                        "default": false
                    },
                    "saveHtmlSnapshots": {
                        "title": "Save failed page snapshots",
                        "type": "boolean",
                        "description": "Save HTML and screenshots for failed pages to the key-value store.",
                        "default": false
                    },
                    "failOnPostError": {
                        "title": "Fail run on post error",
                        "type": "boolean",
                        "description": "If enabled, the Actor fails when any input URL fails. Otherwise, failed URLs are reported in the summary.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
