# Facebook Comments Scraper by Post URL: Text, Likes, Replies (`neverempty/facebook-post-comments-scraper`) Actor

For sentiment analysis, giveaway picking and brand monitoring: paste public Facebook post, video or reel URLs and get one row per comment and reply with text, date, reactions by type and commenter name, as CSV, Excel or JSON. Newest first. No login, no start fee. You pay only for comments returned.

- **URL**: https://apify.com/neverempty/facebook-post-comments-scraper.md
- **Developed by:** [NeverEmpty](https://apify.com/neverempty) (community)
- **Categories:** Social media, Automation
- **Features:** Limited permissions
- **Stats:** 17 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.39 / 1,000 comment returneds

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/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 Comments Scraper by Post URL: Text, Likes, Replies

For sentiment analysis, giveaway picking and brand monitoring: paste public Facebook post, video or reel URLs and download their comments as CSV, Excel or JSON, one row per comment or reply with text, date, reactions by type, commenter name and verified badge. No login, no cookies, no start fee, no extra charge for the date filter. Comments come newest first by default, including the ones Facebook's default view leaves out. You pay **$2.49 per 1,000 comments** on the Free plan, down to **$1.39** on Gold and above, and only for comments returned.

### What can I do with this Facebook comments scraper?

- **Read what people say about a post.** Collect the comments on your own Page posts, a campaign or a competitor's launch, and sort them by reactions to see what stands out.
- **Run sentiment analysis and topic research.** Get clean comment text with dates, reaction counts and reaction types (like, love, haha, wow, sad, angry, care), ready for a spreadsheet, an AI model or a dashboard.
- **Follow the conversation, not just the top level.** Replies that Facebook lists come in their own rows with `isReply` and `parentCommentId`, so you can rebuild those threads.
- **Pick giveaway entrants.** Get the names of people who commented, with a profile link where Facebook shows one.
- **Check videos and reels too.** Posts, photos, videos, reels, `watch/?v=` links, `permalink.php` links, `/share/` links and `fb.watch` links all work with the same input.
- **Follow up on new comments only.** Set `onlyNewerThan` to `7 days` and pay only for recent comments.

### What data do you get?

| Group | Fields |
|---|---|
| Comment | `commentId`, `commentUrl`, `position`, `text`, `commentType` (text, attachment, no-text), `attachmentType`, `likesCount`, `reactions`, `replyCount`, `createdAt`, `createTime` |
| Thread | `isReply`, `depth`, `parentCommentId` |
| Commenter | `authorName`, `authorProfileUrl`, `authorIsVerified`, `authorType` (person or page) |
| Post | `postUrl`, `postId`, `postOwnerName`, `postCommentCount`, `inputUrl` |
| Run | `status`, `note`, `sortOrder`, `source`, `scrapedAt`. The last row can also hold `notCheckedUrls` (URLs to put in a new run) |

`position` is the place of the row in the list read for that post, starting at 1. Replies are placed after the comments of the same page. `likesCount` is the total of all reaction types, and `reactions` splits it by type. `postCommentCount` is the comment count Facebook shows on the post.

Each post that was read also gets one free `post-summary` row with `commentsReturned`, `repliesReturned`, `pagesRead` and `postCommentCount`, so you can compare what was returned with the count on the post.

### How to scrape Facebook comments from a post URL

1. Paste your post, video and reel URLs into `urls`, one per line. Links with tracking parameters work. `startUrls`, `directUrls` and `postUrls` are accepted as other names for `urls`.
2. Set `maxCommentsPerPost` to the most rows you want from each post (comments and replies together).
3. Choose `sortOrder` and whether to `includeReplies`.
4. If you only want recent comments, set `onlyNewerThan` to a date such as `2026-10-01` or a span such as `7 days`.
5. Press **Start**, then download the rows as JSON, CSV or Excel, or read them through the API.

### Input

| Field | What it does | Default |
|---|---|---|
| `urls` | Public Facebook post, video and reel URLs, one per line. Up to 1,000 are read per run. | One free sample post when no URLs are given |
| `maxCommentsPerPost` | Reading a post stops after this many rows, comments and replies together (1 to 100,000). | 500 |
| `includeReplies` | Also return the replies under each comment, each in its own row with `isReply: true`. | On |
| `sortOrder` | `newest` (newest first, including comments the default view leaves out), `all` (Facebook's ranked order without its usual filter) or `relevant` (Facebook's default Most relevant view, which shows fewer comments). | `newest` |
| `onlyNewerThan` | Return only comments newer than a date (`2026-10-01`) or a span back from now (`12 hours`, `7 days`, `2 weeks`, `3 months`). Older comments are skipped and not charged. | Empty (any date) |

```json
{
    "urls": [
        "https://www.facebook.com/NASA/posts/1671137804381589/",
        "https://www.facebook.com/watch/?v=1234567890"
    ],
    "maxCommentsPerPost": 500,
    "includeReplies": true,
    "sortOrder": "newest",
    "onlyNewerThan": "30 days"
}
```

### Output example

```json
{
    "status": "ok",
    "inputUrl": "https://www.facebook.com/NASA/posts/1671137804381589/",
    "postUrl": "https://www.facebook.com/NASA/posts/1671137804381589/",
    "postId": "1671137804381589",
    "postOwnerName": "NASA",
    "postCommentCount": 12,
    "commentId": "1234567890123456",
    "commentUrl": "https://www.facebook.com/NASA/posts/1671137804381589/?comment_id=1234567890123456",
    "position": 1,
    "text": "What a view of the launch!",
    "commentType": "text",
    "attachmentType": null,
    "likesCount": 14,
    "reactions": { "like": 11, "love": 3 },
    "replyCount": 2,
    "createdAt": "2026-10-28T15:04:31.000Z",
    "createTime": 1793199871,
    "isReply": false,
    "depth": 0,
    "parentCommentId": null,
    "authorName": "Orbit Watcher",
    "authorProfileUrl": "https://www.facebook.com/orbit.watcher",
    "authorIsVerified": false,
    "authorType": "person",
    "sortOrder": "newest",
    "source": "facebook-comment",
    "scrapedAt": "2026-11-01T09:12:44.000Z"
}
```

The comment, names, IDs and counts in this example are made up to show the shape of a row.

### How much does it cost?

**$2.49 per 1,000 comments** on the Free plan, with lower prices on paid Apify plans:

| Apify plan | Price per 1,000 comments |
|---|---|
| Free | $2.49 |
| Bronze | $1.99 |
| Silver | $1.69 |
| Gold and above | $1.39 |

There is no start fee, no charge per post and no extra charge for `onlyNewerThan` or `sortOrder`. Replies are charged like comments. You are charged only for rows with `status: "ok"`, and each comment is returned once per run. Every other row is free, and the [list is below](#rows-you-are-not-charged-for).

To keep a run inside a budget, set `maxCommentsPerPost`, or set a maximum total charge when you start the run. The run stops at that amount and says so in a `budget-reached` row.

### FAQ

**How do I export Facebook comments to Excel or CSV?**
Paste the post URL into `urls` and run the Actor. When the run ends, open the **Output** tab and download the dataset as CSV or Excel. Each comment and each reply is one row.

**Can I scrape Facebook comments without logging in?**
Yes. You don't need a Facebook account, a cookie or an API key.

**Can I get the replies to a comment?**
Yes, the replies Facebook lists, one level deep. Not every reply is listed, so the count can be lower than on the post. With `includeReplies` on, replies come in their own rows with `isReply: true` and the `parentCommentId` of the comment they answer.

**How many comments can I get from one post?**
As many as Facebook lists for that post to visitors who are not logged in, up to your `maxCommentsPerPost`. This is often fewer than the count shown on the post; see [Limitations](#limitations).

**Can I scrape comments from Facebook reels and videos?**
Yes. Use the reel or video URL, such as `https://www.facebook.com/reel/1234567890/` or `https://www.facebook.com/watch/?v=1234567890`. Reels, videos and posts return the same fields.

**Can I run this from an API or an AI agent?**
Yes. Call the Actor through the Apify API, or from an AI agent through the Apify MCP server, with a list of URLs. The rows come back as JSON.

**How do I scrape comments from many posts at once?**
Paste a list of URLs (the limit is 1,000 per run). Every post the run reaches returns the comments Facebook lists for it, or one free row that says why there are none. If Facebook stops answering, the run ends early, and the posts it did not reach are listed in `notCheckedUrls` in the last row, ready for a new run a few hours later.

**What happens if a run reaches its timeout?**
The run stops about 90 seconds before its timeout. Comments already returned stay in the dataset. A post that was cut short gets a `stopped-reading` row, and posts it did not start are listed in `notCheckedUrls` in the last row. To read them, start a new run with those URLs, or set a longer timeout.

**Why is `text` empty on some rows?**
`commentType` tells you why. `attachment` means the comment is only a sticker, a photo, a GIF or a link, and `attachmentType` says which. `no-text` means Facebook gave the comment without text or an attachment. These rows are still real comments and are charged like any other.

### Rows you are not charged for

A post that was read but did not return comments gets its own row, so you can see what happened to it. Posts the run did not check (past the 1,000 URL limit, past the maximum total charge, stopped because Facebook stopped answering, or stopped before the run timeout) are counted in one last row, and `notCheckedUrls` lists them for a new run.

| `status` | What it means |
|---|---|
| `post-summary` | One row per post that was read: how many comments and replies were returned, how many pages were read, and the count shown on the post. |
| `sample` | No URLs were given, so up to 20 comments of one sample post were read to show the output. These rows are free. Add your own URLs to `urls`. |
| `no-public-post` | Facebook shows no public post at this address. It may be deleted, not public, not available in some countries, or mistyped. |
| `login-required` | Facebook asks visitors to log in before it shows this post, for example a post in a group, or a post that was deleted or never public. |
| `comments-not-shown` | Facebook shows the post but has comments turned off for it. |
| `no-comments-listed` | The post has no comments listed, or none newer than `onlyNewerThan`. |
| `max-comments-reached` | `maxCommentsPerPost` rows were returned and Facebook showed that the post may list more. Raise the limit to read further. |
| `stopped-reading` | Reading stopped part way, because Facebook did not answer the next page or the run was about to reach its timeout. The comments before that point are in the dataset. |
| `blocked` | Facebook did not let this run open the post. Run the URL again later. |
| `unreadable` | The page loaded, but it showed a login page or the comment data was not in the expected form. In our tests this was 1 public post in about 300; run the URL again later. Nothing is guessed. |
| `invalid-input` | The entry is not a Facebook post, video or reel URL, such as a Page or profile link, or an input value could not be read. |
| `duplicate` | The same post was already in this run's list. |
| `not-checked` | One row at the end: how many posts were not read and why. The URLs are in `notCheckedUrls`. |
| `budget-reached` | The run reached the maximum total charge you set. Comments that did not fit are not in the dataset and were not charged. |

### Limitations

- The Actor returns the comments Facebook lists to visitors who are not logged in. This is often fewer than the count shown on the post (`postCommentCount`), which also counts comments Facebook hides. In our tests on 1 November 2026, a post with about 3,200 comments returned 85% of that count in newest-first order, and posts with 12 to 90 comments returned 58% to 100% of it. `relevant` returns fewer.
- Replies are read one level deep. Answers posted under a reply are not in the output.
- With `onlyNewerThan` and `newest` order, reading a post stops at the first page of comments that are all older than the date, so a new reply under an older comment may be missed.
- Only public posts can be read. Posts in groups, and posts that are deleted or not public, return a free `login-required` or `no-public-post` row. Facebook shows the same login page for a deleted post as for a post that needs a login, so the two cannot always be told apart.
- `likesCount` is the total of all reaction types, not only likes. `reactions` holds the split for the types Facebook lists.
- Numeric account IDs and profile links that contain one are not collected, so `authorProfileUrl` is empty for many commenters (52% to 70% of comment rows in our tests).
- On long lists Facebook may stop answering, so the run can end early. The rest are not charged and are listed in `notCheckedUrls`.
- Email addresses and phone numbers in comment text are masked on a best-effort basis. Not every way of writing them can be caught, so some may remain. Masking can also go too far: a long number such as a reference code may be masked as well.
- Use the data in line with the rules that apply to you, including privacy law for the personal data in comments.

### Need help or a missing field?

Open the **Issues** tab and tell us what you need. If a row looks wrong, include the run ID.

### Thanks for using this Actor

We build these tools for people who run them every day, and we improve them from what users tell us.

- **Missing a field, or need another filter?** Tell us in the **Issues** tab. If the data is there, we add it.
- **Found a bug or a wrong value?** Post the run ID in the **Issues** tab. Wrong data is the thing we fix first.

If this Actor saved you time, a short review helps other people find it.

# Actor input Schema

## `urls` (type: `array`):

Public Facebook post, video or reel addresses, one per line, such as https://www.facebook.com/NASA/posts/1671137804381589/ or https://www.facebook.com/reel/1234567890/. watch/?v=, permalink.php, /share/ and fb.watch links also work. Up to 1,000 per run. Several posts are read at the same time.

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

Reading a post stops after this many rows (comments and replies together). The charge follows the rows returned.

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

Also return the replies under each comment, each marked with isReply and the parent comment ID. Turn off to return top-level comments only.

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

newest: newest first, including comments Facebook's default view leaves out. all: Facebook's ranked order without its usual filter. relevant: Facebook's default Most relevant view, which shows fewer comments.

## `onlyNewerThan` (type: `string`):

Leave empty to return comments of any date. Otherwise a date such as 2026-10-01, or a span back from now such as 7 days, 2 weeks, 3 months or 12 hours. Older comments are skipped and not charged.

## Actor input object example

```json
{
  "urls": [
    "https://www.facebook.com/NASA/posts/1671137804381589/"
  ],
  "maxCommentsPerPost": 500,
  "includeReplies": true,
  "sortOrder": "newest"
}
```

# Actor output Schema

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

One row per Facebook comment or reply: text, date, reactions by type, author name, verified badge, reply mark, parent comment and the post it belongs to. Each post read also gets a free summary row. Addresses that show no public post, posts without listed comments and limits come back as free rows that say why.

# 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 = {
    "urls": [
        "https://www.facebook.com/NASA/posts/1671137804381589/"
    ]
};

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

# Run the Actor and wait for it to finish
run = client.actor("neverempty/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 '{
  "urls": [
    "https://www.facebook.com/NASA/posts/1671137804381589/"
  ]
}' |
apify call neverempty/facebook-post-comments-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neverempty/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/PuldHH8cuUgPvmzIY/builds/uVTGXcXfKrxQkZrt0/openapi.json
