Meta Threads Profile Posts Scraper

Meta Threads Profile Posts Scraper is an Apify Actor for public Threads profile collection through Apify and Apify MCP. It accepts one or more Threads usernames or full profile URLs and returns one dataset record per scraped item. Post records capture text, media URLs, likes, replies, reposts, quotes, timestamps, canonical post URLs, author display names, verification status, and author follower counts. When profile metadata is enabled, the Actor also emits one profile record per username with bio, external URL, profile picture URL, and follower count at scrape time.

Best fit and connected workflows

This Actor fits workflows centered on public profile-level Threads collection:

• Content analytics for a defined set of Threads profiles.
• Engagement review across recent posts from one or more usernames.
• Creator, brand, and account research where post rows and profile metadata belong in the same dataset.
• AI agent research tasks that need structured Threads data through Apify MCP.
• Exports into spreadsheets, databases, dashboards, or enrichment pipelines.

Meta Threads Profile Posts Scraper is designed as a focused standalone workflow.

Practical scenario

A social media analyst starts with three public Threads profile URLs for a campaign review. They set maxPostsPerProfile to 50 and leave includeProfileInfo enabled. The dataset returns post records with postUrl, text, publishedAt, likeCount, replyCount, repostCount, quoteCount, and mediaUrls, plus profile records with authorFullName, authorFollowerCount, bio, externalUrl, and profilePicUrl. The analyst compares the engagement fields across the profiles and opens the profile links to continue the content audit.

Input fields

Field	Type	Description
usernames	array of string	Threads usernames such as zuck or full profile URLs such as https://www.threads.com/@zuck. Accepts both formats interchangeably. Defaults to a demo list if empty. This field is for profile inputs rather than keyword or hashtag search.
maxPostsPerProfile	integer	Maximum number of posts to scrape per username. Accepts 1-500. Defaults to 30. The scraper stops early when a profile has fewer posts than this limit.
includeProfileInfo	boolean	When true, emits one extra record per username with profile metadata: full name, bio, follower count, following count, is_verified, profile pic URL, and external URL. Defaults to true. Adds a separate charged event per profile metadata record.
proxyConfiguration	object	Proxy settings for requests. Defaults to Apify residential proxies for reliability. Use the default unless you supply your own proxy setup.

Focused JSON input example

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

Output fields

Field	Type	Description
type	string	Record type: post or profile
username	string	Threads username without @
postId	string or null	Unique Threads post ID for post records
postUrl	string or null	Full canonical URL of the post
text	string or null	Full post text content
publishedAt	ISO 8601 UTC or null	Post timestamp
likeCount	integer or null	Total likes on the post
replyCount	integer or null	Total direct replies
repostCount	integer or null	Total reposts or re-shares
quoteCount	integer or null	Total quote-posts referencing the post
mediaUrls	array of string	Image or video CDN URLs attached to the post
isRepost	boolean	True when the record represents reposted content
authorFullName	string or null	Display name of the post author
authorIsVerified	boolean	True when the author has a Meta verified badge
authorFollowerCount	integer or null	Author follower count at the time of scrape
bio	string or null	Profile bio text for profile records
externalUrl	string or null	External URL from the profile bio for profile records
profilePicUrl	string or null	Profile picture CDN URL for profile records
scrapedAt	ISO 8601 UTC	Timestamp when the record was scraped

Illustrative JSON output record

{
  "type": "post",
  "username": "zuck",
  "postId": "1234567890",
  "postUrl": "https://www.threads.com/@zuck/post/1234567890",
  "text": "Example post text",
  "publishedAt": "2026-06-11T12:34:56Z",
  "likeCount": 1200,
  "replyCount": 34,
  "repostCount": 18,
  "quoteCount": 5,
  "mediaUrls": ["https://cdn.example.com/image.jpg"],
  "isRepost": false,
  "authorFullName": "Mark Zuckerberg",
  "authorIsVerified": true,
  "authorFollowerCount": 1000000,
  "scrapedAt": "2026-06-11T12:35:10Z"
}

