# Threads Scraper: All Posts, Views & Profiles (`s_actors/threads-scraper`) Actor

Scrape all posts of Threads profiles without login: text, likes, replies, reposts, quotes, exact views, media, links. Every post down to the first one, date range, latest replies and reposts, only new posts since the last run, and a profiles table with followers, bio links and contacts.

- **URL**: https://apify.com/s_actors/threads-scraper.md
- **Developed by:** [Superior Actors](https://apify.com/s_actors) (community)
- **Categories:** Social media, Marketing, AI
- **Stats:** 3 total users, 1 monthly users, 96.6% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 posts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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: All Posts, Views & Profiles

Scrape **all posts of Threads profiles** to CSV, Excel or JSON: text, **likes, replies, reposts, quotes, shares**, the **exact view count**, engagement rate, posting date, **images and videos**, links, mentions and topic tags. Every post down to the account's first one, not only the few that the profile page holds. Filter by **date range** and **minimum likes**, add the account's **latest replies and reposts**, get **only new posts** since the last run, and get a **profiles table**, one row per account, free: followers, bio, bio links, **contacts**, average and median views, engagement, posts per week, top post.

```json
{ "usernames": ["@zuck", "https://www.threads.com/@nasa"], "maxPostsPerProfile": 0 }
```

No Threads or Instagram login, no cookies, no browser extension. Use it as a **Threads profile API**: one call returns clean JSON. `0` = every post of the profile, newest first (all 226 posts of @zuck, back to July 2023, in about 20 seconds).

#### What you get

One row per post. Real example, October 2026 (the newest post of each profile):

| profile | mediaType | viewCount | likeCount | replyCount | repostCount | quoteCount | shareCount | engagementRate | createdAt |
|---|---|---|---|---|---|---|---|---|---|
| zuck | text | 401,057 | 2,651 | 2,483 | 163 | 153 | 175 | 1.36 | 2026-09-28 |
| nasa | video | 71,173 | 1,215 | 53 | 46 | 9 | 23 | 1.86 | 2026-10-01 |
| mosseri | text | 11,071 | 134 | 56 | 2 | 3 | 2 | 1.76 | 2026-10-02 |

| Field | Description |
|---|---|
| `postId`, `postCode`, `postUrl`, `text`, `createdAt` | Post ID, short code, link, full text and exact posting time (UTC) |
| `viewCount` | **Exact** views from the post page (Threads shows them rounded, like 401K) |
| `likeCount`, `replyCount`, `repostCount`, `quoteCount`, `shareCount` | Likes, replies, reposts, quotes and shares |
| `engagementRate` | (likes + replies + reposts + quotes) / views, in % |
| `mediaType`, `imageUrl`, `imageUrls`, `videoUrls`, `mediaCount` | `text`, `image`, `video` or `carousel`; every image (the cover for videos) and video file |
| `links`, `linkPreviewTitle`, `linkPreviewDomain` | Links in the text and the link card, as real addresses (not `l.threads.com` redirects) |
| `mentions`, `hashtags`, `topicTag` | Mentioned @usernames, #hashtags in the text, and the post's topic tag (`Space Threads`) |
| `threadId`, `positionInThread`, `isReply`, `replyToUsername` | Multi-part threads: every part of the author's own thread is a row; 1 = the first post |
| `isQuote`, `quotedPostUrl`, `quotedPostAuthor`, `quotedPostText` | The post this one quotes |
| `isPinned`, `isEdited`, `isPaidPartnership`, `countsHidden` | Pinned to the profile, edited, paid partnership label, likes and views hidden by the author |
| `authorUsername`, `authorFullName`, `authorId`, `authorIsVerified`, `authorProfilePicUrl`, `authorFollowerCount` | The author and the profile's followers |
| `postType` | `post`, `reply` (with **Latest replies**) or `repost` (with **Latest reposts**) |
| `replyToPostUrl`, `replyToText` | For replies: the post the account answered |
| `repostedBy`, `repostedAt` | For reposts: the account and when it reposted (the row is the original post with its author and stats) |
| `input`, `profile`, `positionInProfile`, `scrapedAt` | Which profile the row came from; 1 = its newest post |

**Profiles table** (run's **Output** tab → *Profiles (CSV)*, also as JSON: key-value store records `profiles.csv` and `PROFILES`), one row per account, free. Real example, October 2026, averages over the 20 latest posts:

| username | followerCount | website | topics | averageViews | medianViews | averageLikes | averageEngagementRate | postsPerWeek |
|---|---|---|---|---|---|---|---|---|
| nasa | 12,755,968 | | NASA, Space Threads, Science Threads | 106,973 | 54,084 | 2,170 | 3.19 | 4.13 |
| zuck | 5,746,813 | | AI Threads, UFC Threads, AI, MMA, memes | 178,310 | 85,578 | 1,423 | 1.59 | 4.96 |
| mosseri | 1,046,388 | mosseri.net | Arsenal Threads | 124,329 | 52,794 | 1,570 | 1.82 | 1.04 |

| Column | Description |
|---|---|
| `username`, `fullName`, `userId`, `isVerified`, `isPrivate`, `bio`, `topics`, `profilePicUrl`, `profileUrl` | The account, its topic tags and the full-size profile picture |
| `followerCount` | Exact followers from the profile page |
| `bioLinks`, `email`, `emails`, `emailSource`, `website`, `linkInBio`, `telegram`, `instagram`, `youtube`, `x`, `facebook`, `linkedin`, `whatsapp`, `twitch` | Contacts written in the profile: bio links, links in the bio, handles like `IG: @name`, emails in the bio |
| `postsScraped`, `repliesScraped`, `repostsScraped`, `newestPostAt`, `oldestPostAt`, `postsPerWeek`, `averageViews`, `medianViews`, `averageLikes`, `averageReplies`, `averageReposts`, `averageEngagementRate`, `topPostUrl`, `topPostViews`, `topPostLikes` | Over the account's own posts of the run (your limit and dates) |
| `error` | Why a profile failed (not found, private) |

#### How it works

1. Add **profiles**: `@user`, `user` or `threads.com/@user` (and/or **post links**)
2. Set **Max posts per profile** (`0` = all), optional dates and filters
3. Run, then download the dataset as CSV, Excel, JSON or HTML

| Input | What it does |
|---|---|
| **Threads profiles** | Any number of public profiles |
| **Max posts per profile** | Newest first (pinned posts first, as on the profile); default 100, `0` = all |
| **Post links** | Single posts by link, with views and all stats |
| **View counts** | On by default: exact views and engagement rate; off = faster runs |
| **Thread continuations** | On by default: every part of the author's multi-part threads; off = first posts only |
| **Latest replies / Latest reposts** | The replies the account wrote (with the post it answered) and the posts it reposted |
| **Posted after / Posted before** | A date (`2025-01-01`) or a period (`30 days`, `6 months`, `1 year`) |
| **Minimum likes** | Only posts with at least this many likes |
| **Only new posts since the previous run** | For schedules: only what each profile posted since the last check |

A private, deleted or misspelled profile is reported in the run status and the profiles table and is not charged. Posts left out by a filter are not charged.

#### Why this Actor

| | |
|---|---|
| 📜 **Every post, not just the latest few** | The profile page itself holds only 4 posts; this Actor pages through the whole profile, thousands of posts per run |
| 👁️ **Exact view counts** | Views from each post page, not rounded, with the engagement rate per post and per account |
| 🧵 **Whole threads** | Multi-part threads come as separate rows with their thread ID and part number |
| 🔔 **New-post alerts** | Schedule it hourly or daily: each run returns only new posts of every profile, a run with nothing new costs only the start |
| 📊 **Profiles table, free** | Followers, average and median views, engagement, posts per week, top post: ready for influencer vetting and competitor benchmarks |
| 📇 **Contacts** | Website, Instagram, YouTube, X, Telegram and email from the bio and bio links, once per account |
| 💰 **$2.49 per 1,000 posts** | Views, filters, replies, reposts and the profiles table included, no add-on fees |

#### Monitor accounts: only new posts

1. Add the profiles you follow (competitors, creators of a campaign, your own)
2. Turn on **Only new posts since the previous run**, save as a task and add a schedule, e.g. every hour
3. **First run** returns the latest posts and remembers the newest one per profile. **Every later run** returns only posts published since then (and replies or reposts not seen before)

The newest post seen is kept in your account (key-value store `threads-profile-state`) and is shared by all your runs and tasks. Connect [Google Sheets](https://apify.com/s_actors/google-sheets-import-export), Slack or email with an integration to be notified.

#### Pricing

Pay per result, no subscription needed. Apify Scale and Business plans pay less:

| Event | Free and Starter plans | Scale plan | Business plan |
|---|---|---|---|
| Run start | $0.001 | $0.001 | $0.001 |
| Post in the results (post, reply or repost) | $0.00249 | $0.002241 | $0.001992 |

| Task | Cost |
|---|---|
| All 226 posts of @zuck | ~$0.56 |
| Latest 20 posts of 100 accounts (2,000 posts) | ~$4.98 |
| Profiles table of 1,000 accounts (1 post each) | ~$2.49 |
| Hourly new-post alert for 10 accounts for a month | ~$0.72 + $0.00249 per new post |

Profiles that are not found or private and posts left out by filters are not charged.

#### Ready-made tasks

Open it, change the profiles, and run:

| Task | What you get |
|---|---|
| [Export All Threads Posts by Username](https://apify.com/s_actors/threads-scraper/examples/export-all-threads-posts-by-username) | Every post of a profile with views, likes and replies |

#### FAQ

**Does it get all posts of a profile?** Yes, every post Threads lists on the profile, newest first, down to the account's first post. The profile page itself holds only 4; the Actor loads the rest the way the website does when you scroll.

**Does it get all replies of an account?** Threads shows only the latest 15 replies and 25 reposts of an account without login, so **Latest replies** and **Latest reposts** return those. The replies other people wrote under a post are a separate tool.

**Are the view counts exact?** Yes, they are the numbers Threads stores for the post (the website rounds them: 401K). Accounts can hide likes and views: then `countsHidden` is true and the counts are empty.

**Can it scrape private accounts?** No. Threads shows a private account's posts only to approved followers. The profiles table still says the account is private.

**Do I need a Threads or Instagram account or cookies?** No. The Actor reads public profiles the way the Threads website does for a visitor.

**How long do the image and video links work?** `imageUrls` and `videoUrls` are Threads' own CDN links and expire after a few days: download the files you need soon after the run.

**Where do the emails come from?** From what the account wrote in the profile: the bio and the bio links. The Actor does not guess emails.

#### Use with the API and AI agents

Run it via the [Apify API](https://docs.apify.com/api/v2) from Python, Node.js or any HTTP client, or connect it to Claude, ChatGPT and other AI agents through the [Apify MCP server](https://mcp.apify.com): "Which of these 20 accounts gets the most views per post, and what did they post about this week?"

#### Other Threads tools

| Tool | What it does |
|---|---|
| [Threads Search Scraper](https://apify.com/s_actors/threads-search-scraper) | Posts by keyword or hashtag |
| [Threads Replies Scraper](https://apify.com/s_actors/threads-replies-scraper) | All replies under Threads posts |
| [TikTok Profile Scraper](https://apify.com/s_actors/tiktok-profile-scraper) | All videos and stats of TikTok profiles |
| [YouTube Channel Scraper](https://apify.com/s_actors/youtube-channel-scraper) | Exact views, subscribers and all videos of YouTube channels |
| [Telegram Channel Analytics](https://apify.com/s_actors/telegram-channel-analytics) | Subscribers, reach and ads of Telegram channels |
| [Google Sheets Import & Export](https://apify.com/s_actors/google-sheets-import-export) | Send the posts to a Google Sheet |

#### Is it legal?

The Actor collects only public profiles, posts and stats that Threads shows to any visitor, without logging in. Posts are their authors' content: respect copyright when you reuse texts and images, and use personal data such as usernames and emails in line with GDPR and other privacy laws.

# Actor input Schema

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

One per line: @username, a username, or a profile link (threads.com/@user). Public profiles only: private and missing accounts are reported in the run status and are free. Each account's followers, bio, bio links and contacts go to the profiles table once, free.

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

How many posts to scrape from each profile, newest first (pinned posts come first, as on the profile). 0 = every post down to the account's first one (about 15 threads a second).

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

Optional: single posts by link (threads.com/@user/post/CODE), with views and all stats. Can be used alone or together with profiles.

## `includeViews` (type: `boolean`):

Exact view count of each post (and the engagement rate from it). Threads shows views only on the post page, so the Actor reads the start of each page: about 0.2 seconds per post. Turn off for the fastest runs.

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

Also output the author's follow-up posts in their own threads (multi-part posts), each as a row with threadId and positionInThread. Off = only the first post of every thread.

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

Also output the replies the account wrote under other people's posts, with the post it answered (replyToPostUrl, replyToText). Threads shows only the latest 15 replies without login.

## `includeReposts` (type: `boolean`):

Also output the posts the account reposted (the original post with its author and stats, plus repostedAt). Threads shows only the latest 25 reposts without login.

## `postedAfter` (type: `string`):

Only posts published after this: a date like 2025-01-01 or a period like 7 days, 2 weeks, 6 months, 1 year (ago). Reading stops at the first older post.

## `postedBefore` (type: `string`):

Only posts published before this: a date like 2025-03-01 or a period like 30 days (ago).

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

Only posts with at least this many likes. Leave empty for all.

## `onlyNewPosts` (type: `boolean`):

Output only posts newer than the newest one any earlier run in your account saw for this profile (key-value store threads-profile-state); replies and reposts already seen are skipped too. The first run outputs posts as usual (within Max posts per profile) and remembers the newest. A run with no new posts costs only the start.

## `maxConcurrency` (type: `integer`):

How many profiles (and post links) are scraped in parallel. Each profile's posts are read page by page (15 threads a page).

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

Requests go direct first and switch to Apify datacenter proxies (then residential) when Threads refuses them. The default works for most runs.

## `debugLog` (type: `boolean`):

Log every retried request (for troubleshooting).

## Actor input object example

```json
{
  "usernames": [
    "@nasa",
    "@mosseri"
  ],
  "maxPostsPerProfile": 20,
  "includeViews": true,
  "includeThreadContinuations": true,
  "includeReplies": false,
  "includeReposts": false,
  "onlyNewPosts": false,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "debugLog": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Every post of the profiles: text, views, likes, replies, reposts, quotes, shares, engagement, date, media.

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

One row per account: followers, bio, bio links, contacts (email, website, Instagram, YouTube, X, Telegram), average and median views, likes, engagement, posts per week, top post.

## `summary` (type: `string`):

The same profiles table as JSON.

## `all` (type: `string`):

Every field of every row.

# 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": [
        "@nasa",
        "@mosseri"
    ],
    "maxPostsPerProfile": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("s_actors/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": [
        "@nasa",
        "@mosseri",
    ],
    "maxPostsPerProfile": 20,
}

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

```

## MCP server setup

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