Threads Followers Scraper (Common Followers Finder)

Threads Followers Scraper — Extract Followers & Audience Overlap

Threads Followers Scraper (Common Followers Finder) collects follower lists for one or more Threads profiles and returns typed JSON: one row per unique follower, tagged with recordType, overlapCount, and overlapTargets, plus a single overlap-summary row with the full audience-overlap breakdown for the run. Unlike scraping frameworks that return raw HTML you have to parse yourself, every field arrives as a ready-to-use JSON value — no DOM parsing, no CSS selectors to maintain. Where a plain follower export stops, this Actor keeps going: it buffers followers across every profile in your list and computes exactly how many of your targets each person follows. This guide documents every input, every output field, and three ways teams run it in production.

🧭 What Does Threads Followers Scraper (Common Followers Finder) Do?

Threads Followers Scraper (Common Followers Finder) is an Apify Actor that pulls the follower list of one or more Threads profiles and, when you supply more than one profile, cross-references those lists to find the accounts that follow multiple targets — audience overlap. It authenticates with a Threads/Instagram session cookie you provide (sessionId), not a username/password login, and requires that cookie to run at all: the Actor logs an error and exits without collecting any data if sessionId is empty (src/main.py).

How overlap is computed (exact method): for each profile in urls, the Actor collects up to maxFollowers unique followers, deduplicated by pk (falling back to user_id, then @username). Every follower record from every profile is then merged into one in-memory index keyed by that same dedupe key — so a person following two of your target profiles is stored once, not twice, with the first-seen base record preserved and the list of matching targets appended. For each unique follower, overlapCount is the number of distinct target profiles that person was found under (equivalent to counting how many of the N per-profile follower sets that key belongs to), and overlapTargets lists which target usernames matched. Only followers whose overlapCount is greater than or equal to minOverlap are pushed as follower rows — so minOverlap: 2 returns the union of all pairwise intersections between your targets' sampled follower sets, and minOverlap set to the number of targets returns the full intersection of all sampled sets. Because each per-profile set is a sample bounded by maxFollowers, not necessarily every follower the profile has, this overlap is computed over the sampled space — raise maxFollowers for a more complete picture on large accounts.

Key capabilities:

• 📝 Accepts a bulk list of profiles (urls) — plain @usernames or full threads.com/threads.net links, mixed freely
• 🎚️ Caps how many followers are sampled per profile (maxFollowers, 1–100,000)
• 🔗 Computes cross-profile audience overlap and filters output with minOverlap (1–1,000)
• 🧮 Emits exactly one overlap-summary row per run with the full distribution breakdown
• 🌐 Falls back through Apify's datacenter and residential proxy pools when the direct connection fails to resolve valid tokens
• 🔑 Requires a logged-in Threads session cookie (sessionId) — there is no username/password login flow

Features & Capabilities

Threads Followers Scraper's capabilities split into follower collection, cross-profile overlap analysis, and network resilience.

Core features

• Deduplicated follower rows keyed by pk (falls back to user_id, then @username) — no duplicate people even across paginated GraphQL responses
• Full base follower record on every row, read straight from Threads' own GraphQL schema: source, target_username, user_id, pk, username, full_name, is_verified, is_private, profile_pic_url, follower_count, following, followed_by, outgoing_request, has_onboarded_to_text_post_app, __typename, profile_url
• Overlap fields added on top of every follower row: recordType ("follower"), overlapCount, overlapTargets
• One overlap_summary row per run: targets, numTargets, totalUniqueFollowers, minOverlapApplied, pushedFollowerRows, perTargetFollowerCount, overlapDistribution, sharedByAtLeast
• Bulk profile input — any number of profiles in urls, processed in a single run
• Proxy ladder: a direct attempt first, then an Apify datacenter proxy (proxy group BUYPROXIES94952), then up to three residential proxy attempts (proxy group RESIDENTIAL); once a residential proxy resolves valid tokens the run stays on residential ("sticky") for the remaining profiles
• Pagination stop condition: for each profile, collection stops as soon as either maxFollowers unique followers are collected, or 10 consecutive pagination rounds return no new unique follower — whichever happens first. On accounts with far more followers than maxFollowers can reach through repeated pagination, this means the actual per-profile sample can land below maxFollowers.

