Threads Profile Scraper: Followers, Bio, Posts

Threads Profile Scraper: Followers, Bio, Posts

Scrape Threads profiles (threads.com, Meta's text app) without a login: give usernames or profile URLs, or words to find profiles by, and get one row per profile with the follower count, bio, bio links, verified and private flags, profile picture, profile tags and engagement figures from its recent posts. Ask for more and get the profile's posts, the replies it wrote and the posts it reposted as rows of their own, and the follower and following counts of the Instagram account linked to it. Pay per profile, from $0.49 per 1,000.

Built for influencer and creator research, competitor and brand tracking, audience growth monitoring, lead research on public brand accounts, and AI data sets. Name a memory and every later run adds the follower change since the previous run to each profile and delivers only posts it has not delivered before. Rows carry what Threads shows publicly about a profile; use them under the rules that apply to you.

Quick start

1. Open the Actor and paste Threads handles (zuck, @mosseri) or profile URLs (https://www.threads.com/@nasa, threads.net links work too) into Usernames or profile URLs, up to 1,000 a run. Or give Find profiles by a word (a brand, a topic, a name) and the profiles Threads' account search finds for it are read the same way.
2. Run. You get one profile row per profile. The Console form also asks for 5 posts per profile and the Instagram counts; through the API both are off unless you ask.
3. For posts, replies and reposts set Posts per profile, Replies the profile wrote and Reposts by the profile (each 0 when left out, up to 5,000), with date, likes, media and language filters if you like.
4. For a monitor: give a Memory name and schedule the run. Each run delivers every profile with its fresh counts and followerCountChange, and only the posts, replies and reposts it has not delivered before.

What you get

One profile row per profile found, charged once per run, 27 fields. Fill rates measured over 340 real profiles read on 2026-10-09 (305 authors of 80 Threads search pages over 40 words, plus 36 large accounts); a run of 100 other profiles on the platform the same day gave name 95, bio 64, bio links 38, tags 22, verified 25 and an engagement sample 96 percent:

Field	What it is	Filled
userId, username, url	the numeric Threads user id (as text), the handle and the profile page	100%
followerCount	Threads followers at the time of reading, as a number	100% (95% above 0; median 282)
fullName	the display name	95.9%
biography	the bio as written	63.5%
bioLinks, bioLinkItems	the links in the bio (bioLinkItems adds each link's title)	31.2%
profileTags, profileTagItems	the topic tags on the profile (name and handle)	25.3%
verified, private, threadsBadge	the verified badge, a private profile, the Threads badge	always set; 24.4% verified
profilePic, profilePicHd	the profile picture and its largest version (the URLs expire after some days)	100%
engagement	from the profile's own recent posts on its page, pinned posts left out: postsSampled, averageLikes, averageReplies, averageReposts, averageQuotes, engagementRatePercent (their sum per post as a percent of followers), latestPostAt, oldestSampledPostAt	95.9% of profiles have posts on the page (median 4 posts sampled); the rest have no posts
instagramFollowerCount, instagramFollowingCount, instagramStatsStatus	the follower and following counts of the Instagram account linked to the profile, when you switch Instagram follower and following counts on	95 of 100 profiles of a platform run (the rest not_available)
previousFollowerCount, followerCountChange, previousCheckedAt	with a memory name: the followers at the previous run under that name and the change since	from the second run on
sourceQuery	the search word that found the profile, or null for a username you gave	when searched

With Posts per profile, Replies the profile wrote or Reposts by the profile, post rows (charged once per run, and once per memory name across runs) with code, url, postId, text, language, postedAt, the author fields, likeCount, replyCount, repostCount, quoteCount, mediaType, images, videos, carousel, linkAttachment, isReply, quotedPost and source:

• source: "profile": the profile's own posts, newest first (pinned posts first, as on the profile).
• source: "profile_replies": a reply the profile wrote, with repliedToPost (code, URL, author, text and time of the post it answers; that post is context, not a row, and is never charged).
• source: "profile_reposts": a post the profile reposted, as the original (its author, text and counts) with repostedAt and repostedByUsername.

Free rows next to them: one coverage row per profile (what each tab read, delivered and charged, and why it stopped), one per search word (profilesFound, profilesAdded, the handles), a status row for a handle with no public profile, a private profile, an unusable value or inputs a stopped run did not start, and one summary row with every counter and what was charged.

How deep it goes

Measured logged out on 2026-10-09: 396 profile page calls drew no refusal (10 got no answer, and a call with no answer is tried again on a fresh exit); a profile's posts come 11 a call with a cursor, read until Threads gives no next page, your cap or your date range; the replies and reposts tabs 25 a call (mosseri's replies 15 pages back to 2025-06-11 and still going; his reposts 28, back to 2023-07-04, to the end); a search word finds up to about 100 profiles in one call (95 for "nike", 100 for "coffee"), and Threads gives no further page of them.

How much does it cost to scrape Threads profiles?

Pay per event. Prices per 1,000 events (USD):

Event	Free plan	Bronze	Silver	Gold
Profile (one profile row)	0.60	0.55	0.52	0.49
Post (one post, reply or repost row)	1.10	1.05	1.00	0.99
Actor start (once per run, per GB of memory; runs use 256 MB, so one)	0.006 per run	0.006 per run	0.006 per run	0.006 per run

Platinum and Diamond plans pay the Gold price. There is no discount on the Actor start event. The Instagram counts are included in the Profile price.

The Store pricing card shows these same prices per 1,000 events: "$0.49 / 1,000" on the Profile row means one profile costs 0.049 cents, and "$0.99 / 1,000" on the Post row means one post costs 0.099 cents.

Worked examples on the Free plan: one profile costs 0.006 + 0.0006 = $0.0066; 100 profiles cost 0.006 + 0.06 = $0.066; 10 profiles with 50 posts each cost 0.006 + 0.006 + 500 x 0.0011 = $0.562; a daily monitor of 100 profiles with no new posts costs $0.066 a run.

Free: a handle with no public profile, a profile that could not be read, a search word, filtered rows, a row already delivered in the run, posts a named memory knows, the post a reply answers, the coverage, status and summary rows, and every row of a run that cannot bill safely (a memory that could not be read or saved, a run the platform restarted).

The work allowance

Work that may end without a charge (handles with no profile, a search word that finds nobody, pages of posts that all fail your filters or that the memory already knows) is bounded per run: 40 seconds of such unpaid work, plus 8 seconds for each charged profile and 6 seconds for each charged post. When it is spent the run stops, says so in the summary (stoppedBy: "work_allowance") and lists the inputs it did not start in a free status row. Calls that deliver charged rows never use it up.

Input

Field	Type	What it does
usernames	list	Threads handles (zuck, @zuck) or profile URLs (threads.com or threads.net), up to 1,000 a run. Capitals do not matter.
searchProfiles	list	Words or names to find profiles by (up to 20 a run); each word is one free search, and every profile it finds is read like a username.
maxProfilesPerSearch	integer	Profiles read per search word, in Threads' order (default 10, up to 100).
includeInstagramStats	boolean	Add the linked Instagram account's follower and following counts (one small extra call per profile, same price). Off by default.
maxPostsPerProfile	integer	The profile's own posts as rows, newest first (default 0, up to 5,000).
maxRepliesPerProfile	integer	Replies the profile wrote, newest first, each with the post it answers (default 0, up to 5,000).
maxRepostsPerProfile	integer	Posts the profile reposted, newest first (default 0, up to 5,000).
postedAfter, postedBefore	text	Keep posts, replies and reposts in a date range (UTC; a repost by the time it was reposted): YYYY-MM-DD, YYYY-MM-DDTHH:MM, today, yesterday, 7 days, 6 hours. A tab stops at its first page older than postedAfter. The profile row is always delivered.
minLikes, onlyWithMedia, excludeReplies	integer, boolean, boolean	Keep rows with at least this many likes, rows with media, or leave out replies inside the Posts tab.
languages, dropUnknownLanguage	list, boolean	Keep rows in these languages (en, es, ja); rows with no detected language are kept unless dropUnknownLanguage is on.
maxItems	integer	A cap of post, reply and repost rows for the whole run (profile rows are not counted; no cap when left out).
memoryName, resetMemory	text, boolean	A named memory this Actor keeps in your account: the follower change on each profile row, and posts, replies and reposts charged once across runs. Each run reads every tab you asked for again, newest first, to its cap, your date range or its end; rows the memory knows are free and the rows it has not delivered before are charged. Re-reading known rows is unpaid work within the work allowance, so keep the caps or a date range ("7 days") to what a monitor needs.
proxyConfiguration	object	Apify datacenter proxy. Threads answers it fully, so a residential or other Apify proxy group is not used (the run says so in its summary); your own proxy URLs are used as given.

API examples

curl -X POST "https://api.apify.com/v2/acts/automation_craft~threads-profile-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"usernames": ["zuck", "mosseri", "nasa"], "includeInstagramStats": true}'

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation_craft/threads-profile-scraper').call({
    usernames: ['nasa'],
    maxPostsPerProfile: 50,
    maxRepliesPerProfile: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.find((x) => x.type === 'profile').followerCount, 'followers');

from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation_craft/threads-profile-scraper").call(run_input={
    "searchProfiles": ["coffee roaster"],
    "maxProfilesPerSearch": 30,
    "memoryName": "coffee accounts",
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item["type"] == "profile":
        print(item["username"], item["followerCount"], item["followerCountChange"])

What this Actor does NOT do

• It does not read followers or following lists: they need a logged in Threads session, and this Actor reads only what Threads shows a visitor who is not logged in. It never logs in and never asks for your cookies or a Threads account.
• It does not give view counts on a profile's posts: Threads shows a view count on a post's own page only, and reading a page per post would cost more than a post row earns.
• It does not pull emails or phone numbers out of a bio: the bio is delivered as written.
• It does not read the posts, replies or reposts of a private profile: Threads closes them to a logged out visitor; the profile row (counts, bio) is delivered and marked private.
• It cannot tell a handle that never existed from a renamed one or an Instagram account that never joined Threads: Threads answers all three the same way, and the free status row says so.
• It does not search posts by keyword or hashtag, or read the replies under a post: the Threads Search Scraper and the Threads Replies Scraper of Automation Craft do (linked below).
• It does not use residential proxies: Threads answers the Apify datacenter pool, and a residential group in the input is replaced by it (the summary says so).

FAQ

How do I scrape a Threads profile without logging in?

Paste the handle or the profile URL into usernames and run. The profile row comes from the public profile page, which Threads shows to anyone; this Actor never logs in, never asks for cookies and uses no Threads account.

How can I see how many followers a Threads account has?

Every profile row carries followerCount as a number, read at the time of the run. With a memory name, later runs add previousFollowerCount and followerCountChange, so a scheduled run tracks follower growth.

Can I scrape all posts from a Threads profile?

Set maxPostsPerProfile (up to 5,000): the posts come newest first, 11 a call, until the profile's first post, your cap or your date range. The replies the profile wrote and the posts it reposted come the same way with maxRepliesPerProfile and maxRepostsPerProfile.

Can I find Threads accounts by keyword?

Yes: give words in searchProfiles. Each word is one free search of Threads' accounts, and up to maxProfilesPerSearch profiles it finds (100 at most, in Threads' order) are read and charged like usernames, with the word in sourceQuery.

Why does this Actor run with limited permissions?

Least privilege: it only needs its own storages and the named memory store it creates itself, so it asks for nothing else in your account.

More data tools by Automation Craft

• Threads Scraper: Posts, Search, Tags, Replies
• Threads Search Scraper: Keywords, Hashtags, Dates
• Threads Replies Scraper: Comments of Any Post
• TikTok Profile Scraper: Exact Stats, No Login
• Telegram Channel Scraper: Posts, Views, Dates
• Substack Scraper: Posts, Notes and Profiles

Changelog

• 0.1 (2026-10-09): first release. Threads profiles by username or by search word without a login: followers, bio, links, tags, verified, private, engagement from recent posts, the linked Instagram counts as an option, the profile's posts, replies and reposts as rows, filters, a cross run memory with the follower change, free rows for misses.