# Facebook Comments \[$1.5💰] Scraper (`memo23/facebook-comments-scraper`) Actor

💰 $1.5 per 1,000 results – No limits, no quotas, unlimited extraction. Extracts Facebook comments with profile data (name, ID, avatar, URL), comment metadata (text, date, likes, replies), post context (title, URL), and threading info for posts, reels, photos, and group content.

- **URL**: https://apify.com/memo23/facebook-comments-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 42 total users, 7 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.49 / 1,000 results

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 Scraper

### ⚙️ How it works

<p align="center">
  <img src="https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-facebook-comments.png" alt="How the Facebook Comments Scraper works" width="900" />
</p>

**Scrape all public comments — and nested replies — from any Facebook post, Reel, Watch video, or photo.** Paste a URL, get one clean JSON row per comment: author, text, timestamp, like count, permalink, and full reply threading. Pure HTTP via Comet/GraphQL pagination — **no browser farm, no login, no cookies required.**

| Paste this | Get back |
|---|---|
| `facebook.com/{page}/posts/{id}` (page post) | All comments on the post |
| `facebook.com/reel/123…` (Reel) | All comments on the Reel |
| `facebook.com/watch?v=123…` (Watch video) | All comments on the video |
| `facebook.com/photo?fbid=123…` (photo / album) | All comments on the photo story |
| `facebook.com/groups/…/posts/123…` (group post) | All comments on the group post |
| `facebook.com/share/p/…` (share link) | Resolves to the story, then all comments |
| `…` with `includeNestedComments: true` | **Each reply as its own row**, with parent linkage |

> Pure HTTP. No headless browser, no third-party CAPTCHA service. One stable output schema across every URL type.

---

### ✨ Why use this scraper?

- 💬 **Full comment history, not just the first page.** Walks Facebook's own GraphQL comment pagination until your `maxItems` cap — so you get the whole thread, not the 10 comments visible on first load.
- 🧵 **Nested replies as first-class rows.** Toggle `includeNestedComments` to materialize every reply with `parentComment`, `parentReply`, `replyToCommentId`, and `threadingDepth` (1 = reply, 2 = reply-to-reply).
- 🔀 **One schema for every surface.** Posts, Reels, Watch, photos, group posts, share links — identical field set. Store once, query everything.
- 🎯 **Sort-mode control.** `ALL`, `NEWEST`, or `MOST_RELEVANT` — mapped to Facebook's own Comet intents so ordering matches the UI.
- ⚡ **No browser overhead.** Loads the desktop story page, extracts Comet tokens, calls the comment API directly. Fast and cheap compared to a headless-browser scraper.
- 💰 **Just $0.50 / 1,000 comments.** Pay only for the rows you keep. No subscription, no monthly minimum.

---

### 🎯 Use cases

| Audience | What they do with it |
|---|---|
| **Social listening / brand teams** | Track sentiment + complaints under brand posts and competitor pages |
| **Moderation pipelines** | Pull comment streams into a toxicity / spam classifier |
| **Researchers & data teams** | Build labelled comment datasets for NLP / discourse analysis |
| **Agencies & marketers** | Measure engagement quality (not just counts) on campaign posts |
| **Creators** | Export comment threads from Reels / Watch for community analysis |

---

### 📥 Supported inputs

The actor loads each URL as a desktop story page, extracts Comet tokens + the story `feedback` target, then runs the same GraphQL comment pagination for every type below. **Public** content + a **working residential proxy** are required (block/login pages fail for any format).

| Content type | Example URL |
|---|---|
| Page posts | `https://www.facebook.com/humansofnewyork/posts/pfbid0Bb…` |
| Numeric page posts | `https://www.facebook.com/584256070497766/posts/890521929871177` |
| Reels | `https://www.facebook.com/reel/813381761171953` |
| Watch videos | `https://www.facebook.com/watch?v=1312736054237897` |
| Photos | `https://www.facebook.com/photo?fbid=1465799148444403` |
| Photo albums | `https://www.facebook.com/photo/?fbid=123&set=a.456` |
| Photo (legacy path) | `https://www.facebook.com/photo.php?fbid=1423151982709120` |
| Group posts | `https://www.facebook.com/groups/183774529022936/posts/123…` |
| Group posts (permalink) | `https://www.facebook.com/groups/…/permalink/2090871251646578/` |
| Permalink posts | `https://www.facebook.com/permalink.php?story_fbid=123` |
| Share links | `https://www.facebook.com/share/p/1CfaPmdZLU` |

