# Threads Posts & Follower Count Scraper - Likes, Replies, Search (`neverempty/threads-posts-and-followers-scraper`) Actor

For brand monitoring, influencer research and competitor tracking: Threads posts by account, keyword or URL with likes, replies, reposts, quotes, images and videos, plus exact follower counts and bios. Filter by language, keyword and minimum likes. Monitoring returns only new posts. No login.

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

## Pricing

from $2.60 / 1,000 post returneds

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 Posts & Follower Count Scraper - Likes, Replies, Search

**For brand monitoring, influencer research and competitor tracking: get Threads posts from any public account, keyword or post URL with each post's likes, replies, reposts, quotes, images and videos, plus the exact follower count, bio and verified badge of every account.** Export the table as CSV, Excel or JSON, or read it through the API. No login, no cookies, no API key.

Keyword results come back clean: keep only posts that contain your keyword (on by default), only posts in your language (en, ja, es...) and only posts above a minimum number of likes. Posts left out by these filters are never charged.

### What you can use it for

- **Brand and mention monitoring**: schedule your brand and product keywords with *Monitoring mode* on and receive only posts you have not seen before.
- **Influencer research**: exact follower count, bio, verified badge and the likes, replies and reposts of recent posts for every creator on your list.
- **Competitor tracking**: put competitor accounts side by side and compare engagement post by post.
- **Follower history**: schedule a daily run with *Maximum posts per account* set to 0, and each run adds one exact follower count per account.
- **Research and AI datasets**: post text, posted time and detected language, one row per post, ready for sentiment analysis or a RAG pipeline.

### What you get

| Input | Rows returned |
|---|---|
| **Account** (`zuck`, `@zuck` or a profile URL) | 1 profile row (exact follower count, name, bio, bio links, verified badge, profile picture) + the newest posts |
| **Keyword** (`coffee`, `machine learning`) | The top posts Threads shows for it, filtered by keyword, language and likes |
| **Post URL** | That post with its current like, reply, repost and quote counts |

Every post row has: post URL and code, text, posted time (UTC), like / reply / repost / quote / share counts, media type, image URLs, video URLs, link preview, topic tag, author username, name, verified badge and ID, whether it is a reply or pinned, quoted and reposted post links, and the detected language.

### Why use this Threads scraper

- **Exact follower counts**, not rounded "5.7M" text (@zuck: 5,744,563 on 2026-10-13). Run it daily and you have a follower history for any public account.
- **Relevant keyword results.** Threads search mixes in replies and context posts that never mention your word. With *Only posts that contain the keyword* (on by default) those are left out and **not charged**.
- **Language filter and minimum likes**, so an English keyword gives you English posts with real engagement instead of a pile of zero-like posts in other languages. In a run on 2026-10-12, the keyword *coffee* with English selected returned 12 posts and left out 5 that were not in English or did not contain the word, at no charge.
- **Monitoring mode** returns only posts you have not received before, for brand, competitor and creator tracking on a schedule.
- **Low start fee**, and posts left out by your filters cost nothing. Empty results and accounts that need a login come back as free rows that say why.

### How to use

1. Put accounts in **Threads accounts**, keywords in **Search keywords**, or links in **Post URLs** (any mix).
2. Set **Maximum posts per account** (0 = profile row only, for follower tracking).
3. Optional: **Languages**, **Minimum likes**, **Posted on or after**.
4. Run. Export the table as CSV, Excel or JSON, or read it through the API.

For daily follower tracking, schedule a run with your accounts and `maxPostsPerAccount: 0`. For new-post alerts, turn on **Monitoring mode** and schedule it.

### Input fields

| Field | What it does |
|---|---|
| `usernames` | Threads accounts (`zuck`, `@zuck` or profile URL) |
| `searchQueries` | Keywords to search Threads for |
| `postUrls` | Threads post links (threads.com or threads.net) |
| `maxPostsPerAccount` | Newest posts per account (default 30, 0 = profile row only) |
| `maxPostsPerQuery` | Posts per keyword (default 20) |
| `includeProfile` | One profile row per account with the exact follower count (default on) |
| `onlyPostsContainingQuery` | Keep only keyword results whose text contains the keyword (default on) |
| `languages` | Keep only posts in these languages (`en`, `ja`, `es`...) |
| `minLikes` | Keep only posts with at least this many likes |
| `postedAfter` | Keep only posts created on or after this date (UTC) |
| `monitoringMode` | Return only posts not returned by earlier runs |
| `resetMonitoringState` | Forget what was returned for these inputs |

#### Example input

```json
{
  "usernames": ["zuck", "@nasa"],
  "searchQueries": ["coffee"],
  "maxPostsPerAccount": 30,
  "languages": ["en"],
  "minLikes": 10
}
```

#### Example post row

```json
{
  "type": "post",
  "inputType": "account",
  "input": "zuck",
  "postUrl": "https://www.threads.com/@zuck/post/DeZtp-TkQHh",
  "text": "Introducing ...",
  "postedAt": "2026-10-12T16:56:29.000Z",
  "likeCount": 973,
  "replyCount": 149,
  "repostCount": 75,
  "quoteCount": 36,
  "mediaType": "image",
  "imageUrls": ["https://scontent-...cdninstagram.com/..."],
  "authorUsername": "zuck",
  "authorIsVerified": true,
  "detectedLanguage": "en"
}
```

#### Example profile row

```json
{
  "type": "profile",
  "username": "zuck",
  "fullName": "Mark Zuckerberg",
  "followerCount": 5744558,
  "isVerified": true,
  "biography": "...",
  "bioLinks": []
}
```

### Pricing

