🧵 Threads User Following Scraper

🧵 Threads User Following Scraper

The 🧵 Threads User Following Scraper extracts the accounts a Threads profile follows and streams structured data to your Apify dataset in real time. It solves the tedious task of manually collecting “following” lists by automating token extraction and GraphQL pagination — ideal for influencer research, audience mapping, lead generation, and competitor analysis. Marketers, developers, data analysts, and researchers can use this Threads user following scraper to build a reliable Meta Threads social graph scraper pipeline that scales.

What data / output can you get?

Below are the exact fields pushed to the dataset for each followed account. Values are taken from the GraphQL response and preserved as-is for accuracy.

Data field	Description	Example value
username	Handle of the followed account	"zuck"
full_name	Display name	"Mark Zuckerberg"
id	Global node ID	"1234567890123456789"
pk	Numeric user ID	"1234567890"
profile_pic_url	Avatar image URL	"https://example.cdninstagram.com/…/avatar.jpg"
is_verified	Verified badge flag	true
follower_count	Number of followers	58234567
friendship_status	Follow/interaction flags object	{"following": true, "is_bestie": false}
profile_context_facepile_users	Context users array (if present)	[{"username":"user1"}, {"username":"user2"}]
following_index	1-based position in the list for this run	42
text_post_app_is_private	Account privacy on Threads	false
source	Constant identifier for this extractor	"threads_following"

Note: Some fields may be null or omitted when not provided by Threads for a given node. Results are available in your Apify Dataset (Output tab) for quick download and further processing, making this a practical Threads following list extractor and Instagram Threads user following export tool.

Key features

• 🔬 Bold accuracy via GraphQL flow
  Uses the same BarcelonaFriendshipsFollowingTabRefetchableQuery with tokens extracted from profile HTML/JS bundles for precise, stable data — a Meta Threads following scraper you can trust.

• 🔄 Smart connection fallback
  Starts direct, escalates to datacenter proxy on 401/403/429 or bad/empty responses, then switches to residential with sticky mode and per-batch retries (up to 3). Keeps runs moving when routes get noisy.

• 📦 Real-time streaming to Apify Dataset
  Each row is pushed immediately as it’s discovered, so you see results live in the output table — perfect for monitoring and fast feedback loops.

• 📑 Pagination handled for you
  Collects results in PAGE_CHUNKs of 50 with robust cursor handling until your configured cap is reached. Ideal for Threads user following list export workflows.

• 🎯 Precise limits per profile
  Control depth with maxFollowing to sample or capture full lists at scale.

• 🔗 Flexible input parsing
  Accepts profile URLs like https://www.threads.com/@username or plain usernames. Great for bulk queues in a Threads account following scraper tool.

• ⚙️ Developer-friendly internals
  Built on aiohttp with async concurrency and explicit headers/CSRF/app id/doc id handling. Easy to incorporate into a Threads user following API scraper pipeline.

• 🧠 Production-ready resilience
  Timeout strategies, retry logic on residential, and structured logging throughout — designed for reliability on real datasets.

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

