# Meta Threads Profile Scraper (`data_wiki/meta-threads-profile-scraper`) Actor

Scrape public Meta Threads profiles in bulk: followers, verified status, bio, bio links, topics and profile picture, plus posts, replies, reposts or media with likes and replies. No login needed. Great for influencer research, lead lists and audience analysis.

- **URL**: https://apify.com/data_wiki/meta-threads-profile-scraper.md
- **Developed by:** [Data WiKi](https://apify.com/data_wiki) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

### 🚀 What is Meta Threads Profile Scraper?

Meta Threads Profile Scraper is an Apify Actor and threads profile scraper for public accounts. Give it usernames or profile links and it returns followers, verification, bio, bio links and topics, plus the posts, replies, reposts or media posts of each profile. It needs no Threads login, cookies or browser.

- **One list, one tab each:** pick posts, replies, reposts or media for every profile, or collect profile details only.
- **Date filter:** keep items newer than `12h`, `7d`, `2w`, `3m`, `1y` or a calendar date.
- **Rows arrive as profiles finish:** you can open the dataset while the run is still going.
- **Plain requests, 1,024 MB:** the Actor starts without a proxy and switches to a proxy when Threads rejects requests.
- **Pay per saved row:** one `main_result` event per item, see the pricing section.

Click **Try for free**, add usernames under **Threads profiles**, press **Start**.

### 📊 What data can you extract from Threads?

Every saved row is one item of the tab you chose, written as JSON that exports to CSV or Excel. A post row carries the profile details of its author next to the post, so Threads profile data and the posts sit in one table. As a Threads data extractor the Actor covers profile and post fields alike. Profile rows appear when the content type is none, when a profile is private, or when a tab holds no items.

The engagement counts on each post row are Threads post engagement data you can compare across accounts. Post rows have up to 31 fields:

| Field | Description | Example |
|---|---|---|
| `username` | Profile the row was collected from | `examplecreator` |
| `profile_url` | Link to that profile | `https://www.threads.com/@examplecreator` |
| `profile_id` | Numeric profile ID | `"1000000001"` |
| `full_name` | Display name | `Example Creator` |
| `is_verified` | Whether the profile shows the Threads verified badge | `false` |
| `follower_count` | Followers of the profile | `12500` |
| `profile_pic_url` | Link to the Threads profile picture | `https://example.com/pic.jpg` |
| `id` | Post ID | `"1000000000000000001"` |
| `code` | Short code in the post link | `EXAMPLE1abc` |
| `url` | Post link | `https://www.threads.com/@examplecreator/post/EXAMPLE1abc` |
| `author` | Username of the post author (the original author on reposts) | `examplecreator` |
| `text` | Post text | `Fictional sample post about coffee. #coffee` |
| `created_at` | Posting time, UTC | `2026-11-04T09:30:00Z` |
| `type` | `image`, `video`, `carousel` or `text` | `image` |
| `like_count` | Likes | `120` |
| `reply_count` | Replies | `14` |
| `repost_count` | Reposts | `6` |
| `quote_count` | Quotes | `2` |
| `is_reply` | True when the item is a reply | `false` |
| `reply_to` | Username that was answered | `null` |
| `is_pinned` | True for the pinned post | `false` |
| `is_edited` | True when the post was edited | `false` |
| `topic` | Topic tag of the post | `null` |
| `hashtags` | Hashtags found in the text | `["coffee"]` |
| `mentions` | Mentioned usernames | `[]` |
| `links` | Links in the text | `[]` |
| `link_preview` | Link card with `url`, `title`, `domain` | `null` |
| `media` | Images and videos with `type`, `url`, `thumbnail_url`, `width`, `height`, `alt_text` | see Output |
| `quoted_post` | Quoted post with `id`, `url`, `author`, `text`, `created_at`, `like_count`, `reply_count` | `null` |
| `reply_control` | Who may reply, as shown by Threads | `null` |
| `reposted_at` | Time of the repost, only on repost rows | `2026-11-05T08:00:00Z` |

Profile rows have these fields:

| Field | Description | Example |
|---|---|---|
| `username` | Profile username | `examplecreator` |
| `url` | Profile link | `https://www.threads.com/@examplecreator` |
| `id` | Numeric profile ID | `"1000000001"` |
| `full_name` | Display name | `Example Creator` |
| `is_verified` | Verification flag | `false` |
| `is_private` | True for private profiles | `false` |
| `follower_count` | Followers | `12500` |
| `threads_count_label` | Thread count as the profile page shows it, rounded | `1.5K` |
| `biography` | Bio text | `Coffee notes and weekend bakes` |
| `bio_links` | The Threads bio links as plain URLs | `["https://example.com"]` |
| `bio_mentions` | Usernames mentioned in the bio | `["examplebrand"]` |
| `topics` | Topics shown on the profile | `["Food"]` |
| `profile_pic_url` | Profile picture link | `https://example.com/pic.jpg` |

Items the Actor cannot read are saved as `null` or an empty list. The Output tab shows Profiles, Posts and Media tables; the table view does not show every field, so download the dataset for all of them. Use `is_verified` to see which accounts are a Threads verified account.

### 💡 Use cases for Threads data

- **Influencer research:** Threads influencer research starts with `follower_count`, `is_verified`, `biography` and `topics` for every account on your shortlist.
- **Competitor analysis:** For Threads competitor analysis, pull a rival's recent posts and compare `repost_count`, `quote_count` and `created_at`.
- **Brand monitoring:** Schedule a weekly run with `postedAfter` set to `7d` for Threads brand monitoring on your own and partner accounts.
- **Audience growth:** The Threads followers count is in every row. Keep the datasets from scheduled runs and you have a simple Threads follower tracker.
- **Content research:** Sort a profile's posts by `like_count` for Threads content research. Read `hashtags` to see which Threads hashtags an account uses.
- **Outreach research:** Threads lead generation can start from `bio_links` and `bio_mentions`; the Actor does not collect email addresses.
- **Records and AI:** Archive Threads posts with their text, dates and media links. Build a Threads dataset for analysis or models.
- **Account watchlist:** Monitor Threads accounts you choose by running the same list each week and comparing the datasets.

### 🛠️ How to scrape Threads profiles

1. Create a free Apify account and open **Meta Threads Profile Scraper**.
2. Add usernames, `@names` or profile links under **Threads profiles**, one per line.
3. Choose **Content to collect**: Posts, Replies, Reposts, Media posts or None for profile details only.
4. Set **Maximum items per profile** and, if you want, **Only items newer than**, for example `7d`.
5. Leave **Proxy** on its default and press **Start**.
6. Watch the log counters, then open the **Output** tab.
7. Download Threads posts and profiles as JSON, CSV, Excel, XML or HTML.

A Threads profile viewer shows one account at a time. This Actor reads a whole list and puts the profile details of every username into one table. Run it as a Threads profile downloader when you only need follower counts and bios: set **Content to collect** to None.

Threads data scraping with this Actor is simple: a list goes in and one row per saved item comes out. The Actor reads only what a visitor can see on [Threads](https://www.threads.com), and the integration section below shows how to run it on a schedule.

#### How to scrape posts from one profile

Set `feed` to `posts` and `maxItems` to the number you need. A Threads post scraper for a single account needs only these two values. To scrape Threads posts from the last week, add `postedAfter` set to `7d`.

#### How to collect replies, reposts or media

Set `feed` to `replies` and the Actor works as a Threads replies scraper for each profile's own replies. Choose `reposts` to receive Threads reposts as rows of the original post with `reposted_at` filled. Choose `media` to receive Threads media posts. The Actor returns media links rather than files, so it is not a Threads media downloader.

### 💰 How much does it cost to scrape Threads?

The Actor uses pay per event. The Pricing tab shows the current rates, and the table below lists them.

| Event | When it is charged | Free | Bronze | Silver | Gold, Platinum, Diamond |
|---|---|---|---|---|---|
| `main_result` | Once for every saved item (a post, reply, repost, media post, or a profile row) | $0.004 | $0.0036 | $0.0032 | $0.0028 |
| `apify-actor-start` | Once per run (one event per GB of memory, this Actor is set to 1,024 MB) | $0.00005 | $0.00005 | $0.00005 | $0.00005 |

Per 1,000 saved items that is $4.00, $3.60, $3.20 and $2.80 for the four columns. Apify platform usage (compute) is billed on top of the events above.

Worked example at the Free price: 500 posts cost 500 x $0.004 = $2.00, and 100 profile rows with content type none cost 100 x $0.004 = $0.40. Add $0.00005 for the start of each run. Items that fail are saved as an error row and are not charged. You can set a maximum cost per run in Apify; the Actor stops cleanly when it is reached.

### ⬇️ Input

Only `urls` is required. The example below collects the latest post of one profile, newer than seven days.

```json
{
  "urls": ["examplecreator"],
  "feed": "posts",
  "maxItems": 1,
  "postedAfter": "7d",
  "proxyConfiguration": { "useApifyProxy": true }
}
```

| Field | Description | Default |
|---|---|---|
| `urls` | Usernames, `@names` or profile or post links, one per line. Duplicates are removed; entries that are not a Threads username or link are skipped. | none, required |
| `feed` | `posts`, `replies`, `reposts`, `media` or `none` (profile details only) | `posts` |
| `maxItems` | Items to keep per profile, 1 to 2000 | `10` |
| `postedAfter` | Keep items posted after this point: `12h`, `7d`, `2w`, `3m`, `1y` (`m` is 30 days, `y` is 365 days) or a date such as `2026-01-31`. Ignored when `feed` is `none`. | empty, no filter |
| `includeAnalytics` | Reserved for a later version. It has no effect and adds nothing to the output. | `true` |
| `proxyConfiguration` | Optional proxy settings. Requests start without a proxy and switch to a proxy when rejected. | Apify Proxy on |

💡 Keep `maxItems` low for a first test run. See the Input tab for every option.

### ⬆️ Output

The results are shown as a dataset in the **Storage** tab. The table view is for convenience and does not show **all the fields**. Export formats are JSON, CSV, Excel, XML and HTML. For a long list it acts as a threads exporter that writes one file for all profiles. The sample below is fictional and matches the input above.

```json
[
  {
    "username": "examplecreator",
    "profile_url": "https://www.threads.com/@examplecreator",
    "profile_id": "1000000001",
    "full_name": "Example Creator",
    "is_verified": false,
    "follower_count": 12500,
    "profile_pic_url": "https://example.com/pic.jpg",
    "id": "1000000000000000001",
    "code": "EXAMPLE1abc",
    "url": "https://www.threads.com/@examplecreator/post/EXAMPLE1abc",
    "author": "examplecreator",
    "text": "Fictional sample post about coffee. #coffee",
    "created_at": "2026-11-04T09:30:00Z",
    "type": "image",
    "like_count": 120,
    "reply_count": 14,
    "repost_count": 6,
    "quote_count": 2,
    "is_reply": false,
    "reply_to": null,
    "is_pinned": false,
    "is_edited": false,
    "topic": null,
    "hashtags": ["coffee"],
    "mentions": [],
    "links": [],
    "link_preview": null,
    "media": [
      {
        "type": "image",
        "url": "https://example.com/photo.jpg",
        "thumbnail_url": null,
        "width": 1080,
        "height": 1350,
        "alt_text": null
      }
    ],
    "quoted_post": null,
    "reply_control": null
  }
]
```

#### Profile details output

With `"urls": ["examplecreator"]` and `"feed": "none"` the run saves one profile row:

```json
[
  {
    "username": "examplecreator",
    "url": "https://www.threads.com/@examplecreator",
    "id": "1000000001",
    "full_name": "Example Creator",
    "is_verified": false,
    "is_private": false,
    "follower_count": 12500,
    "threads_count_label": "1.5K",
    "biography": "Coffee notes and weekend bakes",
    "bio_links": ["https://example.com"],
    "bio_mentions": ["examplebrand"],
    "topics": ["Food"],
    "profile_pic_url": "https://example.com/pic.jpg"
  }
]
```

#### Error rows

A profile that cannot be read is saved as `{ "username": "...", "url": "...", "error": "not_found" }`. Error rows are never charged. The `error` value is one of `not_found`, `blocked`, `transport`, `source_changed` or `failed`.

### ⚠️ Limitations and error handling

- **Public data only:** a private profile returns its profile row (`is_private` is `true`) and no items.
- **Item ceiling:** reading of a profile stops after 2000 examined items, and the log says the profile was only partly read. Items skipped by the date filter count as examined.
- **Smaller tabs:** replies, reposts and media tabs can hold fewer items than the posts tab.
- **Blocked requests:** the Actor retries up to three times, switches to a proxy, and keeps the items it already collected for that profile. If nothing could be saved because access was blocked, the run ends with a message that says so; try again later or set a proxy in the Proxy input.
- **Unreachable site:** after several network failures in a row the Actor stops reading, and profiles it could not reach are saved with the `transport` error.
- **Page changes:** if Threads changes how a profile page is built, affected profiles come back with `source_changed` until the Actor is updated.
- **Date filter:** `postedAfter` only filters items. It is ignored with a log warning when `feed` is `none`, and an unreadable value stops the run with a message that names the field.
- **Concurrency:** up to six profiles are read at the same time.
- **Run summary:** the key-value store record `RUN_SUMMARY` holds `totalProfiles`, `savedItems`, `chargedItems`, `failedItems`, `skippedProfiles`, `durationSecs` and `feed`.
- **Reserved option:** `includeAnalytics` has no effect in this version.

⚠️ Results reflect what Threads shows publicly at the time of the run.

### 🔌 Integrating Meta Threads Profile Scraper with other apps

Start the Actor from the Console, a schedule or code. One call to the [Apify API](https://docs.apify.com/api/v2) works as a Threads scraper API for any language:

```bash
curl -X POST "https://api.apify.com/v2/actors/data_wiki~meta-threads-profile-scraper/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"urls":["examplecreator"],"feed":"posts","maxItems":10}'
```

- **Schedules:** run it daily or weekly with [Apify schedules](https://docs.apify.com/actors/running/schedules) to build a history of runs.
- **Webhooks:** call your own URL when a run ends, see [webhooks](https://docs.apify.com/integrations/webhooks).
- **No-code tools:** connect results to spreadsheets and apps with [Make](https://docs.apify.com/integrations/make), [Zapier](https://docs.apify.com/integrations/zapier) or other [Apify integrations](https://docs.apify.com/integrations).
- **AI agents:** the Actor can be found and started through the [Apify MCP server](https://docs.apify.com/mcp).

### 🔗 Other Threads and social media scrapers by data_wiki

These Actors cover what Meta Threads Profile Scraper does not do. For another network, a social media profile scraper such as [Bluesky profiles, posts and followers](https://apify.com/data_wiki/bluesky-scraper-enterprise-grade) works on the same idea.

| Actor | What it extracts | When to use it |
|---|---|---|
| [Threads Scraper](https://apify.com/data_wiki/threads-scraper) | Threads profiles, posts, replies and keyword or hashtag search results; four modes including search and post links, reply threads, a minimum-likes filter and a before date | You want to search Threads or read specific posts and the replies under them |
| [Threads Scraper - Posts, Profiles & Search](https://apify.com/data_wiki/threads-scraper-posts-profiles-search) | Six modes: user posts, reposts and replies, keyword search, Find Profiles by keyword and post links; contact details found in bios | You need to discover accounts by keyword or collect contact details from bios |
| [Bluesky Scraper Enterprise Grade](https://apify.com/data_wiki/bluesky-scraper-enterprise-grade) | Bluesky posts, comments, profiles, followers and following | Your creators or audience are also on Bluesky |
| [Instagram Hashtag Scraper](https://apify.com/data_wiki/instagram-hashtag-scraper) | Public Instagram reels by hashtag or keyword with plays, likes and comments | You research creators across Meta platforms, starting from hashtags |

### ⚖️ Is it legal to scrape Threads?

Meta Threads Profile Scraper only collects data that anyone can see on Threads without logging in, and it is an independent tool that is not affiliated with Meta. Results can still contain personal data, so use them only with a legitimate reason and follow GDPR, CCPA and the platform's terms. Read [is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/) and [what is ethical web scraping](https://blog.apify.com/what-is-ethical-web-scraping-and-how-do-you-do-it/) if you are unsure, and ask a lawyer for advice on your case.

### ❓ FAQ

#### What does a threads profile scraper collect?

It collects the public details of each profile you list (followers, verification, bio, bio links, topics, picture link) and, if you choose a tab, the posts, replies, reposts or media posts with their counts, hashtags, mentions, links and media URLs.

#### Do I need a Threads account or cookies?

No. The Actor reads public pages only and needs no login, cookies or API key from you.

#### How do I scrape data from Threads for many accounts?

Put one username or link per line in `urls`, pick a tab and a `maxItems` value, and start the run. Duplicates are removed, and several profiles are read in parallel.

#### Is there a threads profile API?

This Actor does not use an official Threads API. You start it and read the dataset through the Apify API, which also gives you JSON, CSV and Excel exports.

#### How many items can I get per profile?

Up to the `maxItems` you set, with a maximum of 2000. Reading a profile stops after 2000 examined items, and tabs such as replies can hold fewer.

#### Can I export Threads posts to a spreadsheet?

Yes. Open the dataset and choose CSV or Excel to export Threads posts. You can also export Threads data to a sheet with an integration.

#### Can I scrape private profiles?

No. A private profile returns only its public profile fields.

#### Which Threads Actor should I use?

Use this one when you already have a list of profiles and want their details plus one tab per profile with a relative date filter. Use [Threads Scraper with search, post links and reply threads](https://apify.com/data_wiki/threads-scraper) for search, exact posts, replies under a post, a minimum-likes filter or an end date. Use [the Threads Actor with Find Profiles and bio contact details](https://apify.com/data_wiki/threads-scraper-posts-profiles-search) to find accounts by keyword.

#### Why is a field empty?

Fields that a post or profile does not have, such as links or a quoted post, are `null` or an empty list.

#### Can I use it through an MCP server?

Yes. AI agents can find and run the Actor through the [Apify MCP server](https://docs.apify.com/mcp).

### 💬 Your feedback

Found a bug or need another field? Open an issue in the Actor's **Issues** tab. Need a custom solution? Contact hello.datawiki@gmail.com.

# Changelog

This Actor's version history is a separate document: https://apify.com/data_wiki/meta-threads-profile-scraper/changelog.md

# Actor input Schema

## `urls` (type: `array`):

One entry per line: a Threads username (zuck), an @name (@natgeo) or a profile or post link (https://www.threads.com/@natgeo). Add as many as you like.

## `feed` (type: `string`):

Which tab to collect for every profile. Choose none to get profile details only.

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

Maximum number of posts, replies, reposts or media posts to keep for each profile. Reading of a profile stops after 2000 examined items.

## `includeAnalytics` (type: `boolean`):

Reserved for a later version. This option has no effect in this version and adds no analytics to the output.

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

Keep only items posted after this point. Use a relative value such as 12h, 7d, 2w, 3m, 1y or a date such as 2026-01-31. Leave empty for no date filter.

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

Requests start without a proxy. If they are rejected, the actor switches to a datacenter proxy and then to a residential proxy.

## Actor input object example

```json
{
  "urls": [
    "zuck",
    "https://www.threads.com/@natgeo"
  ],
  "feed": "posts",
  "maxItems": 10,
  "includeAnalytics": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Profile rows with followers, bio, topics and verification. Filled when the content type is none or the profile is private.

## `posts` (type: `string`):

One row per collected post, reply, repost or media post.

## `analytics` (type: `string`):

Reserved. This version does not produce analytics data.

# 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 = {
    "urls": [
        "zuck",
        "https://www.threads.com/@natgeo"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_wiki/meta-threads-profile-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 = {
    "urls": [
        "zuck",
        "https://www.threads.com/@natgeo",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("data_wiki/meta-threads-profile-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 '{
  "urls": [
    "zuck",
    "https://www.threads.com/@natgeo"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call data_wiki/meta-threads-profile-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,data_wiki/meta-threads-profile-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/hrNoj2JIpPHkv7RYA/builds/PeegYOXD4USKfS0Fe/openapi.json