# Threads Scraper: Public Posts from Profiles and Post URLs (`redfoxscout/threads-scraper`) Actor

Scrape public Threads posts from profiles and single post URLs: text, date, likes, replies, reposts, quotes, media and author. No login. $2.00 per 1,000 posts, pay per event.

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

## Pricing

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

Scrape **public Threads posts** from **profiles, post URLs and keyword searches**: **text, date, likes, replies, reposts, quotes, media, mentions, hashtags and links** for each post. The main feature is the **profile watch**: schedule a run with a monitor name and it returns only the posts a profile published since the last run, with their engagement counts. **No login is needed.** Optional **session cookies** from your own Threads account add logged-in keyword search (**Top or Recent**, more pages) and view counts.

**Price: $2.00 per 1,000 posts.** Duplicates and failed targets are free. Apify's free plan ($5 monthly credit) covers about 2,500 posts a month.

![Track new Threads posts from competitors (only new posts): real output preview (Profile watch: only posts that are new since the last run)](https://raw.githubusercontent.com/TikTop-Data/apify-store-assets/main/images/threads-scraper-output.png)

### Questions it answers

- Which posts did a competitor publish since my last check?
- What did a brand or public figure post on Threads, and how many likes, replies and reposts did each post get?
- Whom does a brand quote, mention or link to on Threads?
- What are the replies under a post, and what are an account's follower count and bio?
- What are public Threads posts saying about a product, a hashtag or a place?

### Who uses this

- 📣 **Brand and social teams:** track competitor and partner accounts and see how each post performs.
- 📊 **Marketers and analysts:** build a dataset of posts, replies and engagement counts per account or keyword.
- 🔎 **Researchers:** collect public posts and replies for analysis.
- 📰 **Media monitors:** follow the public announcements of companies and public figures.

### Why this Threads Scraper

- 🔔 **Profile watch:** each run returns only new posts, and scheduled runs give a feed of them.
- 🔒 **No login needed:** public posts, replies and profiles need no Threads account, cookie or API key.
- 🔑 **Logged-in mode (optional):** your own session cookies add recent-sorted search, more search pages and view counts.
- 📇 **Bio contacts as shown:** the bio is returned as the profile shows it, with its email addresses and phone numbers listed on their own.
- 🧩 **One input for everything:** mix usernames, post links and search keywords in the same run.
- 📋 **Same keys on every row:** camelCase fields, ready for a spreadsheet or database.
- 💰 **$2.00 per 1,000 posts,** with duplicates and error rows free.

### How to use the Threads Scraper

1. Click **Try for free** (a free Apify account is enough).
2. Enter what to read, one per line: Threads usernames (`zuck`), profile or post links (`https://www.threads.com/@zuck/post/Dd1MqfcG0aH`), or search words in **Keywords or hashtags to search** (`coffee`, `#espresso`).
3. Optional: turn on profile details, replies, the profile watch, or paste your session cookies for logged-in search.
4. Click **Start**, then download as JSON, CSV or Excel, or schedule it for a regular feed.

### Input

| Field | Default | What it does |
|---|---|---|
| `targets` | – | Threads usernames, profile URLs or post URLs, one per line. |
| `searchQueries` | – | Words or hashtags to search, one per line. Logged out, Threads returns one page of top posts per search; with session cookies, more pages. |
| `includeProfile` | `false` | Profile targets: also output one profile row per username (details below). |
| `includeReplies` | `false` | Post URLs: also output the replies Threads shows under the post. |
| `maxReplies` | `20` | Replies read per post URL when replies are on (1 to 500). |
| `includeSelfReplies` | `false` | Also keep the author's follow-up replies to their own posts (profiles only). |
| `postedAfter` | – | Profiles only: skip posts older than this date (`YYYY-MM-DD`). |
| `monitorName` | – | Profile watch: a name for the watch, e.g. `competitors-weekly`. |
| `onlyNewPosts` | `false` | Profiles only: return only posts that earlier runs with this monitor name did not return. Needs a monitor name. |
| `maxItems` | `50` | Rows per search, counting posts, replies and profile rows (max 2,000). |
| `sessionCookies` | – | Optional: your own logged-in Threads cookies, as a Cookie header or a JSON array from a cookie-editor extension. Stored encrypted. See Logged-in mode. |
| `searchSort` | `top` | With session cookies: `top` (Threads' ranking) or `recent` (newest first) for keyword searches. |
| `maxConcurrency` | `3` | How many searches run at once. |

Profile details (`includeProfile`) add one row per profile: full name, verified badge, follower count, bio as shown, bio emails and phone numbers, bio links, profile picture URL and the private flag.

Example (the input behind the output below):

```json
{ "targets": ["zuck"], "maxItems": 12 }
```

### Output

One row per post, reply or profile. `recordType` is `post` or `profile`, and `source` says where a post came from: `profile`, `post`, `reply` or `search`. Replies carry `parentPostUrl`. Quote posts have `isQuote: true` and `quotedPostUrl`. `hashtags`, `mentions` and `links` list what the text contains. Media links are in `images` and `videos`; `mediaType` is `text`, `photo`, `video` or `carousel`. `viewCount` is filled only when Threads returns a view count; the logged-out rows we checked had none (null).

A real row from that run (text shortened):

```json
{
  "recordType": "post",
  "postId": "3996155940894885511",
  "code": "Dd1MqfcG0aH",
  "url": "https://www.threads.com/@zuck/post/Dd1MqfcG0aH",
  "text": "We believe superintelligence will create significant new opportunities for all people and businesses. Meta already serves billions of people at scale and helps hundreds of millions of businesses reach customers. ...",
  "createdAt": "2026-09-28T12:35:32.000Z",
  "likeCount": 2684,
  "replyCount": 2601,
  "repostCount": 168,
  "quoteCount": 156,
  "shareCount": 179,
  "viewCount": null,
  "isReply": false,
  "mediaType": "text",
  "images": [],
  "videos": [],
  "authorUsername": "zuck",
  "authorFullName": "Mark Zuckerberg",
  "authorVerified": true,
  "authorId": "63055343223",
  "authorFollowers": 5745866,
  "source": "profile",
  "parentPostUrl": null,
  "isQuote": false,
  "quotedPostUrl": null,
  "hashtags": [],
  "mentions": [],
  "links": [],
  "isNewPost": null,
  "biography": null,
  "bioLinks": [],
  "bioEmails": [],
  "bioPhones": [],
  "profilePicUrl": null,
  "isPrivate": null,
  "searchQuery": "@zuck"
}
```

### Example tasks

Ready-made inputs you can open, change and run:

- [Track new Threads posts from competitors (only new posts)](https://apify.com/redfoxscout/threads-scraper/examples/track-new-threads-posts-competitors)
- [Get the latest 30 posts from Mark Zuckerberg on Threads](https://apify.com/redfoxscout/threads-scraper/examples/threads-zuck-latest-posts)
- [List NASA's Threads posts since 1 September 2026](https://apify.com/redfoxscout/threads-scraper/examples/threads-nasa-posts-since-date)
- [Compare recent posts from Nike, National Geographic and Meta](https://apify.com/redfoxscout/threads-scraper/examples/threads-brand-accounts-compare)
- [Pull recent posts from a profile by pasting its Threads link](https://apify.com/redfoxscout/threads-scraper/examples/threads-profile-url-latest)

### Profile watch: only new posts

Set a **monitor name** (for example `competitors-weekly`) and turn on **Only new posts since the last run**. Each run:

- returns the posts of each profile that earlier runs with the same monitor name did not return, newest first;
- stops at the first post an earlier run returned, so older posts never come back as new;
- skips a pinned post that sits above the new posts;
- sets `isNewPost` to `true` on every row it returns.

The first run returns the newest posts up to the limit. The posts each profile has already returned are kept in a key-value store called `threads-scraper-monitor` in your Apify account, one record per profile and monitor name. Schedule the run (daily, for example) to keep a feed of new posts. If a profile publishes more posts between two runs than **Max results per search**, the oldest extra posts are not returned later, so raise the limit or run more often.

Without **Only new posts**, a monitor name only adds `isNewPost` to each row and every post is returned. The watch works on profile targets only.

### Profile bios: contacts as shown

With **Include profile details**, each profile row keeps the bio exactly as the profile shows it, line breaks included, in `biography`. The contacts written in that bio are listed next to it, so you do not have to parse the text:

- `bioEmails`: the email addresses in the bio, as written, without duplicates.
- `bioPhones`: the phone numbers in the bio, as written, trimmed, without duplicates.
- `bioLinks`: the web links in the bio.

`bioEmails` and `bioPhones` combine what the bio text shows with the profile's mailto: and tel: contact links. Post text is returned exactly as posted.

### Logged-in mode: session cookies (optional)

Add your own Threads session cookies in **Session cookies** and keyword searches can read what a logged-in viewer sees:

- **Recent first:** set **Search sort** to `recent` for the newest matching posts.
- **More pages:** a search keeps reading pages past the first, up to 20 pages and your **Max results per search**.
- **View counts:** `viewCount` is filled when the logged-in response includes a count; otherwise it stays null.

Get the cookies from your own browser after you log in to Threads: either export them as JSON with a cookie-editor extension, or copy the `Cookie` header from the browser's developer tools. Paste either form. The Actor only reads the cookies you paste. It never asks for your password, never creates an account, and never posts, follows or sends messages.

If Threads does not accept the cookies, the run logs one warning and continues logged out, so the rows are the same as without cookies.

**Risks:** this mode uses your own account. Threads may restrict or log out accounts that automate their use, and that can affect your account, so use it only with an account you can afford to lose access to. The cookies are stored encrypted by Apify as a secret input, and the Actor never writes them to the dataset or the log. Anyone who has the cookies can use your account, so treat them like a password. We have not yet run this mode from a logged-in account, so check the first run's rows and log.

### What it covers

- **Profiles:** posts from the account's public Threads tab, newest first. Self-replies are added only when you turn them on.
- **Post URLs:** threads.com and threads.net links to one post, with its replies when you turn them on.
- **Keyword and hashtag search:** the top posts Threads shows logged out, one page per search (13 to 25 posts in our test runs). With session cookies: Top or Recent, and more pages.
- **Profile details:** name, verified badge, follower count, bio as shown with its emails and phone numbers, bio links and picture URL, for profile targets.

### What this Actor does not do

- **No login without your cookies.** The Actor never logs in with a password and never creates accounts. It uses the session cookies only if you paste them.
- **No account actions.** No posting, replies, follows, likes, direct messages or fake engagement.
- **No view counts when logged out.** The logged-out rows we checked had `viewCount` empty.
- **No private accounts.** Their posts are not public, so they are not read.
- **No Replies tab of a profile, no follower lists and no direct messages.**
- **No watch for keywords or post URLs.** The profile watch works on profiles only.

### How much does it cost?

$2.00 per 1,000 rows. Profile rows and replies are charged the same way as posts.

- 100 rows: about $0.20
- 10,000 rows: about $20
- Duplicates, failed targets and error rows: free

Apify's free plan gives $5 of credit every month, enough for about 2,500 rows.

### FAQ

**Is this legal?** It reads posts, replies, profile details and bio contacts that Threads shows to anyone who opens a public profile, post or search link without signing in, and returns them as shown. Post text has email addresses and phone numbers masked. With your own session cookies (optional), it reads what your logged-in account can see; that use is under your own account and Threads' terms. The Actor does not solve CAPTCHAs, log in with a password or take any action on Threads. How you use the data is your responsibility, including the data protection rules where you live.

**Can I search Threads by keyword?** Yes, with **Keywords or hashtags to search**. Logged out, Threads shows one page of top posts per search, so each search returns about 13 to 25 posts. With session cookies, a search can sort by **Recent** and read more pages.

**Are my cookies safe?** They are stored encrypted by Apify as a secret input, and the Actor never writes them to the dataset or the log. Anyone who has them can use your account, so only paste them into this Actor.

**How do I get only new posts every day?** Set a monitor name, turn on **Only new posts since the last run** and schedule the run. See Profile watch above.

**Why are image links expiring?** Images and videos are served from Meta's media servers through links with a built-in expiry time, and the links stop working after a few days. Download the files soon after the run if you need them.

**Why does a target return an error row?** The username or post does not exist, or the profile is not public. Error rows are free and show the reason, so you can fix the input and run again.

### Related Actors

- [Company Social Links Finder](https://apify.com/redfoxscout/company-social-links): a company's Threads and other social profiles from its website, ready to paste into this Actor.
- [RSS Feed Finder](https://apify.com/redfoxscout/rss-feed-finder): the RSS feed of any list of websites, to follow a brand's blog next to its Threads posts.

# Actor input Schema

## `targets` (type: `array`):

Threads usernames, profile URLs or post URLs, one per line, e.g. zuck, https://www.threads.com/@nasa or https://www.threads.com/@zuck/post/Dd1MqfcG0aH.

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

Threads searches, one per line: a word or a hashtag, e.g. coffee or #espresso. Logged out, Threads shows about 13 to 25 top posts per search; with session cookies, more pages.

## `includeProfile` (type: `boolean`):

Also output one profile row per profile username: full name, verified badge, follower count, bio as shown, bio emails and phone numbers, bio links, profile picture URL and private flag. Each profile row is charged like one post.

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

For post URLs, also output the replies Threads shows under the post, with the post's URL in parentPostUrl. Each reply is charged like one post.

## `maxReplies` (type: `integer`):

Replies read for each post URL when replies are included. Threads shows 10 replies at a time, so more pages are read as needed.

## `includeSelfReplies` (type: `boolean`):

Also keep the author's follow-up replies in their own threads, e.g. a multi-part post; profiles only.

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

Profiles only: skip posts older than this date, e.g. 2026-09-01.

## `monitorName` (type: `string`):

A name for this watch, e.g. competitors-weekly. Runs with the same name remember which posts they returned for each profile, in a key-value store in your account.

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

Profiles only. Return just the posts that earlier runs with the same monitor name did not return. Needs a monitor name. Schedule the run to keep a feed of new posts.

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

Stop each search after this many rows (posts, replies and profile rows).

## `sessionCookies` (type: `string`):

Cookies from your own logged-in Threads browser session: a Cookie header (name=value; name2=value2) or a JSON array exported by a cookie-editor extension. Used for keyword searches (Top or Recent, more pages) and view counts; if Threads refuses them, the run continues logged out. Stored encrypted by Apify.

## `searchSort` (type: `string`):

Keyword searches with session cookies: Top, or Recent (newest first). Without cookies, searches return the logged-out top posts.

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

How many searches run at once.

## Actor input object example

```json
{
  "targets": [
    "zuck"
  ],
  "includeProfile": false,
  "includeReplies": false,
  "maxReplies": 20,
  "includeSelfReplies": false,
  "onlyNewPosts": false,
  "maxItems": 12,
  "searchSort": "top",
  "maxConcurrency": 3
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "targets": [
        "zuck"
    ],
    "maxItems": 12
};

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

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

```

## MCP server setup

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