# Threads Scraper - Profiles, Posts, Replies, Search & Tags (`vladimir_trifonov/threads-scraper`) Actor

Scrape Threads (Meta) without login: profile stats, posts with likes and reply counts, full reply threads, keyword search and tags.

- **URL**: https://apify.com/vladimir\_trifonov/threads-scraper.md
- **Developed by:** [Vladimir Trifonov](https://apify.com/vladimir_trifonov) (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.40 / 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.

- **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 Scraper

Extract public data from **Threads (Meta)** — profiles, posts with engagement counts, full reply threads, keyword search and topic tags.

No login. No access token. No `doc_id`.

### Why the missing `doc_id` matters

Most Threads scrapers call Meta's private GraphQL endpoint, which requires a `doc_id` — an internal query identifier that Meta rotates without warning. When it changes, every tool holding a hardcoded copy breaks at once, and stays broken until someone ships an update. That is the single most common reason a Threads scraper that worked last month returns nothing today.

This Actor does not use GraphQL at all. It reads the server-rendered page, the same one your browser receives, and pulls the data Threads itself embeds there. There is no identifier to go stale.

### What you get

**Profiles** — follower count, bio, display name, verification, private flag, avatar, external link, plus that account's recent posts.

**Posts** — text, publication time, permanent link, author, likes, replies, reposts, quotes, a combined engagement number, images, videos, link cards, hashtags, mentions and detected language.

**Reply threads** — give it a post URL and it returns the post together with its replies, each labelled with the account it answers. This is the richest view the Actor produces.

**Search and tags** — collect the posts Threads shows publicly for a keyword or a topic tag.

### Example input

```json
{
  "profiles": ["zuck", "mosseri"],
  "searchQueries": ["ai agents"],
  "postUrls": ["https://www.threads.com/@zuck/post/Dbq20Xaj8RL"],
  "tags": ["ai"]
}
```

Any combination works; leave the lists you do not need empty.

### Example output

```json
{
  "type": "post",
  "source": "profile",
  "sourceValue": "zuck",
  "postId": "3957216315664483403",
  "code": "Dbq20Xaj8RL",
  "url": "https://www.threads.com/@zuck/post/Dbq20Xaj8RL",
  "username": "zuck",
  "fullName": "Mark Zuckerberg",
  "isVerified": true,
  "text": "Announcing Muse Code beta, our multi-agent coding harness...",
  "publishedAt": "2026-08-04T09:49:27.000Z",
  "likeCount": 2416,
  "replyCount": 243,
  "repostCount": 158,
  "quoteCount": 47,
  "engagementTotal": 2864,
  "hasMedia": false,
  "hashtags": [],
  "mentions": []
}
```

And a profile row:

```json
{
  "type": "profile",
  "username": "zuck",
  "fullName": "Mark Zuckerberg",
  "biography": "Mostly superintelligence and MMA takes",
  "followerCount": 5699793,
  "isVerified": true,
  "isPrivate": false,
  "profileUrl": "https://www.threads.com/@zuck"
}
```

Ready-made views — **Posts**, **Replies**, **Profiles** and **Media** — let you export just the columns you need.

### What people use it for

- **Competitor tracking** — follow what accounts in your niche post and which posts actually land
- **Audience research** — pull the replies under a popular post to read what people genuinely say
- **Influencer vetting** — compare follower counts against real per-post engagement before paying for a placement
- **Brand and topic monitoring** — search your brand or category on a schedule and catch mentions early
- **Content research** — rank posts by `engagementTotal` and study what the top ones have in common

### Honest limits

Read this before you buy — it will save you a disappointing run.

- **A profile returns its most recent posts, not its whole history.** Threads renders roughly the latest handful of posts into the page, and deeper paging requires the GraphQL path this Actor deliberately avoids. If you need thousands of posts from one account, this is not the right tool.
- **Replies are the deep surface.** A post URL typically yields around 30 rows — the post and its visible replies. That is where the volume is.
- **Public accounts only.** Private or removed profiles return a clear error rather than empty rows.
- **Engagement counts are whatever Threads shows publicly** and can lag the real numbers slightly.

### Proxies

Threads throttles by IP, and it does not answer a throttled address with an error — it returns a page that looks fine but contains no data. The Actor detects this and retries on a fresh address, but that only works if it has addresses to rotate. **Use residential proxies**, which is the default configuration.

### Pricing

Pay per result: you are charged for the rows you actually receive. A profile that turns out to be private or missing costs you nothing beyond the lookup.

### Integrations

Results are available through the Apify API and export as JSON, CSV, Excel or XML, or flow onward through the standard Apify integrations — Google Sheets, Slack, Zapier, Make, Airtable and webhooks.

### Is scraping Threads legal?

The Actor reads only pages Threads serves publicly, without logging in and without bypassing any access control — the same content any visitor sees. It collects no private posts and no contact details. How you use the data is your responsibility, particularly where it concerns identifiable people; check the rules that apply to you before collecting personal information at scale.

# Actor input Schema

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

Threads usernames to scrape. Accepts zuck, @zuck or a full profile link. Returns profile statistics plus that account's recent posts.

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

Links to individual posts, like https://www.threads.com/@zuck/post/ABC123. Returns the post together with its replies — the deepest data this Actor can reach.

## `searchQueries` (type: `array`):

Keywords to search across Threads. Each query returns the posts Threads shows publicly for it.

## `tags` (type: `array`):

Topic tags to collect posts from, with or without the leading #.

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

Stop once this many rows have been collected across all tasks. Leave at 0 for no limit.

## `includeReplies` (type: `boolean`):

Keep replies when scraping a post URL. Turn off to get only the original posts.

## `includeRelated` (type: `boolean`):

Threads pads post pages with unrelated recommendations. They are dropped by default; enable this to keep them.

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

Threads throttles by IP and answers unwanted addresses with an empty page instead of an error. Residential proxies are strongly recommended.

## Actor input object example

```json
{
  "profiles": [
    "zuck"
  ],
  "postUrls": [],
  "searchQueries": [],
  "tags": [],
  "maxItems": 0,
  "includeReplies": true,
  "includeRelated": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Every row from the run: profiles and posts.

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

Post text, author, publication time and engagement counts.

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

Replies collected from post URLs, with the account each one answers.

## `profiles` (type: `string`):

Follower counts, bios and verification status for the scraped accounts.

## `media` (type: `string`):

Direct links to the images and videos attached to the posts.

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

Per-run statistics: tasks requested, succeeded and failed, success rate, item totals and failure reasons.

# 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": [
        "zuck"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vladimir_trifonov/threads-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": ["zuck"] }

# Run the Actor and wait for it to finish
run = client.actor("vladimir_trifonov/threads-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 '{
  "profiles": [
    "zuck"
  ]
}' |
apify call vladimir_trifonov/threads-scraper --silent --output-dataset

```

## MCP server setup

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