How Threads Followers Scraper compares to other Threads follower scrapers

Feature	Threads Followers Scraper (Common Followers Finder)	igview-owner/threads-user-followers-scraper	apibox/threads-user-followers-scraper
Cross-profile audience overlap	Yes — built-in minOverlap filter plus an overlap-summary row	Not documented (checked 2026-07-26)	Not documented (checked 2026-07-26)
Bulk profile input in one run	Yes — urls accepts a list	Not documented — the Quick Start example takes one username (checked 2026-07-26)	Not documented — the input example takes one username (checked 2026-07-26)
Login/session required	Yes — sessionId session cookie	No — listing states the actor "doesn't require any login credentials" (checked 2026-07-26)	Not documented
Follower cap per profile	Up to 100,000 (maxFollowers)	Up to 1,000 per run, per the listing's FAQ (checked 2026-07-26)	Not documented
Pricing model	Pay per event (row_result)	Pay per event, per Apify Store snapshot (2026-07-08)	Flat price per month, per Apify Store snapshot (2026-07-08)

If your use case is feeding structured data to an LLM or a lead-scoring pipeline, the overlap row is the decision-maker — neither competitor listing documents a way to find people who follow more than one target account without downloading each follower list separately and diffing them yourself outside the Actor.

When another tool might suit you better

If you only need a single profile's public follower list and don't want to supply a session cookie, apibox's or igview-owner's Threads follower scrapers are a lower-friction starting point — both accept just a username with no login step, per their Store listings (checked 2026-07-26). Likewise, if Threads posts, replies, or reposts matter more to you than followers, makework36/threads-scraper or this account's own Threads User Posts Scraper With Creator Contact Leads cover that entity type — this Actor returns follower and overlap data only, never post content.

Threads Followers Scraper within the Scrapio data stack

Threads Followers Scraper (Common Followers Finder) covers Threads followers and audience overlap. For Threads post content and creator outreach details, use Threads User Posts Scraper With Creator Contact Leads. For the equivalent overlap-style analysis on Instagram, Scrapio's Instagram Lookalike Audience Builder and Instagram Competitor Network Mapper build comparable audience-graph views for that platform.

Why do developers and data teams scrape Threads followers?

Growth, partnerships, and influencer marketing teams

A common workflow: set urls to your own brand's Threads handle plus a shortlist of competitor or complementary-brand handles, and set minOverlap: 2. The output is every follower who follows two or more of those handles, each tagged with overlapTargets so you know exactly which accounts they already follow. Growth and partnerships teams use that shared-audience list to prioritize influencer outreach or co-marketing proposals toward people already primed by more than one adjacent brand, instead of cold-outreaching an entire follower list one account at a time.

AI training data and RAG indexing

username and full_name are the highest-signal identity fields this Actor returns, and overlapCount/overlapTargets are the fields worth indexing for audience-graph use cases. Two uses: (1) RAG enrichment — index overlapTargets and overlapCount alongside a CRM or lead record so an agent answering "does this lead already follow our competitors on Threads" has a structured field to query instead of raw text; (2) training data — the fixed, typed schema (booleans for is_verified/is_private, integers for follower_count and overlapCount) gives a consistent structure across every row, which raw HTML scraping does not. This Actor does not return post text or a bio field, so it suits identity resolution and audience-graph tasks better than prose-based NLP training.

Competitive and market intelligence

Run the same urls list (your brand plus named competitors) on a recurring schedule and track follower_count and the sharedByAtLeast counts in the overlap-summary row over time. A rising sharedByAtLeast["2"] value is the metric to watch for a shared audience that's growing between you and a competitor — useful for spotting when a rival's audience is increasingly also following you, or vice versa.

Research and academic use

Social-network researchers building datasets on cross-account audience overlap can use minOverlap and the overlapDistribution breakdown directly, without post-processing several separate follower exports by hand. Scope is limited to accounts visible through your own authenticated Threads session — this Actor does not access anything a logged-in Threads user couldn't already view themselves, which keeps research reproducible but public-data-only.

Product and SaaS development