Pay per event: a small fee per run start, a price per **post row** (`post-returned`) and the same price per **profile row** (`profile-returned`). In monitoring mode, each account, keyword or post URL that is read also costs a small check fee (`target-checked`), with or without new posts. Posts left out by your filters, and free rows (empty results, accounts that need a login, invalid input), are never charged. Set a maximum total charge on the run to cap the cost; the run stops cleanly at that limit and says so.

### FAQ

**How do I search Threads posts by keyword in one language?**
Add the keyword in *Search keywords* and your language code in *Languages* (for example `en`). Keep *Only posts that contain the keyword* on to drop unrelated replies.

**Why does a Threads keyword search give me posts in other languages or with no likes?**
Threads mixes replies and posts in many languages into keyword results. Set *Languages* (for example `en`) and *Minimum likes*, and keep *Only posts that contain the keyword* on. Posts that do not pass are left out and not charged.

**How do I get the follower count of a Threads account every day?**
Add the usernames, set *Maximum posts per account* to 0, and schedule the Actor daily. Each run returns one profile row per account with the exact `followerCount`.

**Can I export Threads posts to CSV or Excel?**
Yes. Download the run's table as CSV, Excel or JSON from the Output tab, or read it through the Apify API.

**How do I scrape all posts from a Threads profile?**
Add the username and raise *Maximum posts per account*. The Actor pages through the account's posts newest first, as far as Threads shows them to visitors who are not logged in (about the newest 150 threads).

**Can I get only new posts since the last run?**
Yes. Turn on *Monitoring mode* and schedule the Actor. Later runs return only posts not returned before for each account and keyword.

**Do I need a Threads account or cookies?**
No. The Actor reads public Threads pages without logging in.

### Good to know

- Threads shows visitors who are not logged in about the newest 150 threads of an account, and about the top 20 posts for a keyword (no "recent" tab without login). Use several related keywords to collect more.
- Some accounts (and names that do not exist) send visitors to the Threads login page. These come back as a free `not-available-without-login` row; this Actor never logs in.
- `detectedLanguage` is estimated from the post text, so it can be wrong on short or mixed-language posts. Very short posts get `null` and are left out when *Languages* is set.
- Image and video URLs are signed Threads CDN links and expire after some days; download the files if you need them later.
- A post returned for one input is not returned (or charged) a second time in the same run.
- Email addresses and phone numbers in bios and post text are masked.

### Thanks for using this Actor

We build these tools for people who run them every day, and we improve them from what users tell us.

- **Missing a field, or need another filter?** Tell us in the **Issues** tab. If the data is there, we add it.
- **Found a bug or a wrong value?** Post the run ID in the **Issues** tab. Wrong data is the thing we fix first.

If this Actor saved you time, a short review helps other people find it.

# Actor input Schema

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

Usernames to read, one per line: zuck, @zuck or https://www.threads.com/@zuck. Each account gives one profile row (exact follower count, bio, verified badge) and its newest posts. If usernames, searchQueries and postUrls are all empty with monitoring off, the example account @zuck is read.

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

Words to search Threads for, one per line. Each keyword returns the top posts Threads shows for it (up to about 20). Leave empty to skip search.

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

Threads post links such as https://www.threads.com/@zuck/post/DeZgeQhm6RW (threads.net links work too). Each link returns that post with its current like, reply, repost and quote counts. Leave empty to skip.

## `maxPostsPerAccount` (type: `integer`):

How many of the newest posts to return for each account (0 = profile row only, for follower tracking). Threads shows about the newest 150 threads of an account to visitors who are not logged in.

## `maxPostsPerQuery` (type: `integer`):

How many posts to return for each search keyword, after the filters below.

## `includeProfile` (type: `boolean`):

On = one row per account with the exact follower count, full name, bio, bio links, verified badge and profile picture. Off = posts only.

## `onlyPostsContainingQuery` (type: `boolean`):

On = keyword results keep only posts whose text contains every word of the keyword, so replies and context posts that do not mention it are left out (free). Off = every post Threads shows for the keyword.

## `languages` (type: `array`):

Keep only posts in these languages, as two-letter codes such as en, ja, es. The language is detected from the post text; posts too short to tell are left out when this is set. Leave empty for all languages.

## `minLikes` (type: `integer`):

Keep only posts with at least this many likes. 0 keeps every post. Posts whose author hides like counts are left out when this is above 0.

## `postedAfter` (type: `string`):

Only posts created on or after this date (UTC), for example 2026-10-01 or 2026-10-01T12:00:00Z. Leave empty for no date limit.

## `monitoringMode` (type: `boolean`):

Off = every run returns the newest posts. On = the Actor remembers which posts it returned for each account and keyword, and later runs return only new ones. Profile rows and post URLs are returned on every run (so follower counts can be tracked over time). In monitoring mode each account, keyword or post URL read costs a small check fee, plus the price of each row returned. Do not put the same input in two schedules that can run at the same time.

## `resetMonitoringState` (type: `boolean`):

Clears what was remembered for the accounts and keywords in this input, so the next monitoring run starts over. Turn it off again after one run.

## Actor input object example

```json
{
  "usernames": [
    "zuck"
  ],
  "maxPostsPerAccount": 30,
  "maxPostsPerQuery": 20,
  "includeProfile": true,
  "onlyPostsContainingQuery": true,
  "minLikes": 0,
  "monitoringMode": false,
  "resetMonitoringState": false
}
```

# Actor output Schema

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

One row per Threads post (post URL, text, posted time, likes, replies, reposts, quotes, shares, images, videos, author, detected language) and one row per account profile (exact follower count, name, bio, bio links, verified badge). In monitoring mode only posts not returned before. Accounts that need a login, empty results and invalid input come back as free rows that say why.

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

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neverempty/threads-posts-and-followers-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/kwMcgWDLg1Vd4wv4X/builds/JlHBbQanqbABqA5P8/openapi.json