# Threads User Replies Scraper (`futurizerush/threads-user-replies-scraper`) Actor

Collect public replies from Threads profile Replies tabs. Export each user reply with replied-to content when available, author details, timestamps, available engagement counts, media links when present, and source URLs for research and public conversation review. (Beta)

- **URL**: https://apify.com/futurizerush/threads-user-replies-scraper.md
- **Developed by:** [Rush](https://apify.com/futurizerush) (community)
- **Categories:** AI, Agents, Automation
- **Stats:** 4 total users, 3 monthly users, 93.8% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 User Replies Scraper

Collect public replies from a Threads profile's **Replies** tab and export structured rows for review and download.

Use this Actor when you want to understand what a public Threads user replied to, what they said, when they replied, and which replied-to public content was visible with that reply.

[Explore more FuturizeRush Actors](https://apify.com/futurizerush?fpr=rush)

### What You Get

- Public user reply rows from Threads profile Replies tabs
- Reply rows with replied-to public content fields on the same row when available
- Author username, display name, verification status, and profile URL
- Reply text, content type, timestamps, available engagement counts, view count status, media links when present, mentions, hashtags, and URLs
- A run summary with saved row counts and completion status

### How to Use

1. Paste one or more Threads profile URLs, Replies tab URLs, or usernames.
2. Choose the maximum number of public reply rows to save per profile.
3. Start the Actor.
4. Review the default dataset view or download the results in your preferred format.
5. Open the run summary when you need saved row counts or completion status.

### Input

You can provide profile URLs, Replies tab URLs, usernames, or a mix of them. Use up to 20 profiles per run.
`max_replies_per_profile` accepts 10 to 5,000 and is a per-profile cap, not a promised result count. Use a larger value when you want the run to keep looking for public replies until the selected cap is reached or no more public replies are available during the run.

```json
{
  "profiles": [
    "https://www.threads.com/@boris_cherny"
  ],
  "max_replies_per_profile": 20
}
````

### Output

Each saved row represents one public reply written by the requested profile.

The dataset is organized around four practical views:

- Reply Review: a readable preview of the requested profile's reply
- Replied-To Content: the public content visible with that reply when available
- Engagement: available public counts and view count status for the user reply and the replied-to content
- Media & Links: media when present, URLs, mentions, and hashtags from the saved reply

#### Short Output Example

This synthetic, shortened example shows the most important fields. The Dataset schema defines the full export field list.

```json
{
  "record_type": "user_reply",
  "input_username": "sample_profile",
  "profile_username": "sample_profile",
  "target_reply_code": "EXAMPLE_REPLY_ID",
  "reply_content_type": "text",
  "reply_content_preview": "Thanks for the helpful details.",
  "reply_text": "Thanks for the helpful details.",
  "reply_url": "https://www.threads.com/@sample_profile/post/EXAMPLE_REPLY_ID",
  "reply_like_count": 4,
  "reply_reply_count": 0,
  "reply_repost_count": 1,
  "reply_quote_count": 0,
  "reply_share_count": 2,
  "reply_view_count": 120,
  "reply_view_count_status": "available",
  "replied_to_available": true,
  "replied_to_author_username": "example_user",
  "replied_to_text": "Here is the original public comment.",
  "replied_to_post_url": "https://www.threads.com/@example_user/post/EXAMPLE_CONTEXT_ID",
  "replied_to_like_count": 38,
  "replied_to_reply_count": 6,
  "replied_to_repost_count": 3,
  "replied_to_quote_count": 1,
  "replied_to_share_count": 7,
  "replied_to_view_count": 840,
  "replied_to_view_count_status": "available",
  "created_at": "2026-01-15T03:31:15Z",
  "has_media": false,
  "media_type": "none",
  "media_url": "",
  "media_urls": [],
  "has_sticker": false,
  "sticker_count": 0,
  "sticker_urls": [],
  "urls": [],
  "source_tab": "profile_replies",
  "scraped_at": "2026-06-15T02:30:00Z"
}
```

Fields that start with `reply_` describe the requested user's reply. `reply_text` contains only visible reply text; media, GIFs, and stickers are represented by their own fields. Fields that start with `replied_to_` describe the public content they replied to when that content is available. View count status fields help distinguish available view counts from counts that were not publicly available during the run.

For most reviews, start with the `reply_*` and `replied_to_*` fields. Full exports also include saved-row fields such as `post_url`, `text_content`, and `like_count`; for this Actor, those fields mirror the requested user's reply row and help spreadsheets and automations work with a predictable export shape.

`conversation_index` is the saved result order for the requested profile.

### Dataset Views

- 💬 Reply Review: the default view for reading reply previews next to the public content they replied to
- 📊 Engagement: available reply-side and replied-to-side counts, including view count status, for comparison
- 🧵 Replied-To Content: conversation context fields for review
- 🔗 Reply Media & Links: media, stickers, URLs, mentions, and hashtags from saved replies

Main dataset fields include the requested profile, reply content type, reply preview, reply text, reply URL, reply time, available user reply counts, view count status, replied-to author, replied-to text, replied-to URL, available replied-to counts, media links when present, stickers when present, mentions, hashtags, and source timestamps. The dataset schema defines the complete field list for exports and advanced workflows.

### Common Use Cases

- Social listening and community research
- Audience and creator engagement analysis
- Public reply and conversation review
- Replied-to conversation review
- Public Threads research datasets

### FAQ

#### Does this collect private content?

No. It is designed for public Threads profile pages and saves only public content that is available at run time.

#### How is replied-to content included?

When Threads shows the replied-to post or comment next to the user's reply, that public content is included on the same saved reply row in the `replied_to_*` fields.

#### Can I choose how many replies to save?

The selected maximum is a cap, not a promised result count. The Actor saves public reply items exposed on the requested profile's Replies tab at run time, and the final run summary reports how many were actually saved. Threads may limit or change what is publicly visible.

#### Why can `reply_text` be empty?

`reply_text` contains only visible text. A reply can still be valid when it is image-only, GIF-only, sticker-only, quote-only, or otherwise has no visible text. Use `reply_content_type`, `reply_content_preview`, `media_url`, `media_urls`, and `sticker_urls` to review those rows.

#### Why are some fields empty or null?

Some public pages expose different metrics or media details across rows. Unavailable text fields are saved as empty strings, while unavailable numeric or optional fields may be null.

#### Can I use profile URLs instead of usernames?

Yes. You can paste profile URLs such as `https://www.threads.com/@zuck`, Replies tab URLs such as `https://www.threads.com/@zuck/replies`, or usernames in the `profiles` field.

### Related Actors

This Actor collects replies written by a public profile. If you need replies under a specific Threads post, use the post replies Actor instead.

- [Threads Scraper - Posts, Profiles & Search](https://apify.com/futurizerush/meta-threads-scraper?fpr=rush)
- [Threads Replies Scraper](https://apify.com/futurizerush/threads-replies-scraper?fpr=rush)

### Disclaimer

This Actor is intended for collecting publicly available Threads data for legitimate research, monitoring, and analysis.

- It is not affiliated with Threads, Meta, or Instagram.
- It does not collect private content.
- Public page availability, structure, and completeness can change.
- Review your use case, applicable laws, platform terms, and privacy obligations before using or sharing collected data.

### Keywords

Threads scraper, Threads user replies scraper, Threads replies, Threads comments, Threads profile replies, Threads social listening, Threads engagement analysis, Threads audience research, Threads community monitoring, Apify Threads Actor, Claude Code, OpenClaw, Gemini, Antigravity, Codex, ChatGPT

# Actor input Schema

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

Paste up to 20 Threads profile URLs or usernames. Replies tab URLs also work. Example: https://www.threads.com/@boris\_cherny

## `max_replies_per_profile` (type: `integer`):

Set a per-profile cap for public reply rows. The final saved count can be lower when fewer public replies are available during the run.

## Actor input object example

```json
{
  "profiles": [
    "https://www.threads.com/@boris_cherny",
    "https://www.threads.com/@duolingo",
    "https://www.threads.com/@futurizerush"
  ],
  "max_replies_per_profile": 20
}
```

# Actor output Schema

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

Saved user reply rows with replied-to public content fields when available.

## `summary` (type: `string`):

Final status, saved row counts, profile totals, and any profiles that could not be completed.

# 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 = {
    "profiles": [
        "https://www.threads.com/@boris_cherny",
        "https://www.threads.com/@duolingo",
        "https://www.threads.com/@futurizerush"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("futurizerush/threads-user-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 = { "profiles": [
        "https://www.threads.com/@boris_cherny",
        "https://www.threads.com/@duolingo",
        "https://www.threads.com/@futurizerush",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("futurizerush/threads-user-replies-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "profiles": [
    "https://www.threads.com/@boris_cherny",
    "https://www.threads.com/@duolingo",
    "https://www.threads.com/@futurizerush"
  ]
}' |
apify call futurizerush/threads-user-replies-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=futurizerush/threads-user-replies-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Threads User Replies Scraper",
        "description": "Collect public replies from Threads profile Replies tabs. Export each user reply with replied-to content when available, author details, timestamps, available engagement counts, media links when present, and source URLs for research and public conversation review. (Beta)",
        "version": "0.0",
        "x-build-id": "AfaCAZ9Mc3a4sf6hw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/futurizerush~threads-user-replies-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-futurizerush-threads-user-replies-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/futurizerush~threads-user-replies-scraper/runs": {
            "post": {
                "operationId": "runs-sync-futurizerush-threads-user-replies-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/futurizerush~threads-user-replies-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-futurizerush-threads-user-replies-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "profiles"
                ],
                "properties": {
                    "profiles": {
                        "title": "👤 Threads profiles or usernames",
                        "minItems": 1,
                        "maxItems": 20,
                        "type": "array",
                        "description": "Paste up to 20 Threads profile URLs or usernames. Replies tab URLs also work. Example: https://www.threads.com/@boris_cherny",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 200
                        }
                    },
                    "max_replies_per_profile": {
                        "title": "📊 Max replies per profile",
                        "minimum": 10,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Set a per-profile cap for public reply rows. The final saved count can be lower when fewer public replies are available during the run.",
                        "default": 20
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
