# Threads Profile API (`lergassy/threads-profile-api`) Actor

One Threads username in, one row out: followers, name, bio, bio links, website, e-mails and phones from the bio, verification, linked Instagram and the latest post. Built for one call per account, from an agent, n8n or code.

- **URL**: https://apify.com/lergassy/threads-profile-api.md
- **Developed by:** [Matvey](https://apify.com/lergassy) (community)
- **Categories:** Social media, Agents, MCP servers
- **Stats:** 8 total users, 5 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.80 / 1,000 profiles

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 Profile API** turns one Threads username into one row: followers, full name, bio, the links and the website from the bio, any e-mail or phone published there, verification, the linked Instagram account, and the account's latest post with its engagement.

One call, one account, one row. That is the shape an AI agent, an n8n loop or a `for` loop in your code actually wants — not a batch job that returns a thousand posts you did not ask for.

No login, no cookies, no official API access. An account that does not exist comes back as an error row and is **never billed**.

### Tested head-to-head — 24 September 2026

![Tested against 4 other Threads profile Actors: correct Threads follower counts for all five accounts, the latest post's date in every row, and the lowest bill for the request](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/benchmarks/threadsprofileapi-tested-2026-09-24.png)

The same request went to this Actor and to the four most-used Actors on the Apify Store that return a Threads profile by username, on the same afternoon from a fresh free account: five public accounts (zuck, mosseri, nasa, natgeo, nytimes), one row each. Follower counts were checked against what Threads itself shows.

| | This Actor | The 4 others |
|---|---|---|
| Accounts with the correct Threads follower count | **5 of 5** | 5 of 5 at two; Instagram's count at one; nothing at one |
| Date, link and likes of the latest post in the row | **Yes** | Only one of the four |
| What this request cost | **$0.020** | $0.021 – $0.045 (the one that returned nothing cost $0) |

### What is the Threads Profile API?

Meta publishes an API for your own Threads account and nothing for anyone else's. This Actor is the missing lookup: give it `zuck`, get back the profile as structured data, in about a second.

Typical uses: creator and influencer research, enriching a CRM with a social profile, checking follower counts on a schedule, pulling the contact an account publishes in its bio, and giving an AI agent a tool that answers "who is this account".

### What comes back

| Field | Example |
|---|---|
| `username`, `fullName`, `userId` | `zuck` · Mark Zuckerberg · 314216 |
| `followerCount` | 5 738 024 |
| `biography` | "Mostly superintelligence and MMA takes" |
| `bioLinks`, `websiteUrl` | every link the account published |
| `emails`, `phones` | the contact details put in the bio, when there are any |
| `isVerified`, `isPrivate` | true · false |
| `instagramUrl`, `profilePicUrl`, `profileUrl` | linked Instagram, the avatar in full size, the profile link |
| `latestPostAt`, `latestPostUrl`, `latestPostText` | when the account last posted, and what it said |
| `latestPostLikes`, `latestPostReplies` | how that post landed |
| `recentPosts` | the last N posts with text, time, engagement and media — when you ask for them |

### How much does it cost?

**$4 per 1,000 profiles** — one account, one charge, no start fee.

- A username that does not exist, is private or was renamed: **$0**.
- Rate limits and blocks: **$0**.

At one call per account, a thousand lookups cost four dollars. There is no monthly minimum and no quota to hit.

#### Bulk export

This Actor is built for bulk jobs — put hundreds of inputs into one run, or call it from the API on
a schedule. There is **no fee per run, no fee per page and no proxy charge**: you pay for the rows
you keep, and error rows are free, so a 50,000-row job costs exactly 50,000 × the row price with
nothing added on top.

### How to use it

1. Put one username into **👤 Username** — `zuck`, `@natgeo`, or a full profile URL.
2. Press **Start**. One row comes back, usually within a second or two.
3. To do it from code, call the run from the API, n8n, Make, Zapier or an AI agent, one account per call.

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

def threads_profile(username: str) -> dict:
    run = client.actor("lergassy/threads-profile-api").call(run_input={"username": username})
    return next(client.dataset(run["defaultDatasetId"]).iterate_items())

p = threads_profile("natgeo")
print(p["fullName"], p["followerCount"], p["websiteUrl"])
```

Have a spreadsheet instead of a loop? **👥 Or several at once** takes a short list; each account is still one row and one charge.

### ⬆️ Output

```json
{
  "username": "zuck",
  "fullName": "Mark Zuckerberg",
  "userId": "314216",
  "followerCount": 5738024,
  "biography": "Mostly superintelligence and MMA takes",
  "bioLinks": [],
  "websiteUrl": null,
  "emails": [],
  "isVerified": true,
  "isPrivate": false,
  "instagramUrl": "https://www.instagram.com/zuck/",
  "profileUrl": "https://www.threads.net/@zuck",
  "latestPostAt": "2026-09-15T23:01:39.000Z",
  "latestPostUrl": "https://www.threads.net/@zuck/post/DAbC1dEfGh",
  "latestPostLikes": 1296,
  "recentPosts": [],
  "scrapedAt": "2026-09-17T00:41:02.118Z"
}
```

A failed lookup pushes one `type: "error"` row naming the account and the reason — `account not found, private, or renamed` — free of charge.

### ❓ FAQ

#### Why a single username instead of a big list?

Because that is how it gets used. An agent asks about one account; an n8n node runs once per row; a CRM enrichment fires per contact. A batch actor makes that awkward and bills you for work you did not need. A list input is here anyway for the spreadsheet case.

#### Is a private account returned?

No. Threads shows a logged-out visitor nothing but the fact that the account is private, and that is what you get — as an error row, not as an invented profile.

#### Does it need my Threads account?

No. No login, no cookies, nothing of yours can be rate-limited because of it.

#### Is the follower count live?

It is what the profile page showed at the moment of the check, with `scrapedAt` on the row so you always know when that was.

#### Can I use it through the Apify API or an MCP server?

Yes to both. There is one required-looking field and a sensible default, so an agent can call it correctly without reading this page.

### Your feedback

Something missing from the row? Open an issue on the **Issues** tab — it gets read and answered.

### You might also like

| Actor | What it does |
|---|---|
| [Threads Scraper](https://apify.com/lergassy/threads-scraper) | The full archive: search, an account's posts, replies, reposts, whole threads and account discovery |
| [Threads Monitor](https://apify.com/lergassy/threads-monitor) | Watch accounts or keywords and receive only what is new since the last check |
| [Threads Profile Scraper](https://apify.com/lergassy/threads-profile-scraper) | The same profile data in bulk, for long lists |
| [Threads Replies Scraper](https://apify.com/lergassy/threads-replies-scraper) | Replies and conversations: who answered what |

# Actor input Schema

## `username` (type: `string`):

One Threads account — <b>zuck</b>, <b>@natgeo</b>, or a full profile URL. One call, one account, one row: the shape an agent or an n8n loop expects.

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

A short list instead of one name, for a spreadsheet that would rather not loop. Each account is still one row and one charge.

## `latestPosts` (type: `integer`):

Attach this many of the account's most recent posts to the row, with text, time and engagement. Zero keeps the row to the profile alone; the latest post's date, link and text are always included.

## `includeContacts` (type: `boolean`):

Accounts often publish a contact in the bio. Turn this off if you do not want those fields in your data.

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

Apify Proxy is on by default and needs no setup. Threads is read without a login, so datacenter addresses are enough.

## Actor input object example

```json
{
  "username": "zuck",
  "usernames": [],
  "latestPosts": 0,
  "includeContacts": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per account: followers, full name, bio, bio links, website, e-mails and phones from the bio, verification, linked Instagram and the latest post.

# 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 = {
    "username": "zuck",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("lergassy/threads-profile-api").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 = {
    "username": "zuck",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("lergassy/threads-profile-api").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 '{
  "username": "zuck",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call lergassy/threads-profile-api --silent --output-dataset

```

## MCP server setup

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

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/pT9FBhNLFPWn3vwiM/builds/tZUScg56BTrDdWwoQ/openapi.json