`watch?v=…` and `watch/?v=…` are both accepted. For **pfbid**, **group**, **`permalink.php`**, and **share** URLs, the numeric story id is resolved from the loaded page HTML when the URL isn't already in `/{pageId}/posts/{postId}` shape.

**Not supported:** private/friends-only content, login-walled posts, Stories (24h), Marketplace listings, and anything requiring authentication.

---

1. **Load the story page.** Fetch the desktop HTML for each input URL through a residential proxy.
2. **Extract Comet tokens.** Parse the page for the GraphQL `doc_id`, the story `feedback` id, and the request tokens Facebook's own front-end uses.
3. **Paginate comments.** Call `CommentsListComponentsPaginationQuery` with your `commentsMode` intent, walking cursor pages until `maxItems` is reached or the thread ends.
4. **Expand replies (optional).** When `includeNestedComments` is on, fan each top-level comment out into its reply thread and emit each reply as its own row with parent linkage.
5. **Emit flat rows.** One JSON object per comment to your Apify dataset — export as JSON, CSV, or Excel.

---

### 🔧 Input configuration

| Field | Type | Default | Notes |
|---|---|---|---|
| `startUrls` | array | — *(required)* | `{ "url": "…" }` objects. Each URL = one story to scrape comments for. |
| `maxItems` | integer | `60` | Max comment rows **per start URL** (not global). |
| `commentsMode` | string | `ALL` | `ALL` \| `NEWEST` \| `MOST_RELEVANT` — Facebook's comment sort/filter intent. |
| `includeNestedComments` | boolean | `false` | When `true`, emits reply rows with parent linkage. `false` = top-level only (faster). |
| `maxConcurrency` | integer | `2` | Parallel requests. Keep low (1–3) for Facebook. |
| `minConcurrency` | integer | `1` | Floor for the autoscaled pool. |
| `maxRequestRetries` | integer | `3` | Retries per failed request before giving up. |
| `proxy` | object | Apify Residential | Residential strongly recommended — datacenter IPs are usually blocked. |

#### Example input

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/humansofnewyork/posts/pfbid0BbKbkisExKGSKuhee9a7i86RwRuMKFC8NSkKStB7CsM3uXJuAAfZLrkcJMXxhH4Yl" },
    { "url": "https://www.facebook.com/reel/4364570517119853" },
    { "url": "https://www.facebook.com/watch?v=1312736054237897" },
    { "url": "https://www.facebook.com/photo?fbid=1485098743181110" }
  ],
  "maxItems": 60,
  "commentsMode": "ALL",
  "includeNestedComments": true,
  "maxConcurrency": 2,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

***

### 📊 Output overview

One **flat JSON object per comment** (and one per reply when nested mode is on). The same field set is used for **every** supported URL type — only values differ (e.g. `commentUrl` shape, or `facebookId` being a story id vs a photo `fbid`). Optional fields (`likesCount`, `profileUrl`, `parentComment`, …) appear only when Facebook's GraphQL payload includes them.

#### Sample comment row

```jsonc
{
  "facebookUrl": "https://www.facebook.com/photo/?fbid=1489500156068574&set=a.800788574939739",
  "commentUrl": "https://www.facebook.com/photo/?fbid=1489500156068574&set=a.800788574939739&comment_id=930672569337014",
  "commentId": "930672569337014",
  "id": "Y29tbWVudDoxNDg5NTAwMzYyNzM1MjIwXzkzMDY3MjU2OTMzNzAxNA==",
  "text": "Watching a match without a ticket is not a crime. No laws cover it...",
  "date": "2026-03-13T20:25:06.000Z",
  "profileId": "pfbid02GSbxMEz86kbVK11uFfAzmTwENwvsVpGiAQqvMKhdcEBh8ifMRokRhEEtDsLLUQqHl",
  "profileName": "Rupesh R. S.",
  "profileUrl": "https://www.facebook.com/rupesh.r.shambharkar",
  "profilePicture": "https://scontent.fptp3-1.fna.fbcdn.net/…",
  "likesCount": "6",
  "commentsCount": 3,
  "threadingDepth": 0,
  "comments": [],
  "facebookId": "1489500362735220",
  "feedbackId": "ZmVlZGJhY2s6MTQ4OTUwMDM2MjczNTIyMF85MzA2NzI1NjkzMzcwMTQ=",
  "postTitle": "",
  "pageAdLibrary": { "is_business_page_active": false, "id": "0" },
  "inputUrl": "https://www.facebook.com/photo/?fbid=1489500156068574&set=a.800788574939739"
}
```

