# Threads Scraper – Posts, Profiles, Replies & Search (`ninhothedev/threads-scraper`) Actor

Scrape public Threads posts, profiles, replies and keyword searches without login. Export text, engagement, followers and media to JSON/CSV. Profile pagination where available.

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

## Pricing

from $1.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.

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 Scraper – Posts, Profiles, Replies & Search

Scrape **Meta Threads** (threads.com / threads.net) **without login, cookies or API key**. Get public profile posts with pagination where Threads makes continuation data available, profile info with **follower count, bio, verified badge and bio links**, **replies** of any post, and **keyword / hashtag search** results. Every post comes with likes, replies, reposts, quotes, images, videos, links, hashtags, mentions, quoted post and author details. Fast HTTP-only scraper (no browser) – **$1 per 1,000 results** plus the small Actor-start event described below.

### What data can you extract?

| Field | Example | Notes |
|---|---|---|
| `type` | `post` | `post`, `reply` or `profile` |
| `id` / `code` / `url` | `4006434140014576097` / `DeZtp-TkQHh` | stable post ID + shortcode + permalink |
| `text` | `Introducing Muse Wonder, …` | full post text |
| `created_at` | `2026-10-12T16:56:29Z` | ISO 8601, UTC |
| `like_count`, `reply_count`, `repost_count`, `quote_count`, `reshare_count` | `1967`, `333`, `154`, `58`, `137` | engagement metrics |
| `media_type`, `images`, `videos` | `carousel`, `[…]`, `[…]` | full-resolution media URLs (all carousel items) |
| `author_username`, `author_full_name`, `author_id` | `zuck`, `Mark Zuckerberg` | |
| `author_verified`, `author_followers` | `true`, `5749180` | followers for every author (also in search & replies) |
| `is_reply`, `reply_to_username`, `parent_post_id` | `true`, `zuck`, `4006…` | reply / thread structure |
| `quoted_post`, `quoted_post_url`, `is_repost`, `reposted_post_url` | `{…}` | quoted post with text, author, likes |
| `links`, `hashtags`, `mentions`, `link_preview_title` | `["https://research.meta.ai/…"]` | extracted entities, topic tags |
| `biography`, `bio_links`, `follower_count` | profile rows only | |
| `source`, `source_type`, `scraped_at` | `@zuck`, `profile` | where the row came from |

The output schema is **identical for all modes** (profiles, posts, search), so you can merge datasets without mapping.

### How to use

1. Add **profiles** (`zuck`, `@mosseri`, `https://www.threads.net/@nasa`), **post URLs** and/or **search queries** (`web scraping`, `#ai`).
2. Set **Max posts per profile / search**, optional date (`onlyPostsNewerThan`: `7 days`, `2026-01-01`) and `minLikes` filters.
3. Click **Start** and download results as JSON, CSV, Excel or via API.

```json
{
  "profiles": ["zuck", "https://www.threads.com/@mosseri"],
  "postUrls": ["https://www.threads.com/@zuck/post/DeZtp-TkQHh"],
  "searchQueries": ["web scraping", "#ai"],
  "maxPostsPerSource": 50,
  "maxRepliesPerPost": 100,
  "onlyPostsNewerThan": "30 days"
}
```

### Output example

Post (real output, media URLs shortened):

```json
{
  "type": "post",
  "id": "4006434140014576097",
  "code": "DeZtp-TkQHh",
  "url": "https://www.threads.com/@zuck/post/DeZtp-TkQHh",
  "text": "Introducing Muse Wonder, our new family of frontier models with state of the art performance for personal and professional agentic work.",
  "created_at": "2026-10-12T16:56:29Z",
  "like_count": 1967,
  "reply_count": 333,
  "repost_count": 154,
  "quote_count": 58,
  "reshare_count": 137,
  "media_type": "image",
  "images": [
    "https://scontent-iad6-1.cdninstagram.com/v/t51.82787-15/844965867_17991705567103224_8296143909108287920_n.webp?…"
  ],
  "videos": [],
  "author_username": "zuck",
  "author_full_name": "Mark Zuckerberg",
  "author_id": "63055343223",
  "author_verified": true,
  "author_followers": 5749184,
  "author_profile_pic_url": "https://scontent-iad6-1.cdninstagram.com/v/t51.82787-19/825322135_17989325280103224_1252773933700107438_n.jpg?…",
  "is_reply": false,
  "reply_to_username": null,
  "parent_post_id": null,
  "quoted_post": null,
  "quoted_post_url": null,
  "is_repost": false,
  "reposted_post_url": null,
  "links": [],
  "hashtags": [],
  "mentions": [],
  "link_preview_title": null,
  "is_paid_partnership": false,
  "biography": null,
  "bio_links": null,
  "follower_count": null,
  "source": "@zuck",
  "source_type": "profile",
  "scraped_at": "2026-10-15T21:27:29Z"
}
```

Profile row:

```json
{
  "type": "profile",
  "id": "63055343223",
  "url": "https://www.threads.com/@zuck",
  "author_username": "zuck",
  "author_full_name": "Mark Zuckerberg",
  "author_verified": true,
  "follower_count": 5749184,
  "biography": "Mostly superintelligence and MMA takes",
  "bio_links": []
}
```

### Pricing

