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

Scrape Meta Threads (threads.net) posts by keyword, the latest posts of any profile, and the replies under any post. Get text, likes, replies, reposts, quotes, shares, images, video links and author details. No login or cookies needed. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/clover_folktale/threads-scraper.md
- **Developed by:** [Silkline](https://apify.com/clover_folktale) (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

from $3.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?

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 Scraper extracts public data from Threads (threads.net), the social app by Meta, and returns clean, flat JSON. It works in three modes: search posts by keyword, get the latest posts of any profile, and collect the replies under any post. Every item includes the text, likes, replies, reposts, quotes, shares, image and video links, and the public profile of the author. No Threads or Instagram account, API keys, proxies or cookies needed.

It is made for marketers, social media analysts, researchers and developers who want Threads posts and replies in a spreadsheet, database or data pipeline. Pricing is pay per event: **$0.003 per post or reply**, plus a **$0.01 start fee** for each keyword, profile or post you give it, so you can work out the cost before you run.

### What is Threads?

Threads is a social app from Meta for short public posts, available on the web at threads.net. People publish text, images and videos, and other users like, reply to, repost, quote and share them. This Actor turns those public posts and replies into structured data you can filter, sort and analyse.

### What data can you get?

#### Modes

| Mode | Give it | You get |
|---|---|---|
| `search` | keywords | up to 20 posts per keyword |
| `userPosts` | usernames, @names or profile links | the latest posts of each profile, up to 25, with the author's bio and follower count (replies to other people are left out) |
| `replies` | Threads post links | the direct replies under each post, up to about 20 |

#### Fields

Every item is one post (`"type": "post"`) or one reply (`"type": "reply"`). The table lists the exact field names in the dataset.

| Field | What it contains | Where you get it |
|---|---|---|
| `text` | Post or reply text; `null` for pictures without a caption | All modes |
| `likeCount` | Number of likes | All modes |
| `replyCount` | Number of replies | All modes |
| `repostCount` | Number of reposts | All modes |
| `quoteCount` | Number of quotes | All modes |
| `shareCount` | Number of shares | All modes |
| `createdAt` | Publishing time, ISO 8601 UTC | All modes |
| `url` | Link to the post or reply on threads.net | All modes |
| `username` | Public username of the author | All modes |
| `userId` | Author's Threads user ID | All modes |
| `displayName` | Public display name of the author | Posts only; not included on replies |
| `avatarUrl` | Author's profile picture URL (largest available in profile mode) | All modes |
| `isVerified` | Whether the author has a verified badge | All modes |
| `isPrivate` | Whether the author's account is private | All modes |
| `authorFollowers` | Follower count of the author | `userPosts` only (`null` on search posts; not included on replies) |
| `bio` | Author's bio as published | `userPosts` only (`null` on search posts; not included on replies) |
| `mediaType` | `text`, `image`, `video` or `carousel` | All modes |
| `imageUrls` | Pictures of the post (one per carousel slide); an empty list when there are none | All modes |
| `videoUrl` | First video of the post | All modes |
| `type` | `post` or `reply` | All modes |
| `postId` | Post ID | Posts |
| `shortcode` | The code in the post or reply link | All modes |
| `replyId` | Reply ID | Replies |
| `parentPostId` | ID of the post a reply belongs to | Replies |
| `parentUsername` | Username of the author being replied to | Replies |

In Apify Console the dataset has two table views, **Posts** and **Replies**, that show the text, username, main counts, `createdAt` and `url` at a glance. The full items with all fields are included in every export.

### How to use Threads Scraper

1. Open Threads Scraper in Apify Console.
2. Choose a **Mode**: search posts by keyword, profile posts, or replies of posts.
3. Fill in the list for that mode: keywords, usernames or post links. Usernames can be written as `zuck`, `@zuck` or `https://www.threads.net/@zuck`. Profile posts and replies modes need at least one entry.
4. Set **Max results per keyword, profile or post** (default 20).
5. Click **Start**.
6. Open the dataset and export the results as JSON, CSV or Excel, or read them through the Apify API.

### Input

| Field | Type | Required | What it does | Default |
|---|---|---|---|---|
| `mode` | string | Required | What to scrape: `search` (posts by keyword), `userPosts` (posts of profiles) or `replies` (replies under posts) | `search` |
| `keywords` | array of strings | Optional (mode `search`) | Search keywords; each returns up to 20 posts. Falls back to "coffee" when empty | none (prefilled with `coffee` in Console) |
| `usernames` | array of strings | Required in mode `userPosts` | Usernames (`zuck`), `@zuck` or profile links; each returns up to the 25 most recent posts, replies to others left out | none (prefilled with `zuck` in Console) |
| `postUrls` | array of strings | Required in mode `replies` | Threads post links (`https://www.threads.net/@<user>/post/<code>`); each returns up to about 20 direct replies | none (prefilled with one sample post link in Console) |
| `maxResults` | integer (1 to 25) | Optional | Maximum items per keyword, profile or post; capped at 20 for search, 25 for profile posts and 20 for replies | `20` |

`maxResults` is the limit for each keyword, profile or post, not for the whole run. The run delivers at most that many items per input. Threads returns one page only per input, so a value above the cap of a mode does not return more items.

In `userPosts` mode `usernames` must contain at least one entry, and in `replies` mode `postUrls` must contain at least one entry; an empty list fails the run. The Console prefill does not apply to API calls. An entry that is not a readable username or post link also fails the whole run. Only `keywords` falls back to "coffee" when empty. Each list is cut to its first 50 unique entries; the rest are dropped.

#### Search posts by keyword

```json
{
  "mode": "search",
  "keywords": ["coffee", "espresso machine"],
  "maxResults": 20
}
```

#### Profile posts

```json
{
  "mode": "userPosts",
  "usernames": ["zuck", "@mosseri"],
  "maxResults": 25
}
```

#### Replies of a post

```json
{
  "mode": "replies",
  "postUrls": ["https://www.threads.net/@jue.halus/post/DeOvnAEiZHG"],
  "maxResults": 20
}
```

#### Empty input

An empty input `{}` searches for "coffee" and returns up to 20 posts. It is a quick way to see the output format.

### Output example

The values below are illustrative samples.

#### Post (profile mode)

```json
{
  "type": "post",
  "postId": "3998123456789012345",
  "shortcode": "DdAbCdEfGhI",
  "url": "https://www.threads.net/@sample.roastery/post/DdAbCdEfGhI",
  "text": "New single-origin beans are in this week. Which brew method should we test first?",
  "username": "sample.roastery",
  "userId": "63123456789",
  "displayName": "Sample Roastery",
  "avatarUrl": "https://.../avatar.jpg",
  "isVerified": false,
  "isPrivate": false,
  "authorFollowers": 12840,
  "bio": "Small-batch coffee roaster. Brewing tips every week.",
  "createdAt": "2026-10-08T09:21:54Z",
  "likeCount": 148,
  "replyCount": 20,
  "repostCount": 6,
  "quoteCount": 0,
  "shareCount": 7,
  "mediaType": "carousel",
  "imageUrls": ["https://.../slide1.jpg", "https://.../slide2.jpg"],
  "videoUrl": null
}
```

In search mode posts have the same fields, but `authorFollowers` and `bio` are `null`.

#### Reply

Reply items do not include `displayName`, `authorFollowers` or `bio`.

```json
{
  "type": "reply",
  "replyId": "3998234567890123456",
  "parentPostId": "3998123456789012345",
  "parentUsername": "sample.roastery",
  "shortcode": "DdBcDeFgHiJ",
  "url": "https://www.threads.net/@sample.reader/post/DdBcDeFgHiJ",
  "text": "Pour-over first, please!",
  "username": "sample.reader",
  "userId": "58123456789",
  "avatarUrl": "https://.../avatar.jpg",
  "isVerified": false,
  "isPrivate": false,
  "createdAt": "2026-10-08T10:02:11Z",
  "likeCount": 12,
  "replyCount": 1,
  "repostCount": 0,
  "quoteCount": 0,
  "shareCount": 0,
  "mediaType": "text",
  "imageUrls": [],
  "videoUrl": null
}
```

### How much does it cost?

Threads Scraper uses pay-per-event pricing. There are two events:

| Event | Price | When it is charged |
|---|---|---|
| Start fee (`run-start`) | $0.01 | Once for each keyword, profile or post you give it |
| Result (`result`) | $0.003 | For each post or reply returned |

Examples:

- 20 search results for one keyword: $0.01 + 20 × $0.003 = **$0.07**.
- Two keywords with 20 results each: **$0.14**.
- **100 results** from five keywords (20 each): 5 × $0.01 + 100 × $0.003 = **$0.35**.
- 100 results from four profiles (25 each): 4 × $0.01 + 100 × $0.003 = **$0.34**.

On the free Apify plan, a run returns at most 20 results in total; any paid Apify plan removes the limit. On the free Apify plan each account can run this Actor up to 3 times per 24 hours and 10 times per 7 days, within a small lifetime free allowance shared across all our Actors, and all free accounts share a daily free budget. When any of these limits is reached, the run stops before fetching anything and nothing is charged.

How charging works:

- The start fee for the first keyword, profile or post is charged when the first request to the data source succeeds, even if that request returns nothing. It is not charged when the data source fails from the start or rejects the IDs, or when your spending limit cannot cover it.
- Each further start fee is charged just before the first request for that keyword, profile or post, and is kept even if that input then fails or returns nothing.
- A keyword that returns no results, or a profile that does not exist, still costs its start fee because the request was made.
- If the data source is down for the whole run, nothing is charged.
- You are never charged for items the run did not deliver, and never for more than `maxResults` items per input.
- The run stops by itself if your spending limit is reached.

### Use cases

- **Brand and product monitoring**: search keywords for a product, a competitor or a topic and see what people post about it today, with likes, replies and reposts for each post.
- **Creator and competitor research**: pull the latest posts of a profile together with its follower count and bio, and compare how each post performs.
- **Social listening and sentiment**: collect the direct replies under a launch, an announcement or a widely shared post.
- **Creator shortlists**: compare profiles by `authorFollowers`, `isVerified` and the engagement counts of their recent posts.
- **AI and data projects**: Threads text with clean metadata for classification, summaries and trend analysis.
- **Recurring reports**: schedule runs on the same keywords or profiles and compare the counts from run to run.

### Integrations and API

You can start Threads Scraper from your own code through the Apify API, run it on a schedule in Apify Console, and send the results to other tools through Apify integrations and webhooks. Results are stored in a dataset that you can download as JSON, CSV or Excel, or read item by item through the API.

Python example with the `apify-client` package:

```python
from apify_client import ApifyClient
client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("clover_folktale/threads-scraper").call(run_input={
    "mode": "search",
    "keywords": ["coffee", "espresso machine"],
    "maxResults": 20,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

To get profile posts or replies instead, change `mode` and pass `usernames` or `postUrls` as shown in the Input section.

### Tips and limits

- **One page per input.** Search returns about 20 posts per keyword, profiles about 25 posts, and replies about 20 per post. Asking for more is not possible; the limits are also in the input description. If you need more data, use more keywords or more profiles.
- **Up to 50 inputs per list.** Each list (keywords, usernames or post links) is cut to its first 50 unique entries; the rest are dropped.
- **Check your list.** In profile posts and replies modes an empty list fails the run, and so does any entry that is not a readable username or post link.
- **Search order.** Search results are what Threads search returns for the keyword, not a time-ordered feed.
- **Profile order.** Profile mode returns posts in the order Threads lists them (newest first). Replies the profile wrote to other people are left out.
- **Direct replies only.** Replies mode returns direct replies; answers nested under a reply are not expanded.
- **Not found.** Unknown profiles and posts are skipped (their start fee still applies). When 5 inputs have returned nothing, the run stops to protect your budget and ends with the status Failed.
- **Failed runs.** Besides the 5-miss stop above, a run also ends as Failed if the data source goes down mid-run before anything has been delivered. You are never charged for items the run did not deliver.
- **Counts and media.** Counts are what Threads shows at the time of the run. Media links are temporary; download what you need soon after the run.
- **Empty fields.** Reply items do not include `authorFollowers`, `displayName` or `bio`, and search results have no `authorFollowers` or `bio` (they are `null`). Follower counts and bios come with profile posts. `text` is `null` for pictures without a caption, `imageUrls` is an empty list when a post has no pictures, and `videoUrl` is empty when a post has no video.
- **Free plan.** On the free Apify plan, a run returns at most 20 results in total; any paid Apify plan removes the limit.

### FAQ

#### Do I need a Threads or Instagram account?

No. You do not need a Threads or Instagram account, API keys, proxies or cookies.

#### Is it legal to scrape Threads?

The Actor only returns public data: public posts, public replies and the public profile fields of their authors (username, display name, user ID, profile picture, verified and private flags, and in profile mode the bio and follower count). It does not return private account data such as private messages. Bios are returned as published and may contain contact details the author made public. You are responsible for how you use the data, including any data protection rules that apply to you.

#### How fresh is the data?

Data is collected when you run the Actor. Likes, replies, reposts, quotes, shares and follower counts are the values Threads shows at that moment.

#### Why are some fields empty?

Some fields only exist in one mode. `authorFollowers` and `bio` come only with profile posts (they are `null` on search posts), and reply items do not include `displayName`, `authorFollowers` or `bio` at all. `text` is `null` for pictures without a caption.

#### How many results can I get?

Up to about 20 posts per keyword, 25 posts per profile and 20 replies per post, because Threads answers one page per request. Each list of keywords, profiles or post links takes up to 50 unique entries; anything after the first 50 is dropped. On the free Apify plan a run returns at most 20 results in total.

#### Can I schedule runs and export the data?

Yes. You can schedule runs in Apify Console or start them through the Apify API, and export each dataset as JSON, CSV or Excel.

#### What happens if a profile or post does not exist?

It is skipped and its start fee still applies. When 5 inputs have returned nothing, the run stops to protect your budget and ends with the status Failed.

#### A field or mode is missing. What can I do?

Open an issue from the Actor page and it will be looked at.

### More tools from the same developer

- [Reddit Scraper - Posts, Comments & User IDs, No Login](https://apify.com/clover_folktale/reddit-scraper)
- [Telegram Scraper - Channel Messages, Search & Info, No Login](https://apify.com/clover_folktale/telegram-scraper)
- [TikTok Scraper - Video Search, Hashtags & Author Profiles](https://apify.com/clover_folktale/tiktok-scraper)
- [YouTube Scraper - Shorts, Channel Videos & Video Search](https://apify.com/clover_folktale/youtube-scraper)
- [Weibo 微博 Scraper - Posts, Comments, User IDs & IP Location](https://apify.com/clover_folktale/weibo-scraper)
- [Xiaohongshu 小红书 RedNote Scraper - Notes, Comments & User IP](https://apify.com/clover_folktale/xiaohongshu-scraper)

# Actor input Schema

## `mode` (type: `string`):

What to scrape: posts by keyword, the posts of profiles, or the replies under posts.

## `keywords` (type: `array`):

Search keywords; each returns up to 20 posts (the most that Threads search answers). Falls back to "coffee" when empty.

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

Usernames (zuck), @zuck, or profile links (https://www.threads.net/@zuck). Each returns up to the 25 most recent posts; replies to others are left out.

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

Threads post links (https://www.threads.net/@<user>/post/<code>). Each returns up to about 20 direct replies.

## `maxResults` (type: `integer`):

Maximum items per keyword, profile or post. Capped at 20 for search, 25 for profile posts and 20 for replies: Threads returns one page only. You are charged $0.003 per item returned, plus a $0.01 start fee for each keyword, profile or post. On the free Apify plan a run returns at most 20 results in total; any paid Apify plan removes the limit.

## Actor input object example

```json
{
  "mode": "search",
  "keywords": [
    "coffee"
  ],
  "usernames": [
    "zuck"
  ],
  "postUrls": [
    "https://www.threads.net/@jue.halus/post/DeOvnAEiZHG"
  ],
  "maxResults": 20
}
```

# Actor output Schema

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

All scraped items (JSON, CSV, Excel via the dataset API).

# 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 = {
    "keywords": [
        "coffee"
    ],
    "usernames": [
        "zuck"
    ],
    "postUrls": [
        "https://www.threads.net/@jue.halus/post/DeOvnAEiZHG"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("clover_folktale/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 = {
    "keywords": ["coffee"],
    "usernames": ["zuck"],
    "postUrls": ["https://www.threads.net/@jue.halus/post/DeOvnAEiZHG"],
}

# Run the Actor and wait for it to finish
run = client.actor("clover_folktale/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 '{
  "keywords": [
    "coffee"
  ],
  "usernames": [
    "zuck"
  ],
  "postUrls": [
    "https://www.threads.net/@jue.halus/post/DeOvnAEiZHG"
  ]
}' |
apify call clover_folktale/threads-scraper --silent --output-dataset

```

## MCP server setup

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