Teams building an audience-overlap or lookalike-audience feature on top of Threads data can use this Actor as the collection layer — calling it through the Apify API, reading overlapCount/overlapTargets per run, and layering their own scoring or visualization on top, rather than reimplementing Threads' GraphQL token discovery and pagination logic from scratch.

🍚 Input Parameters

Every parameter below is read directly from .actor/actor.json, in schema order.

Parameter	Required	Type	Description	Example value
urls	Yes	array (string list)	Threads profile links or plain usernames, one per line. Paste @handles or full threads.com/threads.net URLs, mixed freely.	["zuck", "https://www.threads.com/@creator"]
sessionId	Yes	string (default "")	Your Threads/Instagram sessionid cookie value, pasted as plain text. Required — the run exits immediately with no output if this is empty.	"589xxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
maxFollowers	No	integer (min 1, max 100000, default 20)	Maximum unique followers collected per profile in urls — the overlap sample size.	40
minOverlap	No	integer (min 1, max 1000, default 1)	Only followers who follow at least this many of your target profiles are kept as follower rows. 1 (default) keeps everyone — the same result as a plain follower export. 2 or higher returns your shared audience.	2
proxyConfiguration	No	object (proxy editor)	Optional Apify Proxy configuration. Defaults to {"useApifyProxy": true}.	{"useApifyProxy": true}

A note on maxFollowers: the Apify Console always pre-fills the schema default of 20 for a new run. Internally, src/main.py falls back to 200 only if the field arrives empty or 0 (e.g. a run triggered programmatically without setting it) — worth knowing if you're calling this Actor from your own code rather than the Console.

JSON input example:

{
  "urls": ["zuck", "mosseri"],
  "sessionId": "YOUR_THREADS_SESSIONID_COOKIE",
  "maxFollowers": 40,
  "minOverlap": 2,
  "proxyConfiguration": { "useApifyProxy": true }
}

Supported URL types and input formats

urls accepts, per entry:

• A plain handle: zuck or @zuck
• A full profile URL: https://www.threads.com/@creator or https://www.threads.net/@creator — the Actor extracts the segment after @ up to the next / or ?
• Duplicate targets (case-insensitive) are removed automatically before the run starts

Two real examples:

• ["zuck", "mosseri"] — two plain handles
• ["https://www.threads.com/@zuck", "@mosseri", "creator_handle"] — mixed formats in one list, deduplicated automatically

⚠️ Your session cookie is not masked in the input form

The sessionId field is defined with "editor": "textfield" in .actor/actor.json and carries no isSecret flag. That means the Apify Console renders it as a plain visible text box, not a masked password field — unlike a typical secret input. Anyone who can see your screen, a shared Console session, or an exported run's input configuration can read the raw cookie value in plain text. Treat it exactly like a password: don't paste it into shared runs, screenshots, or logged integrations, and log out and back in to rotate the Threads/Instagram session afterward if you ever shared the input with anyone.

📦 Output Format

Every run pushes typed, normalized JSON to the default dataset — no HTML, no framework wrapper objects. Two record shapes appear in the same dataset, distinguished by recordType. Export the dataset as JSON, CSV, Excel (XLSX), or XML directly from the Apify Console, or pull it programmatically through the Apify API or apify-client.

Output for follower records (recordType: "follower")

{
  "recordType": "follower",
  "overlapCount": 2,
  "overlapTargets": ["zuck", "mosseri"],
  "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://scontent.cdninstagram.com/v/t51.2885-19/example.jpg",
  "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"
}

target_username records the primary (first-seen) target this follower was matched under; overlapTargets lists every target they follow, in the order first seen.

Output for the overlap-summary record (recordType: "overlap_summary")

Exactly one of these is pushed at the end of every run. Base follower-record fields are included as null so every dataset item shares one schema:

