# Threads Profile & Posts Scraper (`fetch_cat/threads-profile-posts-scraper`) Actor

Export public Threads profile metadata, bios, follower counts, avatars, and visible post previews from usernames or profile URLs.

- **URL**: https://apify.com/fetch\_cat/threads-profile-posts-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Social media, Lead generation, Developer tools
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 1,000 result extracteds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Threads Profile & Posts Scraper

Scrape public Threads profile metadata and public post previews from Threads profile URLs or usernames.

### What does Threads Profile & Posts Scraper do?

Threads Profile & Posts Scraper helps you collect structured data from public Threads profiles. Provide one or more usernames or profile URLs and the actor returns clean rows with profile metadata such as display name, bio, follower count, thread count, avatar URL, profile URL, and scrape timestamp. When Threads exposes public post previews in logged-out HTML, the actor also saves post rows with post URL, post ID, text preview, media URL array, and engagement fields when visible.

### Who is it for?

- 🧵 Social media analysts tracking public Threads presence
- 📣 Brand teams monitoring official accounts and creator profiles
- 📰 Journalists researching public profiles and public conversations
- 📊 Growth teams comparing follower counts and profile positioning
- 🤖 Automation builders who need Threads profile data in a dataset, API, or workflow

### Why use this actor?

Threads pages are optimized for browsing, not exporting. This actor turns public profile pages into structured data you can download as JSON, CSV, Excel, or access through the Apify API. It accepts simple usernames, supports multiple profiles per run, and includes proxy configuration for reliable production use.

### What data can you extract?

| Field | Description |
| --- | --- |
| `itemType` | `profile` or `post` |
| `profileUrl` | Canonical Threads profile URL |
| `username` | Threads username without `@` |
| `displayName` | Public profile display name |
| `bio` | Public profile bio text when available |
| `followerCount` | Parsed numeric follower count |
| `threadCount` | Parsed numeric thread count |
| `avatarUrl` | Public avatar image URL |
| `postId` | Post identifier when a post preview is visible |
| `postUrl` | Public post URL when a post preview is visible |
| `text` | Visible post preview text when available |
| `timestamp` | Visible post timestamp when available |
| `mediaUrls` | Visible media URLs when available |
| `replyCount` | Visible reply count when available |
| `repostCount` | Visible repost count when available |
| `likeCount` | Visible like count when available |
| `isReply` | Whether the row appears to be a reply |
| `isRepost` | Whether the row appears to be a repost |
| `sourceUrl` | Final fetched URL |
| `scrapedAt` | ISO timestamp for the scrape |

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee charged when a run starts. Covers fixed startup cost. | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `result` | Charged per profile or post result extracted. | $0.1864 / 1,000 | $0.16209 / 1,000 | $0.12643 / 1,000 | $0.09725 / 1,000 | $0.06484 / 1,000 | $0.04538 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### How to use

1. Open the actor on Apify.
2. Add Threads usernames or profile URLs.
3. Choose the maximum number of visible post previews per profile.
4. Keep the direct-connection default unless you have a specific proxy requirement.
5. Start the run.
6. Download the dataset in JSON, CSV, Excel, XML, or HTML.

### Input example

```json
{
  "profileUrlsOrUsernames": ["zuck", "https://www.threads.com/@instagram"],
  "maxPostsPerProfile": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### Output example

```json
{
  "itemType": "profile",
  "profileUrl": "https://www.threads.com/@zuck",
  "username": "zuck",
  "displayName": "Mark Zuckerberg",
  "bio": "Mostly superintelligence and MMA takes.",
  "followerCount": 5600000,
  "followerCountText": "5.6M Followers",
  "threadCount": 150,
  "threadCountText": "150 Threads",
  "avatarUrl": "https://...",
  "sourceUrl": "https://www.threads.com/@zuck",
  "scrapedAt": "2026-06-27T21:53:47.678Z"
}
```

### Supported profile formats

- `zuck`
- `@zuck`
- `https://www.threads.com/@zuck`
- `https://www.threads.net/@zuck`

### Tips for best results

- Use public profiles only.
- Start with 1-5 profiles while testing your workflow.
- Set `maxPostsPerProfile` to `0` if you only need profile metadata.
- Use stable profile URLs for recurring monitoring.
- Expect Threads to expose different fields for different public pages.

### Limits and caveats

Threads controls what is visible to logged-out visitors. Some pages expose only profile metadata, while others may expose post previews. Private, missing, age-restricted, login-gated, or temporarily blocked profiles may return no rows. Engagement counts and timestamps are saved only when visible in public page data.

### Integrations

Use the actor with:

- Google Sheets exports for profile tracking
- Make or Zapier automations through Apify webhooks
- BI dashboards that ingest Apify datasets
- CRM enrichment workflows for public creator lists
- Scheduled Apify tasks for recurring monitoring

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/threads-profile-posts-scraper').call({
  profileUrlsOrUsernames: ['zuck'],
  maxPostsPerProfile: 5,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/threads-profile-posts-scraper').call(run_input={
    'profileUrlsOrUsernames': ['zuck'],
    'maxPostsPerProfile': 5,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~threads-profile-posts-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"profileUrlsOrUsernames":["zuck"],"maxPostsPerProfile":5}'
