How to Compare Twitter Followers and Find the Overlap Between Accounts

To compare Twitter followers, you pull the follower list of each account and see which user ids appear in both. Free tools do this for small accounts in a few clicks. For large accounts or repeat reports, a short Python script does the same job for about $0.016 per 1,000 followers through a followers API.

This guide covers the free tools, the math that makes an overlap number mean something, and the script.

TL;DR: X has no built-in follower comparison, so every method rests on two lists and one set intersection. Use Followerwonk, Fedica or HypeAuditor for a quick look. For anything larger, crawl both lists by id, intersect them, and report the overlap coefficient: shared followers divided by the smaller list. Two 100,000 follower accounts cost about $3.20 on a per-call API and $2,000 on official reads at $0.010 per follower. Crawl both lists the same day, since follower lists change daily.

6 tools every Twitter creator should know about: Hypefury, Twemex, Typeshare, Black Magic, Shots, Followerwonk: net followers and best times.

@thejustinwelsh view on X

Followerwonk has been acquired by @tweepsmap. All Followerwonk users can now access new capabilities on the Tweepsmap dashboard.

@followerwonk view on X

How do you compare Twitter followers?

Comparing followers means building two lists of user ids and intersecting them. Everything else, from the free tools to custom dashboards, is a layer on that operation. The result is the set of people who follow both accounts, and it answers whether two audiences are really the same people.

The question comes up constantly, and X has never offered a native answer:

Is there any way to see the common followers of multiple Twitter accounts? from r/Twitter

Which tools compare followers for free?

Several tools compare accounts with no code. Followerwonk's compare page lists mutuals and common followers, Fedica compares two or more accounts with exports, and HypeAuditor offers a free side-by-side. They suit a one-off check on accounts of modest size.

Followerwonk deserves a note, since a common search result still says it has gone. It was acquired by Tweepsmap in 2023, and its site today lists audience overlap, bot detection, and exports of up to 50K followers a day, alongside Fedica tools. Circleboom has a similar comparison, and this open-source project is a good read if you want to see the method in a notebook.

Most tools are built for one-off checks, which leaves a gap for reporting. When you need the same comparison every month, across many accounts, or inside your own product, you outgrow them.

By need

Tool or script

	Compare tool	API script
Setup	None	An hour
List size	Plan limits	Any size
Export	Varies	Whatever you write
Repeatable	By hand	Scheduled
Best for	One-off checks	Reports and products

What does an overlap percentage mean?

An overlap number depends entirely on the denominator, so always state your formula. The overlap coefficient divides shared followers by the smaller list, and it answers how much of the small audience you already reach. The Jaccard index divides by the union of both lists, and it answers how alike the two audiences are.

Take one example: accounts of 40,000 and 100,000 followers with 8,000 in common.

Overlap metrics on one worked example

Metric	Formula	Result	Source
Shared followers	Size of A and B	8,000	derived
Overlap coefficient	Shared / smaller list	20%	derived
Share of larger list	Shared / larger list	8%	derived
Jaccard index	Shared / union	6.1%	derived

as of 2026-11-05

The same pair reads as 20 percent, 8 percent or 6 percent depending on the formula. This is the main reason two tools disagree. For a sponsorship decision, use the overlap coefficient. For a similarity map across many accounts, use Jaccard.

How do you compare followers in Python?

Crawl each account's followers by paging with the cursor, store the ids in a set, and intersect. The script below works at any size. It needs a TwitterAPIs key, and every page costs $0.0008. Pass username, read users, and stop when a page comes back empty.

import json, os, time, requests

BASE = "https://api.twitterapis.com/twitter"
HEADERS = {"Authorization": f"Bearer {os.environ['TWITTERAPIS_KEY']}"}

def followers(username):
    ids, cursor = set(), None
    while True:
        params = {"username": username}
        if cursor:
            params["cursor"] = cursor
        r = requests.get(f"{BASE}/user/followers_v2", params=params,
                         headers=HEADERS, timeout=30)
        r.raise_for_status()
        data = r.json()
        users = data.get("users", [])
        if not users:
            return ids
        ids.update(u["id"] for u in users)
        cursor = data.get("next_cursor")
        if not cursor:
            return ids
        time.sleep(0.11)      # stays under 600 requests a minute

a = followers("account_a")
b = followers("account_b")
shared = a & b
print(len(a), len(b), len(shared))
print("overlap", round(len(shared) / min(len(a), len(b)), 3))
print("jaccard", round(len(shared) / len(a | b), 3))
json.dump(sorted(shared), open("shared_ids.json", "w"))

Before crawling, check how big the job is. One profile read gives you the follower count, so you can price the crawl first:

curl -G "https://api.twitterapis.com/twitter/user/info" \
  --data-urlencode "username=account_a" \
  -H "Authorization: Bearer $TWITTERAPIS_KEY"

We ran one page of this against a real account to confirm the response shape and the page size.

56 users came back on one followers_v2 call for @followerwonk with count=5, so the page size is set by X and your loop should follow the cursor.

Our data · Dataset: x-follower-page-sample-2026 · Source: public X posts, pulled through our API · Query: GET /twitter/user/followers_v2?username=followerwonk&count=5 · Pulled: 2026-11-05 · n = 56 · Method: count of user rows returned on one call.

To keep a crawl from starting over after a network error, save the cursor as you go:

import json, pathlib

STATE = pathlib.Path("crawl_state.json")

def save(cursor, ids):
    STATE.write_text(json.dumps({"cursor": cursor, "ids": sorted(ids)}))

def load():
    if STATE.exists():
        s = json.loads(STATE.read_text())
        return s["cursor"], set(s["ids"])
    return None, set()

