# Facebook Post Comments Scraper — Reactions, Replies, No Login (`foxlabs/facebook-post-comments-scraper`) Actor

Comments of public Facebook posts, most relevant or newest first: author (name, id, address, verification, picture — or a code instead), text, exact time, depth, reply count, reactions in total and by kind; the post itself with its counts as a row of its own. Only-new mode. No login.

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

## Pricing

from $0.80 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Facebook Post Comments Scraper — Reactions, Replies, No Login 🚀

**foXLabs Facebook series:** [Page Posts](https://apify.com/foxlabs/facebook-page-posts-scraper) · [Page Profile](https://apify.com/foxlabs/facebook-page-profile-scraper) · [Page Reviews](https://apify.com/foxlabs/facebook-page-reviews-scraper) · [Page Videos](https://apify.com/foxlabs/facebook-page-videos-scraper) · [Page Events](https://apify.com/foxlabs/facebook-page-events-scraper)

🎉 Comments of public Facebook posts, exactly as Facebook shows them to a signed-out visitor — in Facebook's own orders (most relevant, newest, all) — with **the author (name, id, URL, verification, picture — or a code), the text with tagged accounts, exact time, depth, reply count, reactions in total and by kind, attachments** — plus the post itself as a row with its counts. No login, no cookies, no account of anyone. Only-new mode for recurring runs.

### 🔍 What is the Facebook Post Comments Scraper — and when should you use it?

Give this Actor public Facebook post URLs (posts, videos or reels) and it returns their comments as clean rows — with the author, text, reactions by kind, and the post itself as a row of its own.

**Use it when you need:** every comment on a post (not just the top few); community sentiment and the most-reacted comments; or a recurring feed of only-new comments on a post.

**Use something else when:** you want a Page's posts (each with its *top* comments) → [Page Posts](https://apify.com/foxlabs/facebook-page-posts-scraper); the Page's reviews → [Page Reviews](https://apify.com/foxlabs/facebook-page-reviews-scraper).

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for this Actor by name: `foxlabs/facebook-post-comments-scraper`. An agent can discover it, run it and read the dataset over MCP.

**Real-time Standby API.** This Actor ships a Standby endpoint so an agent can fetch a post's comments on demand — `GET /comments?post=<address>&maxComments=20&order=newest&authors=0`, billed with the same events.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```
I want public Facebook post comments using the Apify Actor
`foxlabs/facebook-post-comments-scraper`.

Input: `posts` is a list of post URLs or ids; `order` is relevant/newest/all; `includePost`
adds the post as a row; `hideAuthors` returns codes; `minReactions` filters. Each comment row
has author, text, createdAt, reactions, reactionsByType and replyCount.

Start with:
{ "posts": ["https://www.facebook.com/NASA/posts/…"], "maxCommentsPerPost": 50 }

Ask me which posts to read, run the Actor, then summarise the comments and sentiment.
```

The machine-readable API, MCP config and OpenAPI definition live at `apify.com/foxlabs/facebook-post-comments-scraper.md`.

### 📋 Overview

Everything you need to turn a public Facebook post's comments into clean, structured data — every comment with its author and reactions, plus the post's own counts — in one Actor, with no login, cookies or account.

**Why teams pick this Actor:**

- ✅ **Every comment, not the top few** — pages through all of them in Facebook's own orders.
- ❤️ **Reactions by kind** — like/love/care/haha/wow/sad/angry each with its count.
- 🕵️ **Author privacy** — `hideAuthors` returns a stable code instead of name/id/URL/picture.
- 🎞️ **Videos & reels too** — comments on a video or reel post, with the post read from the video's page.
- 💰 **Pay only for results** — `comment`/`post` events per row; status rows and unreadable posts free.
- 🤖 **Agent-ready** — MCP + a real-time Standby API.

### ✨ Features

- 🔍 **All comments** — in `relevant`, `newest` or `all` order, ten a call.
- 👤 **Author** — name, id, URL, verification, picture, isPage — or a stable code with `hideAuthors`.
- 💬 **Comment** — text with tagged accounts, exact time, depth, reply count, attachments.
- 📌 **Post row** — the post itself with its text, media, reactions by kind and counts (`includePost`).
- 🔁 **Only-new lists** — remember delivered comments and skip them next run.

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~facebook-post-comments-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"posts": ["https://www.facebook.com/NASA/posts/PFBID_EXAMPLE"], "maxCommentsPerPost": 50}'
```

### 🚀 Getting Started (3 steps)

1. **Choose your posts** — one per line: a post/video/reel URL (any form) or a numeric id.
2. **Pick order & depth** — `order` (relevant/newest/all), `maxCommentsPerPost`, `hideAuthors` for privacy.
3. **Run and export** — get a clean dataset as JSON, CSV or Excel.

### 📥 Input

| Field | Default | What it does |
|---|---|---|
| `posts` | — | One post per line: its URL in any form (`…/posts/…`, `…/videos/…`, `/reel/…`, `/watch/?v=…`, `permalink.php`, a share link) or numeric id. The `url` from the Page Posts Scraper works as-is. |
| `maxCommentsPerPost` | 100 | Comments to deliver per post. |
| `maxComments` | 100000 | Comment rows in the whole run. |
| `order` | `relevant` | `relevant` (what the site shows), `newest`, or `all`. |
| `includePost` | true | The post as a row of its own (billed as a `post` event). |
| `hideAuthors`, `authorCodeKey` | false | Replace commenters' names/ids/URLs/pictures with codes; a shared key gives the same person the same code. |
| `minReactions` | — | Keep only comments at or above this many reactions. |
| `onlyNewComments`, `listName` | false, `default` | Remember delivered comments under a name and skip them later. |
| `proxyConfiguration` | residential Apify Proxy | Nothing to change for normal use. |

### 📤 Output

One row per comment (`type: "comment"`), plus one per post (`type: "post"`) with `includePost`. A value Facebook does not give is `null`.

| Field | What it is |
|---|---|
| `commentId`, `url` | the comment's id and address |
| `postId`, `postUrl` | the post it belongs to |
| `author`, `authorId`, `authorUrl`, `authorIsVerified`, `authorPictureUrl`, `authorIsPage` | who wrote it — or a stable code with `hideAuthors` |
| `text`, `createdAt` | the comment's text and when it was written (UTC) |
| `depth`, `parentCommentId`, `replyCount` | thread depth (0 under the post), parent, and reply count |
| `reactions`, `reactionsByType` | all reactions and each kind with its count |
| `attachments`, `mentions` | stickers/GIFs/photos; tagged accounts |
| `order`, `position`, `input`, `type`, `error` | read order and place; input line; row type / free status row |

```json
{
  "type": "comment",
  "commentId": "848869361623320",
  "postId": "1652244896270880",
  "text": "That eight-pronged diffraction pattern is Webb's signature…",
  "createdAt": "2026-10-10T07:11:42.000Z",
  "author": "Beyond Earth",
  "authorId": "61594630482587",
  "authorIsVerified": false,
  "reactions": 3,
  "reactionsByType": { "like": 3 },
  "replyCount": 0,
  "order": "relevant",
  "position": 1,
  "input": "https://www.facebook.com/NASA/posts/PFBID_EXAMPLE"
}
```

### 💼 Use cases

**1. Community sentiment** — read everything a post's audience said, not just the top comments.
*Input:* the post URL, `order: all`. *Output:* every comment + reactions. *Use:* gauge reaction to an announcement.

**2. Most-engaged commenters** — find the comments people reacted to most.
*Input:* the post, `minReactions` set. *Output:* high-reaction comments. *Use:* surface influential voices.

**3. Ongoing monitoring** — keep collecting only-new comments as they arrive.
*Input:* the post, `onlyNewComments` + `order: newest`, scheduled. *Output:* new comments each run. *Use:* live comment feed.

### 🔗 Integration

**JavaScript / Node.js**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/facebook-post-comments-scraper').call({
  posts: ['https://www.facebook.com/NASA/posts/PFBID_EXAMPLE'], maxCommentsPerPost: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('foxlabs/facebook-post-comments-scraper').call(
    run_input={'posts': ['https://www.facebook.com/NASA/posts/PFBID_EXAMPLE'], 'maxCommentsPerPost': 50}
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)
```

Written for `apify-client` 3 for Python, where `call()` returns a run object; with version 1 or 2 it returns a dict — write `run['defaultDatasetId']` there.

**Automation (n8n / Zapier / Make):** schedule or webhook → HTTP request to the Actor API with your `posts` → handle the JSON dataset → push to a sheet, CRM or dashboard.

### 📊 Pricing

Pay per event: **`comment`** per delivered comment row, **`post`** per delivered post row. The prices are on the Pricing tab. Nothing else is charged: no start fee, nothing for a status row, nothing for a comment the filter left out, nothing for a post that could not be read.

### ❓ FAQ

**Can I get every comment?** Yes — unlike the Page Posts Scraper's *top* comments, this pages through all of them in Facebook's own order.

**Does it work on videos and reels?** Yes — give a video or reel URL; the post row is read from the video's page and the comments page the same way.

**Are replies included?** Replies are counted (`replyCount`); this version delivers the comments under the post (depth 0). Reply texts are planned.

**Can I hide commenter names?** Yes — `hideAuthors` returns a stable code instead of name/id/URL/picture.

**Can I export to CSV / Excel / JSON?** Yes — directly from the Apify dataset.

### 🐛 Troubleshooting

- **Fewer comments than the post's count** — the count includes replies and comments Facebook hides from a visitor; `order: all` gets every one a visitor can see.
- **A post returns a status row** — it's from a personal profile/group, signed-in only, or has commenting off (free).
- **A video post needed retries** — a video's page sometimes comes without data (one in four, measured); the Actor retries up to three times before a status row.

**How it reads Facebook:** opens the post's page as a signed-out visitor (the post, its counts, and the first ten "most relevant" comments) and asks Facebook's comments endpoint for the rest (ten a call) in the order asked for. Residential Apify Proxy by default; rate-limited exits dropped and replaced. Every run starts with a one-call check and ends with a clear message if Facebook's queries changed.

### ⚠️ Trademark

Independent, third-party tool. Not affiliated with, endorsed by or connected to Meta Platforms, Inc. "Facebook" and related marks belong to their owners and are used here for identification only.

### ⚖️ Is it legal to scrape this data?

It reads only what Facebook shows a signed-out visitor. Comments carry the names of people who wrote them publicly; personal data is protected by the GDPR and similar laws, so only collect and process it with a legitimate basis — or turn on `hideAuthors`. The Actor does not log in, use anyone's account or cookies, or solve CAPTCHAs. See Apify's blog post on the legality of web scraping.

### 🤝 Support & contact

- 🌐 **Website:** [data.foxlabs.com.tr](https://data.foxlabs.com.tr)
- 📧 **Email:** info@foxlabs.com.tr
- 🐛 **Issues:** open a ticket in the Actor's **Issues** tab — include the run id; the run's `SOURCE_REPORT` record holds what was asked and why the run stopped.
- 🧰 **More clean data actors:** [Fox Labs on Apify](https://apify.com/foxlabs)

### Changelog

#### 0.1.2 — 2026-10-11 — the shared core of the family, a restart's count

- A restarted run now counts the post rows written before the restart; the post row of a video post carries the video's duration and live status (shared core updated with Page Videos, Events and Reviews; comment rows unchanged).

#### 0.1.1 — 2026-10-11 — videos and reels

- Video and reel addresses bring their comments; the post row is read from the video's page. A reel line is opened through `/watch/?v=`; a video page served without data is retried up to three times. The `isEdited` column was removed (Facebook doesn't give it to a visitor).

#### 0.1.0 — 2026-10-11 — first release

- Comments of public Facebook posts as a signed-out visitor sees them: the post's page (post, counts, first ten "most relevant") and Facebook's comments query, ten a call, in the order asked for.
- Every comment row: author (name/id/URL/verification/picture — or a stable code with `hideAuthors`), text with tagged accounts, exact time, depth, reply count, reactions in total and by kind, attachments; the post's id and address. The post as a row of its own (`includePost`). Reactions filter; free status rows; "only new" lists; restarted runs continue without duplicates. Standby mode prepared; published in batch mode.

# Changelog

This Actor's version history is a separate document: https://apify.com/foxlabs/facebook-post-comments-scraper/changelog.md

# Actor input Schema

## `posts` (type: `array`):

One post per line: its address in any form Facebook uses (…/posts/…, …/videos/…, …/photos/…, /reel/…, permalink.php, a share link) or its numeric id. A post written twice is read once. Only posts of public Pages that Facebook shows to visitors who are not signed in can be read.

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

How many comments to deliver for each post. Facebook hands them out ten a call; the first ten of the "most relevant" order come with the post's page itself.

## `maxComments` (type: `integer`):

The run stops when this many comment rows have been delivered. You are charged only for delivered rows.

## `order` (type: `string`):

Facebook's own orders: most relevant (the default, what the site shows), newest first, or all comments in Facebook's "all comments" order.

## `includePost` (type: `boolean`):

One row of type "post" per input post, with its text, time, reactions by kind, comment and share counts (billed as a post event). Off: comment rows only.

## `hideAuthors` (type: `boolean`):

Each commenter's name, id, address and picture are replaced by a code that is the same for the same person (threads stay readable). Use it when you do not need who wrote what.

## `authorCodeKey` (type: `string`):

With "Replace commenters' names with codes": runs that share this key give the same person the same code. Leave empty for the Actor's own key.

## `minReactions` (type: `integer`):

Deliver only comments with at least this many reactions. Leave empty for every comment.

## `onlyNewComments` (type: `boolean`):

Remember delivered comments under the list name below and skip them in later runs. Schedule the same posts and each run brings only the comments it has not delivered before (with "newest first" the new ones come first). With this on, "Maximum comments per post" is how far the Actor looks.

## `listName` (type: `string`):

Name of the memory used by "Only comments not delivered before" (looked at only when that is on). Letters, digits and hyphens (a hyphen not first or last), up to 40 characters; capitals are read as lower case.

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

Nothing to change for normal use: the Actor reads Facebook through Apify Proxy residential addresses, the only kind Facebook serves its public posts to (measured: residential 25 of 25 requests, datacenter 0 — sent to the login page). Set a proxy here to send every request through it instead.

## Actor input object example

```json
{
  "posts": [
    "https://www.facebook.com/NASA/posts/pfbid0dPToN66CzcAHGMoaNe3jszH4FfBKvqkE5gogCNJkTxXDPsSGYrGvcVwsLgByyMQQl"
  ],
  "maxCommentsPerPost": 40,
  "maxComments": 100000,
  "order": "relevant",
  "includePost": true,
  "hideAuthors": false,
  "onlyNewComments": false,
  "listName": "default"
}
```

# Actor output Schema

## `dataset` (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 = {
    "posts": [
        "https://www.facebook.com/NASA/posts/pfbid0dPToN66CzcAHGMoaNe3jszH4FfBKvqkE5gogCNJkTxXDPsSGYrGvcVwsLgByyMQQl"
    ],
    "maxCommentsPerPost": 40
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/facebook-post-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 = {
    "posts": ["https://www.facebook.com/NASA/posts/pfbid0dPToN66CzcAHGMoaNe3jszH4FfBKvqkE5gogCNJkTxXDPsSGYrGvcVwsLgByyMQQl"],
    "maxCommentsPerPost": 40,
}

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

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

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

```

## CLI example

```bash
echo '{
  "posts": [
    "https://www.facebook.com/NASA/posts/pfbid0dPToN66CzcAHGMoaNe3jszH4FfBKvqkE5gogCNJkTxXDPsSGYrGvcVwsLgByyMQQl"
  ],
  "maxCommentsPerPost": 40
}' |
apify call foxlabs/facebook-post-comments-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,foxlabs/facebook-post-comments-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/7VtxRqj8iohKNxP0y/builds/dWxhKADZPfb8OL0Xy/openapi.json