🧵✨ Threads User Followers Scraper

🧵✨ Threads User Followers Scraper

🧵✨ Threads User Followers Scraper is an Apify actor that turns Threads profile links or @usernames into structured follower lists — fast. It solves the “export followers without an official API” problem by combining profile HTML parsing with JS bundle doc_id discovery and web GraphQL, making it a dependable Threads followers scraper and Meta Threads followers extractor for scale. Built for creators, marketers, developers, data analysts, and researchers, it helps you automate influencer research, audience analysis, lead generation, and competitor tracking — all in a single run.

What data / output can you get?

Data field	Description	Example value
username	The follower’s Threads handle	"baselad21"
full_name	Display name from the profile	"Bassel Kaddour"
user_id	Threads user ID (stringified)	"73956966771"
pk	Primary key (stringified)	"73956966771"
profile_url	Canonical profile URL	"https://www.threads.net/@baselad21"
is_verified	Verification badge flag	false
is_private	Whether the Threads profile is private	false
follower_count	Follower count for the profile	1
profile_pic_url	Avatar image URL	"https://..."
following	Whether the target account follows this user	false
followed_by	Whether this user follows the target account	false
outgoing_request	Whether there’s an outgoing follow request	false

Notes:

• Each dataset item includes additional metadata for completeness: source, target_username, has_onboarded_to_text_post_app, and __typename.
• Export your dataset to CSV, JSON, or Excel from the Apify platform for analysis or CRM import.

Key features

• 🚀 Bulk profile input
  Paste multiple Threads profile URLs or @usernames to run large exports in one go — perfect for Threads user followers list export and Threads profile followers export.

• 🔐 Session-based access (required)
  Uses your session cookie (sessionId) to fetch the same public data you can see while logged in. No passwords, just a cookie value — a practical Threads followers API alternative.

• 🌐 Smart proxy ladder with sticky residential
  Starts direct, then falls back to Apify datacenter, then residential (up to 3 attempts). When residential succeeds, it sticks to residential for the rest of the run for maximum stability — ideal for scraping Threads followers without API friction.

• 📡 Web GraphQL + JS token strategy
  Automatically extracts app_id, csrf token, user_id, and doc_id from profile HTML and JS bundles, then fetches followers in batched queries for reliable, repeatable results.

• ⏱️ Rate-limited batching and dedupe
  Batches of 50 followers per request with ~0.35s pacing, stopping after 10 consecutive rounds with no new unique followers. Built-in deduplication ensures clean, unique rows.

• 📤 Live dataset streaming
  Each follower record is pushed to the Dataset as soon as it’s discovered for real-time monitoring and incremental Threads followers CSV export.

• 🧰 Developer-friendly on Apify
  Run via the Apify UI or programmatically through Apify’s API/SDK. Easy to plug into downstream automations for Threads follower crawler bot workflows.

• ⚙️ Configurable proxy options
  Provide proxyConfiguration if you need custom networking; otherwise, the defaults are optimized for stability.

How to use 🧵✨ Threads User Followers Scraper — step by step

1. Sign in to Apify and open the 🧵✨ Threads User Followers Scraper actor.

2. Collect your session cookie. In your browser, open cookie settings for Instagram or Threads, find sessionid, and copy its value.

