# Threads Replies Scraper: Every Page of Replies (`luzivanlt/threads-replies-scraper`) Actor

Replies to Threads posts, newest first, page after page: 1,800 from one post in a test, nested replies too. $1 per 1,000 replies. Text, date, likes, author, level. No account needed.

- **URL**: https://apify.com/luzivanlt/threads-replies-scraper.md
- **Developed by:** [Luzi](https://apify.com/luzivanlt) (community)
- **Categories:** Social media, Marketing, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 replies

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

## Threads Replies Scraper: Every Page of Replies

Get the replies to Threads posts, newest first, page after page instead of
stopping at the first batch: the text, the date, likes, replies, reposts,
quotes, images, GIFs and links, with who wrote each one. Turn on replies to
replies to get the whole conversation, each reply with its level and the
reply it answers. Paste post links. No Threads or Instagram account needed.

Tested daily. Latest checks: 1,803 replies from one post in under 2 minutes;
418 replies from 2 posts with replies to replies on.

### What does this Actor do?

You give it links to Threads posts. For each one it reads the post's replies
from the newest back, about 100 at a time, and saves one row per reply until
it reaches your limit, your date, or the last reply Threads shows.

A reply can come with its author's own follow-ups underneath it. Each of them
is its own row, with `reply_level` 2 and the reply it answers in
`parent_reply_id`. With **Include replies to replies** on, the Actor also
reads the replies to each reply, at every depth, and places each one the
same way.

Each reply comes with:

- its text, link and date, and whether it was edited
- its likes, replies, reposts and quotes
- whether it is text or an image, with the image and video links, and its GIF
- the link it shares, the links and accounts named in its text, the post it
  quotes and its topic tag, when it has them
- its level in the conversation, the reply it answers and the account it
  answers
- whether the post's author pinned it or liked it
- the author's username, name, ids, picture, verified badge and whether the
  account is private
- the post it replies to: its link, author, reply count and its own details

### Why use it?

- **Past the first page.** The Actor keeps reading a post's replies page
  after page, so a large post gives you hundreds or thousands of replies, not
  the first handful.
- **The whole conversation.** Replies to replies are rows of their own, with
  their level and the reply they answer, so you can rebuild each thread.
- **Newest first.** Run it daily with **Only replies newer than** set to
  `1 day` to follow a post's new replies.
- **Know what you got.** Every row carries the reply count the post shows, so
  you can compare it with what the run returned.
- **Use the data anywhere.** Download as JSON, CSV or Excel, or send it to
  your own tools through Apify's API and integrations.

### How to use it

1. Paste one or more posts into **Post links**:
   `https://www.threads.com/@nasa/post/Dd9aFLHgnnj` or
   `threads.net/@nasa/post/Dd9aFLHgnnj` both work.
2. Optionally, set **Max replies per post**, turn on **Include replies to
   replies**, or set **Only replies newer than**.
3. Click **Start**. When the run ends, open the **Output** tab to view the
   replies or download them.

A profile, search or tag link is not supported: paste the link of the post
itself. Put one post on each line of the list.

Run it with no input to see a sample: up to 20 replies to a NASA post,
charged as usual.

### Input

| Field                                                   | What it does                                                                                  | Default |
| ------------------------------------------------------- | --------------------------------------------------------------------------------------------- | ------- |
| **Post links** (`startUrls`)                            | The posts to read. Required.                                                                  | —       |
| **Max replies per post** (`maxRepliesPerPost`)          | Stop reading a post after this many replies (replies to replies included), from 1 to 10,000   | `100`   |
| **Include replies to replies** (`includeNestedReplies`) | Also read the replies to each reply, at every depth                                           | off     |
| **Only replies newer than** (`onlyRepliesNewerThan`)    | A date (`YYYY-MM-DD`, UTC) or a period (`7 days`, `2 weeks`, `3 months`). Empty = every reply | empty   |

Example input:

```json
{
  "startUrls": ["https://www.threads.com/@nasa/post/Dd9aFLHgnnj"],
  "maxRepliesPerPost": 1000,
  "includeNestedReplies": true
}
```

### Output

One row per reply. An example, with made-up values:

```json
{
  "reply_id": "4100000000000000001",
  "reply_code": "DAbCdEfGhIj",
  "reply_fbid": "17900000000000001",
  "url": "https://www.threads.com/@example.fan/post/DAbCdEfGhIj",
  "text": "Congrats on the launch! When does it ship to Europe?",
  "posted_at": "2026-10-13T18:28:06.000Z",
  "is_edited": false,
  "like_count": 41,
  "reply_count": 2,
  "repost_count": 0,
  "quote_count": 0,
  "media_type": "text",
  "reply_level": 1,
  "parent_reply_id": null,
  "reply_to_username": "example.brand",
  "is_pinned_by_post_author": false,
  "is_liked_by_post_author": true,
  "author_username": "example.fan",
  "author_full_name": "Example Fan",
  "author_is_verified": false,
  "post_id": "4000000000000000001",
  "post_url": "https://www.threads.com/@example.brand/post/DXyZaBcDeFg",
  "post_author_username": "example.brand",
  "post_reply_count": 512
}
```

| Field                             | What it holds                                                                                  |
| --------------------------------- | ---------------------------------------------------------------------------------------------- |
| `reply_id`                        | Threads' id for the reply                                                                      |
| `reply_code`                      | The short code in the reply's link                                                             |
| `reply_fbid`                      | Meta's other id for the reply                                                                  |
| `url`                             | The reply's page                                                                               |
| `text`                            | The reply's text. `null` for a reply with only an image or a GIF                               |
| `posted_at`                       | When it was posted (UTC, ISO 8601)                                                             |
| `is_edited`                       | `true` when the author edited the text                                                         |
| `language`                        | The reply's language, when Threads names it                                                    |
| `like_count`                      | Likes                                                                                          |
| `reply_count`                     | Replies to this reply                                                                          |
| `repost_count`                    | Reposts                                                                                        |
| `quote_count`                     | Quotes                                                                                         |
| `reshare_count`                   | Shares, when Threads gives them (rarely on a reply)                                            |
| `like_counts_hidden`              | `true` when the author hid the reply's like count                                              |
| `media_type`                      | `text`, `image`, `video` or `carousel`                                                         |
| `image_urls`                      | The reply's images                                                                             |
| `video_urls`                      | The reply's videos                                                                             |
| `image_alt_texts`                 | The image descriptions Threads gives the reply's images, when it has them                      |
| `media_width`, `media_height`     | The size of the reply's image or video in pixels. `null` for a text reply                      |
| `has_audio`                       | For a video, whether it has sound                                                              |
| `gif_url`                         | The GIF in the reply, when it has one                                                          |
| `link_url`                        | The web link the reply shares, when it has one                                                 |
| `link_title`                      | The title of that link's preview card                                                          |
| `link_image_url`                  | The image of that link's preview card                                                          |
| `link_favicon_url`                | The site icon on that link's preview card                                                      |
| `text_links`                      | Web links written in the reply's text                                                          |
| `mentioned_users`                 | The accounts the text names: `username`, `id` and `profile_pic_url` for each                   |
| `topic`                           | The reply's topic tag, when it has one                                                         |
| `topic_is_community`              | `true` when that topic is a Threads community                                                  |
| `music_title`, `music_artist`     | The song on the reply, when it has one                                                         |
| `music_song_id`, `music_audio_id` | Threads' ids for that song and its audio                                                       |
| `reply_control`                   | Who may reply to it, as Threads names it (for example `everyone`)                              |
| `ai_detection_method`             | Threads' AI-content label; `NONE` when it has none                                             |
| `is_spoiler`                      | `true` when the reply's media is marked as a spoiler                                           |
| `is_ghost_post`                   | `true` for a ghost post (one set to disappear)                                                 |
| `reply_level`                     | `1` for a reply to the post, `2` for a reply to a reply, and so on                             |
| `parent_reply_id`                 | The reply this one answers; `null` for a reply to the post                                     |
| `reply_to_username`               | The account it answers                                                                         |
| `reply_to_user_id`                | That account's id                                                                              |
| `is_pinned_by_post_author`        | `true` when the post's author pinned this reply                                                |
| `is_liked_by_post_author`         | `true` when the post's author liked this reply                                                 |
| `author_username`                 | The author's username                                                                          |
| `author_full_name`                | The author's display name                                                                      |
| `author_id`                       | Threads' id for the author                                                                     |
| `author_fbid`                     | Meta's other id for the author                                                                 |
| `author_is_verified`              | `true` when the author has the verified badge                                                  |
| `author_is_private`               | `true` when the author's account is private                                                    |
| `author_profile_pic_url`          | The author's profile picture                                                                   |
| `author_is_meta_ai_bot`           | `true` when the author is a Meta AI account                                                    |
| `quoted_post`                     | The post the reply quotes, with its own details, when it quotes one                            |
| `post_id`                         | Threads' id for the post replied to                                                            |
| `post_url`                        | The post's link                                                                                |
| `post_author_username`            | The post's author                                                                              |
| `post_reply_count`                | The reply count the post shows                                                                 |
| `post`                            | The post's own details (text, date, counts, media, author), in the same field names as a reply |

Not included: view counts, polls, and replies Threads does not show the
public.

### How much does it cost?

No surcharges and no paid options; an item that fails is not charged.

You pay for what you get:

- **$1 per 1,000 replies** ($0.001 a reply). Each reply is charged once per run.
- No start fee, and nothing per post.

So 500 replies from each of 4 posts cost $2. If you set a maximum cost for a
run, the Actor stops when it reaches it and keeps every reply saved so far.

### How long does a run take?

About 100 replies every few seconds. A post with 1,800 replies takes about 2
minutes. Replies to replies take one more step for each reply that has any,
so a run with them on takes longer.

### Good to know

- **Threads shows the public only part of a large post's replies.** On the
  posts we tested, the replies you can read came to about half to 70% of the
  reply count the post shows (`post_reply_count`), and repeated reads of the
  same post gave the same replies. The Actor reads every reply Threads shows,
  to the last page.
- **Pinned replies come first.** A reply the post's author pinned opens the
  list whatever its date. With **Only replies newer than** set, an older
  pinned reply is left out.
- **Replies to replies count toward your maximum.** They are read after the
  page of replies they sit under, so with **Max replies per post** at 100 a
  post with 100 or more replies returns only its newest 100 replies. Raise the
  maximum to get the conversations under them.
- **The date window and replies to replies.** With **Only replies newer
  than** set, the replies to an older reply are not read, even when they are
  new; a newer follow-up under an older reply is kept, and its
  `parent_reply_id` names the older reply, which is not in the dataset.
- **Check your input first.** A link that is not a Threads post stops the run
  before anything is read, and the message names it.
- **One post that cannot be read does not stop the run.** A post that does
  not exist or was deleted ends with a message, the others carry on, and the
  run's status lists the posts that could not be read. Such a post is tried a
  few times before it is given up, which can add two or three minutes to the
  run.
- **Counts move.** Likes and replies are the numbers at the moment the reply
  was read.
- **Remove repeats by `reply_id`.** A daily run reads recent replies again.

### More Actors from us

- [Threads Posts Scraper: A Profile's Whole Post History](https://apify.com/luzivanlt/threads-posts-scraper): A Threads profile's whole post history, back to its very first post, newest first.
- [AliExpress Product Scraper: Search Results & Prices](https://apify.com/luzivanlt/aliexpress-products-scraper): Every product of an AliExpress search to its last page, with exact sold counts and ratings.
- [Amazon Product Scraper: Search Results & Prices](https://apify.com/luzivanlt/amazon-products-scraper): Every product on Amazon's search pages to the last page, sponsored marked, with monthly sales.
- [App Store Reviews Scraper: All Reviews, Not 500](https://apify.com/luzivanlt/app-store-reviews-scraper): Every written App Store review of an app, not just the newest 500.
- [Facebook Ads Library Scraper: Meta Ads by Keyword or Page](https://apify.com/luzivanlt/facebook-ads-library-scraper): Meta Ad Library ads by keyword, Page or Ad Library link, with text, images, videos and dates.
- [Facebook Comments Scraper: With Replies](https://apify.com/luzivanlt/facebook-comments-scraper): Comments and replies from public Facebook posts, reels and videos, with reactions by type.
- [Facebook Pages Scraper: Contacts, Followers & Ratings](https://apify.com/luzivanlt/facebook-pages-scraper): Facebook Page details from links: exact follower count, phone, email, address, websites.

### Use it from an AI agent or the API

One call starts a run and returns its items (Apify waits up to 300 seconds; for a
longer run, start it with `POST /v2/acts/…/runs` and read its dataset):

```text
POST https://api.apify.com/v2/acts/luzivanlt~threads-replies-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>
```

With the sample input as its JSON body:

```json
{
  "startUrls": ["https://www.threads.com/@nasa/post/Dd9aFLHgnnj"],
  "maxRepliesPerPost": 20,
  "includeNestedReplies": false
}
```

Its inputs, in the order of the input form:

| Input                                               | What it takes                                                                                                                    | Default |
| --------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- | ------- |
| `startUrls` (Post links)                            | Threads posts to read the replies of: links such as https://www.threads.com/@nasa/post/Dd9aFLHgnnj (threads.net links work too). | —       |
| `maxRepliesPerPost` (Max replies per post)          | Stop reading a post after this many replies (nested replies included).                                                           | `100`   |
| `includeNestedReplies` (Include replies to replies) | Also read the replies to each reply, at every depth.                                                                             | `false` |
| `onlyRepliesNewerThan` (Only replies newer than)    | Keep only replies from this date on: a date (YYYY-MM-DD, UTC) or a period such as "7 days", "2 weeks" or "3 months".             | —       |

Apify's MCP server, `https://mcp.apify.com`, lists it as `luzivanlt/threads-replies-scraper`. To give an
AI agent this Actor as a tool, add the server to the agent's MCP config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=luzivanlt/threads-replies-scraper"
    }
  }
}
```

The client signs in with OAuth, or add `"headers": { "Authorization": "Bearer <APIFY_TOKEN>" }`.

Charged per reply delivered; the sample input above costs at most $0.02.

### FAQ

**Do I need a Threads or Instagram account?**
No. The Actor reads what anyone can see on a public Threads post.

**Can it read the replies to a private account's posts?**
No, only public posts.

**Can I get a profile's posts instead?**
Not with this Actor: it reads the replies to posts you link.

**Can I run it from my own code, on a schedule, or with other apps?**
Yes. Like any Apify Actor, you can start it through the Apify API, run it on a
schedule, and connect it to other apps with Apify's integrations and webhooks.

### Is it legal to scrape Threads?

This Actor reads only public replies that anyone can see. Replies hold
personal data, such as names, ids and pictures: check Meta's terms and the
laws that apply to you (such as the GDPR) before you use the data. If you are
unsure, ask a lawyer.

### Support

Found a problem or missing a feature? Open an issue on the **Issues** tab and
include the run's link.

***

This Actor is not affiliated with, endorsed by or sponsored by Threads, Meta
or Instagram.

# Changelog

This Actor's version history is a separate document: https://apify.com/luzivanlt/threads-replies-scraper/changelog.md

# Actor input Schema

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

Threads posts to read the replies of: links such as https://www.threads.com/@nasa/post/Dd9aFLHgnnj (threads.net links work too). Each post gives you its replies, newest first. A profile, search or tag link is not supported. Example: https://www.threads.com/@nasa/post/Dd9aFLHgnnj

## `maxRepliesPerPost` (type: `integer`):

Stop reading a post after this many replies (nested replies included). From 1 to 10,000; 100 if left empty. You pay per reply saved, so this caps each post's cost.

## `includeNestedReplies` (type: `boolean`):

Also read the replies to each reply, at every depth. Each one is its own row, with its level and the reply it answers. They count toward Max replies per post and are read after the page of replies they sit under, so raise that maximum to get them on a busy post. Off by default: only the replies to the post itself (and a replier's own follow-ups) are read.

## `onlyRepliesNewerThan` (type: `string`):

Keep only replies from this date on: a date (YYYY-MM-DD, UTC) or a period such as "7 days", "2 weeks" or "3 months". Leave empty for every reply. A date in the future is refused. Example: 7 days

## Actor input object example

```json
{
  "startUrls": [
    "https://www.threads.com/@nasa/post/Dd9aFLHgnnj"
  ],
  "maxRepliesPerPost": 20,
  "includeNestedReplies": false
}
```

# Actor output Schema

## `replies` (type: `string`):

Every reply the run saved, one row per reply.

## `allFields` (type: `string`):

The same rows with every field.

# 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.threads.com/@nasa/post/Dd9aFLHgnnj"
    ],
    "maxRepliesPerPost": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("luzivanlt/threads-replies-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.threads.com/@nasa/post/Dd9aFLHgnnj"],
    "maxRepliesPerPost": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("luzivanlt/threads-replies-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 '{
  "startUrls": [
    "https://www.threads.com/@nasa/post/Dd9aFLHgnnj"
  ],
  "maxRepliesPerPost": 20
}' |
apify call luzivanlt/threads-replies-scraper --silent --output-dataset

```

## MCP server setup

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