# Threads Replies Scraper - No Login (`parsedeck/threads-replies-scraper`) Actor

Scrape every reply Threads shows publicly on a post - reliably and fully populated. No login, no account.

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

## Pricing

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Threads Replies Scraper - No Login

Scrape every reply Threads shows publicly on a post - reliably and fully populated. No account, no cookies, no API key. Paste post URLs, get back structured JSON: author, text, engagement, media, nesting, the lot.

Built because the only other replies scraper on the Store finishes 4 out of 5 runs and ships thin, partly-empty records. This one is built reliability-first: automatic recovery from soft-blocks, health-monitored around the clock, and it never silently serves garbage - a bad run pauses itself rather than damage your data.

### Features

- **No login required** - works on any public Threads post, exactly as a logged-out visitor sees it
- **Full field set** - author (username, display name, verified badge, avatar), engagement (likes, replies, reposts, quotes, shares), media (photo/video/carousel/gif, dimensions, alt text), timestamps, mentions, hashtags, links
- **Real reply nesting** - `is_top_level` and `parent_reply_id` resolved for ~96% of replies; the ambiguous ~4% (usually an author replying to themselves) are left `null`, never guessed
- **Honest nulls** - a field is `null` only when Threads genuinely doesn't expose it logged-out (e.g. `view_count`), never because parsing failed
- **Partial-batch delivery** - one broken post in a 20-post batch never blocks the rest; you get every post that worked, the failures are flagged, and you're billed only for what's delivered
- **Self-healing** - automatic session rotation if Threads serves a soft-block, a rotating canary that watches run health around the clock, and an auto-pause if something breaks for real (protects you from a degraded run, not just us)

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `post_urls` | array of strings | *(required)* | Up to 20 Threads post URLs, e.g. `https://www.threads.com/@username/post/ABC123` |
| `max_replies` | integer | 40 | Cap on replies returned per post. Range 10-50, matching Threads' own logged-out visible ceiling |
| `include_nested_replies` | boolean | true | Adds `is_top_level` and `parent_reply_id` to each reply |

Example input:

```json
{
  "post_urls": ["https://www.threads.com/@zuck/post/C8Vk2tLxupR"],
  "max_replies": 40,
  "include_nested_replies": true
}
```

### Example output

One reply record, taken from a live run (image URL truncated for readability):

```json
{
  "reply_id": "Dad19aBFN5B",
  "author_username": "brycebots",
  "author_display_name": "Bryce Botsford",
  "author_is_verified": false,
  "author_profile_pic_url": "https://instagram.frba3-2.fna.fbcdn.net/...",
  "author_profile_url": "https://www.threads.com/@brycebots",
  "text_content": "They literally made fun of AI in the movie",
  "mentions": [],
  "hashtags": [],
  "urls": [],
  "like_count": 149,
  "reply_count": 0,
  "repost_count": 0,
  "quote_count": 0,
  "share_count": 1,
  "view_count": null,
  "created_at": "2026-07-06T21:20:25.000Z",
  "has_media": true,
  "media_type": 1,
  "media_category": "photo",
  "media_url": "https://instagram.frba3-2.fna.fbcdn.net/...",
  "media_width": 1290,
  "media_height": 1573,
  "reply_to_username": "lanenomad",
  "parent_reply_id": null,
  "is_top_level": true,
  "is_reply": true,
  "item_type": "reply",
  "source_post_url": "https://www.threads.com/@lanenomad/post/DadD0tukYzZ",
  "scraped_at": "2026-07-13T05:38:33.178Z"
}
```

The original post is returned too (`item_type: "original_post"`), so you always have the full context, not just an orphaned list of replies.

### How it works

We fetch the exact page a logged-out browser loads when you open a public Threads post. Threads embeds the entire reply tree directly in that page's HTML - no separate API call, no login. We parse it straight out of the response.

If Threads ever serves an empty app shell instead of the real page (a rare, intermittent soft-block), we detect it immediately and retry through a fresh residential IP - the kind of self-healing most scrapers in this niche don't bother with.

### Pricing

$5 per 1,000 results, and nothing else - no run fee, no separate platform usage charge. A result is either a reply or the original post - so a 20-post batch averaging ~40 replies each returns roughly 800 results, about $4.00. On Apify's free plan your monthly platform credit covers your first ~1,000 results, so you can check the data quality before paying anything.

