# Threads Search Scraper (`futurizerush/threads-search-scraper`) Actor

Search Threads posts by keyword. Get full engagement metrics (likes, comments, reposts, views), author profiles, media URLs, and timestamps. Supports one-keyword search, exclude filters, and time range filtering. Perfect for brand monitoring, trend analysis, and competitor research. (Beta)

- **URL**: https://apify.com/futurizerush/threads-search-scraper.md
- **Developed by:** [Rush](https://apify.com/futurizerush) (community)
- **Categories:** Social media, AI, Automation
- **Stats:** 187 total users, 33 monthly users, 92.3% runs succeeded, 5 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $4.00 / 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/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

Search public Threads posts by keyword or hashtag and export clean data for monitoring, research, trend tracking, and content analysis. No Threads login input is required.

### What It Helps You Do

- Monitor public conversations around brands, products, competitors, and campaigns
- Track newer or popular posts for social listening and market research
- Collect engagement fields such as likes, replies, reposts, shares, and public view counts when available
- Export author, profile, media, hashtag, mention, and link fields for analysis

### How To Use

1. Enter one or more **keywords** or **hashtags**
2. Choose **Top / Popular** or **Recent / Latest first**
3. Choose the maximum number of posts per keyword
4. Optionally add a date range
5. Start the Actor and export the results from the dataset

#### Input Example

```json
{
  "keywords": ["AI", "#startup", "台北 餐廳"],
  "search_filter": "recent",
  "max_posts": 50
}
````

#### Date-Bounded Example

```json
{
  "keywords": ["OpenAI"],
  "search_filter": "top",
  "start_date": "2026-01-01",
  "end_date": "2026-02-28",
  "max_posts": 100
}
```

### Input

| Field | Description |
|---|---|
| `keywords` | Keywords or hashtags to search. The `#` is optional. |
| `max_posts` | Maximum posts per keyword. Actual results depend on public availability at run time. |
| `search_filter` | `top` for popular posts or `recent` for newer matching public posts first. |
| `start_date` | Optional start date. Supports `YYYY-MM-DD` or relative values such as `7 days`. |
| `end_date` | Optional end date. `YYYY-MM-DD` is recommended for clarity. |

### Output

Each dataset row is a public Threads post when available. Common fields include:

| Field | Description |
|---|---|
| `post_url` | Direct URL of the Threads post |
| `post_code` | Threads post identifier |
| `text_content` | Post text |
| `created_at` | Post timestamp when available |
| `username` | Author username |
| `display_name` | Author display name |
| `profile_url` | Author 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 |
| `has_media` | Whether media is attached |
| `media_type` | Media type when available |
| `media_urls` | Media URLs when available |
| `hashtags` | Hashtags found in the post |
| `mentions` | Mentions found in the post |
| `search_keyword` | Keyword or hashtag associated with the row |
| `search_filter` | Sort order used for the run |
| `keyword_match` | Whether the post text directly matches the searched keyword |
| `scraped_at` | When the row was collected |

#### Output Example

The example below is illustrative and shows the dataset shape.

```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"
}
```

### Dataset Views

- **Posts**: post text, URL, date, author, media, and search fields
- **Engagement**: likes, replies, reposts, quotes, shares, and public views
- **Authors**: author fields attached to search results
- **Bio Links**: public author bio links and contact fields when present

### Tips

- Use short, focused keywords for broader discovery
- Use `recent` for monitoring newer public conversations
- Use date filters when you need a specific research window
- Use `keyword_match` to separate direct text matches from broader related results

### Limitations

- Threads can change what it shows publicly over time
- Some public posts may not expose every engagement or author field
- Very new, deleted, private, restricted, or partially available posts may return incomplete fields
- Search ranking may include broadly related posts, not only exact keyword matches
- A keyword can return fewer rows than requested when fewer matching public posts are available

### Need Another Threads Workflow?

- [Threads Scraper - Posts, Profiles & Search](https://apify.com/futurizerush/meta-threads-scraper?fpr=rush): collect public posts, search keywords, discover profiles, and export account data.
- [Threads Replies Scraper](https://apify.com/futurizerush/threads-replies-scraper?fpr=rush): collect public replies and comments for conversation analysis.

### FAQ

#### Does this require a Threads login?

No. The Actor is designed for publicly accessible Threads data and does not require you to provide a Threads account.

#### Why did I get fewer results than requested?

Result count depends on what is publicly available 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 at collection time.

#### Are `top` and `recent` exact filters?

They reflect the public search ordering available at run time. `recent` aims to show newer matching public posts first, but some related older posts may still appear.

### Disclaimer

Use this Actor responsibly and ensure your usage complies with applicable laws, platform terms, and your organization's policies. Data availability and accuracy may vary over time.

**Keywords**: Threads Search Scraper, Threads keyword search, Threads hashtag search, Threads data scraper, Meta Threads scraper, Threads post extractor, Threads engagement metrics, Threads monitoring, Threads analytics, social listening, social media monitoring, competitor research, trend research, market research, brand monitoring, public Threads data, export Threads posts, OpenClaw, Claude Code, Gemini, Antigravity, Codex, ChatGPT

# Actor input Schema

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

Enter one or more keywords or hashtags. The # is optional, e.g. 'AI', '#startup', or '台北 餐廳'.

## `max_posts` (type: `integer`):

Maximum posts per keyword. Actual results depend on public availability at run time.

## `search_filter` (type: `string`):

Choose popular posts or newer matching public posts first.

## `start_date` (type: `string`):

Optional. Keep posts from this date onward. Supports YYYY-MM-DD or relative values such as '7 days'.

## `end_date` (type: `string`):

Optional. Keep posts up to this date. YYYY-MM-DD is recommended for clarity.

## Actor input object example

```json
{
  "keywords": [
    "AI"
  ],
  "max_posts": 50,
  "search_filter": "top"
}
```

# Actor output Schema

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

Scraped Threads search results

# 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"
    ],
    "max_posts": 50,
    "search_filter": "top"
};

// Run the Actor and wait for it to finish
const run = await client.actor("futurizerush/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 = {
    "keywords": ["AI"],
    "max_posts": 50,
    "search_filter": "top",
}

# Run the Actor and wait for it to finish
run = client.actor("futurizerush/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"
  ],
  "max_posts": 50,
  "search_filter": "top"
}' |
apify call futurizerush/threads-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=futurizerush/threads-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Threads Search Scraper",
        "description": "Search Threads posts by keyword. Get full engagement metrics (likes, comments, reposts, views), author profiles, media URLs, and timestamps. Supports one-keyword search, exclude filters, and time range filtering. Perfect for brand monitoring, trend analysis, and competitor research. (Beta)",
        "version": "0.0",
        "x-build-id": "h5dlRStXvFrehbJVt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/futurizerush~threads-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-futurizerush-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/futurizerush~threads-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-futurizerush-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/futurizerush~threads-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-futurizerush-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",
                        "minItems": 1,
                        "maxItems": 20,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Enter one or more keywords or hashtags. The # is optional, e.g. 'AI', '#startup', or '台北 餐廳'.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 100
                        }
                    },
                    "max_posts": {
                        "title": "📦 Max Results",
                        "minimum": 10,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum posts per keyword. Actual results depend on public availability at run time.",
                        "default": 50
                    },
                    "search_filter": {
                        "title": "🔎 Sort Order",
                        "enum": [
                            "top",
                            "recent"
                        ],
                        "type": "string",
                        "description": "Choose popular posts or newer matching public posts first.",
                        "default": "top"
                    },
                    "start_date": {
                        "title": "📅 Start Date",
                        "type": "string",
                        "description": "Optional. Keep posts from this date onward. Supports YYYY-MM-DD or relative values such as '7 days'."
                    },
                    "end_date": {
                        "title": "📅 End Date",
                        "type": "string",
                        "description": "Optional. Keep posts up to this date. YYYY-MM-DD is recommended for clarity."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
