# Threads Search Scraper (`parsebird/threads-search-scraper`) Actor
Scrape public Threads search posts by keyword or hashtag. Extract post text, authors, engagement metrics, media URLs, hashtags, mentions. Export JSON, CSV, Excel.
- **URL**: https://apify.com/parsebird/threads-search-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:** Social media, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet
## Pricing
from $3.59 / 1,000 threads 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/platform/actors/running/actors-in-store#pay-per-event
## What's an Apify Actor?
Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):
```bash
pip install apify-client
```
In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):
````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash
In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).
If your project is in a different language, use 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 Scraper
Threads Search Scraper extracts public [Threads](https://www.threads.com/) search post data by keyword or hashtag, including post text, author details, available engagement metrics, media URLs, hashtags, mentions, and search metadata.
Search Threads by keyword or hashtag, choose top or recent public posts, apply optional date windows, and export structured social listening data for analysis or integrations.
##### Copy to your AI assistant
Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.
```text
Use Apify Actor parsebird/threads-search-scraper to scrape public Threads search posts. Example with ApifyClient: client.actor("parsebird/threads-search-scraper").call(run_input={"keywords":["AI","#startup","stock market"],"search_filter":"recent","max_posts":50}). Inputs: keywords string[] required default ["AI"]; search_filter string enum "top" or "recent" default "recent"; max_posts integer default 50; start_date optional string YYYY-MM-DD or relative like "7 days"; end_date optional string YYYY-MM-DD. Output fields: post_url, post_code, text_content, created_at, username, display_name, profile_url, followers_count, bio, like_count, reply_count, repost_count, quote_count, share_count, view_count, has_media, media_type, media_urls, hashtags, mentions, search_keyword, search_filter, keyword_match, scraped_at. API docs: https://docs.apify.com/api/client/python/ and https://docs.apify.com/api/client/js/. Token: https://console.apify.com/account/integrations.
````
### What is Threads Search Scraper?
**Threads Search Scraper** is a Threads scraper and Threads API alternative for collecting public search posts without manually copying results from the website. Enter one or more keywords, hashtags, or phrases, choose `top` or `recent`, and the actor returns structured rows ready for analysis.
Use it for Threads data extraction workflows where you need repeatable exports, scheduled monitoring, API access, or integrations through [Apify](https://apify.com/). The actor works with public data availability at run time, so some fields may be empty when Threads does not expose them publicly.
### What can Threads Search Scraper do?
- Search public Threads posts by keyword, hashtag, or phrase.
- Choose `top` for popular matching posts or `recent` for newer matching public posts first.
- Extract post text, post URLs, author usernames, display names, profile URLs, media links, hashtags, mentions, and available engagement metrics.
- Add optional `start_date` and `end_date` filters for repeatable research windows.
- Run searches on demand or with [Apify schedules](https://docs.apify.com/platform/schedules).
- Access results through the [Apify API](https://docs.apify.com/api/v2), webhooks, and [integrations](https://apify.com/integrations).
- Download datasets as JSON, CSV, Excel, XML, RSS, or HTML from Apify storage.
### What Threads data can you extract?
| Field | Description |
|-------|-------------|
| `post_url` | Direct URL of the Threads post when available or reconstructable |
| `post_code` | Threads post identifier returned in public page data |
| `text_content` | Public post text |
| `created_at` | Post timestamp when available |
| `username` | Author username |
| `display_name` | Author display name |
| `profile_url` | Public Threads profile URL |
| `followers_count` | Public follower count when available |
| `bio` | Public author bio when available |
| `like_count` | Likes when available |
| `reply_count` | Replies when available |
| `repost_count` | Reposts when available |
| `quote_count` | Quotes when available |
| `share_count` | Shares when available |
| `view_count` | Public views when available |
| `media_urls` | Public media URLs returned in page data |
| `hashtags` | Hashtags found in the post text |
| `mentions` | Mentions found in the post text |
| `search_keyword` | Keyword or hashtag associated with the row |
| `keyword_match` | Whether the text directly includes the searched keyword |
### How to scrape Threads search posts
1. Open [Threads Search Scraper](https://apify.com/parsebird/threads-search-scraper) on Apify.
2. Add one or more `keywords`, for example `AI`, `#startup`, or `stock market`.
3. Choose `search_filter`: `top` for popular posts or `recent` for newer matching public posts.
4. Set `max_posts` for the maximum public posts to collect per keyword.
5. Optionally add `start_date` and `end_date` in `YYYY-MM-DD` format, or use a relative start such as `7 days`.
6. Run the actor, open the dataset, and export results as JSON, CSV, Excel, or through the [Apify API](https://docs.apify.com/api/v2).
### Input parameters
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `keywords` | array of strings | **Yes** | `["AI"]` | Keywords or hashtags to search. The `#` is optional. |
| `max_posts` | integer | No | `50` | Maximum posts per keyword. Actual results depend on public availability at run time. |
| `search_filter` | string | No | `recent` | `top` for popular posts or `recent` for newer matching public posts first. |
| `start_date` | string | No | - | Optional start date. Supports `YYYY-MM-DD` or relative values such as `7 days`. |
| `end_date` | string | No | - | Optional end date. `YYYY-MM-DD` is recommended for clarity. |
Example input:
```json
{
"keywords": ["AI", "#startup", "stock market"],
"search_filter": "recent",
"max_posts": 50
}
```
Date-bounded input:
```json
{
"keywords": ["OpenAI"],
"search_filter": "top",
"start_date": "2026-01-01",
"end_date": "2026-02-28",
"max_posts": 100
}
```
### Input / Output
Example output:
```json
{
"record_type": "post",
"post_url": "https://www.threads.com/@example/post/ABC123",
"post_code": "ABC123",
"text_content": "Example public Threads post about AI research.",
"created_at": "2026-02-15T08:30:00+00:00",
"username": "example",
"display_name": "Example Account",
"profile_url": "https://www.threads.com/@example",
"followers_count": 12500,
"bio": "Public profile bio",
"like_count": 152,
"reply_count": 18,
"repost_count": 7,
"quote_count": 2,
"share_count": 4,
"view_count": 4200,
"has_media": true,
"media_type": "photo",
"media_urls": ["https://scontent.cdninstagram.com/..."],
"hashtags": ["AI"],
"mentions": ["openai"],
"search_keyword": "AI",
"search_filter": "top",
"keyword_match": true,
"scraped_at": "2026-02-18T12:00:00+00:00"
}
```
The example is illustrative and shows the dataset shape. Download results in JSON, CSV, Excel, HTML, XML, or RSS from the Apify dataset.
### Python API example
```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("parsebird/threads-search-scraper").call(run_input={
"keywords": ["AI", "#startup", "stock market"],
"search_filter": "recent",
"max_posts": 50,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item)
```
### JavaScript API example
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('parsebird/threads-search-scraper').call({
keywords: ['AI', '#startup', 'stock market'],
search_filter: 'recent',
max_posts: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```
See Apify's official [Python client](https://docs.apify.com/api/client/python/) and [JavaScript client](https://docs.apify.com/api/client/js/) documentation for more options.
### How much does it cost to scrape Threads?
**What is the price per Threads search post?**
| Event | Free, Bronze, Silver | Gold |
|-------|----------------------|------|
| `post-scraped` | $0.00399 per post (**$3.99 / 1,000**) | $0.00359 per post (**$3.59 / 1,000**) |
Each `post-scraped` event means one public Threads post was extracted and pushed to the dataset. A run with 1,000 posts costs $3.99 on Free, Bronze, and Silver plans, or $3.59 on Gold. Apify free trial credits may cover test runs where applicable.
### Use cases
- Monitor public Threads conversations around brands, products, competitors, campaigns, or topics.
- Track newer or popular posts for social listening and market research.
- Collect public engagement fields for trend analysis when Threads exposes those fields.
- Build keyword datasets for content research, audience research, or reporting.
- Feed Threads search data into spreadsheets, BI tools, databases, or automation workflows.
### How it works
1. The actor validates keywords, `search_filter`, `max_posts`, and optional date filters.
2. It requests public Threads search pages with browser-like headers.
3. It extracts public Threads post objects from embedded page data when Threads exposes them.
4. It normalizes author, engagement, media, hashtag, mention, search, and scrape-time fields.
5. It pushes one row per post to the default Apify dataset and charges one PPE event per saved post on the Apify platform.
### What are the limitations of Threads search scraping?
- Threads may change which public data appears in its web pages over time.
- Some public posts do not expose every engagement or author field.
- New, deleted, private, restricted, or partially available posts may produce incomplete rows.
- Threads search can return broadly related posts, not only exact keyword matches.
- A keyword may return fewer rows than requested when fewer matching public posts are available.
### Is it legal to scrape Threads?
**Is scraping Threads legal?**
Scraping publicly available web data is generally allowed in many jurisdictions, but you should review Threads' terms, avoid collecting private or sensitive information, and make sure your use case complies with applicable laws. For background, read Apify's guide: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).
### Other Threads scrapers / Related Actors
| Actor | Best for |
|-------|----------|
| [Threads Search Scraper](https://apify.com/parsebird/threads-search-scraper) | Public keyword and hashtag search posts |
| [YouTube Search Scraper](https://apify.com/parsebird/youtube-search-scraper) | Structured YouTube search results |
| [Pinterest Search Scraper](https://apify.com/parsebird/pinterest-search-scraper) | Pinterest keyword search results |
| [Truth Social Scraper](https://apify.com/parsebird/truth-social-scraper) | Public Truth Social profile posts |
| [Product Hunt Scraper](https://apify.com/parsebird/product-hunt-scraper) | Product launches and maker data |
### FAQ
**Does Threads Search Scraper require a Threads login?**
No login input is required. The actor is designed for public Threads web data that is available without a user account.
**Can I schedule recurring Threads searches?**
Yes. Use Apify schedules to run the actor hourly, daily, weekly, or at another interval.
**Can I use it as a Threads scraper API?**
Yes. Start runs and fetch datasets through the Apify API, Python client, JavaScript client, webhooks, or integrations.
**Why did I get fewer results than requested?**
Result counts depend on what Threads shows publicly for the keyword at run time. Try a broader keyword, a different sort order, or a wider date range.
**Why are some fields empty?**
Some posts and profiles expose only partial public data. Empty fields usually mean the information was not public or not available in the page data when the actor ran.
**Are top and recent exact filters?**
They follow the public Threads search ordering available at run time. Search ranking can still include related posts rather than only exact keyword matches.
**Where can I report issues or request fields?**
Open the Issues tab on the actor page and include your input example, run ID, and the fields you expected.
# Actor input Schema
## `keywords` (type: `array`):
Add Threads keywords or hashtags to search. The # symbol is optional for hashtags.
## `max_posts` (type: `integer`):
Maximum public posts to return per keyword. Actual results depend on what Threads exposes publicly at run time.
## `search_filter` (type: `string`):
Choose top for popular public posts or recent for newer matching public posts first.
## `start_date` (type: `string`):
Optional start date. Use YYYY-MM-DD for clarity, or a relative value such as 7 days.
## `end_date` (type: `string`):
Optional end date. YYYY-MM-DD is recommended for clear, repeatable runs.
## Actor input object example
```json
{
"keywords": [
"AI",
"#startup",
"stock market"
],
"max_posts": 50,
"search_filter": "recent"
}
```
# Actor output Schema
## `dataset` (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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"keywords": [
"AI",
"#startup",
"stock market"
],
"max_posts": 50,
"search_filter": "recent"
};
// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"keywords": [
"AI",
"#startup",
"stock market",
],
"max_posts": 50,
"search_filter": "recent",
}
# Run the Actor and wait for it to finish
run = client.actor("parsebird/threads-search-scraper").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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",
"#startup",
"stock market"
],
"max_posts": 50,
"search_filter": "recent"
}' |
apify call parsebird/threads-search-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=parsebird/threads-search-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Threads Search Scraper",
"description": "Scrape public Threads search posts by keyword or hashtag. Extract post text, authors, engagement metrics, media URLs, hashtags, mentions. Export JSON, CSV, Excel.",
"version": "1.0",
"x-build-id": "CwRgJCAvHgvjTbJ2T"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/parsebird~threads-search-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-parsebird-threads-search-scraper",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
},
"/acts/parsebird~threads-search-scraper/runs": {
"post": {
"operationId": "runs-sync-parsebird-threads-search-scraper",
"x-openai-isConsequential": false,
"summary": "Executes an Actor and returns information about the initiated run in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/runsResponseSchema"
}
}
}
}
}
}
},
"/acts/parsebird~threads-search-scraper/run-sync": {
"post": {
"operationId": "run-sync-parsebird-threads-search-scraper",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
}
},
"components": {
"schemas": {
"inputSchema": {
"type": "object",
"required": [
"keywords"
],
"properties": {
"keywords": {
"title": "Keywords",
"type": "array",
"description": "Add Threads keywords or hashtags to search. The # symbol is optional for hashtags.",
"default": [
"AI"
],
"items": {
"type": "string"
}
},
"max_posts": {
"title": "Max Posts",
"minimum": 1,
"type": "integer",
"description": "Maximum public posts to return per keyword. Actual results depend on what Threads exposes publicly at run time.",
"default": 50
},
"search_filter": {
"title": "Search Filter",
"enum": [
"top",
"recent"
],
"type": "string",
"description": "Choose top for popular public posts or recent for newer matching public posts first.",
"default": "recent"
},
"start_date": {
"title": "Start Date",
"type": "string",
"description": "Optional start date. Use YYYY-MM-DD for clarity, or a relative value such as 7 days."
},
"end_date": {
"title": "End Date",
"type": "string",
"description": "Optional end date. YYYY-MM-DD is recommended for clear, repeatable runs."
}
}
},
"runsResponseSchema": {
"type": "object",
"properties": {
"data": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"actId": {
"type": "string"
},
"userId": {
"type": "string"
},
"startedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"finishedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"status": {
"type": "string",
"example": "READY"
},
"meta": {
"type": "object",
"properties": {
"origin": {
"type": "string",
"example": "API"
},
"userAgent": {
"type": "string"
}
}
},
"stats": {
"type": "object",
"properties": {
"inputBodyLen": {
"type": "integer",
"example": 2000
},
"rebootCount": {
"type": "integer",
"example": 0
},
"restartCount": {
"type": "integer",
"example": 0
},
"resurrectCount": {
"type": "integer",
"example": 0
},
"computeUnits": {
"type": "integer",
"example": 0
}
}
},
"options": {
"type": "object",
"properties": {
"build": {
"type": "string",
"example": "latest"
},
"timeoutSecs": {
"type": "integer",
"example": 300
},
"memoryMbytes": {
"type": "integer",
"example": 1024
},
"diskMbytes": {
"type": "integer",
"example": 2048
}
}
},
"buildId": {
"type": "string"
},
"defaultKeyValueStoreId": {
"type": "string"
},
"defaultDatasetId": {
"type": "string"
},
"defaultRequestQueueId": {
"type": "string"
},
"buildNumber": {
"type": "string",
"example": "1.0.0"
},
"containerUrl": {
"type": "string"
},
"usage": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "integer",
"example": 1
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
},
"usageTotalUsd": {
"type": "number",
"example": 0.00005
},
"usageUsd": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "number",
"example": 0.00005
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
}
}
}
}
}
}
}
}
```