🧵 Threads User Following Scraper

🧵 Threads User Following Scraper

The 🧵 Threads User Following Scraper is a focused Apify actor that extracts a Threads profile’s following list via native GraphQL — turning usernames or profile URLs into a structured table of accounts they follow. It solves the tedious and error-prone task of collecting followings by automating token extraction (app id, CSRF, user id, doc id from JS bundles) and paginated requests to Threads’ BarcelonaFriendshipsFollowingTabRefetchableQuery. Built for marketers, developers, data analysts, and researchers, this Threads user following scraper scales from quick samples to full lists with CSV/JSON exports for downstream analysis and reporting.

What data / output can you get?

Below are real output fields the actor saves to the Apify dataset (one item per followed account). You can export to CSV or JSON from the dataset.

Data type	Description	Example value
source	Static marker for the record source	"threads_following"
id	Unique Threads/Instagram entity ID	"1234567890123456789"
pk	Profile key (string form of user ID)	"9876543210"
username	Handle of the followed account	"exampleuser"
full_name	Display name	"Example User"
profile_pic_url	Avatar URL	"https://static.cdninstagram.com/.../avatar.jpg"
is_verified	Verification badge flag	true
text_post_app_is_private	Account privacy flag for Threads	false
has_onboarded_to_text_post_app	Threads onboarding flag	true
follower_count	Follower count of the followed account	24567
following_index	1-based index in the collected list	1
__typename	GraphQL typename	"User"

Note: Two additional metadata fields are also included in each item:

• friendship_status (object; provided as-is from the API)
• profile_context_facepile_users (array; provided as-is from the API)

Exports: Download your results from the Apify dataset as CSV or JSON for analysis, sharing, or to import into tools like Google Sheets.

Key features

• ⚙️ Native Threads GraphQL flow Uses the BarcelonaFriendshipsFollowingTabRefetchableQuery with proper tokens (app id, CSRF, user id, doc id) extracted from the profile HTML and JS bundles for robust, accurate results.

• 🌐 Smart connection escalation Starts direct, escalates to Apify datacenter proxy on blocks (401/403/429 or bad/empty payloads), then to residential proxy if still blocked. On residential, each GraphQL batch retries up to 3 times with a fresh proxy URL.

• 📥 Structured following list extractor Collects usernames, names, avatars, verification flags, follower counts, and more — ideal as a Threads following list extractor with clean, structured output.

• 📦 Bulk-ready input Paste a list of Threads profile URLs or plain usernames. The actor parses both formats, enabling batch runs for multi-profile workflows.

• 🎚️ Flexible limits per profile Control depth with maxFollowing to gather quick samples or full lists — perfect for fast iteration and scaled runs.

• 🚀 Streaming results to dataset Items are pushed as they’re collected, so you can monitor progress live and export anytime as CSV or JSON.

• 🧩 Developer-friendly Runs on the Apify platform with programmatic access via the Apify API and SDK. Ideal for building a Threads followings scraper pipeline or integrating into existing data flows.

• 🛡️ Production-minded reliability Async HTTP with tuned timeouts, paginated fetching, and intelligent retries help maintain stability during large or noisy runs.

How to use 🧵 Threads User Following Scraper - step by step

1. Sign in to Apify Create or log in to your Apify account to run the actor in the cloud.

2. Open the actor Find “🧵 Threads User Following Scraper” in your dashboard or Apify Store.

3. Add input profiles In the urls field, paste Threads profile URLs like https://www.threads.com/@username or plain usernames (one per line or as a list).

4. Provide your session cookie Paste your Threads/Instagram sessionid into sessionId. Runs are tied to your logged-in session so only accounts you’re allowed to see are collected.

5. Set limits Adjust maxFollowing to control how many followings to collect per profile.

6. (Optional) Configure proxy Leave proxyConfiguration off for normal runs; enable it if you already use Apify Proxy and want extra flexibility.

7. Start the run Click Start. The actor extracts tokens, queries the following list via GraphQL, and streams results to the dataset. If the platform is picky, it will escalate the connection automatically.

8. Export your data Go to the dataset in the run’s Output tab and export as CSV or JSON. You can import the CSV into Google Sheets for quick analysis.

Pro Tip: Use the Apify API to pull the dataset into your data pipeline or CRM, or schedule runs for recurring updates.

Use cases

Use case name	Description
Influencer discovery & vetting	Map who a creator follows to understand niche focus, collab networks, and verification/follower signals. Export to CSV for fast filtering.
Competitor benchmarking	Compare followings of peer brands to reveal partnerships, interests, and category trends. Track over time to spot shifts.
Social audience insights	Analyze followings to define audience affinities and segments, informing content and partnership strategy.
Campaign research	Compile followings lists for potential outreach, then sort by follower_count or verification for prioritization.
Data enrichment for CRM	Append structured followings data to profiles in your CRM with a repeatable export/import workflow.
Academic & social graph research	Build datasets of who-follows-whom for network analysis, using JSON exports for reproducible studies.
Developer API pipeline	Orchestrate bulk collection via the Apify API and stream results into analytics or BI stacks.

Why choose 🧵 Threads User Following Scraper?

A precision-built Threads following list scraper that blends accuracy, scale, and resilience for production workflows.

• 🎯 Accurate, token-aware extraction Pulls app id, CSRF, user id, and doc id from live HTML/JS bundles for reliable GraphQL requests.

• 🔄 Robust anti-block strategy Direct → datacenter → residential proxy escalation with retries helps maintain continuity under rate limits or transient blocks.

• 📊 Structured, analysis-ready fields Captures usernames, names, avatars, follower counts, and verification flags for immediate segmentation.

• 🧪 Built for batch workflows Paste many usernames or profile URLs and cap depth per profile with maxFollowing.

