# Facebook Comments Scraper - Replies & Reactions (`chronometrica/facebook-comments-scraper`) Actor

Scrape public Facebook comments and replies from posts, Reels, photos, Watch URLs, and supported share links. Get text, authors, dates, reaction breakdowns, profile pictures, attachments, and threads. Sort and filter results, set exact maximums or remove the numeric cap—without login or cookies.

- **URL**: https://apify.com/chronometrica/facebook-comments-scraper.md
- **Developed by:** [Chronometrica](https://apify.com/chronometrica) (community)
- **Categories:** Social media, Agents, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 facebook comment results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

### 💬 What does Facebook Comments Scraper do?

Paste direct public Facebook post, Reel, video, Watch, photo, permalink, or
supported share links. Get clean public comment and reply rows with text,
authors, dates, reaction breakdowns, profile pictures, attachments, and thread
links.

Use it for audience research, brand monitoring, customer feedback, creator
research, social listening, comment analysis, spreadsheets, and automated data
pipelines. Each saved result is one real public comment or reply, not a post
summary.

The Actor uses public, logged-out Facebook pages. It does not require a
Facebook login, API key, cookies, or copied browser session from you. Invalid,
duplicate, unsupported, unavailable, and confirmed zero-comment inputs do not
create paid result rows.

With Facebook Comments Scraper, you can:

- 💬 Collect public comments from posts, Reels, videos, Watch pages, photos,
  permalinks, `fb.watch`, and supported share links.
- 🧵 Rebuild reply threads with saved parent and root comment IDs.
- ❤️ Analyze total reactions and Like, Love, Care, Haha, Wow, Sad, and Angry
  breakdowns when Facebook exposes them.
- ↕️ Choose All comments, Newest, or Most relevant order.
- 📅 Keep comments inside inclusive start and end dates.
- 🎯 Set an exact per-content result limit, or remove the numeric cap.
- 🧹 Receive clean unique rows after equivalent URLs and repeated comment IDs
  are removed.
- 📦 Export JSON, JSONL, CSV, Excel, XML, RSS, or HTML, or use the Apify API,
  SDKs, webhooks, schedules, and integrations.
- 💸 Pay only for public comments and replies saved to the dataset.

### ✨ Why use this Actor?

- **Clean and useful:** one flat row for each public comment or reply.
- **Strict identity:** every row stays tied to the requested Facebook content.
- **Connected threads:** replies are saved only with their saved parent and
  root comment.
- **Exact controls:** choose order, dates, replies, and the maximum saved rows
  for each content item.
- **Rich public context:** get reaction types, profile pictures, attachments,
  and parent content details when Facebook exposes them.
- **Clear billing:** empty and failed inputs do not become charged fake rows.
- **Honest limits:** an uncapped run can still stop at source end, charge limit,
  timeout, or failure.

In a fixed production-style test, the Actor saved 500 unique comment and reply
rows from one busy public post. All 500 rows had the requested
content ID. All 155 replies had their saved parent and root comment. Live speed
and public comment availability can change.

### 📦 What data do I get?

Each dataset row represents one real public Facebook comment or reply.

| Data group          | Main fields                                                                             |
| ------------------- | --------------------------------------------------------------------------------------- |
| 🔗 Content identity | `inputUrl`, `postUrl`, `contentId`, `contentType`                                       |
| 💬 Comment content  | `commentId`, `commentUrl`, `text`, `publishedAt`, `attachments`                         |
| 🧵 Thread links     | `parentCommentId`, `rootCommentId`, `isReply`                                           |
| 👤 Public author    | `authorId`, `authorName`, `authorUrl`, `authorProfilePictureUrl`                        |
| ❤️ Public signals   | `reactionsCount`, `reactionCounts`, `replyCount`                                        |
| 📝 Parent content   | Public post text, author, and publish time when exact target-bound values are available |
| 🕐 Collection time  | `scrapedAt`                                                                             |

Public values that Facebook does not expose stay `null`. They are not guessed
and they are not replaced with fake zeroes.

### ⚙️ Can I use this Actor through an API?

Yes. Run Facebook Comments Scraper manually in Apify Console or use it through:

- 🔌 Apify API
- 🐍 Python SDK
- 🟢 JavaScript SDK
- 🪝 Webhooks
- ⏰ Scheduled runs
- 🧩 Apify integrations

#### API example

Keep your Apify token in an environment variable or secret store.

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/chronometrica~facebook-comments-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": ["https://www.facebook.com/reel/1733966934399341"],
    "commentSortMode": "all",
    "maxResultsPerPost": 25,
    "collectAllAvailable": false,
    "includeReplies": false
  }'
