# Threads Scraper & Monitor: Profiles, Posts, Search, No Login (`panix/threads-scraper`) Actor

Scrape Meta Threads without login: profiles with followers and engagement, full post histories, keyword and hashtag search, single posts. Likes, replies, reposts, media, links, hashtags. Only new posts mode for scheduled monitoring, brand tracking, social listening and AI agents.

- **URL**: https://apify.com/panix/threads-scraper.md
- **Developed by:** [PANIX AI LAB](https://apify.com/panix) (community)
- **Categories:** Social media, For creators, Marketing
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.30 / 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 & Monitor: Profiles, Posts, Search, No Login

Get public posts and profiles from Meta's Threads as clean data: an account's full post history, keyword and #hashtag search results, or single posts by link, with likes, replies, reposts, quotes, media and links. Turn on **Only new posts** and a scheduled run returns just what was posted since the last run, which suits brand alerts, social listening, n8n or Make workflows and AI agents.

- **Whole account histories:** go back as far as the account goes (our test reached the first posts from July 2023), newest first, with a date filter that stops paging once it reaches older posts, so you pay only for the period you want.
- **Profiles with engagement:** followers, bio, links, topics, verified badge, and average likes, replies, reposts, engagement rate and posts per week of the newest posts.
- **No account, cookies or API key.** Threads' public pages only. The default Apify proxy is enough; no residential proxy needed.

**Try it now:** the input is already filled in (10 posts and the profile of @zuck, plus 10 posts about artificial intelligence). Click **Start** and the rows appear in a table you can export to Excel, CSV or JSON. The example takes about 10 seconds and costs a few cents, which the $5 of free monthly credit on Apify's free plan covers.

**Price:** from **$1.30 per 1,000 posts**, and you pay only for results you get. The full price table is in the Pricing section below.

### Example result

One post, a real row from a run on 2026-11-17 (profile `mosseri`, image shortened):

```json
{
  "type": "post",
  "id": "3962887631160101435",
  "code": "Db_AU3kFko7",
  "url": "https://www.threads.com/@mosseri/post/Db_AU3kFko7",
  "text": "Thought I’d share this on Threads to and see what the hot takes might be. We updated the Instagram wordmark today, which is more than a decade old and felt dated. ...",
  "createdAt": "2026-08-13T14:57:20Z",
  "username": "mosseri",
  "authorName": "Adam Mosseri",
  "authorVerified": true,
  "authorFollowers": 1060370,
  "likes": 5409,
  "replies": 3610,
  "reposts": 274,
  "quotes": 274,
  "shares": 564,
  "engagement": 9567,
  "engagementRate": 0.9022,
  "mediaType": "image",
  "images": ["https://scontent-xxc1-1.cdninstagram.com/v/t51.82787-15/7703..."],
  "hashtags": [],
  "mentions": [],
  "links": [],
  "quotedPost": null,
  "isReply": false,
  "isPinned": false,
  "language": "en",
  "source": "profile",
  "sourceInput": "mosseri",
  "scrapedAt": "2026-11-17T08:17:24Z"
}
```

And a profile row (same account, run of 2026-11-17 with 50 posts per profile):

```json
{
  "type": "profile",
  "username": "mosseri",
  "fullName": "Adam Mosseri",
  "bio": "Father of three boys, married to an amazing woman, head of Instagram and supporter of Threads.",
  "bioLinks": ["http://mosseri.net/"],
  "followers": 1060381,
  "isVerified": true,
  "topics": ["Arsenal Threads"],
  "recentPostsAnalyzed": 25,
  "recentAvgLikes": 962,
  "recentMedianLikes": 629,
  "recentAvgReplies": 641,
  "recentAvgReposts": 59,
  "recentEngagementRate": 0.1594,
  "postsPerWeek": 1.11,
  "lastPostAt": "2026-11-16T22:39:07Z",
  "url": "https://www.threads.com/@mosseri"
}
```

### What you get

Profiles, posts and searches from Threads (threads.com and threads.net links both work):

- **Profiles:** give usernames, @handles or profile links. You get a profile row and the account's posts, newest first, up to 10,000 per profile.
- **Search:** keywords, phrases or #hashtags/topics. Choose Threads' **Top** results, the **Recent** ones, or **Both** merged without duplicates (the default, for the most posts per keyword).
- **Single posts:** paste post links (threads.com/@user/post/... or threads.net/t/...).
- **Every post row has:** text (with the author's own follow-up posts in the same thread in `threadContinuation`), date, likes, replies, reposts, quotes, shares, total engagement and engagement rate (when the author's follower count is known), images and videos, outbound links (Threads' redirect removed), link preview title, hashtags, mentions, topic tag, the quoted or reposted post, reply and pinned flags, language and paid-partnership flag.
- **Free filters:** posted after or before a date (or "7 days"), minimum likes, skip pinned posts, skip replies. Posts left out by a filter are not charged.

### Who uses it

- **Brand and social listening:** track what people post about a brand, product or competitor, with a schedule and **Only new posts**.
- **Influencer and creator research:** compare accounts by followers, engagement rate and posting frequency, and read their full history.
- **Marketing and content teams:** see which posts of an account or a topic get the most replies and reposts.
- **AI agents, RAG and n8n/Make workflows:** a fresh Threads feed for an LLM or an automation, through the Apify API or the Apify MCP server.
- **Researchers and journalists:** collect an account's posts over months or years into one table, with exact UTC dates.

### Why this scraper

- **Full history, not just the latest page:** the Actor pages through a profile until your limit, your date or the account's first post.
- **"Only new posts" that really remembers:** each profile and each search keeps its own memory in your account. Scheduled runs deliver and charge only what was not delivered before, and paging stops as soon as it reaches known posts.
- **Follower tracking:** in monitoring mode each profile row also shows `followersChange` and `followersBefore` since the previous run, so a daily schedule doubles as a follower-growth tracker.
- **Profile analytics included:** engagement rate and posts per week come with the profile row, computed from the newest 25 posts.
- **Clean links:** outbound links come without Threads' redirect wrapper.
- **One post, one charge:** a post found by a profile and by a search in the same run is delivered once.
- **Free rows for problems:** a missing profile or a broken link gets one free `error` row that says why, and the other inputs carry on.
- **Built to keep running:** when Threads asks a visitor to wait, the request moves to another IP by itself.

#### Coming from another Threads scraper?

| Common problem | How this Actor handles it |
| --- | --- |
| Only the newest dozen posts of a profile | Pages through the whole account, up to 10,000 posts per profile. |
| Scheduled runs return the same posts again | **Only new posts** delivers and charges only new ones, per profile and per search. |
| Paying for old posts you then filter out | The date filter stops paging at the first older post; filtered posts are free. |
| Separate tools for profiles, search and post links | One Actor takes all three in the same run. |
| Engagement rate must be calculated by hand | `engagementRate` on each post and recent averages on the profile row. |
| No way to see follower growth between runs | Monitoring mode adds `followersChange` since the last run. |
| Links point to Threads' redirect | `links` holds the real target addresses. |
| A high start fee makes small runs expensive | The start fee is $0.001 per run. |

### How to use

1. Click **Try for free** (or **Start**) on this page.
2. Add **Profiles**, **Search keywords or #hashtags**, and/or **Post links**.
3. Set **Posts per profile** and **Posts per search**. Add filters if you like.
4. Click **Start**. Rows appear in the **Output** tab while the run works. Download them as Excel, CSV, JSON or HTML, or use the API.

To monitor, tick **Only new posts since the last run**, give it a **Memory name**, and use Apify's **Schedules** to run it every hour or day.

#### Input examples

The last 30 days of two accounts, without replies:

```json
{"profiles": ["mosseri", "nasa"], "maxPostsPerProfile": 1000, "postedAfter": "30 days", "skipReplies": true}
```

A brand alert: new posts mentioning your brand since the last run:

```json
{"searchQueries": ["notion app", "#notion"], "onlyNewPosts": true, "monitorName": "notion-alert"}
```

A competitor's whole history (profile row plus every post):

```json
{"profiles": ["https://www.threads.com/@netflix"], "maxPostsPerProfile": 10000}
```

Profiles only (followers, bio, engagement), no posts:

```json
{"profiles": ["zuck", "mosseri", "instagram"], "maxPostsPerProfile": 0}
```

Single posts by link:

```json
{"postUrls": ["https://www.threads.com/@mosseri/post/Df0csMJDN7W", "https://www.threads.net/t/DfihFPxkaZ1"]}
```

Field names from other Threads Actors also work (`usernames`, `keywords`, `post_links`, `max_posts`, `search_filter`, `start_date`, `end_date`, `startUrls`).

#### Input fields

| Field | What it does |
| --- | --- |
| Profiles (`profiles`) | Usernames, @handles or profile links. |
| Search keywords or #hashtags (`searchQueries`) | Words, phrases or #topics. |
| Post links (`postUrls`) | Links to single posts. |
| Posts per profile (`maxPostsPerProfile`) | Default 20, up to 10,000. `0` = profile row only. |
| Posts per search (`maxPostsPerSearch`) | Default 50. |
| Search results (`searchMode`) | `both` (default), `top` or `recent`. |
| Maximum posts in total (`maxResults`) | Stops the whole run after this many posts. |
| Include profile rows (`includeProfiles`) | On by default. |
| Posted after / before (`postedAfter`, `postedBefore`) | A date (`2026-01-31`) or a relative time (`7 days`, `24 hours`). |
| Minimum likes (`minLikes`), Skip pinned posts, Skip replies | Free filters. |
| Only new posts (`onlyNewPosts`), Memory name (`monitorName`) | Monitoring mode. |
| Inputs in parallel (`maxConcurrency`) | Default 4. |
| Proxy (`proxyConfiguration`) | The default Apify proxy works. |

### Output

Each profile and post is one row in the dataset; the **Posts** and **Profiles** views show the main columns, and **Not available** lists free error rows. Two more records are saved in the key-value store: `INPUTS` (one line per input: pages read, posts seen and delivered, why it stopped) and `SUMMARY` (totals, charged events, posts left out per reason, request statistics, warnings).

#### Main post fields

| Field | Meaning |
| --- | --- |
| `id`, `code`, `url` | Post ID, short code and link |
| `text`, `threadContinuation` | Post text, and the author's own follow-up posts in the same thread |
| `createdAt`, `timestamp` | Post time in UTC (ISO and Unix seconds) |
| `username`, `authorName`, `authorVerified`, `authorFollowers` | The author (followers only for profile inputs) |
| `likes`, `replies`, `reposts`, `quotes`, `shares`, `engagement`, `engagementRate` | Counts, their sum (likes + replies + reposts + quotes) and that sum as a % of followers |
| `mediaType`, `images`, `videos` | `text`, `image`, `video` or `carousel`, with media links |
| `links`, `linkPreviewTitle`, `hashtags`, `mentions`, `topic` | Outbound links, preview title, #tags, @mentions and the Threads topic tag |
| `quotedPost`, `repostedPost` | The quoted or reposted post (link, author, text, date, likes) |
| `isReply`, `replyToUsername`, `isPinned`, `isPaidPartnership`, `language` | Flags and detected language |
| `source`, `sourceInput`, `searchQuery`, `searchMode` | Which input found the post |

### Pricing

Pay per event: you pay for results, not for the Apify platform usage.
| Event | Free plan | Bronze | Silver | Gold and up |
| --- | --- | --- | --- | --- |
| Post (each post row) | $2.00 / 1,000 | $1.70 / 1,000 | $1.50 / 1,000 | $1.30 / 1,000 |
| Profile (each profile row with engagement averages) | $3.00 / 1,000 | $2.50 / 1,000 | $2.20 / 1,000 | $2.00 / 1,000 |
| Actor start (once per run, per GB of memory; the default 512 MB counts as one) | $0.001 | $0.001 | $0.001 | $0.001 |

**Free:** error rows (missing profiles, broken links), posts left out by filters, duplicates, and posts left out by "Only new posts".

Examples at the Bronze price:

- 1,000 posts from 10 accounts with their profiles: about **$1.73**.
- An account's full history of 500 posts: about **$0.85**.
- A daily brand alert on 3 keywords that finds 20 new posts: about **$0.035 per run**, and only the $0.001 start fee on days with nothing new.

Set a spending limit when you start the run (or in the API with `maxTotalChargeUsd`). The run stops cleanly at the limit and keeps everything collected.

### Good to know

- **Search depth:** Threads shows logged-out visitors about 15 to 40 posts per keyword (Top and Recent together). For wider coverage, add several related keywords and #hashtags, or schedule the search with **Only new posts** so results build up over time. Profiles have no such limit.
- **Replies under a post:** Threads hides the reply list from logged-out visitors, so the Actor returns reply counts but not the reply texts. It never logs in.
- **Speed:** about 25 posts per page; a profile's history loads at roughly 100 to 200 posts per minute, several profiles in parallel. In our tests, 500 posts of one account took under 2 minutes, and about 270 posts from 4 profiles and 3 searches took about a minute.
- **Followers on search rows:** search results don't include the author's follower count, so `authorFollowers` and `engagementRate` are filled only for posts from profile inputs.
- **Private, missing or renamed accounts** return a free `error` row.
- **Monitoring:** the first run with **Only new posts** delivers up to your limits and remembers them. Later runs deliver only posts published after that. Use a different **Memory name** per schedule. Profile rows are delivered (and charged) on every run, with the follower change; switch off **Include profile rows** for the cheapest alerts.
- **Public data:** the Actor reads only what Threads shows to anyone without an account. Posts contain public personal data such as names and usernames; use the data in line with privacy laws such as the GDPR and with Threads' terms.

### FAQ

**Do I need a Threads or Instagram account?** No. Nothing is logged in and no cookies are needed.
**Do I need a residential proxy?** No. The default Apify proxy works.
**How far back can I go?** As far as the account goes. Set **Posts per profile** high and, if you want a period, **Posted after**.
**Why did a search return fewer posts than my limit?** Threads shows a limited number of posts per keyword to logged-out visitors (see Good to know). Add more keywords.
**What happens when I hit my spending limit?** The run stops, keeps what it delivered and says "Stopped at your spending limit" in its status.
**Can I use it in an AI agent?** Yes, through the Apify MCP server, or in n8n, Make and Zapier (below).

### Use it from code, n8n, Make or Zapier

Python (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("panix/threads-scraper").call(run_input={
    "profiles": ["mosseri"],
    "searchQueries": ["threads app"],
    "maxPostsPerProfile": 100,
    "onlyNewPosts": True,
    "monitorName": "daily-check",
})
for row in client.dataset(run.default_dataset_id).iterate_items():
    if row["type"] == "post":
        print(row["createdAt"], row["username"], row["likes"], row["text"][:80])
```

JavaScript (`npm install apify-client`):

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('panix/threads-scraper').call({
    searchQueries: ['#ai', 'web scraping'],
    maxPostsPerSearch: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0]);
```

**n8n:** add the **Apify** node, choose **Run an Actor and get dataset**, pick `panix/threads-scraper` and paste one of the input examples above. Put a **Schedule Trigger** in front and set `onlyNewPosts` to `true` for alerts.
**Make and Zapier:** use the Apify app's **Run an Actor** action with the same input, then read the dataset items.

### Feedback

We're a small team and your feedback is how this Actor gets better. If something is missing or broken, please open an issue on the **Issues** tab and we'll answer quickly. If it saved you time, a short review helps other people find it.

# Actor input Schema

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

Threads usernames or profile links, for example zuck, @mosseri or https://www.threads.com/@zuck. You get one profile row (followers, bio, links, recent engagement) and the account's posts, newest first, as far back as you want.

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

Keywords (web scraping), phrases or #hashtags/topics (#ai). Threads shows logged-out visitors about 15-40 posts per search, so add several related keywords for more coverage.

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

Links to single Threads posts (threads.com/@user/post/... or threads.net/t/...). You get the post with its text, media and counts.

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

How many posts to get from each profile, newest first. Use 0 for the profile row only. Large numbers reach far back in time (whole account histories work).

## `maxPostsPerSearch` (type: `integer`):

Most posts to keep from each keyword or hashtag.

## `searchMode` (type: `string`):

Top = posts Threads ranks as most relevant, Recent = newest posts, Both = both lists merged without duplicates (the most posts per keyword).

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

Stop the whole run after this many posts. Leave empty for no limit (your spending limit still applies).

## `includeProfiles` (type: `boolean`):

Add one row per profile with followers, bio, links, topics and recent engagement averages.

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

Only posts newer than this: a date (2026-01-31) or a relative time (7 days, 24 hours). Profile paging stops as soon as it reaches older posts, so you only pay for what you want.

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

Only posts older than this: a date (2026-01-31) or a relative time (30 days).

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

Leave out posts with fewer likes. Left-out posts are not charged.

## `skipPinned` (type: `boolean`):

Leave out posts pinned to the top of a profile.

## `skipReplies` (type: `boolean`):

Leave out posts that are replies to someone else.

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

Remember what earlier runs delivered and return only posts published since then (per profile and per search). Ideal for schedules, alerts and n8n/Make workflows. The first run delivers up to your limits and remembers them.

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

Name of the memory used by 'Only new posts'. Use a different name for each schedule or watchlist.

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

How many profiles or searches to work on at the same time.

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

Apify Proxy is used by default and works well. Residential proxy is not needed.

## Actor input object example

```json
{
  "profiles": [
    "zuck"
  ],
  "searchQueries": [
    "artificial intelligence"
  ],
  "maxPostsPerProfile": 10,
  "maxPostsPerSearch": 10,
  "searchMode": "both",
  "includeProfiles": true,
  "skipPinned": false,
  "skipReplies": false,
  "onlyNewPosts": false,
  "monitorName": "default",
  "maxConcurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All delivered rows. Filter by the type column: profile, post or error. Error rows (missing profiles, broken links) are free.

## `inputs` (type: `string`):

Pages read, posts seen and delivered and why each profile, search or link stopped.

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

Totals, charged events, posts left out per filter, request statistics and warnings.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "profiles": [
        "zuck"
    ],
    "searchQueries": [
        "artificial intelligence"
    ],
    "maxPostsPerProfile": 10,
    "maxPostsPerSearch": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("panix/threads-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "profiles": ["zuck"],
    "searchQueries": ["artificial intelligence"],
    "maxPostsPerProfile": 10,
    "maxPostsPerSearch": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("panix/threads-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "profiles": [
    "zuck"
  ],
  "searchQueries": [
    "artificial intelligence"
  ],
  "maxPostsPerProfile": 10,
  "maxPostsPerSearch": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call panix/threads-scraper --silent --output-dataset

```

## MCP server setup

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