{
  "source": "threads",
  "target_username": null,
  "user_id": null,
  "pk": null,
  "username": null,
  "full_name": null,
  "is_verified": null,
  "is_private": null,
  "profile_pic_url": null,
  "follower_count": null,
  "following": null,
  "followed_by": null,
  "outgoing_request": null,
  "has_onboarded_to_text_post_app": null,
  "__typename": null,
  "profile_url": null,
  "recordType": "overlap_summary",
  "targets": ["zuck", "mosseri"],
  "numTargets": 2,
  "totalUniqueFollowers": 73,
  "minOverlapApplied": 2,
  "pushedFollowerRows": 7,
  "perTargetFollowerCount": { "zuck": 40, "mosseri": 40 },
  "overlapDistribution": { "1": 66, "2": 7 },
  "sharedByAtLeast": { "2": 7 }
}

• overlapDistribution[k] — the number of followers who follow exactly k targets
• sharedByAtLeast[k] — the number of followers who follow k or more targets (computed for every k from 2 up to numTargets)
• perTargetFollowerCount — how many followers were actually collected for each target's own sample (bounded by maxFollowers), regardless of minOverlap

Billing note: every dataset row — including the single overlap-summary row — is pushed with charged_event_name="row_result", so it counts as one billed row_result event. There is no separate uncharged accounting row in this Actor's output; a profile the Actor couldn't resolve simply contributes zero follower rows and is not charged for that profile, but it still appears in the summary row's targets list and perTargetFollowerCount (with a count of 0).

Schema stability and export options

Field names are read directly from Threads' own GraphQL response (the node_to_record function in src/main.py) rather than parsed from rendered HTML, so they don't change when Threads' front end changes its page layout. If Threads' GraphQL schema adds a new field, this Actor's fixed field list won't include it automatically; if Threads removes or renames a field this Actor reads, that would require an Actor update. Export options are the Apify platform's standard dataset exports: JSON, CSV, Excel (XLSX), and XML from the Console's dataset view, or JSON through the Apify API for programmatic access.

A practical note on the two record shapes: because the dataset's default view (views.default in .actor/actor.json) surfaces only 11 of the 19 follower-record fields — recordType, overlapCount, overlapTargets, target_username, username, full_name, follower_count, is_verified, is_private, profile_url, user_id — anyone reading the Console's table view rather than the raw dataset will not see pk, source, profile_pic_url, following, followed_by, outgoing_request, has_onboarded_to_text_post_app, or __typename unless they switch to the JSON/CSV export. The overlap_summary row's own fields (targets, numTargets, totalUniqueFollowers, minOverlapApplied, pushedFollowerRows, perTargetFollowerCount, overlapDistribution, sharedByAtLeast) are not part of the default table view at all — pull the full JSON or CSV export to read the summary row.

Threads Followers Scraper Strategy Guide

Strategy 1: Real-time enrichment pipeline

Feed inbound leads into a real-time enrichment loop: trigger a run with urls set to the lead's Threads handle plus your own brand and top competitor handles, poll the run through the Apify API, then read overlapCount and overlapTargets off each follower row to see whether that lead already follows your competitors. Append user_id, username, and the overlap fields to your CRM record to prioritize outreach toward leads who already follow multiple accounts in your space.

Strategy 2: Scheduled monitoring and alerting

Schedule a recurring run (Apify Schedules) against the same set of target profiles — for example your brand plus two named competitors. Compare each run's overlap_summary row against the previous run's sharedByAtLeast and totalUniqueFollowers values, and alert when the shared-audience count moves meaningfully. Because every run performs a fresh GraphQL fetch with no caching, each scheduled run reflects that day's follower state within the maxFollowers sample size you've configured.

Strategy 3: Bulk dataset build

For a larger research or lookalike-audience dataset, pass a long urls list (duplicates are removed automatically) and raise maxFollowers toward its schema maximum of 100,000 per profile. Profiles in urls are processed one at a time within a single run, not in parallel — the code loops sequentially over usernames — so a long list combined with a high maxFollowers increases run time roughly in proportion to the number of profiles. Export the resulting dataset — every follower row plus the one overlap-summary row — as CSV directly from the Apify Console for loading into a spreadsheet or database.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	CRM / lead scoring	On-demand run per lead batch	JSON via Apify API
Scheduled monitoring	Competitive audience tracking over time	Recurring Apify Schedule	JSON/CSV, diffed externally
Bulk dataset build	Research / lookalike-audience datasets	Single run, long urls list, profiles processed sequentially	CSV/JSON export from the Console