````

### 🎯 Why scrape Facebook comments?

| Use case                  | How comment data helps                                      |
| ------------------------- | ----------------------------------------------------------- |
| 🔍 Audience research      | Find common questions, opinions, needs, and language.       |
| 📣 Brand monitoring       | Track public feedback around products and campaigns.        |
| 🧑‍🎨 Creator research       | Study public audience response and reply threads.           |
| 💡 Content planning       | Find ideas, objections, and recurring questions.            |
| 🤖 Sentiment and NLP      | Feed clean comment text into your own analysis workflow.    |
| 🧱 Data pipeline building | Load stable comment and reply rows into databases and apps. |

The Actor collects source data. It does not add sentiment labels or guess a
person's intent.

### 💵 Pricing: saved comments and replies only

Facebook Comments Scraper uses pay-per-result pricing. One result means one
unique public comment or reply saved to the default dataset. Platform usage is
included.

| Apify plan | Price per 1,000 saved rows |
| ---------- | -------------------------: |
| Free       |                      $2.15 |
| Starter    |                      $1.70 |
| Scale      |                      $1.45 |
| Business   |                      $1.20 |

There is no paid row for an invalid or unsupported URL, an unavailable target,
an explicit zero-comment target, a duplicate input, a duplicate comment, or a
source-deleted placeholder.

Use `maxResultsPerPost`, `collectAllAvailable`, date filters, and
`includeReplies` to control result volume. Replies are separate result rows and
count toward the same per-content limit.

### 🚀 How do I use Facebook Comments Scraper?

1. Open **Facebook Comments Scraper** in Apify Console.
2. Add one or more known public Facebook content URLs.
3. Choose the maximum total comment and reply rows for each content item.
4. Turn on replies only when you need them.
5. Click **Start**.
6. Open **Output** to inspect the dataset and run summary.
7. Download the data or send it to another tool through an integration.

### ⬇️ Input

Here is the exact first-run example used for the release smoke:

```json
{
  "startUrls": ["https://www.facebook.com/reel/1733966934399341"],
  "commentSortMode": "all",
  "maxResultsPerPost": 25,
  "collectAllAvailable": false,
  "includeReplies": false
}
```

#### 🔗 Supported content inputs

- Facebook post URLs with numeric or `pfbid` keys
- Reel URLs
- Watch URLs, owner video URLs, and `video.php` URLs
- Modern, legacy, and owner photo URLs
- `story.php` and `permalink.php` post URLs
- `fb.watch` short links
- Typed `/share/p/`, `/share/v/`, and `/share/r/` links
- `www`, `m`, `mbasic`, and `mobile` Facebook host variants

Equivalent inputs that resolve to the same content or comment rows are
collected once in a run.

#### 🎛️ Settings

| Setting               | What it controls                                                                                                                             |
| --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| `startUrls`           | Add 1–100 public Facebook post, Reel, video, Watch, photo, permalink, or supported share URLs.                                               |
| `maxResultsPerPost`   | Set the maximum comment and reply rows for each URL. Use 1–10,000. Default: 500.                                                             |
| `collectAllAvailable` | Remove the result limit. The run still stops at source end, charge limit, timeout, or failure. Off by default and may greatly increase cost. |
| `includeReplies`      | Save replies as separate paid rows. They count toward the maximum above. Off by default.                                                     |
| `commentSortMode`     | Choose `all`, `newest`, or `most_relevant`. This changes order, not the result limit. Default: `all`.                                        |
| `commentsFrom`        | Pick the first date to keep. Leave empty for no start date. API users may also send an ISO or relative date.                                 |
| `commentsUntil`       | Pick the last date to keep. Leave empty for no end date. Replies need an in-range saved parent.                                              |