• 🧑‍💻 Developer access Retrieve results programmatically from the Apify dataset API to power automations and data products.

• 🛡️ Stable alternative to extensions Avoid brittle browser extensions and manual copy-paste with a cloud-native, scriptable actor.

• 💾 Flexible exports Export CSV/JSON from the dataset for BI tools, spreadsheets, and pipelines.

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

Yes—when used responsibly. This actor relies on your own session and collects data you’re permitted to access, in line with platform terms and applicable laws.

Guidelines:

• Only collect data you’re authorized to view with your account.
• Comply with Meta/Threads terms of service and local data regulations (e.g., GDPR, CCPA).
• Handle your session cookie securely; do not share it publicly.
• Use the data responsibly for research, analysis, and insights, not for abuse.

You are responsible for ensuring your use case complies with Threads policies and your local regulations.

Input parameters & output format

Example JSON input

{
  "urls": [
    "zuck",
    "https://www.threads.com/@exampleuser"
  ],
  "sessionId": "YOUR_SESSIONID_COOKIE_VALUE",
  "maxFollowing": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

Parameter reference

• urls (array)
  • Description: Paste Threads profile links or usernames — one per line or add many at once. Examples: https://www.threads.com/@username or simply username. Bulk-friendly for big lists!
  • Required: Yes
  • Default: —
• sessionId (string)
  • Description: Paste your sessionid from the browser where you’re logged into Threads/Instagram. This keeps the run tied to your account — it isn’t stored or shared beyond this run. Don’t share this value publicly.
  • Required: Yes
  • Default: ""
• maxFollowing (integer)
  • Description: Cap how many following rows to collect per profile — great for quick samples or full lists. Lower = faster & lighter; higher = more complete picture.
  • Required: No
  • Default: 50 (min 1, max 10000)
• proxyConfiguration (object)
  • Description: Totally optional. Leave off for a normal run from Apify’s cloud. Turn on if you already use Apify Proxy and want extra flexibility — helpful when routes get noisy.
  • Required: No
  • Default: { "useApifyProxy": false }

Example JSON output

[
  {
    "source": "threads_following",
    "id": "1234567890123456789",
    "pk": "9876543210",
    "username": "exampleuser",
    "full_name": "Example User",
    "profile_pic_url": "https://static.cdninstagram.com/images/avatars/example.jpg",
    "is_verified": true,
    "text_post_app_is_private": false,
    "has_onboarded_to_text_post_app": true,
    "follower_count": 24567,
    "following_index": 1,
    "friendship_status": null,
    "profile_context_facepile_users": [],
    "__typename": "User"
  },
  {
    "source": "threads_following",
    "id": "223344556677889900",
    "pk": "1122334455",
    "username": "anotheruser",
    "full_name": "Another User",
    "profile_pic_url": "https://static.cdninstagram.com/images/avatars/another.jpg",
    "is_verified": false,
    "text_post_app_is_private": false,
    "has_onboarded_to_text_post_app": true,
    "follower_count": 708,
    "following_index": 2,
    "friendship_status": null,
    "profile_context_facepile_users": [],
    "__typename": "User"
  }
]

Notes:

• friendship_status and profile_context_facepile_users are passed through as provided by the API and may vary by profile.
• Export your dataset as CSV or JSON directly from the run’s Output tab.

FAQ

Do I need to log in or provide cookies?

✅ Yes. You must provide your sessionId (the sessionid cookie from a logged-in Threads/Instagram browser session). The actor ties the run to your account and only collects followings you’re allowed to see.

Does this scrape followers or following?

👣 It scrapes who a user follows (their following list). If you’re searching for a Threads followers scraper or a Threads followers scraper API, note this tool focuses on followings.

Can I enter usernames or profile URLs?

✅ Both. You can paste https://www.threads.com/@username links or just the bare username. The actor parses either format automatically.

How many results can I collect per profile?

📈 Controlled by maxFollowing. Set any value between 1 and 10,000 per profile. Results stream to the dataset as they’re collected.

How does it handle blocks or rate limits?

🛡️ The actor starts without a proxy, escalates to Apify datacenter proxy on blocks (401/403/429, empty/challenge HTML, or bad GraphQL), and then to residential proxy if needed. On residential, each GraphQL batch retries up to 3 times with a fresh proxy URL.

What fields are included in the output?

📊 Each item includes source, id, pk, username, full_name, profile_pic_url, is_verified, text_post_app_is_private, has_onboarded_to_text_post_app, follower_count, following_index, friendship_status, profile_context_facepile_users, and __typename.

Can I export to CSV or Google Sheets?

✅ Yes. Export the dataset as CSV or JSON. You can import the CSV into Google Sheets for quick sharing and filtering.

Is there an API to access the results?

💻 Yes. As with all Apify actors, you can retrieve the run’s dataset via the Apify API to integrate this Threads following list scraper into your pipelines.

Does it support bulk scraping?

🚀 Yes. Add multiple usernames or profile URLs in the urls field to run in batch. The tool is designed for bulk-friendly workflows.

Any tips for better accuracy?

🔧 Use a valid, fresh sessionId from a browser currently logged into Threads/Instagram, start with smaller maxFollowing for testing, and enable proxyConfiguration if you encounter repeated blocks.

Closing CTA / Final thoughts

The 🧵 Threads User Following Scraper is built to turn Threads profiles into clean, structured following lists at scale. With native GraphQL extraction, smart connection handling, and CSV/JSON exports, it’s ideal for marketers, developers, data analysts, and researchers who need reliable followings data fast. Use it in batches, export to spreadsheets, or fetch via the Apify API to power automated workflows. Start extracting smarter social insights today.