# Threads Scraper - Profiles, Posts, Replies & Leads (`scrapesage/threads-scraper`) Actor

Scrape Threads (Meta): full profiles (followers, bio, verified, links), posts with likes/replies/reposts/quotes & media, post replies, plus creator/brand leads with emails & socials. Monitor for new posts.

- **URL**: https://apify.com/scrapesage/threads-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (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 $3.00 / 1,000 profiles

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/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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Scraper — Profiles, Posts, Replies & Creator Leads

Extract **complete data from Threads (Meta)** — the fastest-growing text social network (500M+ monthly actives). Pull **full profiles** (followers, bio, verified badge, links), **posts with real engagement** (likes, replies, reposts, quotes), **all media** (images, video, carousels), and **post replies** — then optionally turn any creator or brand into a **ready-to-contact lead** with emails, phone and social handles.

No login, no API key, no browser — fast JSON extraction straight from Threads' server-rendered data.

### Why this Threads scraper?

Most Threads scrapers return a thin slice — a handle and a follower count. This actor ships the **richest record in the category**, with the engagement, media and contact fields that actually matter:

| Data | Typical scrapers | This actor |
|---|---|---|
| Follower count, verified, private flag | partial | ✅ |
| Full bio + parsed links, @mentions, #hashtags | ❌ | ✅ |
| Bio links / external website | ❌ | ✅ |
| HD profile picture | ❌ | ✅ |
| Post text + likes | partial | ✅ |
| Replies, reposts **and** quote counts | ❌ | ✅ all four |
| Images, video URL & carousels | ❌ | ✅ |
| Link cards & quoted/reposted posts | ❌ | ✅ |
| Parsed hashtags / mentions / links per post | ❌ | ✅ |
| Post **replies** (whole thread) | ❌ | ✅ |
| Creator **contact emails / phone / socials** | ❌ | ✅ opt-in |
| Lead score (0–100) | ❌ | ✅ |
| Only-new **monitor mode** | ❌ | ✅ |

### Use cases

- **Creator & brand lead generation** — Threads creators and brands are active buyers and partners. Score them by audience size and turn each profile into a contactable lead (`emails`, `phones`, `website`, `socials`, `leadScore`) for influencer outreach, sponsorships and B2B sales.
- **Social listening & brand monitoring** — track what creators, competitors and brands post, with full engagement metrics, and run it on a schedule to catch **only new posts**.
- **Engagement & sentiment analysis** — pull a thread with all its replies for conversation mining, sentiment, and community research.
- **Influencer discovery & vetting** — verify follower counts, verified status, posting cadence and engagement before partnering.
- **Content & trend research** — collect posts by hashtag/mention from creators you track and analyze what performs.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Threads Scraper**, pick a **mode**, and enter usernames or paste Threads URLs.
3. Click **Start** and watch results stream into the dataset.
4. **Export** as JSON, CSV, Excel, XML or RSS — or pull results via the [Apify API](https://docs.apify.com/api/v2).

### Modes

- **Profiles** — one full profile per username/URL (followers, bio, verified, links, HD picture), with recent posts inline and optional contact-lead enrichment.
- **User posts** — a profile's recent posts as individual records. Pull from the `threads`, `replies` and/or `media` tabs for more depth.
- **Post** — a single post/thread by URL, plus its replies (each as its own record).

### Input

```json
{
    "mode": "profiles",
    "usernames": ["zuck", "mosseri", "nike"],
    "includePosts": true,
    "postTabs": ["threads"],
    "maxPostsPerProfile": 20,
    "enrichLeads": true,
    "leadsOnly": false
}
````

Single-post example:

```json
{
    "mode": "post",
    "postUrls": ["https://www.threads.com/@zuck/post/DZpPDXbCeTt"],
    "includeReplies": true,
    "maxRepliesPerPost": 50
}
```

- **usernames** — `@handle`, `handle`, or a profile URL (`https://www.threads.com/@zuck`). Used in **Profiles** and **User posts** modes.
- **includePosts** *(default true)* — attach recent posts to each profile record.
- **postTabs** *(default `["threads"]`)* — which profile tabs to collect posts from: `threads` (own posts), `replies`, `media`. Combine for more depth.
- **maxPostsPerProfile** — cap recent posts per profile.
- **enrichLeads** *(default false)* — parse emails/phone from the bio, classify linked socials, crawl the linked website (home + contact/about, max 3 pages) for contacts, and compute a 0–100 `leadScore`.
- **leadsOnly** *(default false)* — only output profiles that yielded at least one contact email.
- **postUrls** — Threads post URLs or codes for **Post** mode.
- **includeReplies / maxRepliesPerPost** — control reply collection in **Post** mode.
- **startUrls** — paste any mix of profile and post URLs; each is auto-routed.
- **monitorMode / monitorStoreName** — output only records not seen on previous runs.
- **maxResults** — overall cap (0 = no limit).

### Output

**Profile record** (`recordType: "profile"`, or `"profileLead"` when enriched):

```json
{
    "recordType": "profileLead",
    "username": "examplecreator",
    "userId": "1234567890",
    "fullName": "Example Creator",
    "biography": "Designer & founder. Bookings: hello@example.com",
    "bioLinks": [{ "url": "https://example.com", "title": null }],
    "externalUrl": "https://example.com",
    "followerCount": 184203,
    "isVerified": true,
    "isPrivate": false,
    "profilePicUrl": "https://...150x150.jpg",
    "hdProfilePicUrl": "https://...640x640.jpg",
    "profileUrl": "https://www.threads.com/@examplecreator",
    "postsCount": 4,
    "recentPosts": [{ "code": "DZ...", "text": "…", "likeCount": 1203, "replyCount": 88, "mediaType": "image" }],
    "emails": ["hello@example.com"],
    "phones": ["+1 415 555 0199"],
    "website": "https://example.com",
    "socials": { "instagram": "https://instagram.com/examplecreator", "youtube": "https://youtube.com/@examplecreator" },
    "leadScore": 88,
    "scrapedAt": "2026-06-18T12:00:00.000Z"
}
```

**Post record** (`recordType: "post"`, replies use `"reply"`):

```json
{
    "recordType": "post",
    "postId": "3920731152608519405",
    "code": "DZpPDXbCeTt",
    "url": "https://www.threads.com/@zuck/post/DZpPDXbCeTt",
    "username": "zuck",
    "authorFullName": "Mark Zuckerberg",
    "authorIsVerified": true,
    "text": "500M monthly actives on Threads in less than 3 years…",
    "likeCount": 17183,
    "replyCount": 4608,
    "repostCount": 534,
    "quoteCount": 259,
    "mediaType": "image",
    "images": ["https://...jpg"],
    "videoUrl": null,
    "hashtags": [],
    "mentions": [],
    "links": [],
    "language": "en",
    "takenAt": "2026-06-16T10:59:56.000Z",
    "takenAtTimestamp": 1781607596,
    "scrapedAt": "2026-06-18T12:00:00.000Z"
}
```

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it hourly/daily to monitor tracked creators for new posts; combine with **Monitor mode** for new-only output.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, email sequence) the moment a run finishes.

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/threads-scraper').call({
    mode: 'profiles',
    usernames: ['zuck', 'mosseri'],
    includePosts: true,
    enrichLeads: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} Threads records`);
```