Reply rows add `replyToCommentId`, `parentComment` (`{ id, author }`), `parentReply`, and `threadingDepth: 1|2`.

#### Key output fields

| Group | Fields |
|---|---|
| **Comment body** | `text`, `date` (ISO 8601 UTC), `commentId` (legacy id), `id` (GraphQL relay id) |
| **Links** | `commentUrl` (direct permalink), `facebookUrl` (story permalink), `inputUrl` (your exact input) |
| **Author** | `profileName`, `profileId` (`pfbid…`/numeric), `profileUrl`, `profilePicture` |
| **Engagement** | `likesCount` (`"6"`, `"1.3K"`…), `commentsCount` (reply count) |
| **Threading** | `threadingDepth` (0 = top-level), `replyToCommentId`, `parentComment`, `parentReply` |
| **Story context** | `facebookId` (story id), `feedbackId`, `postTitle`, `pageAdLibrary` |

***

### 💰 Pricing

Pay-per-result, **$0.50 per 1,000 comments** ($0.0005/row + a small per-run start fee) — among the cheapest Facebook comment scrapers on the Apify Store. You pay only for the comment rows emitted to your dataset — reply rows count as rows when nested mode is on. No subscription, no monthly minimum.

| Run | Approx cost |
|---|---|
| 1 post, 100 comments | ~$0.05 |
| 10 posts, 500 comments each | ~$2.50 |
| 1 Reel, 2,000 comments + replies | ~$1.00 |

***

### ❓ FAQ

**Does it need my Facebook login or cookies?**
No. It only reads public comments via Facebook's own front-end GraphQL. No authentication.

**Will it get private or friends-only comments?**
No. Only public content is reachable. Login-walled or restricted posts will fail.

**Why do I need a residential proxy?**
Facebook blocks datacenter IPs aggressively. Residential proxies (Apify Residential or your own) are required for reliable runs.

**Is `maxItems` global or per URL?**
**Per URL.** Each start URL collects up to `maxItems` comments independently.

**How do I get replies, not just top-level comments?**
Set `includeNestedComments: true`. Each reply becomes its own row with `parentComment` / `replyToCommentId` linkage and `threadingDepth ≥ 1`.

**Is the output the same for Reels, Watch, photos, and posts?**
Yes — identical schema. Only values differ (URL shapes, story ids). Store once, query everything.

**What's the difference between `commentId` and `id`?**
`commentId` is the legacy numeric id used in `comment_id=` permalinks; `id` is the opaque GraphQL relay token. Both are always present in real runs.

**Can it handle share links and `pfbid` URLs?**
Yes. The numeric story id is resolved from the loaded page HTML when the URL isn't already in `/{page}/posts/{id}` form.

***

### 💬 Support

Found a bug or need a field that isn't surfaced? Open an issue on the actor's Apify Console page, or email **muhamed.didovic@gmail.com** — same-day turnaround on data issues.

### 🛠 Additional services

- **Need a custom output shape or extra fields?** Email **muhamed.didovic@gmail.com**.
- **Need Facebook posts, pages, groups, ads, or marketplace data?** Ask — there's a sibling actor for most Facebook surfaces.
- **Need API access (no Apify fee, usage-only)?** Get in touch.

### 🔎 Explore more scrapers