### ⬆️ Output sample

```json
{
  "inputUrl": "https://www.facebook.com/reel/1733966934399341",
  "postUrl": "https://www.facebook.com/reel/1733966934399341/",
  "contentId": "1733966934399341",
  "contentType": "reel",
  "commentId": "1234567890123456",
  "commentUrl": "https://www.facebook.com/reel/1733966934399341/?comment_id=1234567890123456",
  "parentCommentId": null,
  "rootCommentId": "1234567890123456",
  "isReply": false,
  "text": "Example public comment",
  "publishedAt": null,
  "attachments": [
    {
      "type": "Sticker",
      "url": null,
      "thumbnailUrl": "https://scontent.example/sticker.png",
      "width": 240,
      "height": 240
    }
  ],
  "reactionsCount": 12,
  "reactionCounts": {
    "like": 8,
    "love": 2,
    "care": 1,
    "haha": 1,
    "wow": null,
    "sad": null,
    "angry": null
  },
  "replyCount": 3,
  "authorId": "100012345678901",
  "authorName": "Example Author",
  "authorUrl": "https://www.facebook.com/example.author",
  "authorProfilePictureUrl": "https://scontent.example/profile.jpg",
  "postTitle": null,
  "postDescription": null,
  "postPublishedAt": null,
  "postAuthorId": null,
  "postAuthorName": null,
  "postAuthorUrl": null,
  "scrapedAt": "2026-07-13T00:00:00.000Z"
}
```

`reactionCounts` uses the fixed keys `like`, `love`, `care`, `haha`, `wow`,
`sad`, and `angry`. A key is `null` when Facebook does not expose that exact
type count. `attachments` contains media bound to that exact comment. Every
attachment has `type`, `url`, `thumbnailUrl`, `width`, and `height`; individual
values can be `null`. Facebook media and profile-picture URLs can expire.
Download needed media promptly and only when you have the right to store it.

#### 🧵 Comment and reply relationships

Top-level comments have `isReply: false` and `parentCommentId: null`.

Replies have `isReply: true`. Their `parentCommentId` points to a saved parent
row. Their `rootCommentId` points to the saved top-level root of the thread.
The Actor does not save a reply when it cannot prove and save its parent.

#### 📊 Run summary

The `OUTPUT` record includes:

- the chosen comment sort mode;
- inputs received and unique content items planned;
- duplicate inputs skipped;
- content items attempted and items that produced rows;
- comments and replies saved;
- duplicate results, date-filtered results, and results skipped because no
  exact date was available;
- input status and stop-reason counts;
- safe details for inputs that did not produce rows.

Input-level failures stay in the run summary because they do not create paid
dataset rows.

### 🚦 Input outcomes

The dataset contains real comments and replies only. Invalid, unsupported,
unavailable, zero-comment, and duplicate inputs are reported in `OUTPUT`.
They do not become fake or paid dataset rows.

### 🔒 Public-source boundary

Facebook Comments Scraper uses logged-out public Facebook data only.

It does not use:

- a Facebook account or API key supplied by you;
- user login cookies or copied sessions;
- private posts, private groups, or friends-only content;
- Facebook Stories, profiles, Pages, feeds, or search as collection inputs;
- challenge solving or access-control bypasses;
- active Live broadcasts or collection pages.

### ⚠️ Limits and interpretation

- Facebook can delete, hide, reorder, or limit comments at any time.
- Public comment availability can differ by region and logged-out viewer state.
- Exact publish timestamps, author links, reactions, and reply totals are not
  always public. Missing values stay `null`.
- Reaction-type counts, profile pictures, and comment attachments are included
  only when Facebook exposes them on the exact public comment. Media URLs can
  expire.
