# Threads Comments & Replies Scraper (`s_actors/threads-replies-scraper`) Actor

Scrape every reply under Threads posts without login: newest first or top, replies to replies with the parent of each, author, likes, media, links and the post with exact views. Sentiment of each reply. Latest posts of profiles, Only new comments since the last run.

- **URL**: https://apify.com/s_actors/threads-replies-scraper.md
- **Developed by:** [Superior Actors](https://apify.com/s_actors) (community)
- **Categories:** Social media, Marketing, AI
- **Stats:** 5 total users, 4 monthly users, 98.1% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.15 / 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 Comments & Replies Scraper

Scrape **every comment and reply under Threads posts** and export them to CSV, Excel or JSON: reply text, author, **likes, replies, reposts, quotes**, posting time, images and videos, links and mentions, plus **replies to replies at every level** with the reply each one answers. Each row also carries the original post with its **exact view count**. Take **post links** or **profiles** (the latest posts of an account), get the replies **newest first** (all of them) or in Threads' **top order**, add **sentiment** (positive / neutral / negative) to every reply, and get **only new comments** since the last run to monitor your posts.

```json
{ "postUrls": ["https://www.threads.com/@zuck/post/Dd1MqfcG0aH"], "maxRepliesPerPost": 0 }
```

No Threads or Instagram login, no cookies, no browser extension. Use it as a **Threads comments API**: one call returns clean JSON. A visitor of the Threads website sees only the first few replies; this Actor pages through all of them (1,800+ replies of a viral post in about a minute).

#### What you get

One row per reply. Real example, October 2026 (replies to a [NASA post](https://www.threads.com/@nasa/post/DeKza99kXKb)):

| author | text | likeCount | replyCount | replyDepth | parentAuthorUsername | isLikedByPostAuthor | createdAt |
|---|---|---|---|---|---|---|---|
| stellerarts | JWST please, I can only paint so fast! I am still working on the last… | 136 | 4 | 1 | nasa | true | 2026-10-06 |
| nasa | 😍 | 19 | 0 | 2 | stellerarts | false | 2026-10-06 |
| b_righteous | And we're stuck here paying rent 🙄…… | 40 | 0 | 1 | nasa | false | 2026-10-06 |

| Field | Description |
|---|---|
| `postId`, `postCode`, `postUrl`, `text`, `createdAt` | Reply ID, short code, link, full text and exact posting time (UTC) |
| `likeCount`, `replyCount`, `repostCount`, `quoteCount` | Likes, replies, reposts and quotes of the reply |
| `replyDepth`, `threadPosition` | `1` = a direct reply to the post, `2` = a reply to a reply, and so on; the place of the conversation under the post (1 = first) |
| `parentPostId`, `parentPostUrl`, `parentAuthorUsername` | The post or reply this one answers: rebuild the full conversation tree |
| `isByPostAuthor`, `isLikedByPostAuthor` | The post's author replied; the post's author **liked this reply** |
| `mediaType`, `imageUrl`, `imageUrls`, `videoUrls`, `mediaCount` | `text`, `image`, `video` or `carousel`; every image (the cover for videos) and video file |
| `links`, `mentions`, `hashtags`, `linkPreviewTitle`, `linkPreviewDomain` | Links (real addresses, not `l.threads.com` redirects), @mentions, #hashtags, link card |
| `isQuote`, `quotedPostUrl`, `quotedPostAuthor`, `quotedPostText` | A quoted post inside the reply |
| `isEdited`, `countsHidden` | Edited; likes hidden by the author |
| `authorUsername`, `authorFullName`, `authorId`, `authorIsVerified`, `authorProfilePicUrl` | Who replied |
| `rootPostId`, `rootPostUrl`, `rootPostAuthor`, `rootPostText`, `rootPostViewCount` | The original post and its **exact** view count |
| `sortBy`, `input`, `scrapedAt` | Order of the run, the link or profile you gave, time of the run |
| `sentiment`, `sentimentScore` | With **Sentiment** on: `positive`, `neutral` or `negative` and a score from -1 to 1 (empty for replies not in English) |

A summary of every post (text, exact views, likes, reply count on Threads, replies scraped, sentiment split, errors) is in the run's **Output** tab → *Posts (JSON)*.

#### How it works

1. Add **Threads post links** (`https://www.threads.com/@user/post/...`, threads.net links work too) and/or **profiles**
2. Set **Max replies per post** (`0` = all) and the order
3. Run, then download the dataset as CSV, Excel, JSON or HTML

| Input | What it does |
|---|---|
| **Threads post links** | Any number of posts, read in parallel |
| **Profiles** + **Latest posts per profile** | The replies of each account's latest posts (default 5): your own account or a competitor's |
| **Max replies per post** | Default 100, `0` = all; replies to replies count too, and whole conversations are kept together |
| **Order** | **Newest first**: every reply, from the latest back to the first one. **Top first**: the order of the post page; Threads leaves out part of the low-ranked replies here (about half on viral posts) |
| **Replies to replies** | On by default: every level, with the parent of each reply. Off = direct replies only |
| **Sentiment** | Label every reply positive, neutral or negative with a score (see below) |
| **Only new replies since the previous run** | For schedules: only comments that no earlier run delivered |

#### Why this Actor

| | |
|---|---|
| 💬 **All replies, not the first few** | Newest first goes through every reply down to the first one: 1,829 direct replies of a 2,600-reply post |
| 🌳 **The whole conversation tree** | Replies to replies at every level, each with the reply it answers and its level |
| ❤️ **Which replies the author liked** | `isLikedByPostAuthor` and `isByPostAuthor`: see how a brand or creator engages with its audience |
| 👁️ **The post with exact views** | Every row carries the original post, its text and its exact view count |
| 👤 **Profiles in one go** | Give a username and get the comments on its latest posts |
| 🔔 **New-comment alerts** | Schedule it hourly: each run returns only new replies; a run with nothing new costs only the start |
| 😊 **Sentiment** | Positive, neutral or negative on every reply, and the split per post |
| 💰 **$0.252 per 1,000 replies** | Every level, the post's views and monitoring included |

#### Sentiment analysis of Threads replies

Switch on **Sentiment** and every English reply gets `sentiment` (`positive`, `neutral`, `negative`) and `sentimentScore` from -1 (most negative) to 1 (most positive). The run's status shows the split, the **Sentiment** tab of the results lists each reply with its label, and *Posts (JSON)* has the counts of every post. Real example, replies to a Mark Zuckerberg post, October 2026:

| text | sentiment | sentimentScore |
|---|---|---|
| Please help me to recover my account. Thank you | positive | 0.7579 |
| My account was locked in a second by the Meta AI security system… | negative | -0.6059 |
| Give my account back | neutral | 0 |

It uses the VADER rules, made for social media text: slang, emojis, CAPS, `!!!`, negation (`not good`) and `but`. No AI model is called, so it is fast and the same text always gets the same label. Replies in other languages and replies without text get an empty sentiment and are not charged. Polite requests read as positive and sarcasm is beyond any word-based method: read a sample before drawing conclusions.

#### Monitor comments: only new replies

1. Add your posts, or your profile with **Latest posts per profile**
2. Keep **Order** on Newest first, turn on **Only new replies since the previous run**, save as a task and add a schedule, e.g. every hour
3. **First run** returns the replies and remembers them. **Every later run** returns only replies posted since then, including new replies inside old conversations

What was seen is kept in your account (key-value store `threads-replies-state`), per post, and is shared by all your runs and tasks. Connect [Google Sheets](https://apify.com/s_actors/google-sheets-import-export), Slack or email with an integration to be notified.

#### Pricing

Pay per result, no subscription needed. Apify Scale and Business plans pay less:

| Event | Free and Starter plans | Scale plan | Business plan |
|---|---|---|---|
| Run start | $0.001 | $0.001 | $0.001 |
| Reply in the results | $0.000252 | $0.000194 | $0.000147 |
| Sentiment (add-on, per English reply labelled) | $0.00139 | $0.001251 | $0.001112 |

| Task | Cost |
|---|---|
| 100 replies of one post | ~$0.026 |
| 100 replies with sentiment | ~$0.16 |
| All 2,000 replies of a viral post | ~$0.51 |
| Comments on the latest 5 posts of a profile (500 replies) | ~$0.13 |
| Hourly new-comment alert for a profile for a month | ~$0.72 + $0.000252 per new reply |

Posts that do not exist and replies a monitoring run already delivered are not charged.

#### Ready-made tasks

Open it, change the post link, and run:

| Task | What you get |
|---|---|
| [Export Threads Comments and Replies to CSV](https://apify.com/s_actors/threads-replies-scraper/examples/export-threads-comments-to-csv) | Every reply of a post with authors, likes and the reply each one answers |

#### FAQ

**Can I get all comments of a post?** Yes: set **Max replies per post** to `0` and keep **Order** on Newest first. Threads' own reply count also includes replies that were deleted, hidden by the author or restricted, so the Actor usually returns a bit fewer than the number shown under the post.

**What is the difference between Newest first and Top first?** Newest first returns every reply by time. Top first is the order of the post page; Threads stops this list earlier and leaves out part of the low-ranked replies.

**How do I rebuild the conversation?** Each row has `parentPostId` (the post or reply it answers) and `replyDepth`. Rows with the same `threadPosition` belong to one conversation under the post.

**Can I pick a random comment for a giveaway?** Yes: export all replies, then draw one from the dataset (in Excel or Google Sheets); `authorUsername` lets you drop duplicate entries.

**Which languages does sentiment support?** English, plus replies of only emojis. Replies in Spanish, Portuguese, Arabic, Chinese and other languages stay in the results with an empty sentiment, free of the sentiment charge.

**Do I need a Threads or Instagram account or cookies?** No. The Actor reads the public replies the way the Threads website does for a visitor.

**How long do the image and video links work?** `imageUrls`, `videoUrls` and profile pictures are Threads' own CDN links and expire after a few days: download the files you need soon after the run.

#### Use with the API and AI agents

Run it via the [Apify API](https://docs.apify.com/api/v2) from Python, Node.js or any HTTP client, or connect it to Claude, ChatGPT and other AI agents through the [Apify MCP server](https://mcp.apify.com): "Read all replies to our latest Threads post and sum up what people complain about."

#### Other Threads tools

| Tool | What it does |
|---|---|
| [Threads Scraper](https://apify.com/s_actors/threads-scraper) | All posts, views and profiles of Threads accounts |
| [Threads Search Scraper](https://apify.com/s_actors/threads-search-scraper) | Posts by keyword and hashtag, newest first or top |
| [TikTok Comments Scraper](https://apify.com/s_actors/tiktok-comments-scraper) | Comments and replies of TikTok videos |
| [YouTube Comments Scraper](https://apify.com/s_actors/youtube-comments-scraper) | Comments and replies of YouTube videos |
| [Google Sheets Import & Export](https://apify.com/s_actors/google-sheets-import-export) | Send the replies to a Google Sheet |

#### Is it legal?

The Actor collects only public replies and stats that Threads shows to any visitor, without logging in. Replies are their authors' content: respect copyright when you reuse texts and images, and use personal data such as usernames in line with GDPR and other privacy laws.

# Actor input Schema

## `postUrls` (type: `array`):

One per line: a link to a Threads post (https://www.threads.com/@user/post/CODE; threads.net links work too). Every reply under each post is scraped.

## `profiles` (type: `array`):

Optional: @username, a username or a profile link. The Actor takes the latest posts of each profile (pinned ones included) and scrapes their replies. Handy for monitoring the comments on your own or a competitor's account.

## `postsPerProfile` (type: `integer`):

How many of each profile's latest posts to take.

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

How many replies to scrape for each post, replies to replies included. 0 = all of them (thousands for viral posts).

## `sortBy` (type: `string`):

Newest first = every reply, from the latest back to the first one (complete exports and monitoring). Top first = the order Threads shows on the post page; Threads leaves out part of the low-ranked replies in this order (about half on viral posts).

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

Also scrape the replies under each reply, at every level, with the parent reply of each row. Off = only the direct replies to the post (and the ones Threads shows right under them).

## `analyzeSentiment` (type: `boolean`):

Add sentiment and sentimentScore to every English reply and every reply of only emojis: positive, neutral or negative, and a score from -1 (most negative) to 1 (most positive), by the VADER rules made for social media text (slang, emojis, CAPS, "!!!", "not good", "good but"). Replies in other languages get an empty sentiment and are not charged. The status message and the POSTS summary show the share of each per post. Charged per labelled reply (see Pricing).

## `onlyNewReplies` (type: `boolean`):

Output only replies that no earlier run delivered for the same post (key-value store threads-replies-state). With Newest first the Actor stops paging at the previous run's newest reply. The first run outputs replies as usual and remembers them. A run with no new replies costs only the start.

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

How many posts are read in parallel. Each post pages its replies on its own (about 45 replies a request).

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

Requests go direct first and switch to Apify datacenter proxies (then residential) when Threads refuses them. The default works for most runs.

## `debugLog` (type: `boolean`):

Log every retried request (for troubleshooting).

## Actor input object example

```json
{
  "postUrls": [
    "https://www.threads.com/@zuck/post/Dd1MqfcG0aH"
  ],
  "postsPerProfile": 5,
  "maxRepliesPerPost": 50,
  "sortBy": "recent",
  "includeNestedReplies": true,
  "analyzeSentiment": false,
  "onlyNewReplies": false,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "debugLog": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Every reply: author, text, likes, replies, level, the reply it answers, date, links.

## `authors` (type: `string`):

Who replied: photo, username, name, verified badge, post author flag.

## `posts` (type: `string`):

One line per post: text, exact views, likes, reply count on Threads, replies scraped, errors.

## `sentiment` (type: `string`):

With Sentiment on: each reply positive, neutral or negative, with a score from -1 to 1.

## `all` (type: `string`):

Every field of every row.

# 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 = {
    "postUrls": [
        "https://www.threads.com/@zuck/post/Dd1MqfcG0aH"
    ],
    "maxRepliesPerPost": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("s_actors/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 = {
    "postUrls": ["https://www.threads.com/@zuck/post/Dd1MqfcG0aH"],
    "maxRepliesPerPost": 50,
}

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

```

## MCP server setup

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