# Threads Profile Replies Scraper (`automation-lab/threads-account-authored-replies`) Actor

Collect replies authored by public Threads accounts with text, timestamps, engagement, parent context and public-window provenance. No login; limited guest window, not full history.

- **URL**: https://apify.com/automation-lab/threads-account-authored-replies.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 item extracteds

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 Profile Replies Scraper

Collect **threads profile replies authored by selected public accounts**, rather than comments received on their posts. Supply usernames or profile URLs and receive reply text, source timestamps, visible engagement and parent context when available.

The public guest Replies tab is a **limited window**. This Actor does not unlock account history, authenticate, follow private accounts or guarantee that every reply appears. Four replies were exposed by the tested `zuck` window; other accounts may expose fewer or none.

### Who is it for?

Brand analysts, creator researchers and community teams can review where an account participates in public conversations. Use repeated snapshots for changes within the accessible window, not as a complete archive or continuous alert service.

### Why use it?

Account-authored activity is different from replies to a single monitored post. Each row identifies the selected account, the authored reply, its target author and adjacent parent context. Explicit provenance helps prevent sparse guest windows being mistaken for complete activity history.

### Getting started

1. Enter public accounts in `usernames`, such as `zuck`.
2. Set a global `maxItems` limit.
3. Run the Actor.
4. Inspect the default dataset and per-account `COVERAGE-` records in the key-value store.
5. Download JSON, CSV or Excel using Apify dataset exports.

### Input parameters

| Field | Meaning |
| --- | --- |
| `usernames` | Required array of 1–20 usernames, @handles or public Threads profile URLs. Case-insensitively deduplicated. |
| `maxItems` | Global accepted-reply limit across accounts in input order; default 20, range 1–500. |

```json
{"usernames":["zuck"],"maxItems":4}
```

Threads.com and legacy Threads.net profile URLs are accepted. Post URLs, extra paths, URL queries and fragments are rejected. No keyword, date or private-cookie inputs are supported.

### Extracted data

| Field | Meaning |
| --- | --- |
| `replyId`, `url` | Stable source ID and reply permalink |
| `username`, `text` | Selected account and authored reply text |
| `publishedAt` | Source timestamp converted to UTC ISO 8601 |
| `likes`, `replies`, `reposts`, `quotes` | Source-provided public counters, null when absent |
| `replyToUsername` | Target author exposed by Threads |
| `parent` | Adjacent source parent ID, username, URL and text when present |
| `sourceUrl`, `scrapedAt` | Replies-tab provenance and collection time |
| `coverage`, `fullHistory` | Limited public-window designation; fullHistory is always false |

Parent context is included in the same reply row and has no separate event charge. Counters may change between runs. Publication timestamps are source values, not inferred relative dates.

### Output example

A real tested reply from the public `zuck` window had text “Always fun when you visit 🙏”, 493 likes and target author `merab.dvalishvili`. The structure below anonymizes identifiers and content:

```json
{
  "replyId":"1234567890123456789",
  "url":"https://www.threads.com/@exampleuser/post/ExampleCode",
  "username":"exampleuser",
  "text":"Example reply",
  "publishedAt":"2026-08-10T00:00:00.000Z",
  "likes":10,
  "replies":2,
  "reposts":1,
  "quotes":0,
  "replyToUsername":"anotheruser",
  "parent":{"id":"1234567890123456788","username":"anotheruser","url":null,"text":"Example parent"},
  "sourceUrl":"https://www.threads.com/@exampleuser/replies",
  "scrapedAt":"2026-10-08T00:00:00.000Z",
  "coverage":"limited_public_profile_replies_window",
  "fullHistory":false
}
```

### Coverage and limits

There is no full-history pagination. Increasing `maxItems` cannot unlock login-gated records. Accounts are processed sequentially; earlier accounts can consume the global limit. Duplicate reply IDs in an account window are emitted once. A public account may have no visible replies even if it has authored replies elsewhere.

Per-account coverage records distinguish the available guest window from an output truncated by your limit. Later accounts skipped after reaching the global limit have no coverage receipt. Dataset rows cannot prove activity absence outside that window.

### How much does it cost to collect Threads profile replies?

The Actor uses a one-time start event and one event per accepted reply. Only emitted replies incur the item event; duplicate, rejected and unavailable records do not. Parent context is included. The start event is $0.005 per run. Per reply: FREE $0.0023, BRONZE $0.002, SILVER $0.00156, GOLD/PLATINUM/DIAMOND $0.0012. Spend tiers follow aggregate monthly Store spend, not this Actor's private volume. At BRONZE, four replies cost $0.013, ten cost $0.025 and 100 cost $0.205. These are estimates; public coverage may yield fewer replies. Billing caps may stop output earlier. No external paid API or proxy fee is passed through.