### Monitor mode (only new data)

Turn on **Monitor mode** and the actor remembers what it has already returned (in a named key-value store) and outputs **only new** posts or profiles on the next run — perfect for new-post alerts on the creators you track. It is independent of Apify Schedules, so you can pair them: schedule the run, get only the deltas. Use different `monitorStoreName` values to track different watchlists separately.

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new creator leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored creator posts.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "get the Threads profile and recent posts for @nike and list the contact details" and let it run this scraper for you.

### More scrapers from scrapesage

Build a complete **social & creator-economy lead-gen stack**:

- **[Bluesky Scraper](https://apify.com/scrapesage/bluesky-scraper)** — profiles, posts, followers & leads from Bluesky / AT-Protocol.
- **[Twitch Scraper](https://apify.com/scrapesage/twitch-scraper)** — channels, live streams, clips & streamer leads.
- **[Kick Scraper](https://apify.com/scrapesage/kick-scraper)** — creators, channels, streams & clips from Kick.
- **[Spotify Scraper](https://apify.com/scrapesage/spotify-scraper)** — artists, monthly listeners, tracks, playlists & podcasts.
- **[SoundCloud Scraper](https://apify.com/scrapesage/soundcloud-scraper)** — tracks, artists & playlists.
- **[YouTube Scraper](https://apify.com/scrapesage/youtube-scraper)** — videos, channels & stats.
- **[Patreon Scraper](https://apify.com/scrapesage/patreon-scraper)** — creators, membership tiers & earnings estimates.
- **[Substack Scraper](https://apify.com/scrapesage/substack-scraper)** — newsletters, posts & author leads.
- **[Linktree Scraper](https://apify.com/scrapesage/linktree-scraper)** — bio links, emails & creator leads.
- **[Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper)** — emails, phones & socials from any domain list.

### Tips

- **Datacenter proxy is fine** — Threads renders public profiles on Apify's datacenter proxy (fast & cheap). Switch to residential only if your region is blocked.
- **More posts per profile**: add `replies` and `media` to `postTabs` to widen the recent-post window.
- **Lead enrichment** only crawls the creator's own linked website — emails come from there or the bio, never invented.
- **Recurring monitoring**: combine [Schedules](https://docs.apify.com/platform/schedules) with **Monitor mode** to get only new posts.

### FAQ

**Do I need a Threads or Instagram login?** No. This actor reads the same public, server-rendered data a logged-out visitor sees — no login, cookies or API key.

**Can I scrape a specific post and its replies?** Yes. Use **Post** mode with the post URL (`/@user/post/CODE` or `/t/CODE`); set `includeReplies` to also collect the replies.

**Why did a profile return no data?** A small number of Threads profiles are **login-gated** by their owner (not viewable on the web logged-out), private, or simply don't exist on Threads — the actor logs a clear reason and skips them. Public profiles return full data.

**How many recent posts do I get per profile?** Threads server-renders the most recent posts per tab. Add `replies` and `media` tabs (and raise `maxPostsPerProfile`) to widen the window.

**Where do the emails come from?** Never invented — from the public bio and the creator's own linked website (home + contact/about). Tracking/placeholder addresses are filtered out.

**Can I export to Google Sheets, CSV or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**Is scraping Threads legal?** This actor collects publicly available data only. You are responsible for using it in compliance with applicable laws (GDPR/CCPA for personal data) and Threads' terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `mode` (type: `string`):

<b>Profiles</b> = full profile for each username/URL (followers, bio, verified, links, recent posts + optional contact leads). <b>User posts</b> = a profile's recent posts/replies as individual records. <b>Post</b> = a single post/thread by URL, with its replies.

## `usernames` (type: `array`):

Threads usernames or profile URLs for <b>Profiles</b> and <b>User posts</b> modes. Accepts <code>@zuck</code>, <code>zuck</code>, or <code>https://www.threads.com/@zuck</code>.

## `includePosts` (type: `boolean`):

In <b>Profiles</b> mode, attach the profile's most recent posts (with full engagement & media) inline on the profile record.

## `postTabs` (type: `array`):

In <b>User posts</b> mode (and for inline profile posts), which profile tabs to pull recent posts from. <code>threads</code> = the user's own posts, <code>replies</code> = posts they replied to, <code>media</code> = their media posts. Combine for more depth (~4–6 recent items per tab).

## `maxPostsPerProfile` (type: `integer`):

Cap the number of recent posts collected per profile (across the selected tabs).

## `enrichLeads` (type: `boolean`):

In <b>Profiles</b> mode, parse contact emails & phone from the bio, classify linked socials, crawl the linked website (home + contact/about, max 3 pages) for emails/phone/socials, and compute a 0–100 lead score. Turns each profile into a ready-to-contact B2B/creator lead.

## `leadsOnly` (type: `boolean`):

When lead enrichment is on, only emit profiles that yielded at least one contact email (skip profiles with no reachable contact).

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

Threads post URLs for <b>Post</b> mode, e.g. <code>https://www.threads.com/@zuck/post/DZpPDXbCeTt</code> or a short <code>https://www.threads.com/t/DZpPDXbCeTt</code>. A bare post code also works.

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

In <b>Post</b> mode, also output the replies in the thread (each as its own record) below the root post.

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

Cap the number of replies collected per thread.

## `startUrls` (type: `array`):

Paste Threads URLs — profile pages (<code>/@user</code>) or post pages (<code>/@user/post/CODE</code>, <code>/t/CODE</code>). Each is auto-routed to the right scraper.

## `maxResults` (type: `integer`):

Maximum number of records to return for this run (0 = no limit).

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

Remember records seen on previous runs (in a named key-value store) and output only NEW ones — perfect for alerting on new posts from tracked creators or new replies on a thread. Combine with Apify <a href='https://docs.apify.com/platform/schedules'>Schedules</a> to poll automatically.

## `monitorStoreName` (type: `string`):

Name of the key-value store that holds the 'seen' fingerprints for monitor mode. Use different names to track different watchlists independently.

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

Threads works on Apify's datacenter proxy (fast & cheap, recommended). Switch to residential if you hit blocks from your region.

## Actor input object example

```json
{
  "mode": "profiles",
  "usernames": [
    "zuck",
    "mosseri"
  ],
  "includePosts": true,
  "postTabs": [
    "threads"
  ],
  "maxPostsPerProfile": 20,
  "enrichLeads": false,
  "leadsOnly": false,
  "includeReplies": true,
  "maxRepliesPerPost": 50,
  "maxResults": 0,
  "monitorMode": false,
  "monitorStoreName": "threads-monitor",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped Threads records as JSON 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 = {
    "usernames": [
        "zuck",
        "mosseri"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Threads Scraper - Profiles, Posts, Replies & Leads",
        "description": "Scrape Threads (Meta): full profiles (followers, bio, verified, links), posts with likes/replies/reposts/quotes & media, post replies, plus creator/brand leads with emails & socials. Monitor for new posts.",
        "version": "1.0",
        "x-build-id": "zGlSgplmnYfSmN5cW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~threads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-threads-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/scrapesage~threads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-threads-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/scrapesage~threads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-threads-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",
                "properties": {
                    "mode": {
                        "title": "What to scrape",
                        "enum": [
                            "profiles",
                            "userPosts",
                            "post"
                        ],
                        "type": "string",
                        "description": "<b>Profiles</b> = full profile for each username/URL (followers, bio, verified, links, recent posts + optional contact leads). <b>User posts</b> = a profile's recent posts/replies as individual records. <b>Post</b> = a single post/thread by URL, with its replies.",
                        "default": "profiles"
                    },
                    "usernames": {
                        "title": "Usernames / profile URLs",
                        "type": "array",
                        "description": "Threads usernames or profile URLs for <b>Profiles</b> and <b>User posts</b> modes. Accepts <code>@zuck</code>, <code>zuck</code>, or <code>https://www.threads.com/@zuck</code>.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includePosts": {
                        "title": "Include recent posts on each profile",
                        "type": "boolean",
                        "description": "In <b>Profiles</b> mode, attach the profile's most recent posts (with full engagement & media) inline on the profile record.",
                        "default": true
                    },
                    "postTabs": {
                        "title": "Which posts to collect",
                        "type": "array",
                        "description": "In <b>User posts</b> mode (and for inline profile posts), which profile tabs to pull recent posts from. <code>threads</code> = the user's own posts, <code>replies</code> = posts they replied to, <code>media</code> = their media posts. Combine for more depth (~4–6 recent items per tab).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "threads",
                                "replies",
                                "media"
                            ]
                        },
                        "default": [
                            "threads"
                        ]
                    },
                    "maxPostsPerProfile": {
                        "title": "Max posts per profile",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap the number of recent posts collected per profile (across the selected tabs).",
                        "default": 20
                    },
                    "enrichLeads": {
                        "title": "Enrich profiles into contact leads",
                        "type": "boolean",
                        "description": "In <b>Profiles</b> mode, parse contact emails & phone from the bio, classify linked socials, crawl the linked website (home + contact/about, max 3 pages) for emails/phone/socials, and compute a 0–100 lead score. Turns each profile into a ready-to-contact B2B/creator lead.",
                        "default": false
                    },
                    "leadsOnly": {
                        "title": "Only output profiles that became leads",
                        "type": "boolean",
                        "description": "When lead enrichment is on, only emit profiles that yielded at least one contact email (skip profiles with no reachable contact).",
                        "default": false
                    },
                    "postUrls": {
                        "title": "Post / thread URLs",
                        "type": "array",
                        "description": "Threads post URLs for <b>Post</b> mode, e.g. <code>https://www.threads.com/@zuck/post/DZpPDXbCeTt</code> or a short <code>https://www.threads.com/t/DZpPDXbCeTt</code>. A bare post code also works.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeReplies": {
                        "title": "Include replies",
                        "type": "boolean",
                        "description": "In <b>Post</b> mode, also output the replies in the thread (each as its own record) below the root post.",
                        "default": true
                    },
                    "maxRepliesPerPost": {
                        "title": "Max replies per post",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap the number of replies collected per thread.",
                        "default": 50
                    },
                    "startUrls": {
                        "title": "Start URLs (profiles or posts)",
                        "type": "array",
                        "description": "Paste Threads URLs — profile pages (<code>/@user</code>) or post pages (<code>/@user/post/CODE</code>, <code>/t/CODE</code>). Each is auto-routed to the right scraper.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of records to return for this run (0 = no limit).",
                        "default": 0
                    },
                    "monitorMode": {
                        "title": "Monitor mode (only new data)",
                        "type": "boolean",
                        "description": "Remember records seen on previous runs (in a named key-value store) and output only NEW ones — perfect for alerting on new posts from tracked creators or new replies on a thread. Combine with Apify <a href='https://docs.apify.com/platform/schedules'>Schedules</a> to poll automatically.",
                        "default": false
                    },
                    "monitorStoreName": {
                        "title": "Monitor store name",
                        "type": "string",
                        "description": "Name of the key-value store that holds the 'seen' fingerprints for monitor mode. Use different names to track different watchlists independently.",
                        "default": "threads-monitor"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Threads works on Apify's datacenter proxy (fast & cheap, recommended). Switch to residential if you hit blocks from your region.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