1. Sign in to Apify and open the actor
2. Add input “urls” — paste Threads profile links (https://www.threads.com/@username) or just usernames, one per line
3. Provide your “sessionId” — the sessionid cookie from a logged-in Threads/Instagram browser session
4. (Optional) Set “maxFollowing” to cap how many people to collect per profile
5. (Optional) Configure “proxyConfiguration” if you already use Apify Proxy; otherwise the scraper will start direct and escalate automatically only when needed
6. Click Start — the run opens each profile, extracts tokens, and loads following via GraphQL
7. Watch results stream into the Dataset’s live table in the Output tab
8. Download your dataset from the Output tab for analysis and enrichment in your workflows (e.g., use it as a Threads following list CSV export source from the Apify UI)

Pro tip: Chain this Meta Threads social graph scraper with your enrichment pipeline or CRM via the Apify platform API to automate end-to-end audience research.

Use cases

Use case	Description
Influencer discovery & vetting	Build curated lists of who top creators follow to identify niche tastemakers and partners.
Audience mapping for campaigns	Map social graphs to spot clusters and overlaps for better targeting and creative strategy.
Lead generation & outreach	Export following lists to feed prospecting or ambassador programs with verified handles and names.
Competitor analysis	Track who competitors follow to uncover suppliers, partners, or marketing playbooks.
Academic & social research	Collect structured following data for network analysis and trend studies.
API-driven pipelines	Integrate the dataset into automated data flows for enrichment, scoring, and reporting.

Why choose 🧵 Threads User Following Scraper?

The scraper is built for precision, resilience, and scale — a focused Threads following list extractor that works reliably in production.

• 🎯 GraphQL-first precision for clean, consistent records
• 🔐 Requires your session so you only collect data you’re allowed to see
• 🔄 Smart proxy escalation (direct → datacenter → residential with retries) for tough routes
• 🚀 Bulk-friendly input and streaming output for fast iteration
• 🧩 Developer-ready: async architecture, explicit token handling, and structured logs
• 🛡️ Sensible defaults with clear controls (maxFollowing, optional proxyConfiguration)
• 🧷 More reliable than ad hoc scripts or browser extensions under changing site conditions

In short, it’s a production-grade Meta Threads following scraper that balances accuracy with operational reliability.

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

Yes — when used responsibly. This tool automates requests a logged-in user can make, and requires your own session cookie. You should:

• Only collect data in line with Meta/Threads terms and applicable laws
• Respect privacy and avoid misuse of personal data
• Use your own session and do not share credentials publicly
• Consult your legal team if you have questions about specific use cases

The actor does not bypass authentication or access private profiles you cannot view with your session.

Input parameters & output format

Example JSON input

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

• urls (array, required)
  Description: Paste Threads profile links or usernames — one per line or add many at once. Examples: https://www.threads.com/@username or simply username.
  Default: none

• sessionId (string, required)
  Description: Paste your sessionid from the browser where you’re logged into Threads/Instagram. This keeps the run tied to your account. Don’t share this value publicly.
  Default: ""

• maxFollowing (integer, optional)
  Description: Cap how many following rows to collect per profile. Lower = faster & lighter; higher = more complete picture.
  Default: 50
  Min: 1, Max: 10000

• proxyConfiguration (object, optional)
  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.
  Default prefill: { "useApifyProxy": false }

Example JSON output

[
  {
    "source": "threads_following",
    "id": "1234567890123456789",
    "pk": "1234567890",
    "username": "sample_user",
    "full_name": "Sample User",
    "profile_pic_url": "https://static.cdninstagram.com/…/avatar.jpg",
    "is_verified": true,
    "text_post_app_is_private": false,
    "has_onboarded_to_text_post_app": true,
    "follower_count": 24500,
    "following_index": 1,
    "friendship_status": {
      "following": true,
      "is_bestie": false
    },
    "profile_context_facepile_users": [
      { "username": "friend_one" },
      { "username": "friend_two" }
    ],
    "__typename": "User"
  },
  {
    "source": "threads_following",
    "id": "9876543210987654321",
    "pk": "9876543210",
    "username": "another_user",
    "full_name": "Another User",
    "profile_pic_url": "https://static.cdninstagram.com/…/avatar2.jpg",
    "is_verified": false,
    "text_post_app_is_private": false,
    "has_onboarded_to_text_post_app": true,
    "follower_count": 1020,
    "following_index": 2,
    "friendship_status": null,
    "profile_context_facepile_users": null,
    "__typename": "User"
  }
]

Notes:

• Fields may be null or omitted depending on what Threads returns for each node.
• Records are pushed as they are discovered, enabling incremental processing for Threads user following list export workflows.

FAQ

Do I need to be logged in to use this scraper?

Yes. You must provide your own sessionId (sessionid cookie) from a logged-in Threads/Instagram browser session. The actor uses your session to access only what your account can see.

How many profiles and rows can I scrape per run?

You can add multiple usernames/URLs to urls. Use maxFollowing to cap how many followed accounts to collect per profile. The input schema supports values from 1 up to 10,000 per profile.

What input formats are supported for profiles?

Both https://www.threads.com/@username links and plain usernames are accepted. The actor automatically parses and normalizes them.

What happens if the site blocks or throttles requests?

The actor starts without a proxy. On blocks (HTTP 401/403/429, empty/challenge HTML, or bad GraphQL), it escalates to Apify datacenter proxy; if needed, it switches to residential and retries each GraphQL batch up to 3 times, staying on residential for the rest of the run.

Which data fields are included in the output?

Each dataset item includes fields such as username, full_name, id, pk, profile_pic_url, is_verified, follower_count, friendship_status, following_index, text_post_app_is_private, profile_context_facepile_users, source, and __typename.

Can I export the results for analysis?

Yes. Results stream into your Apify Dataset in the Output tab, from where you can download and use them in your workflows (e.g., as a Threads following list CSV export source from the Apify UI).

Is this a Threads user following API scraper I can integrate with?

The actor pushes structured JSON via Actor.push_data to your Apify Dataset, making it straightforward to consume via the Apify platform and integrate into pipelines for export Threads followers and following workflows.

Does it scrape private or hidden data?

No. It requires your session and only loads data your account can access. Always use the tool in line with Meta/Threads terms and applicable laws.

Final thoughts

The 🧵 Threads User Following Scraper is built to extract accurate, structured following lists from Threads profiles at scale. With GraphQL-based precision, smart proxy fallback, and streaming dataset output, it’s a reliable Meta Threads following scraper for marketers, researchers, and developers alike. Add profile URLs or usernames, set maxFollowing, and let the actor handle token extraction, pagination, and connectivity. Developers can easily plug the dataset into automation pipelines for repeatable Instagram Threads user following export. Start mapping your audience and competitors’ social graphs with confidence today.