How it works

This Actor uses HTTP-only collection against public Threads profile pages, so it runs without login. It parses embedded SSR JSON from the profile response, extracts profile and post data, and uses cursor pagination for profiles with more posts than the initial batch. Each post pushed to the dataset creates a post-scraped charged event. When includeProfileInfo is true, the Actor also emits one profile-scraped charged event per username.

The dataset contains two record types:

• post records for individual Threads posts.
• profile records for profile metadata when enabled.

Pricing

Meta Threads Profile Posts Scraper uses Pay per event pricing on the Apify platform, plus standard Apify platform usage.

Charged events:

• post-scraped for each Threads post pushed to the dataset.
• profile-scraped once per username when includeProfileInfo is true.
• apify-actor-start when the Actor starts, based on the selected memory allocation.

For the current live values, open the Pricing tab in the Apify Console.

A simple planning example: one username with thirty posts and profile metadata enabled produces one profile event, thirty post events, and one Actor start event, plus Apify platform usage.

Use with AI agents (MCP)

This Actor is available as an Apify Actor tool through Apify MCP. It accepts usernames or profile URLs, returns structured dataset rows, and gives agents a clean way to retrieve Threads profile posts with counts, timestamps, media URLs, and profile metadata.

Actor identity: khadinakbar/meta-threads-profile-posts-scraper

Tool description:

• Input: one or more Threads usernames or profile URLs.
• Output: dataset rows for posts, plus profile metadata rows when enabled.
• Scope: public profile posts and optional profile metadata.
• Provenance: every row comes from the Actor dataset and includes scrapedAt for collection time.
• Pagination: maxPostsPerProfile controls the per-profile post ceiling, up to the schema maximum.
• Cost guidance: event usage scales with scraped posts, profile metadata records, and the Actor start event.

Collect the public Threads profiles zuck and natgeo, return the last 20 posts per profile, include profile metadata, and summarize the engagement fields from the dataset.

Output interpretation:

• Use type to separate post rows from profile rows.
• Use postUrl as the canonical post link.
• Use mediaUrls for attached media references.
• Use authorFollowerCount, likeCount, replyCount, repostCount, and quoteCount for structured analysis.
• Use scrapedAt to identify when a record was collected.

JavaScript example with APIFY_TOKEN and dataset readback

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

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

const datasetItems = await client.dataset(run.defaultDatasetId).listItems();
console.log(datasetItems.items);

Best results and outcome guidance

Use usernames or full profile URLs that point to public Threads profiles. Set maxPostsPerProfile to match the depth you want for a review or report. Keep includeProfileInfo enabled when you want post rows and profile metadata in the same dataset. Use the default residential proxy configuration unless you supply your own proxy setup. When you want a smaller run, focus the input on the usernames that matter for the current task.

Focused standalone workflow

Meta Threads Profile Posts Scraper is designed as a focused standalone workflow for the public input and structured output contract described above.

Design note

I found that the dataset schema has two record types, post and profile, while the shared required fields stay the same: type, username, and scrapedAt.

FAQ

Can I pass usernames and profile URLs together?
Yes. The usernames field accepts both formats in the same run.

Which field should I use for the canonical Threads post link?
Use postUrl.

How do I tell whether a row is a post record or a profile record?
Check type. Post rows use post, and profile metadata rows use profile.

Can this Actor be used in an AI workflow?
Yes. It is MCP-ready and usable as an Apify Actor through Apify MCP.

What controls how many post rows are returned per username?
maxPostsPerProfile sets the per-profile ceiling, within the schema range.

How does includeProfileInfo change the dataset?
When enabled, the Actor adds one profile metadata record per username alongside the post records.

Responsible use

This Actor collects publicly accessible Threads profile data through HTTP requests. Use it in ways that fit your organization, local law, and the platform terms that apply to your use case. Review the live Pricing tab before running larger collections, especially when increasing the number of usernames or the per-profile post limit.