See the full catalog at [memo23's Apify profile](https://apify.com/memo23) — Facebook posts/pages/groups/ads, VRBO vacation rentals, Expedia/Hotels.com reviews, ImmoScout24, LoopNet, Stepstone, Naukri, and more.

***

### ⚠️ Disclaimer

This Actor accesses publicly available comments on Facebook for legitimate research, social-listening, moderation, and business-analysis purposes. Use of this Actor must comply with Facebook's (Meta Platforms, Inc.) Terms of Service and all applicable laws, including data-protection regulations (GDPR, CCPA, etc.). This Actor is **not affiliated with, endorsed by, or sponsored by Facebook or Meta Platforms, Inc.** All Facebook and Meta trademarks are the property of their respective owners and are used here solely for descriptive purposes. Users must:

- Respect rate limits and avoid overloading Facebook's infrastructure
- Not use scraped data to violate user privacy or Facebook's terms
- Comply with applicable laws in their jurisdiction
- Not republish scraped content in violation of copyright

We do not store any scraped data; the Actor returns it directly to your Apify dataset for your authorized use.

***

### SEO Keywords

facebook comments scraper, facebook comment scraper, scrape facebook comments, facebook post comments scraper, facebook reel comments scraper, facebook watch comments, facebook photo comments scraper, facebook group comments scraper, facebook comments api, facebook comments export, facebook nested replies scraper, facebook comment replies, social listening facebook, facebook sentiment data, facebook moderation data, facebook comments csv, facebook comments json, no-login facebook scraper, facebook graphql comments, apify facebook scraper, facebook engagement data, facebook public comments extraction

# Actor input Schema

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

Public Facebook post permalinks (`/posts/`, `/share/`, …), Reels (`/reel/123…`), **Watch** (`/watch?v=123…`), or photo links (`/photo?fbid=…`, `/photo/?fbid=…&set=a.…`). GraphQL uses CommentsListComponentsPaginationQuery when Comet exposes story feedback (same `doc_id` as posts). **Comments mode** maps to Comet intents: All → ranked chronological replies, **Newest** → `REVERSE_CHRONOLOGICAL_UNFILTERED_INTENT_V1`, Most relevant → `RANKED_FILTERED_INTENT_V1`.

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

Maximum comments to collect per post URL.

## `commentsMode` (type: `string`):

Matches Facebook’s comment sort / filter intents (same tokens as Comet GraphQL).

## `includeNestedComments` (type: `boolean`):

When false, only top-level thread items are targeted (simpler; matches basic competitor mode).

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

Parallel requests. Residential IPs rotate per request, so 10 is safe and far faster/cheaper than 1–3 (runs are network-bound and the machine is otherwise idle). Lower it only if you see blocks.

## `minConcurrency` (type: `integer`):

Minimum parallel requests for the autoscaled pool.

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

Retries per failed HTTP request before giving up.

## `proxy` (type: `object`):

Residential proxies strongly recommended — datacenter IPs are often blocked.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/reel/813381761171953"
    },
    {
      "url": "https://www.facebook.com/photo?fbid=1465799148444403"
    },
    {
      "url": "https://www.facebook.com/reel/4364570517119853"
    },
    {
      "url": "https://www.facebook.com/watch?v=1312736054237897"
    },
    {
      "url": "https://www.facebook.com/photo?fbid=1485098743181110"
    },
    {
      "url": "https://www.facebook.com/photo/?fbid=1489500156068574&set=a.800788574939739"
    },
    {
      "url": "https://www.facebook.com/humansofnewyork/posts/pfbid0BbKbkisExKGSKuhee9a7i86RwRuMKFC8NSkKStB7CsM3uXJuAAfZLrkcJMXxhH4Yl"
    },
    {
      "url": "https://www.facebook.com/groups/183774529022936/permalink/2090871251646578/?rdid=ofrIy5Dr5XISD6GH"
    },
    {
      "url": "https://www.facebook.com/photo.php?fbid=1423151982709120"
    },
    {
      "url": "https://www.facebook.com/share/p/1CfaPmdZLU"
    }
  ],
  "maxItems": 60,
  "commentsMode": "ALL",
  "includeNestedComments": false,
  "maxConcurrency": 10,
  "minConcurrency": 1,
  "maxRequestRetries": 2,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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/reel/813381761171953"
        },
        {
            "url": "https://www.facebook.com/photo?fbid=1465799148444403"
        },
        {
            "url": "https://www.facebook.com/reel/4364570517119853"
        },
        {
            "url": "https://www.facebook.com/watch?v=1312736054237897"
        },
        {
            "url": "https://www.facebook.com/photo?fbid=1485098743181110"
        },
        {
            "url": "https://www.facebook.com/photo/?fbid=1489500156068574&set=a.800788574939739"
        },
        {
            "url": "https://www.facebook.com/humansofnewyork/posts/pfbid0BbKbkisExKGSKuhee9a7i86RwRuMKFC8NSkKStB7CsM3uXJuAAfZLrkcJMXxhH4Yl"
        },
        {
            "url": "https://www.facebook.com/groups/183774529022936/permalink/2090871251646578/?rdid=ofrIy5Dr5XISD6GH"
        },
        {
            "url": "https://www.facebook.com/photo.php?fbid=1423151982709120"
        },
        {
            "url": "https://www.facebook.com/share/p/1CfaPmdZLU"
        }
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/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": [
        { "url": "https://www.facebook.com/reel/813381761171953" },
        { "url": "https://www.facebook.com/photo?fbid=1465799148444403" },
        { "url": "https://www.facebook.com/reel/4364570517119853" },
        { "url": "https://www.facebook.com/watch?v=1312736054237897" },
        { "url": "https://www.facebook.com/photo?fbid=1485098743181110" },
        { "url": "https://www.facebook.com/photo/?fbid=1489500156068574&set=a.800788574939739" },
        { "url": "https://www.facebook.com/humansofnewyork/posts/pfbid0BbKbkisExKGSKuhee9a7i86RwRuMKFC8NSkKStB7CsM3uXJuAAfZLrkcJMXxhH4Yl" },
        { "url": "https://www.facebook.com/groups/183774529022936/permalink/2090871251646578/?rdid=ofrIy5Dr5XISD6GH" },
        { "url": "https://www.facebook.com/photo.php?fbid=1423151982709120" },
        { "url": "https://www.facebook.com/share/p/1CfaPmdZLU" },
    ],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/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": [
    {
      "url": "https://www.facebook.com/reel/813381761171953"
    },
    {
      "url": "https://www.facebook.com/photo?fbid=1465799148444403"
    },
    {
      "url": "https://www.facebook.com/reel/4364570517119853"
    },
    {
      "url": "https://www.facebook.com/watch?v=1312736054237897"
    },
    {
      "url": "https://www.facebook.com/photo?fbid=1485098743181110"
    },
    {
      "url": "https://www.facebook.com/photo/?fbid=1489500156068574&set=a.800788574939739"
    },
    {
      "url": "https://www.facebook.com/humansofnewyork/posts/pfbid0BbKbkisExKGSKuhee9a7i86RwRuMKFC8NSkKStB7CsM3uXJuAAfZLrkcJMXxhH4Yl"
    },
    {
      "url": "https://www.facebook.com/groups/183774529022936/permalink/2090871251646578/?rdid=ofrIy5Dr5XISD6GH"
    },
    {
      "url": "https://www.facebook.com/photo.php?fbid=1423151982709120"
    },
    {
      "url": "https://www.facebook.com/share/p/1CfaPmdZLU"
    }
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call memo23/facebook-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Comments [$1.5💰] Scraper",
        "description": "💰 $1.5 per 1,000 results – No limits, no quotas, unlimited extraction. Extracts Facebook comments with profile data (name, ID, avatar, URL), comment metadata (text, date, likes, replies), post context (title, URL), and threading info for posts, reels, photos, and group content.",
        "version": "0.0",
        "x-build-id": "HDYPaJ0mHDB3B633G"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~facebook-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-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/memo23~facebook-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-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/memo23~facebook-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-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 post or Reel URLs",
                        "type": "array",
                        "description": "Public Facebook post permalinks (`/posts/`, `/share/`, …), Reels (`/reel/123…`), **Watch** (`/watch?v=123…`), or photo links (`/photo?fbid=…`, `/photo/?fbid=…&set=a.…`). GraphQL uses CommentsListComponentsPaginationQuery when Comet exposes story feedback (same `doc_id` as posts). **Comments mode** maps to Comet intents: All → ranked chronological replies, **Newest** → `REVERSE_CHRONOLOGICAL_UNFILTERED_INTENT_V1`, Most relevant → `RANKED_FILTERED_INTENT_V1`.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Results amount",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum comments to collect per post URL.",
                        "default": 60
                    },
                    "commentsMode": {
                        "title": "Comments mode",
                        "enum": [
                            "ALL",
                            "NEWEST",
                            "MOST_RELEVANT"
                        ],
                        "type": "string",
                        "description": "Matches Facebook’s comment sort / filter intents (same tokens as Comet GraphQL).",
                        "default": "ALL"
                    },
                    "includeNestedComments": {
                        "title": "Include comment replies",
                        "type": "boolean",
                        "description": "When false, only top-level thread items are targeted (simpler; matches basic competitor mode).",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Parallel requests. Residential IPs rotate per request, so 10 is safe and far faster/cheaper than 1–3 (runs are network-bound and the machine is otherwise idle). Lower it only if you see blocks.",
                        "default": 10
                    },
                    "minConcurrency": {
                        "title": "Min concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Minimum parallel requests for the autoscaled pool.",
                        "default": 1
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Retries per failed HTTP request before giving up.",
                        "default": 2
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxies strongly recommended — datacenter IPs are often blocked."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