### How we compare to the incumbent

| | This actor | The only other replies scraper on the Store |
|---|---|---|
| Rating | new | 1.19★ |
| Success rate | reliability-first design: session rotation, canary monitoring, auto-pause | 77.9% and degrading |
| Max replies/post | 10-50 | 10-50 |
| Nesting | `is_top_level` + `parent_reply_id`, ~96% resolved | flat, `reply_to_username` only |
| Field completeness | full engagement + media + honest null discipline | partial |
| Price | $5 / 1,000 results | $2.50 / 1,000 results |

We cost more per result because we finish the run and give you real data when we do. A cheap actor that fails one run in five, or hands back half-empty records, isn't actually cheaper.

### Limitations (read this before you buy)

Threads caps how many replies it shows a logged-out visitor - typically tens per post, up to this actor's 50-per-post ceiling, never the full count on a large thread. **This actor returns every reply in that public view, completely and reliably.** It does not, and cannot without logging in, return every reply on a thread with hundreds or thousands of replies. Any actor claiming otherwise is either exaggerating or scraping while logged in, which is a different risk profile (account bans, ToS exposure) than this actor takes on.

A small share of replies (~4%, usually a self-reply) can't be confidently linked to a parent reply. We leave `parent_reply_id` as `null` in that case rather than guess - a wrong guess is worse than an honest gap.

### FAQ

**Does this work without a Threads account?**
Yes. Every request is made logged-out, exactly as any visitor sees it. No cookies, no session, no login step.

**Why didn't I get every reply on my post?**
See Limitations above - Threads itself caps what a logged-out visitor can see. We return everything in that view.

**What counts as one billable result?**
Each reply and the original post, each as one dataset record.

**Can this scrape a private or protected account's posts?**
No. It only reads what's publicly visible, by design - that's also why it never needs your Threads credentials.

**What happens if one of my post URLs is deleted or fails?**
The batch still succeeds. The working posts are delivered, the failed one is flagged by URL in the run summary, and you're only billed for what came back.

**How long does a run take?**
Roughly 5-10 seconds per post, run sequentially (deliberately, not in parallel - it's the safer way to stay reliable at volume).

### Use in Claude, ChatGPT, or any MCP-compatible agent

Apify actors are callable through Apify's MCP server, so this scraper can be wired straight into an AI agent's toolset - hand it a Threads post URL in conversation and get structured reply data back, no separate scraping step.

### Changelog

- **v0.1** - initial release: fetch, parse, reliability layer, honest field completeness vs the incumbent.

***

*This actor is not affiliated with, endorsed by, or sponsored by Meta Platforms, Inc. or Threads. It reads only publicly available data through Threads' own public web pages, exactly as a logged-out visitor's browser would.*

# Actor input Schema

## `post_urls` (type: `array`):

The Threads posts to scrape replies from. Paste up to 20 post URLs (e.g. https://www.threads.com/@username/post/ABC123). Returns every reply Threads shows publicly for each - typically tens per post, not every reply on very large threads.

## `max_replies` (type: `integer`):

Cap on replies returned per post. The public logged-out view shows roughly tens of replies per post; this caps at that visible ceiling.

## `include_nested_replies` (type: `boolean`):

Add nesting fields to each reply: is\_top\_level (a direct reply to the post) and parent\_reply\_id (the parent reply, resolved for ~96% of replies; null for the small share Threads leaves ambiguous logged-out). We never guess a parent.

## Actor input object example

```json
{
  "post_urls": [
    "https://www.threads.com/@mosseri/post/DalA5HOFvaC",
    "https://www.threads.com/@mosseri/post/DaxpWl5gJjx"
  ],
  "max_replies": 40,
  "include_nested_replies": true
}
```

# Actor output Schema

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

Every scraped reply plus one original-post record per source post, as JSON items in the default dataset.

# 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 = {
    "post_urls": [
        "https://www.threads.com/@mosseri/post/DalA5HOFvaC",
        "https://www.threads.com/@mosseri/post/DaxpWl5gJjx"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsedeck/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 = { "post_urls": [
        "https://www.threads.com/@mosseri/post/DalA5HOFvaC",
        "https://www.threads.com/@mosseri/post/DaxpWl5gJjx",
    ] }

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

```

## MCP server setup

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