3. Add profiles in urls. You can paste:

   • @usernames (e.g., @zuck)
   • Full profile URLs (e.g., https://www.threads.com/@creator or https://www.threads.net/@creator) Mix and match as needed.

4. Paste your sessionId into the “Your logged-in session (required)” field. Keep it secret.

5. Set maxFollowers to control how many unique followers to collect per profile. Use samples for speed or higher numbers for deeper exports.

6. (Optional) Configure proxyConfiguration if you need custom proxy behavior. Otherwise, leave it to defaults — the actor will automatically apply a proxy ladder when needed.

7. Run the actor. You’ll see rows appear in the Dataset in real time as the Threads user followers data scraper fetches results.

8. Download your results from the run’s Dataset in CSV, JSON, or Excel for analysis or workflows.

Pro Tip: Running locally? Set APIFY_TOKEN in your environment so proxy fallbacks can authenticate smoothly, then execute via apify run or python -m src with an INPUT.json for testing.

Use cases

Use case	Description
Influencer research & discovery	Identify and analyze who follows key creators to refine outreach and partnership strategies.
Competitor followers scraping	Export competitor follower lists to benchmark audiences and spot high-intent segments.
Audience analysis & segmentation	Build structured datasets for clustering by follower_count, verified status, and privacy flags.
Lead generation & enrichment	Enrich CRM records with Threads profile URLs and usernames from target audiences.
Academic & market research	Collect public follower graphs to study networks, communities, and trends at scale.
Developer pipelines (API/SDK)	Automate a Threads follower crawler bot workflow by fetching datasets via the Apify API for ETL and analytics.

Why choose 🧵✨ Threads User Followers Scraper?

This Instagram Threads followers scraping tool is engineered for precision, stability, and automation at scale.

• 🎯 Accurate token handling: Extracts app_id, csrf token, user_id, and doc_id from HTML/JS for robust GraphQL queries.
• 📈 Built for scale: Batch requests (50 at a time), with ~0.35s pacing and early-stop logic to optimize throughput.
• 🔄 Resilient networking: Auto-switches from direct to datacenter to residential proxies and stays on residential if it works best.
• 💾 Real-time dataset output: See results as they’re collected and export to CSV/JSON/Excel for quick wins.
• 👨‍💻 API/SDK friendly: Runs on Apify infrastructure and integrates easily into your data pipelines.
• 🔐 Privacy-first session model: Uses your sessionId cookie; you only access what your account can see.
• 💰 Cost control: Tune maxFollowers per profile to manage volume and spend.

In short, it’s a reliable Threads followers lookup tool designed to outperform fragile, manual approaches.

Is it legal / ethical to use 🧵✨ Threads User Followers Scraper?

Yes — when used responsibly. This actor collects public account data accessible to your logged-in session. You’re responsible for ensuring your use complies with Threads/Meta terms and applicable laws.

Guidelines:

• Only scrape data you’re allowed to access with your account.
• Avoid collecting sensitive or non-public information.
• Respect platform rate limits and usage policies.
• Align with data protection laws (e.g., GDPR, CCPA) in your jurisdiction.
• Consult your legal team for edge cases or regulated uses.

Input parameters & output format

Example input

{
  "urls": ["@zuck", "https://www.threads.net/@creator"],
  "sessionId": "YOUR_SESSIONID_COOKIE_VALUE",
  "maxFollowers": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}

Parameters

• urls (array, required)
  Description: Paste Threads links or plain usernames — one per line is fine. Examples: @zuck · https://www.threads.com/@creator · mix & match as you like.
  Default: none (required)

• sessionId (string, required)
  Description: Your logged-in session cookie value sessionid from Instagram or Threads. Keep it secret; treat it like a password. With a valid session, you’ll only see data your account is allowed to view.
  Default: ""

• maxFollowers (integer, optional)
  Description: Set a cap on how many follower rows to collect for each profile. Useful for sampling or deep exports; reasonable limits keep runs smooth.
  Default: 20
  Range: 1–100000

• proxyConfiguration (object, optional)
  Description: Network options (optional). Leave defaults if unsure; Apify proxy settings help keep things stable from the cloud. Power users can tweak as needed.
  Default: { "useApifyProxy": true }

Example output item

{
  "source": "threads",
  "target_username": "zuck",
  "user_id": "73956966771",
  "pk": "73956966771",
  "username": "baselad21",
  "full_name": "Bassel Kaddour",
  "is_verified": false,
  "is_private": false,
  "profile_pic_url": "https://...",
  "follower_count": 1,
  "following": false,
  "followed_by": false,
  "outgoing_request": false,
  "has_onboarded_to_text_post_app": true,
  "__typename": "XDTUserDict",
  "profile_url": "https://www.threads.net/@baselad21"
}

Notes:

• Field defaults: When a value is missing, strings may be "", booleans default to false, and numbers default to 0 as per node_to_record logic.
• The actor deduplicates records by pk/user_id or @username, and pushes each unique follower row as it’s discovered.

FAQ

Do I need to log in or provide credentials?

✅ Yes. You must provide a sessionId cookie value (sessionid) from Instagram or Threads. The actor never asks for your password and only uses your session to access data your account can see.

What profiles can it scrape?

✅ It supports @usernames and profile URLs from both threads.com and threads.net. The input parser accepts plain handles like @zuck or full links like https://www.threads.net/@creator.

How many followers can I export per profile?

📈 Controlled by maxFollowers. The actor batches 50 followers per request, paces ~0.35s between rounds, and stops after 10 consecutive rounds with no new unique followers.

Does it use an official API?

❌ No. It’s a Threads followers API alternative. It extracts required tokens from profile HTML/JS (including doc_id) and then uses web GraphQL to fetch followers — a reliable way to scrape Threads followers without API access.

Will it work without proxies?

🔄 It tries direct connections first. If that fails, it falls back to Apify datacenter proxies and then residential proxies (up to 3 attempts). Once residential works, it sticks to it for the rest of the run for stability.

Can it scrape private accounts?

⚠️ Only if your session has permission to see them. The actor uses your sessionId cookie and respects whatever access your logged-in account has.

What data fields are included in the output?

🧾 You’ll get username, full_name, user_id, pk, profile_url, is_verified, is_private, follower_count, profile_pic_url, and friendship flags (following, followed_by, outgoing_request), plus metadata like source, target_username, has_onboarded_to_text_post_app, and __typename.

How do I export the results?

💾 Download from the run’s Dataset in your preferred format (CSV, JSON, or Excel) for Threads followers CSV export and downstream automation.

Final thoughts

🧵✨ Threads User Followers Scraper is built to export clean, structured follower lists from public Threads profiles at scale. With session-based access, a resilient proxy ladder, GraphQL batching, and live dataset streaming, it’s ideal for marketers, researchers, developers, and analysts. Configure urls, sessionId, and maxFollowers, then integrate the Dataset via the Apify API to automate your Threads followers scraping tool workflows. Start extracting smarter audience insights and power your outreach, enrichment, and analytics with dependable follower data.