# Meta Threads Profile Posts Scraper (`khadinakbar/meta-threads-profile-posts-scraper`) Actor

Scrape Threads profile posts: text, media URLs, likes, replies, reposts, quotes, and timestamps. Bulk usernames, HTTP-only, no login required. MCP-ready.

- **URL**: https://apify.com/khadinakbar/meta-threads-profile-posts-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, Lead generation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 profile metadata scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Meta Threads Profile Posts Scraper

Extract posts from any public Meta Threads profile — text, media, engagement metrics, and author metadata. HTTP-only, no login required. Bulk usernames supported. MCP-ready for AI agents.

### What it does

Input one or more Threads usernames (or profile URLs) and get back structured JSON records for each post:

- Full post text
- Like, reply, repost, and quote counts
- Media URLs (images and videos)
- Post timestamp (ISO 8601)
- Canonical post URL
- Author name, follower count, verified status

Optionally include one profile metadata record per username (bio, external URL, profile picture URL, follower count).

### When to use this actor

- **Content analytics** — audit a competitor's or creator's last N posts on Threads.
- **Influencer research** — pull engagement rates across multiple profiles at once.
- **Brand monitoring** — track what an account is posting over time.
- **Social media reporting** — bulk-export posts to CSV, Google Sheets, or a dashboard.
- **AI agents / Claude / ChatGPT** — call this as an MCP tool to retrieve Threads posts as structured data during a research task.

**Do NOT use** for keyword or hashtag search — use a search-focused Threads actor for that.

### Output data

| Field | Type | Description |
|---|---|---|
| type | string | "post" or "profile" |
| username | string | Threads username |
| postId | string | Unique post ID |
| postUrl | string | Canonical URL |
| text | string | Post text (null for media-only) |
| publishedAt | ISO 8601 | Post timestamp UTC |
| likeCount | integer | Total likes |
| replyCount | integer | Total direct replies |
| repostCount | integer | Total reposts |
| quoteCount | integer | Total quote-posts |
| mediaUrls | string[] | Image/video CDN URLs |
| isRepost | boolean | True if this is a repost |
| authorFullName | string | Display name |
| authorIsVerified | boolean | Verified badge |
| authorFollowerCount | integer | Follower count at scrape time |
| bio | string | Profile bio (type=profile only) |
| externalUrl | string | Bio link URL (type=profile only) |
| profilePicUrl | string | Profile picture URL (type=profile only) |
| scrapedAt | ISO 8601 | Scrape timestamp UTC |

### Pricing

- **$0.00005** per run start (per GB RAM)
- **$0.005** per post scraped
- **$0.003** per profile metadata record (when `includeProfileInfo` is true)

Typical cost: 1 username × 30 posts = **~$0.15**

Pay-Per-Usage (compute + proxy passthrough) also enabled for large-scale runs.

### Usage

#### Basic — scrape last 30 posts from one profile

