🧵✨ Threads user followers scraper

🧵✨ Threads user followers scraper

The 🧵✨ Threads user followers scraper is a production-ready Apify actor that extracts structured follower lists from Threads profiles in bulk using GraphQL with HTML token discovery. It solves the tedious task of collecting audience data by turning profile URLs or @usernames into clean records — ideal for audience mapping, competitor research, and influencer outreach. Marketers, developers, data analysts, and researchers can use this Threads followers scraper to download Threads followers lists, export CSV/JSON, schedule runs, and integrate via API at scale.

What data / output can you get?

Below are the exact fields this Threads followers exporter tool saves to the Dataset. You can export results as CSV or JSON, or access them via the Apify API.

Data type	Description	Example value
source	Data source indicator	"threads"
target_username	Username of the profile whose followers are being collected	"zuck"
user_id	Follower’s Threads user ID	"73956966771"
pk	Follower primary key (same as user_id in most cases)	"73956966771"
username	Follower’s handle	"baselad21"
full_name	Follower’s display name	"Bassel Kaddour"
is_verified	Whether the follower is verified	false
is_private	Whether the follower’s Threads app is private	false
profile_pic_url	URL to follower’s profile picture	"https://..."
follower_count	Number of followers that user has	1
following	Friendship flag from the session’s perspective	false
followed_by	Friendship flag from the session’s perspective	false
outgoing_request	Whether there’s an outgoing follow request	false
has_onboarded_to_text_post_app	Threads onboarding flag	true
__typename	Backend type identifier	"XDTUserDict"
profile_url	Normalized Threads profile URL	"https://www.threads.net/@baselad21"

Note: Some fields may be empty strings, false, or 0 if not provided by Threads. Export the dataset to CSV or JSON for analysis, CRM uploads, or reporting.

Key features

• 🔁 Resilient proxy ladder Starts direct (no proxy), then automatically tries Apify datacenter proxy, then residential (up to 3 attempts). Once residential succeeds, it sticks to residential for the rest of the run for stability. Ideal for reliable Meta Threads followers scraping at scale.

• 🔐 Session-based accuracy Requires a valid sessionid cookie (input sessionId). This approach mirrors what you can access while logged in, enabling accurate follower retrieval with friendship flags like following and followed_by.

• 📦 Bulk input, live streaming output Feed multiple profile URLs or @usernames and process them in one run. Each follower is pushed to the Dataset as soon as it’s discovered — perfect for a bulk Threads followers scraper and real-time pipelines.

• ⚙️ GraphQL-driven, deduped records Uses GraphQL with HTML/JS token extraction (app_id, doc_id, CSRF). Requests are paced (~0.35s between rounds) with batches of first=50 and stop after 10 consecutive rounds with no new unique followers, ensuring stable, clean datasets.

• 🧰 Developer-friendly API Integrate results via the Apify API or use this Threads followers API programmatically. Works great in Python-based automation and data workflows.

• 💾 Flexible exports Download Threads followers list as CSV or JSON from the Dataset. Use it for analysis, enrichment, and reporting.

• 🧱 Production-ready infrastructure Built on Apify’s platform with smart retry logic, proxy management, and dataset storage — more reliable than a Threads followers scraper Chrome extension or ad-hoc scripts.

How to use 🧵✨ Threads user followers scraper - step by step

1. Create or log in to your Apify account.
2. Open the actor and prepare your input.
   • Paste @usernames or profile URLs into urls (one per line is fine).
   • Obtain your sessionId cookie value from your browser (Instagram or Threads), then paste it into sessionId.
3. Set maxFollowers per profile as needed (the input form default is 20; if omitted entirely in code, the run caps at 200).
4. (Optional) Configure proxyConfiguration if you need custom proxy behavior; otherwise, leave defaults.
5. Start the run.
   • The actor resolves tokens from the profile page (app_id, doc_id, CSRF), then fetches followers in GraphQL batches of 50 with ~0.35s delays.
   • It deduplicates by user pk/user_id and stops after 10 consecutive rounds with no new unique followers.
   • Rows stream into the Dataset as they’re collected.
6. Download your results.
   • Go to the Dataset tab and export to CSV or JSON, or fetch via the API.
7. Pro Tip: Schedule runs and wire the Dataset API into your workflows for a no-code Threads followers scraper pipeline (e.g., automate weekly refreshes and downstream processing).

Use cases

Use case	Description
Audience mapping for creators	Build a clean follower roster to understand who follows key profiles; export CSV for segmentation and targeting.
Competitor research for marketers	Compare follower bases across rivals using a Threads profile followers scraper and track changes over time.
Influencer outreach lists	Use this Threads followers exporter tool to collect verified flags, follower counts, and profile URLs for qualified outreach.
Data enrichment via API	Pipe followers into internal systems using the Apify API from this Threads followers API workflow.
Academic & social research	Analyze network patterns and public signals (verified/private, follower counts) at scale.
Bulk list builds	Run multiple profiles at once with a bulk Threads followers scraper for campaign planning or CRM enrichment.