```

### MCP usage

Connect Apify MCP to tools that support Model Context Protocol and enable this actor with:

```text
https://mcp.apify.com/?tools=fetch_cat/threads-profile-posts-scraper
```

Claude Code setup:

```bash
claude mcp add apify "https://mcp.apify.com/?tools=fetch_cat/threads-profile-posts-scraper"
```

MCP server JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/threads-profile-posts-scraper"
    }
  }
}
```

Example prompts:

- "Scrape the public Threads profile for @zuck and summarize the bio and follower count."
- "Compare these Threads public profiles and return a table of follower counts."
- "Run the Threads Profile & Posts Scraper weekly and flag large follower changes."

### Scheduling

Create an Apify task with your target usernames and schedule it daily, weekly, or monthly. Scheduled runs are useful for monitoring profile changes over time.

### Proxy configuration

The default input uses direct requests to avoid unnecessary proxy cost. If you experience blocks on larger jobs, enable Apify Proxy in the proxy editor and choose a proxy group available in your account.

### Data quality

The actor normalizes usernames, canonicalizes Threads URLs to `threads.com`, parses abbreviated counts such as `5.6M`, and adds `scrapedAt` timestamps so you can track when the data was collected.

### FAQ

#### Why did a profile produce no rows?

The profile may be private, missing, renamed, temporarily unavailable, or redirected to login. Check the profile in a logged-out browser and verify that it is public.

#### Why are post fields empty?

Threads may not expose post timelines to logged-out visitors for that profile. The actor saves post fields only when public post previews are visible.

#### Why do counts differ from the app?

Threads may round counts in public metadata and may update app counters faster than public web metadata.

### Legality

Only scrape public data you are allowed to access. Respect Threads terms, privacy rights, applicable laws, and reasonable rate limits. Do not use scraped data for spam, harassment, discrimination, or sensitive profiling.

### Related scrapers

Explore related actors and scrapers by fetch\_cat:

- [TikTok Video Scraper](https://apify.com/fetch_cat/tiktok-video-scraper) — collect public TikTok video metadata for social content monitoring.
- [TikTok Comments Scraper](https://apify.com/fetch_cat/tiktok-comments-scraper) — export public TikTok comment threads for engagement analysis.
- [TikTok Ads Library Scraper](https://apify.com/fetch_cat/tiktok-ads-library-scraper) — research public TikTok ad creatives and advertiser activity.
- [Reddit Scraper](https://apify.com/fetch_cat/reddit-scraper) — monitor public Reddit posts and discussions by community or query.
- [Instagram Stories & Highlights Scraper](https://apify.com/fetch_cat/instagram-stories-highlights-scraper) — collect public Instagram story/highlight data when available.

### Support

If you need a field that is publicly visible but not returned, open an issue with a sample public profile URL and the field you expected.

# Actor input Schema

## `profileUrlsOrUsernames` (type: `array`):

Public Threads profiles to scrape. Use full URLs like https://www.threads.com/@zuck or usernames like instagram.

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

Maximum number of public post preview rows to save per profile when post previews are visible in logged-out HTML.

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

Optional proxy configuration. Direct requests work for most public-profile checks; enable Apify Proxy only if your run needs it.

## Actor input object example

```json
{
  "profileUrlsOrUsernames": [
    "zuck",
    "instagram"
  ],
  "maxPostsPerProfile": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `runSummary` (type: `string`):

No description

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

No description

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

No description

## `engagement` (type: `string`):

No description

## `complete` (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 = {
    "profileUrlsOrUsernames": [
        "zuck",
        "instagram"
    ],
    "maxPostsPerProfile": 5,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/threads-profile-posts-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 = {
    "profileUrlsOrUsernames": [
        "zuck",
        "instagram",
    ],
    "maxPostsPerProfile": 5,
    "proxyConfiguration": { "useApifyProxy": False },
}

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

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

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

```

## CLI example

```bash
echo '{
  "profileUrlsOrUsernames": [
    "zuck",
    "instagram"
  ],
  "maxPostsPerProfile": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/threads-profile-posts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/threads-profile-posts-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Threads Profile & Posts Scraper",
        "description": "Export public Threads profile metadata, bios, follower counts, avatars, and visible post previews from usernames or profile URLs.",
        "version": "0.1",
        "x-build-id": "J80sTGzrqItI8N02e"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~threads-profile-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-threads-profile-posts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fetch_cat~threads-profile-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-threads-profile-posts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fetch_cat~threads-profile-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-threads-profile-posts-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "profileUrlsOrUsernames"
                ],
                "properties": {
                    "profileUrlsOrUsernames": {
                        "title": "Profile URLs or usernames",
                        "type": "array",
                        "description": "Public Threads profiles to scrape. Use full URLs like https://www.threads.com/@zuck or usernames like instagram.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPostsPerProfile": {
                        "title": "Maximum posts per profile",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of public post preview rows to save per profile when post previews are visible in logged-out HTML.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy configuration. Direct requests work for most public-profile checks; enable Apify Proxy only if your run needs it.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