Note that the count parameter is advisory, so write your loop around the cursor rather than the page size. Our export followers to CSV guide walks through the crawl in more depth, the pagination guide explains the cursor, and the scraper cost per job breakdown prices related work.

What does a comparison cost?

Budget $0.016 per 1,000 followers. A call costs $0.0008 and returns about 70 followers on the first page and fewer after that, so 1,000 followers takes 15 to 20 calls. Two accounts of 100,000 cost about $3.20. Official reads bill per follower, which puts the same job at $2,000.

What a two-account comparison costs

Each account	Followers to pull	Per-call API	Official X reads	Source
10,000	20,000	$0.32	$200	derived
100,000	200,000	$3.20	$2,000	derived
1,000,000	2,000,000	$32.00	$20,000	derived

as of 2026-11-05

Derived

Cost to pull both lists, per-call API

Point	Value ($)
10k each	0.32 $
100k each	3.2 $
1M each	32 $

followers_total = 200_000            # two accounts of 100,000
per_call = followers_total / 1000 * 0.016
official = followers_total * 0.010   # Following/Followers read
print(round(per_call, 2), official)  # 3.2 2000.0

The official rate comes from X's pricing page. Crawling is mostly limited by time, not money: at 600 requests a minute a million followers finishes in under an hour. See the rate limits guide and pricing for details, and the cost calculator for other volumes.

When do you not need a full crawl?

Skip the crawl when your question is small. To check whether one person follows an account, use a relationship lookup. To check a shortlist of up to 100 people, use the batch endpoint. Reach for a full crawl only when you need the entire shared audience.

curl -G "https://api.twitterapis.com/twitter/user/check_follow_relationship/batch" \
  --data-urlencode "target_username=youraccount" \
  --data-urlencode "source_usernames=alice,bob,carol" \
  -H "Authorization: Bearer $TWITTERAPIS_KEY"

The batch check bills $0.0008 per pair answered, and pairs that return not found are free. For a shortlist of creators or prospects, that is far cheaper than crawling a million followers to answer a question about ten people. The Twitter API reference lists the related endpoints.

What can you do with an overlap?

Overlap tells you whether new spending buys new people. It guides sponsorship picks, competitor research, warm lead lists and partner choices. The practical output is usually a ranked list, so the next step is turning shared ids into profiles you can read and filter.

Worked example

Three creators, one sponsorship budget

Your followers: 40,000 · Creators compared: 3 · Crawl cost: $2.56

☑ Creator A: 100k followers, 20% overlap, 92k new reach · ☐ Creator B: 60k followers, 60% overlap, 36k new reach (mostly your audience) · ☑ Creator C: 40k followers, 5% overlap, 38k new reach (small but fresh)

An illustration, not a customer account. Overlap coefficient is shared followers over the smaller list. Crawl cost covers 160,000 followers across all four lists at $0.016 per 1,000.

For sponsorships, the influencer discovery use case covers the wider workflow: a creator with a slightly smaller audience and low overlap can beat a bigger one that mostly reaches your existing followers. For sales, followers of both you and a competitor are warm prospects, which the lead generation page expands on. Competitor analysis uses the same data, and our build versus buy guide covers that decision.

Turning ids into a spreadsheet is a short step. Once you have profile rows, write them out:

import csv

def export(rows, path="shared_followers.csv"):
    with open(path, "w", newline="") as f:
        w = csv.DictWriter(f, fieldnames=["id", "username", "followers_count"],
                           extrasaction="ignore")
        w.writeheader()
        w.writerows(rows)

Before you act on a list, filter it. Our bot detection guide explains which signals identify spam accounts, which inflate both sides of any comparison. Here is a short walkthrough of the classic tool, for anyone who prefers a UI:

https://www.youtube.com/watch?v=JD84s70hy4U

What skews a comparison?

Timing, sampling and bots skew the most. Lists change daily, so crawl both accounts in the same session. A tool that samples a partial list will understate overlap, and spam accounts following many large accounts inflate it. State the date, the method and the formula beside any number you publish.

Tool to see Social Media Follower Overlap from r/marketing

Researchers run into the same limits, as this developer forum thread shows. If a report goes to a client, include the crawl date and list sizes, so that a later re-run can be explained. For recurring audience work, the Twitter follow checker is a quick way to test a single relationship by hand.

How do you read the result?

A comparison gives you a number and a list, and the list is usually the more useful of the two. Start with the number to decide whether the overlap is high enough to matter, then read a sample of the shared followers to see who they really are. Twenty profiles are enough to tell you whether the overlap is your buyers, other marketers or spam.

Compare like with like. Two accounts of very different sizes will always show a small share of the larger list, which is why the overlap coefficient uses the smaller one. Track the same pair over time as well, since a rising overlap between you and a competitor often means the two audiences are converging on one category. Save each crawl with its date, so you can diff the shared set between runs and see who joined.

Where to go from here

Follower lists feed many other jobs. If you are choosing a provider, start with how to choose a Twitter API and the best API for scraping. For cost planning, the Twitter API cost guide and cost by workload price the wider stack. For the mechanics, the Python tutorial, the authentication guide, the rate limit guide and scraping in Python cover what the script above takes for granted. To keep watching an account once you know its audience, see account monitoring.

The short version

Compare Twitter followers by intersecting two id lists. Use a free tool for a quick look, and a script for anything large or repeated. Report the overlap coefficient for reach decisions and Jaccard for similarity, and say which you used.

A comparison of two 100,000 follower accounts costs about $3.20 here, and the $0.50 signup credit needs no card, which covers about 625 calls or roughly 31,000 followers. Sign up, compare two small accounts first, then scale from the followers API page.