Why choose 🧵✨ Threads user followers scraper?

This Meta Threads followers scraper focuses on precision, stability, and automation for production workflows.

• 🎯 Accurate, structured output using GraphQL tokens and HTML/JS parsing
• 📈 Built for scale with bulk inputs and streaming datasets
• 💻 Developer access via Apify API; a great fit for Threads followers scraper Python workflows
• 🔐 Session-based design respects visibility you already have while logged in
• 🌐 Smart network strategy with a proxy ladder and sticky residential fallback
• 💾 Easy exports to CSV/JSON for ops, analytics, and reporting
• 🧱 More robust and consistent than browser-based extensions or unstable one-off scripts

In short: a reliable Threads followers scraper that’s automation-ready and designed for real-world data pipelines.

Is it legal / ethical to use 🧵✨ Threads user followers scraper?

Yes — when done responsibly. This actor requires your session cookie and accesses only what your account can see while logged in.

Guidelines to follow:

• Only collect data you are allowed to access and process.
• Review and respect Threads/Meta terms of service.
• Ensure compliance with data protection regulations (e.g., GDPR, CCPA) and your organization’s policies.
• Avoid misuse (e.g., spam); use results for legitimate research, enrichment, or analysis.
• Consult your legal team for edge cases or sensitive use.

Input parameters & output format

Example JSON input

{
  "urls": [
    "https://www.threads.com/@zuck",
    "@creator_handle"
  ],
  "sessionId": "YOUR_SESSIONID_COOKIE_VALUE",
  "maxFollowers": 200,
  "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! Running a big list? Go ahead — that’s what this field is for.
  • Default: none
• sessionId (string, required)
  • Description: This tells Threads you’re you — same as when you browse the app yourself. Open your browser’s cookie settings for Instagram or Threads, find sessionid, and paste the value here. Keep it secret — treat it like a password. With a valid session, you only get data your account is allowed to see.
  • Default: ""
• maxFollowers (integer, optional)
  • Description: Set a cap on how many follower rows to collect for each profile in your list. Handy when you only need a sample — or crank it up for a deeper export. Friendly to servers: reasonable limits keep runs smooth for everyone.
  • Default: 20
• proxyConfiguration (object, optional)
  • Description: Totally optional — leave the defaults if you’re not sure. When you need extra stability reaching Threads from the cloud, Apify’s proxy settings can help keep things running smoothly. Power users: tweak here; everyone else can skip.
  • Default: none (prefill uses { "useApifyProxy": true })

Example JSON output

{
  "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:

• Fields may be empty/false/0 if not present in the source.
• Use the Dataset tab to download Threads followers export CSV or JSON, or fetch via the API.

FAQ

Do I need to log in or provide cookies?

✅ Yes. You must provide the sessionid cookie as sessionId. The actor uses your session to access what you can see while logged in.

Can I download the Threads followers list as CSV or JSON?

✅ Yes. Results are saved to the run’s Dataset. You can export as CSV or JSON, or access them programmatically via the Apify API.

Does this capture follower IDs?

✅ Yes. Each record includes user_id and pk, making it suitable as a Threads follower IDs scraper.

How many followers can it collect per profile?

⚙️ Controlled by maxFollowers. Internally, requests pull batches of 50 with ~0.35s delays and stop after 10 consecutive rounds with no new unique followers.

Can I run it for multiple profiles at once?

✅ Yes. Add multiple @usernames or profile URLs to urls. It’s a bulk Threads followers scraper designed for batch jobs.

Is there an API for integration?

✅ Yes. You can consume the Dataset via the Apify API and schedule runs, enabling a Threads followers API workflow for automation.

Is this a Chrome extension?

❌ No. This is a server-side Apify actor. It’s more reliable than a Threads followers scraper Chrome extension and better suited for automation.

Can I use the output with Google Sheets?

✅ Yes. Export CSV from the Dataset and import into Google Sheets, or connect via your own workflow. This provides a no-code Threads followers scraper path to Sheets.

What happens if Threads blocks direct access?

🔁 The actor uses a proxy ladder: direct → Apify datacenter → Apify residential (up to 3 attempts), then sticks to residential once it succeeds for stable throughput.

What data does it not collect?

🔒 It doesn’t bypass account visibility. Fields come from public endpoints and your session’s allowed view; some properties may be empty if not provided by Threads.

Closing CTA / Final thoughts

The 🧵✨ Threads user followers scraper is built to extract accurate, structured follower data from Threads profiles at scale. With bulk inputs, resilient networking, streaming datasets, and CSV/JSON exports, it’s ideal for marketers, developers, data analysts, and researchers. Use the Apify API for automation-ready pipelines or embed it into Threads followers scraper Python workflows. Start exporting smarter follower lists and power your audience insights, enrichment, and outreach with reliability.