# Threads Search Scraper: Posts by Keyword, Likes, Monitor (`themineworks/threads-search-scraper`) Actor

Threads search scraper for public posts on any keyword, recent or top: author, text, posted time, likes, replies, reposts, quotes, media type and link. Monitor mode turns a keyword into a standing brand watch that bills only for new posts. No login. $1.69 per 1,000 posts.

- **URL**: https://apify.com/themineworks/threads-search-scraper.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Social media, Lead generation, MCP servers
- **Features:** Limited permissions
- **Stats:** 128 total users, 51 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 1,000 posts

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 Search Scraper: Keyword Monitor

> 🏆 Part of The Mine Works' 310+ actor portfolio · 290,000+ runs · 99%+ of runs complete

> 💰 From $0.60 / 1,000 results.
>
> Guide and FAQs: [Threads Search Scraper on themineworks.com](https://themineworks.com/actors/threads-search-scraper/).

> ⚡ Keyword or phrase search across public Threads posts, recent or top ordering, with a monitor mode built for a standing brand watch. No login, no API key.

> 💸 An empty search or a blocked run is never charged. You pay per post delivered.

Give it a keyword and get matching public Threads posts. Text, author, timestamps, likes, replies, reposts, media URLs and permalinks. No login, no API key.

### Input

- **searchQuery** (required). Single keywords work best. Logged out Threads search matches phrases closely, so a phrase such as "sangeet outfit" often returns nothing while "sangeet" returns 20 or more posts. The actor then falls back to the single words for you.
- **maxPosts** caps how many posts come back.
- **Result type** picks `recent` or `top` ordering. Default `recent`.
- **broadenPhrase** (on by default). When Threads has no posts for your whole phrase, the actor searches each of its words instead and tags those rows with `matched_term` and `searched_phrase`. Turn it off for exact phrase results only.
- **Monitor mode** returns only posts not delivered in an earlier run, so a schedule bills for new posts instead of the same feed every time.

### Turn it into a standing watch

Set **Monitor mode** to true, save the run as a task, then add that task to an Apify Schedule. Every run after the first returns only what is new. You are never charged twice for the same post, and a run that finds nothing new says so in the log rather than looking like a failure.

### Part of the Threads suite

[Threads Scraper](https://apify.com/themineworks/threads-scraper?fpr=ymnoit\&utm_source=apify-readme\&utm_medium=referral) is the
general-purpose one: 25 fields, 4 modes, no login. These three are focused cuts of it,
each with its own input and its own monitor mode.

- [Threads Profile Scraper](https://apify.com/themineworks/threads-profile-scraper?fpr=ymnoit\&utm_source=apify-readme\&utm_medium=referral), posts by username
- [Threads Hashtag Scraper](https://apify.com/themineworks/threads-hashtag-scraper?fpr=ymnoit\&utm_source=apify-readme\&utm_medium=referral), a tag feed
- [Threads Search Scraper](https://apify.com/themineworks/threads-search-scraper?fpr=ymnoit\&utm_source=apify-readme\&utm_medium=referral), keyword search (this actor)

### Pricing

| Event | Price (Free plan) | You pay when |
| --- | --- | --- |
| Post | $0.001 | A post matching your keyword is delivered to your dataset |

Tiered by Apify plan: Free $0.001, Bronze $0.0009, Silver $0.00075, Gold, Platinum and
Diamond $0.0006. Your plan is shown on your Apify billing page.

An empty search or a blocked run is never charged. You pay only for posts actually
delivered, and with monitor mode on you are never charged twice for the same post.

### Run it on a schedule

Monitor mode is what makes this cheap to run repeatedly: each run after the first returns only posts that were not delivered before.

1. Run it once with the input you want repeated, then click **Save as a task**
   so that exact input is attached to every future run.
2. In the Apify Console go to **Schedules** and create a new one, either a
   preset (hourly / daily / weekly) or a cron expression.
3. Save. It then runs unattended, billed the same pay-per-result way. Nothing
   is charged for the schedule existing.

### Use from Claude, ChatGPT & any MCP agent

Hosted MCP endpoint, no install, OAuth on first connect:

```
https://mcp.apify.com/?tools=themineworks/threads-search-scraper
```

Claude Desktop / Cursor config (token auth):

```json
{
  "mcpServers": {
    "threads-search-scraper": {
      "url": "https://mcp.apify.com/?tools=themineworks/threads-search-scraper",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}
```

Ask your agent: *"Search Threads for posts mentioning \[keyword] this week."*

### FAQ

**Do I need to log in or supply an API key?**
No. It searches public Threads posts directly.

**What is the difference between recent and top?**
`resultType: recent` returns matches in reverse-chronological order. `top` returns the
ranking Threads itself surfaces for that query. Recent is the default.

**How is this different from the hashtag scraper?**
This matches a keyword or phrase anywhere in a post's text. The hashtag scraper matches
posts carrying a specific tag.

**Why did my phrase return no posts?**
Logged out Threads search matches phrases closely. On 13 Oct 2026 "sangeet outfit", "kurta styling" and "office outfit india" returned no posts on Threads itself, while "sangeet", "kurta" and "what to wear" returned 20 or more. So when a phrase finds nothing, the actor falls back to its single words by default (`broadenPhrase`) and tags those rows with `matched_term`. A search that finds nothing at all is never charged.

**Is a keyword with no matches billed?**
No. The post event only fires when a matching post is actually returned.

**Can I cap how many posts come back?**
Yes, `maxPosts` is a ceiling for the whole run, between 1 and 500.

Keywords: Threads search scraper, Threads keyword monitor, scrape Threads by keyword, Threads brand mention tracking, Threads social listening, Threads monitor mode, no login Threads scraper, Threads MCP server

# Actor input Schema

## `searchQuery` (type: `string`):

What to search Threads for. Single keywords work best, e.g. "web3" or "sangeet": logged out Threads search matches phrases closely, so many two and three word phrases return nothing. By default the actor then falls back to the single words (broadenPhrase).

## `maxPosts` (type: `integer`):

Maximum posts to return across the whole run. This is a ceiling, not a target: the actor stops as soon as it has enough or every target is exhausted. In search and hashtag mode a high value is usually reached from one query. In profile mode, ONE username caps around 4 to 5 posts (Threads' own logged-out limit) — to actually reach a high maxPosts here, list several usernames in Profile usernames above; the run draws from each until the total is met. You are never charged for posts that do not exist.

## `resultType` (type: `string`):

For search and hashtag modes: 'recent' or 'top'.

## `broadenPhrase` (type: `boolean`):

On by default. If Threads has no posts for your whole phrase, the actor searches each of its words instead (filler words like 'the' and 'for' are skipped) and returns those posts. Each such row carries matched_term (the word that found it) and searched_phrase, so you can tell them apart; they are charged like any other post. Turn it off to get only posts Threads matches to the exact phrase.

## `monitorMode` (type: `boolean`):

Run on a schedule and get ONLY posts not delivered in a previous run, so a standing keyword watch bills for new mentions instead of the whole result set every time. Keep the query the same across runs.

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

Apify proxy. Defaults to datacenter with a fresh rotating session per request, which clears Threads' IP throttling. Switch to residential only if you see persistent blocks.

## Actor input object example

```json
{
  "searchQuery": "web3",
  "maxPosts": 25,
  "resultType": "recent",
  "broadenPhrase": true,
  "monitorMode": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "searchQuery": "web3",
    "maxPosts": 25,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/threads-search-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 = {
    "searchQuery": "web3",
    "maxPosts": 25,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("themineworks/threads-search-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 '{
  "searchQuery": "web3",
  "maxPosts": 25,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call themineworks/threads-search-scraper --silent --output-dataset

```

## MCP server setup

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