- A requested limit is a maximum, not a guarantee. Public rows can run out
  first.
- Replies are saved only when their parent row is also saved.
- Share and short links must resolve to one matching supported content type.
- Albums, profiles, feeds, searches, groups, Stories, and collection pages do
  not identify one supported comment owner.

### ❓ FAQ

#### Does this Actor need a Facebook login, cookies, or API key?

No. It uses logged-out public Facebook data.

#### Why did I receive fewer rows than requested?

The public comment list may have ended, replies may have been turned off, rows
may have been duplicates, or Facebook may not have exposed a verified public
comment list. Check `OUTPUT` for the status and stop reason.

#### Will it work with Reels and shared links?

The Actor accepts direct public Reel URLs plus supported `fb.watch`, `/share/p/`,
`/share/v/`, and `/share/r/` links. It resolves a supported wrapper to one
matching content item before collecting comments. Unsupported or ambiguous
links are explained in `OUTPUT` and do not create paid rows.

#### Will I get replies?

Turn on `includeReplies`. Each saved reply has `parentCommentId` and
`rootCommentId`, and is saved only when its parent is also saved. Replies count
toward the same per-content result limit.

#### Can I remove the row limit?

Yes. Turn on `collectAllAvailable` to ignore the numeric limit. Collection then
continues until the public source ends, the buyer charge limit is reached, the
run times out, or the run fails.

#### What do I pay for?

You pay for unique public comments and replies saved to the default dataset.
Invalid, unsupported, unavailable, duplicate, source-deleted, and confirmed
zero-comment inputs do not create paid result rows.

#### Can I paste a Facebook Page or Group URL?

No. This Actor collects comments from direct supported public content URLs. It
does not discover every post from a Page, Group, profile, feed, or search page.

#### What happens when a post has no public comments?

The input outcome appears in `OUTPUT`. It does not create a fake dataset row or
a paid result.

#### How are duplicates removed?

Each Facebook content item is collected once per run. Each Facebook comment ID
is saved once.

#### Does the Actor search Facebook for posts?

No. It collects comments from known public content URLs that you provide.

### 🛟 Support

For support, include the Apify run ID, one input URL, the expected public
content, the observed dataset or `OUTPUT` result, and whether the issue affects
one row or the whole run. Do not send Facebook login details or browser
sessions.

### 🔗 Related social media scrapers

Combine this Actor with our other social media scrapers for discovery,
performance tracking, comment research, and transcript collection.

#### Facebook