🌴 Related Threads Scrapers & Tools

Scraper name	What it extracts
Threads User Posts Scraper With Creator Contact Leads	Public Threads posts per creator, plus outreach-ready contact details (email, phone, website) mined from the public bio
Instagram Lookalike Audience Builder	Expands one Instagram profile into a ranked lookalike audience via Instagram's related-accounts graph
Instagram Competitor Network Mapper	Maps the shared account network across multiple Instagram competitor profiles
Instagram Profile Bulk Status Checker	Validates large lists of Instagram profiles/handles in bulk — useful for cleaning a target list before running overlap analysis

How to integrate Threads Followers Scraper with your stack

Threads Followers Scraper (Common Followers Finder) works with any language or tool that can call the Apify API — there's no separate signup flow or credential system beyond your Apify API token.

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("<YOUR_USERNAME>/threads-follower-overlap-finder").call(run_input={
    "urls": ["zuck", "mosseri", "threads"],
    "sessionId": "YOUR_THREADS_SESSIONID_COOKIE",
    "maxFollowers": 50,
    "minOverlap": 2,
})

rows = []
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("recordType") == "follower":
        rows.append(item)
    elif item.get("recordType") == "overlap_summary":
        print("Unique followers:", item["totalUniqueFollowers"])
        print("Shared by 2+:", item["sharedByAtLeast"].get("2"))

