# Threads Scraper — Profiles, Posts & Engagement Data (`scrapesmith/threads-scraper`) Actor

Scrape every post from any Threads by Meta profile. Unlimited pagination, 57 fields per post including likes, replies, reposts, quotes, shares, media URLs, and full profile data. No browser, no proxy, no login.

- **URL**: https://apify.com/scrapesmith/threads-scraper.md
- **Developed by:** [Scrape Smith](https://apify.com/scrapesmith) (community)
- **Categories:** Social media, Developer tools, Automation
- **Stats:** 0 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Scraper — Profiles, Posts & Engagement Data

The most complete Threads scraper on Apify. Extract **every post** a user has ever published on Threads by Meta, along with full profile data and engagement metrics — all without login, without a browser, without a proxy.

Unlike other Threads scrapers that cap at 25–50 posts, this one paginates through the **entire post history** back to July 2023. Verified with 3,300+ posts from a single account.

---

### Why This Scraper?

- **Unlimited posts per user** — scrape every post, not just the latest 25
- **57 data fields per post** — the most comprehensive output on Apify
- **No browser, no proxy, no login** — runs on 256 MB, fast and cheap
- **Bulk-ready** — scrape dozens of users in a single run
- **Flat, CSV-ready output** — every row is one post, ready for spreadsheets

---

### What Data Do You Get?

#### Profile Data (per user)
Username, display name, user ID, bio, bio links, follower count, thread count, profile picture URL, verification status.

#### Post Data (57 fields per post)

| Category | Fields |
|---|---|
| **Content** | Full post text, shortcode, post URL, post ID |
| **Engagement** | Like count, reply count, repost count, quote count, share count, view count |
| **Timestamps** | ISO 8601, human-readable display, Unix timestamp |
| **Media** | Media type (text/photo/video/carousel), media URLs, dimensions, carousel count, has audio |
| **Author** | Username, display name, bio, followers, verified status, profile pic — on every row |
| **Interactions** | Is reply, reply-to username, is quote post, quoted post URL, is repost, reposted post URL |
| **Metadata** | Is pinned, is edited, is paid partnership, is AI generated, is GIF, is spoiler, reply control, language, accessibility caption |
| **Links** | Link preview URL, link title |
| **Location** | Location name, location ID |
| **Tags** | Hashtags array, mentions array |

---

### Input

```json
{
  "usernames": ["zuck", "mosseri", "instagram"],
  "mode": "both",
  "maxPostsPerUser": 500,
  "maxResults": 10000
}
````

| Parameter | Type | Default | Description |
|---|---|---|---|
| `usernames` | string\[] | — | Threads usernames to scrape (without the @) |
| `mode` | string | `both` | `profile` for profile info only, `posts` for posts only, `both` for everything |
| `maxPostsPerUser` | integer | `500` | Maximum posts to collect per user. No upper limit — set to 10000 to get everything |
| `maxResults` | integer | `10000` | Maximum total items across all users |

***

### Sample Output

#### Profile

```json
{
  "type": "profile",
  "username": "zuck",
  "user_id": "63055343223",
  "display_name": "Mark Zuckerberg",
  "bio": "CEO of Meta",
  "bio_links": ["https://meta.com"],
  "follower_count": "5.6M",
  "thread_count": "150",
  "profile_pic_url": "https://...",
  "is_verified": true,
  "url": "https://www.threads.net/@zuck"
}
```

#### Post

```json
{
  "type": "post",
  "post_id": "3920731152608519405",
  "shortcode": "DZpPDXbCeTt",
  "username": "zuck",
  "display_name": "Mark Zuckerberg",
  "followers_count": "5.6M",
  "is_verified": true,
  "text_content": "500M monthly actives on Threads in less than 3 years.",
  "like_count": 17851,
  "reply_count": 1200,
  "repost_count": 340,
  "quote_count": 29,
  "share_count": 111,
  "created_at": "2026-06-16T10:59:56+00:00",
  "created_at_display": "2026-06-16 10:59 UTC",
  "media_type": "text",
  "has_media": false,
  "is_reply": false,
  "is_quote_post": false,
  "is_repost": false,
  "is_pinned": true,
  "is_edited": false,
  "reply_control": "everyone",
  "hashtags": [],
  "mentions": [],
  "post_url": "https://www.threads.net/@zuck/post/DZpPDXbCeTt"
}
```

***

### How Fast Is It?

| Scenario | Posts | Time |
|---|---|---|
| Single user, 200 posts | 200 | ~40 seconds |
| Single user, all posts (400+) | 400+ | ~90 seconds |
| 3 users, 200 posts each | 600 | ~90 seconds |
| Heavy account (news, 3000+ posts) | 3,300+ | ~9 minutes |
| Profile only, 10 users | 10 profiles | ~15 seconds |

No browser, no proxy — runs on 256 MB of memory.

***

### Use Cases

- **Brand monitoring** — track what competitors post, how often, and what engagement they get
- **Influencer research** — analyze posting patterns, engagement rates, and content types across accounts
- **Content analysis** — export every post from an account for sentiment analysis, topic modeling, or trend detection
- **Social listening** — monitor public figures, brands, or news accounts for new content
- **Academic research** — collect large-scale public social media datasets from Threads
- **Competitive intelligence** — compare posting frequency, engagement, and content strategy across brands
- **Media monitoring** — track news outlets and journalists on Threads

***

### FAQ

**How many posts can I get from one account?**
Every post they've ever made on Threads. There is no cap. Accounts with 3,000+ posts have been fully scraped in a single run.

**Does this require a Threads login or account?**
No. Everything is scraped from public data. No login, no cookies, no authentication needed.

**Can I scrape private accounts?**
No. Only public profiles and posts are accessible.

**What's the difference between this and other Threads scrapers?**
Most Threads scrapers on Apify are limited to 25–50 posts per user and use 4 GB browsers. This scraper has no post limit, uses 256 MB, runs without a browser, and outputs 57 fields per post — the most comprehensive data available.

**Can I filter posts by date?**
Posts are returned in reverse chronological order (newest first). Set `maxPostsPerUser` to control how far back you go. A future update will add explicit date filtering.

**What if a username doesn't exist?**
Invalid usernames are gracefully skipped with zero output. The scraper continues to the next username without failing.

**How is engagement data calculated?**
Like count, reply count, repost count, quote count, and share count are pulled directly from Threads. These are exact counts at the time of scraping, not estimates.

**What media formats are supported?**
Text posts, single images, videos, carousels (multi-image), and GIFs are all captured. Media URLs are included for direct download.

**Can I export to CSV or Excel?**
Yes. Apify datasets support JSON, CSV, Excel, XML, and HTML table export. Every post is a flat row with all 57 fields — no nested objects that break spreadsheet import.

**How do I scrape all posts from a large account?**
Set `maxPostsPerUser` to a high number (e.g. 50000) and the scraper will paginate through every page automatically. A news account with 3,300 posts completes in about 9 minutes.

**Is there a free trial?**
Yes. Every run includes free results so you can verify the data before subscribing to a paid plan.

# Actor input Schema

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

List of Threads/Instagram usernames to scrape profiles and posts for.

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

What to scrape: 'profile' (profile info only), 'posts' (profile + recent posts), 'both' (default).

## `maxPostsPerUser` (type: `integer`):

Maximum number of posts to scrape per user. Set high to get all posts.

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

Maximum total result items across all users. Free plan is capped at 25.

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

Specific Threads post URLs to scrape. Format: https://www.threads.net/@username/post/SHORTCODE

## Actor input object example

```json
{
  "usernames": [
    "zuck",
    "mosseri"
  ],
  "mode": "both",
  "maxPostsPerUser": 500,
  "maxResults": 10000
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesmith/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrapesmith/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 '{}' |
apify call scrapesmith/threads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Threads Scraper — Profiles, Posts & Engagement Data",
        "description": "Scrape every post from any Threads by Meta profile. Unlimited pagination, 57 fields per post including likes, replies, reposts, quotes, shares, media URLs, and full profile data. No browser, no proxy, no login.",
        "version": "0.0",
        "x-build-id": "cgSvfGcDkasIsh5UY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~threads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-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/scrapesmith~threads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-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/scrapesmith~threads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-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": {
                    "usernames": {
                        "title": "Usernames",
                        "type": "array",
                        "description": "List of Threads/Instagram usernames to scrape profiles and posts for.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "mode": {
                        "title": "Scraping mode",
                        "enum": [
                            "profile",
                            "posts",
                            "both"
                        ],
                        "type": "string",
                        "description": "What to scrape: 'profile' (profile info only), 'posts' (profile + recent posts), 'both' (default).",
                        "default": "both"
                    },
                    "maxPostsPerUser": {
                        "title": "Max posts per user",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of posts to scrape per user. Set high to get all posts.",
                        "default": 500
                    },
                    "maxResults": {
                        "title": "Max total results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum total result items across all users. Free plan is capped at 25.",
                        "default": 10000
                    },
                    "postUrls": {
                        "title": "Post URLs",
                        "type": "array",
                        "description": "Specific Threads post URLs to scrape. Format: https://www.threads.net/@username/post/SHORTCODE",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