Pay per result: **$1.00 per 1,000 results** (posts, replies or profile rows), plus an Actor-start event of $0.00005 per GB of memory, minimum one event. For example, 20 posts plus one profile row cost $0.021 in result charges, plus the start event. There is no monthly Actor rental. The live Pricing tab is authoritative. Use **Max total results** to limit output and set a maximum charge in Apify Console.

### Use cases

- **Brand & competitor monitoring** – track what brands, founders and competitors post and how it performs.
- **Influencer research** – find creators by keyword/hashtag, compare follower counts and engagement.
- **Social listening & sentiment** – collect replies to a post or campaign for analysis.
- **Lead generation** – collect bio links and profiles of people discussing your niche.
- **Content research** – find top-performing posts and formats in your industry.
- **Academic & market research** – export public conversations into datasets.

### Integrations

Use the results anywhere: Apify API, **Make**, **Zapier**, **n8n**, **Google Sheets**, Slack, webhooks, or schedule runs to monitor accounts daily.

```python
from apify_client import ApifyClient
client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("ninhothedev/threads-scraper").call(run_input={"profiles": ["zuck"], "maxPostsPerSource": 50})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("type") != "profile":
        print(item.get("created_at"), item.get("like_count"), (item.get("text") or "")[:80])
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('ninhothedev/threads-scraper').call({ searchQueries: ['#ai'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

### FAQ

**Do I need a Threads/Instagram account?** No. Only public data visible to logged-out visitors is collected – no cookies, no login, no risk to your account.

**Is scraping Threads legal?** The scraper only collects publicly available data. Personal data is protected by laws such as GDPR – only scrape it for a legitimate purpose and consult a lawyer if unsure.

**How many posts can I get per profile?** The scraper paginates through the profile's timeline, so you can go well beyond the ~15 posts shown on the public web page. Complete history is not guaranteed. Private accounts may expose only public profile metadata; private posts are not collected.

**Search limits?** Threads shows logged-out visitors the **top ~20 posts per keyword or hashtag**. Use several specific keywords/hashtags for more coverage. Replies are paginated while the source supplies continuation data.

**Do I need a proxy?** No. The scraper connects directly and automatically falls back to Apify Proxy if Threads ever blocks a request. Partial results are always saved and every run writes a `RUN_SUMMARY` record.

**Are media URLs permanent?** Threads CDN links are signed and expire after some days – download media you need soon after the run.

**Scheduling?** Yes – use Apify Schedules to monitor profiles or keywords daily and send new posts to Sheets/Slack/webhooks.

**Support?** Open an issue on the Issues tab – include your run ID and a minimal input so the issue can be reproduced.

### Related scrapers by ninhothedev

- [Telegram Scraper](https://apify.com/ninhothedev/telegram-scraper) – public channel posts, views & reactions
- [Pinterest Scraper](https://apify.com/ninhothedev/pinterest-scraper) – pins, boards & profiles
- [YouTube Channel Scraper](https://apify.com/ninhothedev/youtube-channel-scraper) – channel videos & stats

# Actor input Schema

## `profiles` (type: `array`):

Threads usernames or profile URLs, e.g. zuck, @mosseri, https://www.threads.com/@nasa (threads.net links work too). Returns the profile (bio, followers, verified, links) and its recent posts.

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

Threads post URLs or shortcodes, e.g. https://www.threads.com/@zuck/post/DeZtp-TkQHh. Returns the post plus its replies.

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

Keywords or #hashtags (topic tags). Logged-out Threads search returns the top ~20 posts per query.

## `maxPostsPerSource` (type: `integer`):

How many posts to collect for each profile or search query (profile pagination goes back through the full history).

## `maxRepliesPerPost` (type: `integer`):

Replies collected for each post URL (0 = post only).

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

Hard cap on dataset items for the whole run (0 = no cap). You are never charged for more than this.

## `onlyPostsNewerThan` (type: `string`):

Absolute date (2026-01-31) or relative (7 days, 2 weeks, 3 months, 12 hours). Older posts are skipped.

## `minLikes` (type: `integer`):

Skip posts/replies with fewer likes.

## `includeProfileInfo` (type: `boolean`):

Add one row per profile with bio, follower count, verified badge and bio links (type = profile).

## `includeThreadContinuations` (type: `boolean`):

Include the author's own follow-up posts in multi-post threads (self-replies).

## `includeReplies` (type: `boolean`):

Collect replies for each post URL.

## `repliesSort` (type: `string`):

Order of replies for post URLs.

## `enrichAuthorFollowers` (type: `boolean`):

Look up follower counts of authors in search results and replies (one extra lightweight request per unique author). Profile posts always include it.

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

Usually not needed. The scraper connects directly and automatically falls back to Apify Proxy if Threads blocks it.

## Actor input object example

```json
{
  "profiles": [
    "zuck"
  ],
  "maxPostsPerSource": 20,
  "maxRepliesPerPost": 20,
  "maxItems": 0,
  "minLikes": 0,
  "includeProfileInfo": true,
  "includeThreadContinuations": true,
  "includeReplies": true,
  "repliesSort": "top",
  "enrichAuthorFollowers": true
}
```

# Actor output Schema

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

No description

## `profiles` (type: `string`):

No description

## `summary` (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 = {
    "profiles": [
        "zuck"
    ],
    "maxPostsPerSource": 20
};

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

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

```

## MCP server setup

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