# Threads Scraper 🧵 Brand Monitor (keywords + replies, no login) (`tagadanar/threads-scraper`) Actor

Track what people say about your brand on Threads. Keywords or hashtags in, matching public posts out with author, likes, replies, reposts and quotes; paste a post link to get every public reply. Listening suites bill a monthly seat for the same feed. No account to connect.

- **URL**: https://apify.com/tagadanar/threads-scraper.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** Social media, Lead generation, News
- **Stats:** 8 total users, 8 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 post or replies

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?

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 Search & Replies Scraper

Find out what people are saying about your brand on Threads, and read whole
conversations under a post.

Give it a list of keywords or hashtags and you get back the public Threads posts
that match, each with the author, the text, the timestamp and the like, reply,
repost and quote counts. Paste a post link instead and you get that post plus
the replies Threads shows publicly underneath it, one row per reply.

There is no account to connect. The scraper reads the same public, logged-out
view of Threads that anyone gets in a browser window without signing in, so
there are no cookies to refresh, no session to get banned, and no API key to buy.

### What you get

One flat row per post or reply.

| Field | What it is |
| --- | --- |
| `recordType` | `post` for a top-level post, `reply` for a reply under one |
| `postId`, `shortcode`, `url` | Identifiers and the permalink |
| `text` | The full post text, emoji and line breaks kept |
| `postedAt` | ISO 8601 UTC timestamp |
| `language` | Language Threads detected, when it reports one |
| `authorUsername`, `authorName`, `authorId` | Who posted it |
| `authorIsVerified`, `authorIsPrivate` | Account flags |
| `authorUrl`, `authorAvatarUrl` | Profile link and picture |
| `likeCount`, `replyCount`, `repostCount`, `quoteCount`, `reshareCount` | Engagement |
| `isReply`, `replyToUsername`, `rootPostUrl` | Where the row sits in a thread |
| `mediaType`, `mediaUrls` | `text`, `image`, `video` or `carousel`, plus the file URLs |
| `mentions`, `hashtags`, `links` | Accounts tagged, tags used, outbound URLs |
| `isPaidPartnership` | Set when Threads labels the post as sponsored |
| `query`, `sourceUrl`, `scrapedAt` | Which input produced the row, and when |

Empty means empty. When a field is genuinely absent (an author who hid their
like counts, a post with no media) you get `null`, never a zero standing in for
"we could not tell".

### Who it is for

**Social listening and brand monitoring.** Put your brand, your product names
and your competitors in the keyword list, run it on a schedule, and you have a
feed of every public Threads post that mentions any of them, ranked by the
engagement they actually got. The `query` field tells you which term matched, so
one run can cover a whole watchlist.

**Community and support teams.** Paste the link to a post that is blowing up and
get every public reply as structured rows, with the author and the like count on
each one. Much faster than scrolling a thread and copying quotes by hand.

**Market and content research.** Pull the posts around a topic or a hashtag,
look at what the high-engagement ones have in common, and export it to a
spreadsheet or a notebook. Hashtags and mentions come pre-extracted.

**Influencer and creator sourcing.** Search your niche, sort by likes, and you
have a shortlist of accounts already posting about it, with their verified
status and follower-facing profile links.

### Input examples

Track a brand and its competitors:

```json
{
  "keywords": ["nike running", "adidas running", "#runningshoes"],
  "maxResults": 300
}
```

Pull the replies under two specific posts:

```json
{
  "postUrls": [
    "https://www.threads.com/@claudeai/post/DVPbBO5icc6",
    "https://www.threads.com/@zuck/post/DMZ3zK8Rvzg"
  ],
  "maxResults": 200
}
```

Both at once, which is the usual monitoring setup:

```json
{
  "keywords": ["openai", "anthropic"],
  "postUrls": ["https://www.threads.com/@claudeai/post/DVPbBO5icc6"],
  "maxResults": 500
}
```

You can also paste a Threads search link (`https://www.threads.com/search?q=...`)
or a tag page (`https://www.threads.com/t/ai`) straight into the keyword list.

### Pricing

You pay per post or reply delivered. Nothing else.

| Event | Price |
| --- | --- |
| Post or reply | $0.002 per row ($2.00 per 1,000) |
| Actor start | $0.001 per run |

Bronze, Silver and Gold plans get 10%, 20% and 30% off the per-row price, so
1,000 posts are $2.00, or $1.40 on Gold. The start fee is flat.