- [Facebook Metrics Scraper](https://apify.com/chronometrica/facebook-metrics-scraper)
  — collect public post, Reel, video, and profile/page metrics.

#### Instagram

- [Instagram Metrics Scraper](https://apify.com/chronometrica/instagram-metrics-scraper)
  — collect public post, Reel, carousel, profile, and collaboration metrics.
- [Instagram Comments Scraper](https://apify.com/chronometrica/instagram-comments-scraper)
  — collect public comments, authors, dates, likes, and reply counts from posts
  and Reels.

#### TikTok

- [TikTok Search Scraper](https://apify.com/chronometrica/tiktok-search-scraper)
  — find public TikTok videos, creators, and metrics by keyword.
- [TikTok Metrics Scraper](https://apify.com/chronometrica/tiktok-metrics-scraper)
  — collect public video, profile, engagement, hashtag, and music data.
- [TikTok Comments Scraper](https://apify.com/chronometrica/tiktok-comments-scraper)
  — collect public comments, replies, authors, likes, and thread links.
- [TikTok Transcript Scraper](https://apify.com/chronometrica/tiktok-transcript-scraper)
  — extract public caption text and timestamped segments from TikTok videos.

#### YouTube

- [YouTube Search Scraper](https://apify.com/chronometrica/youtube-search-scraper)
  — find public videos, Shorts, channels, and metrics by keyword.
- [YouTube Metrics Scraper](https://apify.com/chronometrica/youtube-metrics-scraper)
  — collect public video, Short, channel, and engagement metrics.
- [YouTube Comments Scraper](https://apify.com/chronometrica/youtube-comments-scraper)
  — collect public comments, replies, authors, likes, pins, and creator hearts.
- [YouTube Transcript Scraper](https://apify.com/chronometrica/youtube-transcript-scraper)
  — extract public captions as clean text, timestamps, SRT, VTT, or LLM-ready
  output.

# Actor input Schema

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

Paste 1–100 post, Reel, video, or photo links. Supported short and share links work too. Page, Group, profile, Story, and private links do not.

## `maxResultsPerPost` (type: `integer`):

The most comments and replies to save for each URL. Choose 1–10,000. Default: 500. For example, 25 URLs at 500 each can save up to 12,500 paid rows.

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

Save replies as separate paid rows. Replies count toward Maximum results per URL.

## `commentSortMode` (type: `string`):

Choose the order Facebook uses. This does not change the result limit.

## `commentsFrom` (type: `string`):

Only save comments on or after this date. Leave empty for no start date. Comments without a public date are skipped when a date is set.

## `commentsUntil` (type: `string`):

Only save comments on or before this date. Leave empty for no end date. Comments without a public date are skipped when a date is set.

## `collectAllAvailable` (type: `boolean`):

Ignore the maximum above. This may cost much more. The run still stops when the public source ends, the charge limit is reached, time runs out, or the source fails.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.facebook.com/reel/1733966934399341"
  ],
  "maxResultsPerPost": 500,
  "includeReplies": false,
  "commentSortMode": "all",
  "collectAllAvailable": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `output` (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": [
        "https://www.facebook.com/reel/1733966934399341"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("chronometrica/facebook-comments-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/reel/1733966934399341"] }

# Run the Actor and wait for it to finish
run = client.actor("chronometrica/facebook-comments-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/reel/1733966934399341"
  ]
}' |
apify call chronometrica/facebook-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Comments Scraper - Replies & Reactions",
        "description": "Scrape public Facebook comments and replies from posts, Reels, photos, Watch URLs, and supported share links. Get text, authors, dates, reaction breakdowns, profile pictures, attachments, and threads. Sort and filter results, set exact maximums or remove the numeric cap—without login or cookies.",
        "version": "2.0",
        "x-build-id": "2wiS4auy3NcIXppv9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/chronometrica~facebook-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-chronometrica-facebook-comments-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/chronometrica~facebook-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-chronometrica-facebook-comments-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/chronometrica~facebook-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-chronometrica-facebook-comments-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 URLs",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Paste 1–100 post, Reel, video, or photo links. Supported short and share links work too. Page, Group, profile, Story, and private links do not.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxResultsPerPost": {
                        "title": "Maximum results per URL",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "The most comments and replies to save for each URL. Choose 1–10,000. Default: 500. For example, 25 URLs at 500 each can save up to 12,500 paid rows.",
                        "default": 500
                    },
                    "includeReplies": {
                        "title": "Include replies",
                        "type": "boolean",
                        "description": "Save replies as separate paid rows. Replies count toward Maximum results per URL.",
                        "default": false
                    },
                    "commentSortMode": {
                        "title": "Comment order",
                        "enum": [
                            "all",
                            "newest",
                            "most_relevant"
                        ],
                        "type": "string",
                        "description": "Choose the order Facebook uses. This does not change the result limit.",
                        "default": "all"
                    },
                    "commentsFrom": {
                        "title": "From date",
                        "type": "string",
                        "description": "Only save comments on or after this date. Leave empty for no start date. Comments without a public date are skipped when a date is set."
                    },
                    "commentsUntil": {
                        "title": "To date",
                        "type": "string",
                        "description": "Only save comments on or before this date. Leave empty for no end date. Comments without a public date are skipped when a date is set."
                    },
                    "collectAllAvailable": {
                        "title": "Remove the result limit",
                        "type": "boolean",
                        "description": "Ignore the maximum above. This may cost much more. The run still stops when the public source ends, the charge limit is reached, time runs out, or the source fails.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