import csv
with open("shared_audience.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=rows[0].keys())
    writer.writeheader()
    writer.writerows(rows)

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('<YOUR_USERNAME>/threads-follower-overlap-finder').call({
  urls: ['zuck', 'mosseri', 'threads'],
  sessionId: 'YOUR_THREADS_SESSIONID_COOKIE',
  maxFollowers: 50,
  minOverlap: 2,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const followers = items.filter((i) => i.recordType === 'follower');
const summary = items.find((i) => i.recordType === 'overlap_summary');

console.log(`${followers.length} shared-audience rows`);
console.log('Per-target counts:', summary.perTargetFollowerCount);

Async and scheduled pipelines

For large urls lists, start the Actor asynchronously with client.actor(...).start() instead of .call(), then poll the run status or read the dataset once it finishes — useful for fire-and-forget jobs you don't want to block on. For recurring audience-overlap checks, use Apify Schedules to trigger the same input on a timer, and attach Apify's standard run-finished webhook from the Console if you want a callback instead of polling; this Actor has no webhook behavior of its own beyond that platform-level feature.

Because usernames are processed sequentially within a run (see Strategy 3 above), a schedule that fires before the previous run finishes will simply queue as a separate concurrent run rather than interrupting the first — plan schedule intervals around how long your urls list plus maxFollowers typically takes to finish.

Who Needs Threads Followers Scraper? (Use Cases & Industries)

Growth and influencer marketing teams

A marketer running urls: ["ourbrand", "competitor_a", "competitor_b"] with minOverlap: 2 gets back every follower shared between at least two of those three accounts, each with overlapTargets showing which ones — a ready-made shortlist for co-marketing or influencer outreach.

AI/ML and RAG engineering teams

Engineers indexing username, overlapCount, and overlapTargets per lead build a structured audience-graph field an agent can query directly, instead of asking a model to infer relationships from unstructured text.

Competitive intelligence analysts

Analysts scheduling the same urls weekly track sharedByAtLeast["2"] in the overlap-summary row to see whether a competitor's audience is increasingly overlapping with their own.

Researchers

Social-graph researchers use minOverlap and overlapDistribution to study audience-overlap patterns across public figures or organizations, scoped to accounts visible through their own authenticated Threads session — public-data-only.

Product and SaaS teams

Teams building an audience-overlap or lookalike feature call this Actor as the data-collection layer through the Apify API, then build their own scoring or visualization on top of overlapCount and overlapTargets.

Is it legal to scrape Threads follower data?

Scraping publicly observable data is generally lawful in the United States following hiQ Labs, Inc. v. LinkedIn Corp., 938 F.3d 985 (9th Cir. 2019), which held that accessing data visible without authorization bypass does not violate the Computer Fraud and Abuse Act. That case concerned public profile data on a professional social network and is commonly cited in discussions of social-network scraping, though it did not address using an authenticated session cookie, which this Actor requires.

Three separate questions apply here:

• Scraping public data: generally permitted in the US under the precedent above, though the legal landscape varies by jurisdiction.
• Violating Terms of Service: using a Threads/Instagram session cookie to make automated requests likely violates Meta's Terms of Service. That is a civil, contractual risk between you and Meta — not a criminal one.
• Data protection obligations: follower rows contain personal data — username, full_name, profile_pic_url, and verification/privacy flags — for identifiable individuals. If you store or process this data about EU/UK or California residents, GDPR and CCPA obligations apply, and you are the data controller responsible for establishing a lawful basis.

Threads Followers Scraper (Common Followers Finder) returns only data reachable through the authenticated Threads session you supply. What you do with that data is your responsibility — consult legal counsel for commercial applications involving personal data.

❓ Frequently asked questions

Does Threads Followers Scraper work without a Threads account?

No. A valid, logged-in Threads/Instagram session cookie (sessionId) is required. The Actor checks for it at startup and exits immediately, without collecting any data, if the field is empty.

How does it handle Threads' anti-scraping measures?

It doesn't render a browser — it replays Threads' own GraphQL followers query directly. If the first (direct) connection fails to resolve valid tokens, it retries through an Apify datacenter proxy, then up to three residential proxy attempts; once a residential proxy succeeds, the run stays on residential ("sticky") for the rest of the targets. A fresh CSRF token is fetched before each pagination round, and GraphQL execution errors (HTTP 200 with data: null and an errors array) are detected and logged rather than mistaken for an empty follower list.

Can I run it at scale without getting blocked?

There is no published uptime or success-rate figure for this Actor. Structurally, profiles in your urls list are processed one at a time, not in parallel, with a short delay between pagination rounds and a stop condition after 10 consecutive rounds with no new unique followers — this pacing, combined with the proxy ladder above, is the Actor's only documented anti-blocking behavior.

How fresh is the data?

Live. Every run sends fresh HTTP requests to Threads' GraphQL endpoint; nothing is cached between runs or between profiles within the same run.

Which fields work best for AI training and RAG indexing?

username and full_name are the highest-signal identity fields for matching or deduplicating people across datasets; overlapCount and overlapTargets are the fields worth indexing for audience-graph or recommendation use cases. This Actor does not return long-form text (no bio or post-content field), so it suits identity resolution and audience-graph tasks better than NLP training on prose — every field returns as a typed primitive (string, integer, or boolean), so no parsing is needed before use.

Does this Actor handle GDPR/CCPA compliance for me?

No. Follower rows contain personal data — username, full_name, profile_pic_url, and verification/privacy flags — for identifiable individuals. The Actor returns only data visible through your own authenticated session; the lawful basis for storing, processing, or acting on that data is your responsibility as the data controller.

Does Threads Followers Scraper work with Claude, ChatGPT, and other AI agent tools?

Yes, as a standard Apify Actor callable over HTTP — there is no Actor-specific MCP integration documented for this tool. Any agent framework that can call the Apify API or apify-client (Python or Node.js) can trigger a run and read back typed JSON rows, with no HTML parsing required before passing results into a model's context window.

How does Threads Followers Scraper compare to other Threads scrapers?

igview-owner/threads-user-followers-scraper and apibox/threads-user-followers-scraper both extract single-profile follower lists without requiring login, per their Store listings (checked 2026-07-26) — a genuinely lower-friction option if you only need one profile's public followers and don't want to supply a session cookie. Neither listing documents cross-profile overlap detection, which is this Actor's core function: computing and filtering on how many of your target profiles each follower follows. makework36/threads-scraper covers a different entity type entirely — posts, likes, replies, and reposts rather than followers.

Disclaimer

Threads Followers Scraper (Common Followers Finder) extracts only data reachable through the Threads/Instagram session cookie you supply. This tool is intended for lawful use cases only. Users are responsible for complying with Meta's Threads Terms of Service and applicable data protection laws (including GDPR and CCPA where they apply) in their jurisdiction.