**Apify platform usage is included in the price** — and this actor uses **no
proxy at all**, so there is nothing else to pay: no compute line, no proxy line,
no subscription, no API key. A keyword that matches nothing costs the start fee
and no more.

### Frequently asked questions

**Do I need a Threads or Instagram login?**
No. No login, no cookies, no session token, no API key. The scraper only reads
what Threads serves to a signed-out visitor.

**How many posts do I get per keyword?**
Threads gives a signed-out reader one batch of results per query rather than
endless scroll, so expect roughly 20 to 30 posts per keyword. The scraper
already squeezes that as far as it goes by searching both the posts tab and the
tag tab for every keyword and merging the two, which is measurably more than
either tab alone. If you want more volume on a topic, give it more keyword
variants: six phrasings around "nike" returned 88 distinct posts in testing,
where one phrasing returned 27.

**How many replies do I get per post?**
The replies Threads renders publicly under the post, which in testing was around
27 on a thread with several hundred total replies. Nobody gets the full reply
list of a big thread without an account, and any scraper that promises one is
either logging in on your behalf or overselling. This one tells you what it
actually returns.

**Why do I get fewer results than `maxResults`?**
`maxResults` is a ceiling, not a target. If the public data is thinner than your
ceiling, you get what exists and pay only for the rows you received.

**Are replies included in keyword search results?**
Yes, and they are labelled. A reply that mentions your brand is still a brand
mention, so it comes back with `recordType` set to `reply` and you can filter it
out if you would rather only see top-level posts.

**Can I schedule it?**
Yes. Set up an Apify schedule and point it at the same keyword list. Rows carry
`postId` and `shortcode`, so de-duplicating across runs on your side is a single
join.

**Does it work on private accounts?**
No, and it should not. Private posts are not part of the public view and this
scraper never tries to reach them.

**What happens if a post link is dead?**
The run logs it, skips it, and carries on with the rest of your input. A bad
link never fails the whole run.

**Can I get profile details and follower counts?**
That is a different job and there is a very good actor for it already. Use
[Meta Threads Profile Scraper](https://apify.com/apify/threads-profile-api-scraper)
for profile info, and this one for posts, keywords and replies.

### Notes on reliability

The scraper impersonates a real browser at the TLS level rather than sending
browser-shaped headers over a Node handshake, which is what Meta actually checks.
Three browser profiles are tried in rotation, and every attempt is logged with
its status code so a failure is diagnosable from the run log instead of showing
up as a mysteriously empty dataset. A run that finds nothing says so in its
status message rather than quietly succeeding with an empty result.

Every Apify actor publishes its own 30-day run stats, and on the figures read on
29 August 2026 the largest Threads scraper on the Store had failed 13.7% of its
63,993 runs, while this one had failed none of its 197. That is a much smaller
sample and it will only be a fair comparison once this actor has run as much —
read both records yourself before trusting either, because they move.

### Related actors

Brand mentions do not live on one network, so two siblings cover the rest:

- [Telegram Channel Monitor](https://apify.com/tagadanar/telegram-channel-monitor)
  — the same keyword watch across public Telegram channels, also with no login
  and no API key, priced per message delivered.
- [Brand News Monitor](https://apify.com/tagadanar/brand-news-monitor)
  — the press side: news articles mentioning a brand across several sources at
  once, for when a Threads spike needs a cause.

***

Keywords: threads scraper, meta threads scraper, threads keyword search, threads
hashtag scraper, threads replies scraper, threads comments scraper, threads brand
monitoring, threads social listening, threads post scraper, scrape threads
without login, threads.net scraper, threads mentions tracker.

# Actor input Schema

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

One search per entry: a brand or product name (<code>nike running</code>), a hashtag (<code>#ai</code>), or a pasted Threads search link. Each entry is looked up on both the posts tab and the tag tab, and the two result sets are merged and de-duplicated for you.

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

Paste Threads post links to pull the post plus every reply Threads shows publicly under it, with the author and engagement counts of each reply. Example: <code>https://www.threads.com/@claudeai/post/DVPbBO5icc6</code>

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

Total rows to return across every keyword and post link. Threads shows a fixed batch of public results per keyword and per post, so asking for far more than is publicly available simply returns what exists.

## Actor input object example

```json
{
  "keywords": [
    "ai"
  ],
  "maxResults": 20
}
```

# Actor output Schema

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

One row per Threads post or reply in the default dataset.

# 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": [
        "ai"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/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": ["ai"],
    "maxResults": 20,
}

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

```

## MCP server setup

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