```json
{
  "usernames": ["zuck"],
  "maxPostsPerProfile": 30
}
````

#### Bulk profiles + no profile metadata

```json
{
  "usernames": ["zuck", "natgeo", "nasa"],
  "maxPostsPerProfile": 50,
  "includeProfileInfo": false
}
```

#### With custom proxy

```json
{
  "usernames": ["someusername"],
  "maxPostsPerProfile": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

#### API

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

#### JavaScript / Node.js

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('khadinakbar/meta-threads-profile-posts-scraper').call({
  usernames: ['zuck', 'natgeo'],
  maxPostsPerProfile: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_TOKEN')

run = client.actor('khadinakbar/meta-threads-profile-posts-scraper').call(run_input={
    'usernames': ['zuck', 'natgeo'],
    'maxPostsPerProfile': 50,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### How it works

1. Loads each Threads profile page via HTTP GET (no headless browser).
2. Parses all embedded `<script data-sjs>` JSON blobs from the SSR response.
3. Extracts user metadata and thread\_items arrays using a schema-agnostic deep-finder — resilient to Threads layout changes.
4. For requests exceeding the SSR batch (~24 posts), paginates via Threads' internal GraphQL endpoint using `LSD` and `fb_dtsg` tokens extracted from the initial page.
5. Pushes each post as a flat JSON record; emits a PPE charge event per post.

### FAQ

**Does it need a Threads account or login?**
No. Only works on public profiles.

**What's the max posts per profile?**
Up to 500. The SSR batch typically includes ~24 posts; additional posts are fetched via GraphQL pagination.

**What happens if a profile is private or doesn't exist?**
The run continues to the next username. A warning is logged. No charge for profiles that return no data.

**Will it break when Threads updates its layout?**
The parser uses key-name traversal rather than fixed JSON paths. Minor layout changes are automatically handled. Major structural changes (rare) may require an actor update.

**Can I use my own proxy?**
Yes — set `proxyConfiguration.useApifyProxy: false` and provide `proxyUrls`.

**Does it scrape replies or hashtag feeds?**
No. This actor focuses on profile posts. For replies or search, use a dedicated actor.

### Legal disclaimer

This actor scrapes **publicly accessible** data from Meta Threads in the same way a web browser would. It does not bypass authentication, access private content, or circumvent paywalls. Users are responsible for ensuring their usage complies with Meta's Terms of Service and applicable laws in their jurisdiction. Web scraping of publicly available data is generally permitted for legitimate research, analytics, and competitive intelligence purposes under most jurisdictions, but this varies by location. Apify and the actor developer assume no liability for misuse.

# Actor input Schema

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

List of Threads usernames (e.g. 'zuck') or full profile URLs (e.g. 'https://www.threads.com/@zuck'). Accepts both formats interchangeably. Defaults to a demo list if empty. NOT for keyword or hashtag search — use a search-focused actor for that.

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

Maximum number of posts to scrape per username. Accepts 1–500. Defaults to 30. Scraper stops early if the profile has fewer posts than this limit. NOT a guarantee — profiles with restricted visibility may return fewer results.

## `includeProfileInfo` (type: `boolean`):

When true, emits one extra record per username with profile metadata: full name, bio, follower count, following count, is\_verified, profile pic URL, external URL. Adds $0.003 charge per profile. When false, only post records are emitted. Defaults to true.

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

Proxy settings for requests. Defaults to Apify residential proxies for best reliability. Use NONE only for lightweight testing — Meta rate-limits datacenter IPs aggressively. NOT needed for most runs: leave as default unless supplying your own proxy.

## Actor input object example

```json
{
  "usernames": [
    "zuck",
    "natgeo"
  ],
  "maxPostsPerProfile": 50,
  "includeProfileInfo": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "usernames": [
        "zuck"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/meta-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 = { "usernames": ["zuck"] }

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/meta-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 '{
  "usernames": [
    "zuck"
  ]
}' |
apify call khadinakbar/meta-threads-profile-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Meta Threads Profile Posts Scraper",
        "description": "Scrape Threads profile posts: text, media URLs, likes, replies, reposts, quotes, and timestamps. Bulk usernames, HTTP-only, no login required. MCP-ready.",
        "version": "1.0",
        "x-build-id": "aYYyjRpsJBgqROSLt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~meta-threads-profile-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-meta-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/khadinakbar~meta-threads-profile-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-meta-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/khadinakbar~meta-threads-profile-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-meta-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": [
                    "usernames"
                ],
                "properties": {
                    "usernames": {
                        "title": "Usernames or profile URLs",
                        "type": "array",
                        "description": "List of Threads usernames (e.g. 'zuck') or full profile URLs (e.g. 'https://www.threads.com/@zuck'). Accepts both formats interchangeably. Defaults to a demo list if empty. NOT for keyword or hashtag search — use a search-focused actor for that.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPostsPerProfile": {
                        "title": "Max posts per profile",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of posts to scrape per username. Accepts 1–500. Defaults to 30. Scraper stops early if the profile has fewer posts than this limit. NOT a guarantee — profiles with restricted visibility may return fewer results.",
                        "default": 30
                    },
                    "includeProfileInfo": {
                        "title": "Include profile metadata",
                        "type": "boolean",
                        "description": "When true, emits one extra record per username with profile metadata: full name, bio, follower count, following count, is_verified, profile pic URL, external URL. Adds $0.003 charge per profile. When false, only post records are emitted. Defaults to true.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings for requests. Defaults to Apify residential proxies for best reliability. Use NONE only for lightweight testing — Meta rate-limits datacenter IPs aggressively. NOT needed for most runs: leave as default unless supplying your own proxy.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```