### Reliability and troubleshooting

A browser loads the public Replies tab and parses its account-bound structured query state. An empty export is accepted only when the requested public account's completed Replies connection explicitly contains no entries; unrelated conversations or page text cannot certify emptiness. Images, video and fonts are blocked. One fresh-context retry covers transient network failures, timeouts, rate limiting or server errors. A persistent upstream failure fails the run rather than claiming an empty successful export.

If Threads requires login, the account is unavailable or the response structure changes, check the run log. For a failed multi-account run, any existing rows are partial. There is no paid proxy fallback and no customer authentication requirement.

### Integrations

Use Apify schedules for repeated snapshots and compare `replyId` downstream. Send dataset rows to Google Sheets, a warehouse, Make, Zapier or an HTTP webhook integration. Deduplicate across runs in your own destination; the Actor does not retain an archive or send alerts itself.

### API usage

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~threads-account-authored-replies/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"usernames":["zuck"],"maxItems":4}'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/threads-account-authored-replies').call({ usernames: ['zuck'], maxItems: 4 });
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 4 });
```

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/threads-account-authored-replies').call(run_input={'usernames':['zuck'],'maxItems':4})
items = client.dataset(run['defaultDatasetId']).list_items(limit=4).items
```

### MCP usage

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/threads-account-authored-replies"
```

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/threads-account-authored-replies"}}}
```

For Claude Desktop, Cursor and VS Code, use the equivalent HTTP MCP configuration above in your client's MCP settings. Example prompts include “Collect four public account-authored replies and summarize their parent context.”

Discover the selected tool schema with `tools/list`. Actor selection also adds run/data tools. Example request: “Collect up to four publicly visible replies authored by zuck, and report limited coverage.”

Start once and keep the returned run ID. If pending, check the same run using bounded backoff (2, 4, 8 seconds, capped at 10) and a 120-second deadline; never restart merely to poll. On failure report partial rows honestly. Once successful, fetch dataset pages of 20 source rows with explicit offsets and fields. Process pages outside model context; admit at most 100 rows and 64 KiB, whichever comes first, and disclose truncation and continuation offset. If the client cannot intercept oversized results, do not promise a hard byte guarantee. These are consumer limits, not Actor collection limits.

### Legality and diagnostics

Only public guest-visible data is collected. Respect platform terms, privacy law and the rights of public authors. Public availability does not grant unrestricted reuse. Do not use this Actor to circumvent private-account access or infer complete user activity.

This Actor uses no AI for extraction and is not affiliated with Meta or Threads. It sends no data to an AI provider. Browser sessions are ephemeral and destroyed after each account; no cookies are persisted. Apify retains dataset/KV/log storage under your account's retention settings; delete run storage through Console/API when no longer needed. There is no Actor-managed archive. For support, open an issue on the Actor's Apify page.

Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; reports are retained for 30 days.

### FAQ

**Does this collect replies received on my posts?** No. It selects replies authored by the supplied account, across conversations exposed in its Replies tab.

**Can I collect everything with a high limit?** No. The public guest window is source-limited, with no full-history guarantee.

**Why do counts differ later?** Engagement and source visibility change over time. Compare snapshots with their collection timestamps.

**Are media files downloaded?** No. The contract is authored reply text, public engagement and parent context, not media archiving.

### Related Actors

- [Threads Scraper](https://apify.com/automation-lab/threads-scraper): profiles, account posts and search.
- [Threads Replies Scraper](https://apify.com/automation-lab/threads-replies-scraper): replies received on supplied post URLs.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/threads-account-authored-replies/changelog.md

# Actor input Schema

## `usernames` (type: `array`):

Supply 1–20 public usernames, @handles or Threads profile URLs. Accounts are case-insensitively deduplicated. Post URLs, URL queries and extra paths are rejected. Only replies authored by these accounts are returned, not replies received on their posts.

## `maxItems` (type: `integer`):

Global accepted-reply limit across all accounts in input order after account/reply deduplication. Zero/unlimited are unsupported. The public guest window may contain only a few replies; this limit does not unlock pagination or full account history.

## Actor input object example

```json
{
  "usernames": [
    "zuck"
  ],
  "maxItems": 4
}
```

# Actor output Schema

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

Typed public replies authored by supplied accounts.

# 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 = {
    "usernames": [
        "zuck"
    ],
    "maxItems": 4
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/threads-account-authored-replies").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 = {
    "usernames": ["zuck"],
    "maxItems": 4,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/threads-account-authored-replies").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 '{
  "usernames": [
    "zuck"
  ],
  "maxItems": 4
}' |
apify call automation-lab/threads-account-authored-replies --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/threads-account-authored-replies"
        }
    }
}
```

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/osbGrLg4QZcHsWLGV/builds/2Z6qFWsTTgISnV0LK/openapi.json