# Scrape Threads Profile Data - Threads Post URL, No Login (`k1ra/scrape-meta-threads-posts-profile`) Actor

Threads analytics for every public profile: a threads post history scraper returning exact likes, replies, reposts and quotes. Threads competitor analysis, brand monitoring, threads content analysis, threads post analysis, threads reply analysis. Threads data api, threads post id, threads stats.

- **URL**: https://apify.com/k1ra/scrape-meta-threads-posts-profile.md
- **Developed by:** [Kevin Savani](https://apify.com/k1ra) (community)
- **Stats:** 2 total users, 2 monthly users, 92.6% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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 Threads Profile Data — Threads Account History, Engagement, No Login

Scrape any public Threads profile's **entire post history** — no login, no cookies, zero account risk. Get exact likes, replies, reposts and quotes, the full post text, media, and timestamps for every post, paginated all the way back through the account's history. Also resolves individual post URLs, pulls reply snapshots, and collects keyword search snapshots.

***

### Why Choose This Threads Scraper

- 🔓 **No login, no cookies** — your Threads or Instagram account is never involved, and never at risk.
- ♾️ **No post ceiling** — walks a profile's posts page by page to the very end of its history, not just the first page.
- 🔢 **Exact engagement** — real `likeCount`, `replyCount`, `repostCount` and `quoteCount` integers, not rounded display strings like "1.2K".
- ⚡ **Zero setup** — no proxy and no configuration. Add a profile and run.
- 💸 **No start fee** — you pay one flat rate per record delivered (a reply is its own record), and an empty run costs `$0`.
- 🛑 **No runaway runs** — `maxPostsPerProfile` is enforced exactly, so your maximum cost is known before you start.
- 🧹 **Deduplication built-in** — stable post IDs, no duplicate posts in your results, even across parallel profiles.
- 🔄 **Incremental monitoring** — `onlyNewPosts` returns only what you have not already seen, so a daily threads daily scraper run costs a fraction of the first.
- 💬 **Replies included** — opt in and every post arrives with its public reply snapshot.
- 🔌 **Automation-ready** — n8n, Make, Zapier, scheduling, and a simple REST API.
- 📄 **Honest about limits** — the search snapshot cap and expiring media URLs are documented below, not hidden.

***

### How It Compares

| Feature | **This Scraper** | Typical Threads scraper |
|---|:---:|:---:|
| Login / cookies required | ✅ never | ❌ many require an account — *"let my Threads account be blocked"* |
| Profile history depth | ✅ full history, no cap | ❌ commonly capped — *"Only allows scraping of 25 posts"* |
| Actor start fee | ✅ none | ❌ $0.04–$0.20 charged before any result (live store pricing) |
| Charged on empty run | ✅ `$0` | ❌ start fee still billed |
| Exact engagement counts | ✅ likes, replies, reposts, quotes | ⚠️ often partial or rounded |
| Replies | ✅ opt-in, with `parentCode` | ⚠️ usually a separate paid actor |
| Post URL resolution | ✅ built in | ⚠️ varies |
| Incremental "new posts only" | ✅ named watch-list | ❌ rarely offered |
| Depth controls | ✅ `maxPostsPerProfile`, `onlyNewerThan` | ❌ some expose a single input only |
| Limits documented up front | ✅ | ⚠️ rarely |

*Competitor column reflects publicly visible store pricing and published user reviews of Threads actors, not a claim about any one actor.*

***

### Use Cases

#### Threads Profile Scraper — Threads Unlimited Posts, Social Media Post History

Most tools stop after the first page of an account. This actor walks a profile's posts page by page to the end of its history — a **bulk Threads scraper** for accounts with thousands of posts.

#### Threads Analytics — Likes, Replies, Reposts & Threads Quote Count

Pull exact **likes, replies, reposts and quotes** for every post in one run — a **Threads analytics scraper** for measuring content performance without opening each post by hand.

#### Threads Monitor — New Post Alerts & Threads Posting Frequency

Schedule this actor with `onlyNewPosts` and a `monitoringId` and it becomes a **Threads monitor** — only posts never seen in a previous run for that watch-list are returned, so you're alerted as soon as a tracked account posts. Follow-up runs stop as soon as they reach posts already reported, so a daily monitor costs a fraction of the first run. Every post carries its timestamp, so posting frequency and cadence fall straight out of the dataset.

#### Competitor Post Tracker & Threads Share of Voice

Point it at any competitor, brand, or creator's public profile and get their full posting history with engagement — built for **social listening**, trend research, and content benchmarking. Pull several accounts in one run to measure share of voice across them.

#### Threads Replies Scraper

Turn on `includeReplies` and every post comes with its reply snapshot — who replied, what they said, and their own engagement — for conversation analysis.

#### Threads Keyword & Hashtag Search

Give it keywords or hashtags and get a snapshot of matching public posts — useful for brand mentions, campaign tracking, and trend discovery. (Search returns a snapshot, not a full archive — see Honest Limitations.)

#### Threads Paid Partnership & Branded-Post Reporting

Each post carries Threads' own paid-partnership flag whenever the post is published with one, so sponsored content can be separated from organic in reporting. (Threads does not publish the flag on every post — see Honest Limitations.)

#### Threads Academic Research & Market Analysis

Export a complete, timestamped post history with engagement for study samples, market sizing, or longitudinal research — no account, no API application, no manual collection.

#### No-Login Threads Scraper

No account, cookies, or session tokens required, ever. This actor never asks for Threads or Instagram credentials and carries **zero ban risk to any account** — the single biggest complaint about other tools in this category.

#### Threads API Integration for Developers

Use it as a **Threads API** — call it over the Apify API and get clean JSON back, with no app review required.

#### CSV, Excel & JSON Export

Every run writes a dataset you can download as **Threads CSV**, Excel, or JSON, or push straight into Google Sheets — ready for reporting without reformatting.

#### Automation for n8n, Make & Zapier

Wire runs into **Threads automation** flows so new posts land in your stack the moment they're published.

***

### Who Uses This

| Use Case | Who It's For |
|---|---|
| Competitor content & engagement tracking | Social media managers, agencies |
| Trend and viral-content research | Social listening teams, researchers |
| Creator/influencer vetting and reporting | Talent agencies, brand partnerships teams |
| Brand-mention and campaign monitoring | Marketing teams, PR/comms |
| Academic and market-sizing research | Analysts, researchers |

***

### What's Supported

| Input | What You Get | Depth |
|---|---|---|
| **Profile** (handle or URL) | Every post with full text, media, timestamp and exact engagement | **Unlimited** — paginates to the account's earliest post |
| **Post URL** | The full post record, resolved from its share link | Single post, plus replies on request |
| **Replies** (`includeReplies`) | Reply text, author and each reply's own engagement | Public reply snapshot per post (~45) |
| **Keyword / hashtag** (`searchQueries`) | Matching public posts with the same fields | Snapshot per query (~40–45), not an archive |

Profile history is the deep surface. Search and replies are snapshots — the honest boundary is spelled out in [Honest Limitations](#honest-limitations).

***

### What's New

**Initial release**

- Full profile post history with no depth limit, paginated to the account's earliest posts.
- Exact likes, replies, reposts and quotes per post.
- Reply snapshots for any post.
- Keyword and hashtag search snapshots.
- New-post monitoring mode for scheduled alerts.

***

### Output

```json
{
  "id": "3986746808466256178",
  "code": "DdTxRmADbEy",
  "url": "https://www.threads.com/@natgeo/post/DdTxRmADbEy",
  "text": "They're just like us when it's time for a sweet treat 😌",
  "likeCount": 3027,
  "replyCount": 41,
  "repostCount": 12,
  "quoteCount": 3,
  "takenAt": "2026-09-08T14:31:07Z",
  "language": "en",
  "mediaType": "image",
  "media": [{ "type": "image", "url": "https://…", "width": 1080, "height": 1350 }],
  "isPaidPartnership": false,
  "isReply": false,
  "replyToUsername": null,
  "isRepost": false,
  "isQuote": false,
  "quotedPostCode": null,
  "linkPreviewUrl": null,
  "owner": { "id": "63269174602", "username": "natgeo", "fullName": "National Geographic", "verified": true, "profilePicUrl": "https://…" },
  "parentCode": null,
  "source": "natgeo",
  "sourceType": "profile"
}
```

`likeCount`, `replyCount`, `repostCount` and `quoteCount` are **exact counts** read live from Threads — not rounded display strings. Replies carry `parentCode` (the post they answer) and `sourceType: "reply"`. Media and profile-picture URLs carry access tokens and **expire** — download promptly if you need the files.

Fields are properly typed, and a post missing an expected field simply ships `null` for it — the run never crashes on one malformed record.

***

### How to Use

**1.** In the **Input** tab, add one or more `profiles` (handles or URLs), and/or `postUrls`, and/or `searchQueries`.

**2.** Set `maxPostsPerProfile` as a cost guard, and optionally `onlyNewerThan` to limit how far back to go.

**3.** Click **Start** — results stream into the **Dataset** tab as they're found, so you can start using them before the run finishes.

**Input format:**

| Field | Type | Example |
|---|---|---|
| `profiles` | array of strings | `["zuck", "https://www.threads.com/@natgeo"]` |
| `postUrls` | array of strings | `["https://www.threads.com/@zuck/post/DdCYWl7GktV"]` |
| `searchQueries` | array of strings | `["nike", "#travel"]` |
| `maxPostsPerProfile` | integer | `100` |
| `onlyNewerThan` | `YYYY-MM-DD` string | `"2026-01-01"` |
| `includeReplies` | boolean | `false` |
| `includeMediaUrls` | boolean | `true` |
| `onlyNewPosts` + `monitoringId` | boolean + string | `true` + `"competitors"` |

**Full profile history:**

```json
{
  "profiles": ["natgeo"],
  "maxPostsPerProfile": 1000
}
```

**Posts with their replies:**

```json
{
  "profiles": ["zuck"],
  "maxPostsPerProfile": 20,
  "includeReplies": true
}
```

**New-post alerts (schedule daily):**

```json
{
  "profiles": ["natgeo", "zuck"],
  "onlyNewPosts": true,
  "monitoringId": "competitors"
}
```

**Keyword search:**

```json
{
  "searchQueries": ["nike", "#travel"]
}
```

***

### Proxy

The actor comes with a built-in proxy that works out of the box — no configuration needed. Just run it.

***

### Pricing

**$2.50 per 1,000 records ($0.0025 per record) — one flat rate, nothing else.**

**No actor-start fee**, and no add-on charge for engagement counts, media URLs, monitoring, or any field. You are charged only for records actually delivered, so an **empty run costs $0**.

| Records returned | Cost |
|---|---|
| 100 | $0.25 |
| 1,000 | $2.50 |
| 10,000 | $25.00 |

Every record — post or reply — carries the full field set: exact likes, replies, reposts and quotes, text, media, timestamp and author.

**What counts as a record:** every row delivered to the dataset. A post is one record, and **each reply is its own record**, so `includeReplies` multiplies the count — a post with 40 public replies returns 41 records (≈ $0.10), not 1. Keyword-search results are records too. Use `maxPostsPerProfile` to cap a run's cost up front, and leave `includeReplies` off unless you need the conversations.

***

### Schedule & Automate

Use Apify's built-in **Scheduler** to run this actor on a cron — daily, weekly, or hourly — for new-post monitoring or recurring engagement snapshots. Connect the dataset to Google Sheets, Zapier, Make, or any webhook via the Apify API.

***

### Integrations & Automation

Plugs into the entire Apify integrations ecosystem and any tool that speaks HTTP:

- **Make** ([docs](https://docs.apify.com/platform/integrations/make)) — trigger Threads pulls from any Make scenario.
- **Zapier** ([docs](https://docs.apify.com/platform/integrations/zapier)) — pipe posts into CRMs, alerts, or spreadsheets.
- **Google Sheets** — auto-export every run's dataset to a live content-tracking Sheet.
- **Slack** ([docs](https://docs.apify.com/platform/integrations/slack)) — get notified when a scheduled monitoring run finds new posts.
- **Airbyte** ([docs](https://docs.apify.com/platform/integrations/airbyte)) — sync posts to your data warehouse (Snowflake, BigQuery, Redshift, Postgres).
- **Apify API** — full programmatic control via the [`apify-client`](https://docs.apify.com/api/v2) SDKs for Node.js and Python, or direct REST calls.
- **Webhooks** ([docs](https://docs.apify.com/platform/integrations/webhooks)) — fire an HTTP endpoint when a run finishes, fails, or finds new posts.

***

### Honest Limitations

- **Keyword search returns a snapshot, not an archive.** Threads publishes roughly 40–45 public results per query, and that is all any tool can return without an account. **Profile history has no such limit** — that is the deep surface here. Use search for monitoring and discovery, and profiles for depth.
- **Replies are a snapshot too** — roughly 45 top and recent replies per post, which is what Threads publishes publicly. A post with thousands of replies returns that snapshot, not all of them.
- **Media and profile-picture URLs expire.** They carry access tokens and stop working shortly after the run — download the files promptly if you need them.
- **Private, deleted, or non-existent profiles return nothing.** They're skipped with a warning and the rest of the run still delivers.
- Some posts don't publish a detected language, a paid-partnership flag, or a link preview — those ship as `null` rather than a guess.

***

### FAQ

**Do I need to log in or provide cookies?**
No. The actor works with no Threads or Instagram account, cookies, or session tokens, and carries zero risk to any account.

**Can I get every post an account has ever published?**
Yes — profile history has no depth cap. Set `maxPostsPerProfile` high enough and the actor works back through the account's posts to the end.

**Why does search return fewer results than a profile?**
Threads publishes only a limited set of public results per search query. Profile history is the deep surface; search is a snapshot for discovery and monitoring.

**Can I monitor accounts for new posts?**
Yes. Enable `onlyNewPosts` with a `monitoringId` and schedule the actor — each run returns only posts never seen before under that monitor.

**Does it return replies?**
Yes — enable `includeReplies` and each post comes with its public reply snapshot, each reply carrying `parentCode`.

**Do the media URLs work forever?**
No — they expire shortly after the run. Download the files promptly if you need them.

**Do I need my own proxy?**
No. The actor works out of the box — a built-in proxy handles it automatically.

**Can I export results to a spreadsheet?**
Yes. After the run completes, go to **Storage** → **Dataset** → **Export** → choose CSV, Excel, or JSON, or auto-export to Google Sheets via the Apify integration.

**Can I run this via API?**
Yes — use the Apify API or the official Node.js/Python SDKs to trigger runs and retrieve results programmatically.

**Is it legal to scrape public Threads posts?**
The actor only extracts **publicly available data** — what Threads displays to any visitor without an account. It does not bypass login walls or extract private data. You are responsible for compliance with Threads' Terms of Service and applicable laws when using the extracted data.

***

### ⭐ Bookmark This Actor & Leave a Review

If this actor saves you time:

- **⭐ Click the star** at the top of the actor page to bookmark it — it makes the actor easier for you to find later and helps other Apify users discover it.
- **📝 Leave a review** — even one sentence on what you use it for helps prioritize the next feature.

Your bookmarks and reviews directly improve this actor's discoverability across the Apify Store.

***

### Related Apify Actors

Looking for more scraping power? You may also like:

- [Social Media Scrapers](https://apify.com/store?category=SOCIAL_MEDIA) — Instagram, Facebook, TikTok, and more
- [Automation Actors](https://apify.com/store?category=AUTOMATION) — monitoring and scheduled-run building blocks

***

### Support & Feedback

Found a bug or want a new field or input option supported?

- **Open an issue** on the actor's Issues tab in the Apify Console.
- **Feature requests** are welcome — especially for new enrichment fields or filters.

# Actor input Schema

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

Public Threads handles or profile URLs to scrape the full post history from (e.g. 'zuck' or 'https://www.threads.com/@zuck'). This is the primary input — profiles have no depth limit. A profile that can't be fetched is skipped; the rest of the run still returns.

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

Individual post URLs to resolve (e.g. 'https://www.threads.com/@zuck/post/ABCdef123'). Each returns the full post record with exact engagement counts.

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

Keywords or hashtags to collect a snapshot of matching public posts (e.g. 'nike'). Search returns a snapshot of roughly 40-45 posts per query, not a full archive — see the actor's README.

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

Stop after this many posts per profile. This is the main cost guard — set it to what you actually need.

## `onlyNewerThan` (type: `string`):

Only keep posts published on or after this date (ISO format, e.g. '2026-01-01'). The run stops once it is past this window instead of walking the whole profile.

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

Also return the reply snapshot for every post found (roughly 45 top and recent replies per post). This adds requests, so runs take longer.

## `includeMediaUrls` (type: `boolean`):

Include image and video URLs for each post. These carry access tokens and expire — download promptly if you need the files.

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

Remember every post across runs and only output ones never seen before. Schedule this actor and get ONLY fresh posts each run — no repeats. Follow-up runs stop once they reach posts already reported, so they finish far faster than the first one.

## `monitoringId` (type: `string`):

Optional name for the monitoring memory. Use different IDs to keep separate watch-lists (e.g. 'competitors' and 'my-brand').

## Actor input object example

```json
{
  "profiles": [
    "zuck"
  ],
  "maxPostsPerProfile": 100,
  "includeReplies": false,
  "includeMediaUrls": true,
  "onlyNewPosts": false
}
```

# Actor output Schema

## `id` (type: `string`):

Threads post id.

## `code` (type: `string`):

Short code identifying the post in its URL.

## `url` (type: `string`):

Direct link to the post.

## `text` (type: `string`):

Full post text, line breaks included.

## `likeCount` (type: `string`):

Exact like count.

## `replyCount` (type: `string`):

Exact number of direct replies.

## `repostCount` (type: `string`):

Exact repost count.

## `quoteCount` (type: `string`):

Exact quote count.

## `takenAt` (type: `string`):

ISO 8601 timestamp of when the post was published.

## `language` (type: `string`):

Language detected for the post, when published.

## `mediaType` (type: `string`):

text, image, video or carousel.

## `isReply` (type: `string`):

True when the post is a reply to another post.

## `replyToUsername` (type: `string`):

Handle the post replies to, when it is a reply.

## `parentCode` (type: `string`):

Code of the post this reply belongs to.

## `isRepost` (type: `string`):

True when the post reposts someone else's post.

## `isQuote` (type: `string`):

True when the post quotes another post.

## `quotedPostCode` (type: `string`):

Code of the quoted post, when the post quotes one.

## `isPaidPartnership` (type: `string`):

True when the post is marked as a paid partnership.

## `linkPreviewUrl` (type: `string`):

URL of the link preview attached to the post.

## `ownerUsername` (type: `string`):

Handle of the account that published the post.

## `ownerFullName` (type: `string`):

Display name of the author.

## `ownerVerified` (type: `string`):

True when the author is verified.

## `ownerProfilePicUrl` (type: `string`):

Author profile picture URL; expires shortly after the run.

## `source` (type: `string`):

The profile, post URL or search query this post came from.

## `sourceType` (type: `string`):

profile, post, search or reply.

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("k1ra/scrape-meta-threads-posts-profile").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"] }

# Run the Actor and wait for it to finish
run = client.actor("k1ra/scrape-meta-threads-posts-profile").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"
  ]
}' |
apify call k1ra/scrape-meta-threads-posts-profile --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,k1ra/scrape-meta-threads-posts-profile"
        }
    }
}
```

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/gwgvlRkKyQaHO17P5/builds/xDMOkISVBPbONGkIZ/openapi.json