# Threads Search Scraper - Keyword Posts & Profiles (`nexuscortex/threads-search-scraper`) Actor

Search Threads (Meta) by keyword without login. Deep paging back in time for the newest posts, top posts per day, week or month, date range and media filters, plus matching profiles. Text, likes, replies, reposts, media and author for each post.

- **URL**: https://apify.com/nexuscortex/threads-search-scraper.md
- **Developed by:** [Nexus Cortex](https://apify.com/nexuscortex) (community)
- **Categories:** Social media, Marketing
- **Features:** Limited permissions
- **Stats:** 22 total users, 8 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 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/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: Search Threads Posts and Profiles by Keyword (No Login)

Search **Threads** (threads.com / threads.net, by Meta) by keyword, phrase or hashtag and export every matching public post as JSON, CSV or Excel, without an account, cookies or API key.

Most Threads search scrapers stop after the first 10 to 20 results, because Threads does not paginate search for logged-out visitors. This Actor keeps going: it walks **back in time** with the same date filters as Threads' own advanced search, so one keyword can return hundreds or thousands of posts, newest first. You can also collect the **top posts of every day, week or month**, filter by date range and media type, and find the **profiles** that match a keyword.

### How to search Threads

1. Click **Try for free** (or **Start**) on this page.
2. Add one or more keywords, phrases or hashtags (`nasa`, `artificial intelligence`, `#booktok`).
3. Choose **Recent** (newest first, deep paging) or **Top** (most relevant per period), and optionally a date range.
4. Set **Maximum posts per keyword** and **Maximum results** to cap the size and cost of the run.
5. Run the Actor and download the results as JSON, CSV, Excel, or read them through the Apify API.

### What can it do?

- **Deep keyword search, newest first**: page after page back in time until your limit or start date. In our tests one keyword returned 150 posts in 14 requests, about 400 posts per minute.
- **Top posts per period**: the 10 to 20 most relevant posts of each day, week or month, newest period first. Great for "what were the best posts about X each week".
- **Date range**: `Posted after` / `Posted before` with dates (`2026-10-01`) or relative ages (`7 days`). Search old periods, not only the last few hours.
- **Media filter**: only text posts, posts with images, or posts with videos (filtered by Threads itself, so you don't pay for posts you'd throw away).
- **Reply context**: when a matching post is a reply, the post it answers is attached in `inReplyTo` (URL, author, text, date). Optionally save those parent posts as their own rows.
- **Phrases that find nothing still return posts**: Threads' logged-out search often has no results for a whole phrase like `looking for a guitar teacher`. The Actor then searches the phrase's words one by one and keeps only posts that contain most of them, marked `matchedVia: "broadened"`.
- **Profile search**: the accounts that match each keyword (about 10 per keyword), with follower count, bio and bio links.
- **Engagement data for every post**: likes, replies, reposts, quotes, media type, image and video URLs, links, mentions, topic tag, language and author.

It uses plain HTTP requests against the same public endpoints the Threads website uses for logged-out visitors. No browser is started, so runs are fast and cheap.

### Why use it?

- **Social listening**: every recent post that mentions your brand, product, competitor or campaign.
- **Trend and news research**: what people say about a topic, day by day.
- **Influencer and creator discovery**: profiles and authors that post about a niche, with follower counts.
- **Datasets** for sentiment analysis, LLM pipelines, dashboards and academic research.
- **Monitoring**: schedule the Actor with `Posted after: 24 hours` and get only new posts every day.

### Input

| Field | Description |
|---|---|
| `searchQueries` | Keywords, phrases or hashtags. Each one is searched separately. |
| `sort` | `recent` (newest first, deep paging), `top` (most relevant per period) or `both` |
| `maxPostsPerQuery` | Stop a keyword after this many posts (per sort order) |
| `maxItems` | Hard cap on results for the whole run (also your cost cap) |
| `dateFrom` | Posted after: `2026-10-01` or `7 days` |
| `dateTo` | Posted before: `2026-10-31` (whole day included) or `1 day` |
| `topPeriod` | For `top`: `day`, `week` or `month` |
| `mediaType` | `any`, `text`, `image` or `video` |
| `includeContextPosts` | Also save the post that a matching reply answers, as its own row |
| `broadenEmptyQueries` | When a phrase finds no posts, search its words one by one and keep posts containing most of them (default on) |
| `searchProfiles` | Also save the accounts that match each keyword |
| `enrichProfiles` | Add follower count, bio and bio links to those accounts |
| `proxyConfiguration` | Apify Proxy settings (default on) |

Example: the newest 500 posts about two topics in October 2026, plus matching accounts.

```json
{
    "searchQueries": ["artemis ii", "#booktok"],
    "sort": "recent",
    "maxPostsPerQuery": 500,
    "maxItems": 1100,
    "dateFrom": "2026-10-01",
    "dateTo": "2026-10-31",
    "searchProfiles": true
}
```

Example: the top posts of each day of the last week that mention a brand and contain a video.

```json
{
    "searchQueries": ["nike"],
    "sort": "top",
    "topPeriod": "day",
    "dateFrom": "7 days",
    "mediaType": "video",
    "maxPostsPerQuery": 200
}
```

### Output

Each dataset item has a `type`: `post` or `profile`. Download as JSON, CSV, Excel, XML or HTML.

Post example (shortened):

```json
{
    "type": "post",
    "id": "4017501246420854228",
    "code": "DfBCBkVmqXU",
    "url": "https://www.threads.com/@michele__norris/post/DfBCBkVmqXU",
    "username": "michele__norris",
    "userVerified": true,
    "text": "🚀 FROM NASA'S ARTEMIS II MISSION TO YOUR MAMA'S KITCHEN! 🌕🌎 ...",
    "createdAt": "2026-10-27T23:24:51.000Z",
    "likeCount": 212,
    "replyCount": 10,
    "repostCount": 12,
    "quoteCount": 0,
    "mediaType": "image",
    "images": ["https://scontent.cdninstagram.com/..."],
    "videos": [],
    "links": [],
    "mentions": [],
    "topicTag": null,
    "isReply": false,
    "replyToUsername": null,
    "inReplyTo": null,
    "language": "en",
    "searchQuery": "artemis",
    "searchSort": "top",
    "matchedVia": "exact",
    "isSearchContext": false
}
```

`matchedVia` is `exact` when Threads matched your keyword as written, or `broadened` when the phrase found nothing and the post was found by one of its words (that word is in `broadenedSearch`) and contains most of the phrase's words.

When the matching post is a reply, `inReplyTo` holds the post it answers: `{ "url", "username", "text", "createdAt" }`.

Profile example (with `enrichProfiles`):

```json
{
    "type": "profile",
    "id": "28829152388",
    "username": "nasa",
    "url": "https://www.threads.com/@nasa",
    "fullName": "NASA",
    "isVerified": true,
    "biography": "Making the seemingly impossible, possible. ✨",
    "biographyLinks": [],
    "followerCount": 12792405,
    "profilePicUrl": "https://scontent.cdninstagram.com/...",
    "searchQuery": "nasa"
}
```

A run summary (items, requests, posts per keyword, broadened phrases, keywords without posts, failed searches) is saved to the key-value store under `SUMMARY`.

Media and profile-picture URLs are signed Meta CDN links that expire after a few days. Download the files you need promptly.

### How much does it cost?

You pay per result: **one `result` event for every post or profile** written to the dataset. Duplicates, posts outside your date range and failed searches are not charged. Set `maxItems` (and the run's maximum cost) to cap your spend; the Actor stops gracefully as soon as the limit is reached. See the pricing box on this page for the current price per 1,000 results. Each run also has Apify's standard start fee of $0.00005 ($0.05 per 1,000 runs), which covers the first seconds of compute. Apify subscribers pay less per result: 10% off on Bronze, 15% on Silver and 20% on Gold and higher plans.

### Limitations (please read)

- **Public posts only.** Private accounts and anything that needs a login are not available and not attempted.
- **Very busy keywords**: Threads' date filter works by the hour, so in Recent mode the Actor gets about 10 to 20 of the newest posts for each hour it walks back through. For keywords with hundreds of posts per hour you get a sample of every hour, not every single post. Run **Top** as well (`sort: both`), add narrower keywords, or schedule the Actor more often.
- **Profile search returns about 10 accounts per keyword**, like the Threads search box.
- **Short keywords work best.** Threads' public search often returns nothing for long phrases, rare word forms and some sensitive topics (for example weight-loss products). With `broadenEmptyQueries` on, a phrase without results is retried word by word; a single word without results stays empty, and the run's status message lists such keywords. One or two common words (`guitar lessons`) usually find more than a sentence (`looking for a guitar teacher`).
- **Threads decides what matches.** Search results include posts that mention the keyword in a related way, and replies whose conversation matches; `inReplyTo` shows the context.
- **No view counts.**
- Meta changes its website regularly. If the Actor breaks, it fails with a clear error message instead of returning wrong data; please report it in the Issues tab.

### FAQ

**Do I need a Threads or Instagram account?** No. The Actor never logs in and never asks for cookies.

**How far back can I search?** As far as Threads keeps posts. Set `Posted before` to any date (our tests went back to 2023) and the Actor searches from there.

**Does it scrape emails or phone numbers?** No. It returns only what public posts and public profiles show.

**Is scraping Threads legal?** The Actor collects only publicly visible data without logging in. In *Meta v. Bright Data* (N.D. Cal., January 2024) a US court held that Meta's terms do not bar logged-off scraping of public data. Laws differ by country and by what you do with the data (personal data is covered by GDPR and similar laws). This is not legal advice; make sure your use case complies with the laws that apply to you.

**Can I scrape a profile's posts or a post's replies?** This Actor focuses on search. For profiles and single posts use our [Threads Scraper](https://apify.com/nexuscortex/threads-scraper); for all replies of a post use [Threads Replies Scraper](https://apify.com/nexuscortex/threads-replies-scraper).

**Can I use it through the API or schedule it?** Yes: use the Apify API, schedules, webhooks and integrations (Make, Zapier, Google Sheets, n8n, and more).

### Feedback

Found a bug or need a field? Open an issue in the Issues tab and we will look at it. If this Actor saved you time, a short review on this page helps other users find it.

### More scrapers from NexusCortex

- [Threads Scraper](https://apify.com/nexuscortex/threads-scraper): posts, profiles and replies of Threads accounts
- [Threads Replies Scraper](https://apify.com/nexuscortex/threads-replies-scraper): all comments of Threads posts
- [Telegram Channel Scraper](https://apify.com/nexuscortex/telegram-channel-scraper): posts, views and reactions of public Telegram channels
- [Google Trends Scraper](https://apify.com/nexuscortex/google-trends-scraper): interest over time, by region and related queries

# Actor input Schema

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

Keywords, phrases or hashtags to search for on Threads, e.g. `nasa`, `artificial intelligence`, `#booktok`. Each keyword is searched separately.

## `sort` (type: `string`):

`Recent` collects the newest posts first and keeps paging back in time until the limit or the start date. `Top` collects the most relevant posts of each period (see "Top posts period"). `Both` runs each keyword in both modes.

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

Stop a keyword after this many posts (per sort order).

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

Hard cap on the number of results (posts and profiles) saved and charged in this run.

## `dateFrom` (type: `string`):

Optional. Only posts published after this date, e.g. `2026-10-01`, or a relative age such as `7 days` or `24 hours`. Recent mode stops paging when it reaches this date.

## `dateTo` (type: `string`):

Optional. Only posts published before this date, e.g. `2026-10-31` (the whole day is included), or a relative age such as `1 day`. Use it to search older periods.

## `topPeriod` (type: `string`):

Only for the Top sort order. Each request returns the 10 to 20 most relevant posts of one period; the Actor walks back period by period (from "Posted before" or today) until the limit or "Posted after".

## `mediaType` (type: `string`):

Only posts with this kind of media, filtered by Threads itself.

## `includeContextPosts` (type: `boolean`):

When the matching post is a reply, Threads shows it under the post it answers. That post is always summarized in the `inReplyTo` field; turn this on to also save it as its own row (charged as a result).

## `broadenEmptyQueries` (type: `boolean`):

Threads' logged-out search often returns nothing for a whole phrase such as `looking for a guitar teacher`, even when its words have plenty of posts. When a phrase finds no posts, search its words one by one and keep only posts whose text contains most of the phrase's words. These rows have `matchedVia: "broadened"` and are charged like any other result. Turn off to get exact phrase results only.

## `searchProfiles` (type: `boolean`):

Also save the accounts that match each keyword (Threads returns about 10 per keyword).

## `enrichProfiles` (type: `boolean`):

For each matching profile, load follower count, bio and bio links (one extra request per profile).

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

Apify Proxy is recommended on the platform. If you see blocking errors, switch to the Residential proxy group.

## Actor input object example

```json
{
  "searchQueries": [
    "nasa"
  ],
  "sort": "recent",
  "maxPostsPerQuery": 50,
  "maxItems": 200,
  "topPeriod": "week",
  "mediaType": "any",
  "includeContextPosts": false,
  "broadenEmptyQueries": true,
  "searchProfiles": false,
  "enrichProfiles": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped items 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 = {
    "searchQueries": [
        "nasa"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexuscortex/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 = {
    "searchQueries": ["nasa"],
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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