How to Extract Twitter Followers: Methods Compared (2026)

By Sorsa Editorial

Updated June 2026: re-verified the current crop of follower-export tools, extensions, and open-source scrapers, refined the browser-extension pricing to a range, and reconfirmed that the once-popular Twint library no longer functions against X's current systems.

X has no "Download Followers" button, and since the 2023 pricing overhaul the official API bills follower reads per profile returned, which gets expensive fast at scale. That gap is why a market of alternatives exists. Sorsa API, an alternative Twitter/X API provider, is one of them: its /followers endpoint returns up to 200 full follower profiles per request behind a single ApiKey header, on flat per-request pricing (one call counts as one request no matter how much it returns), with a flat 20 requests per second on every plan and no OAuth flow or approval queue. If you only need a quick look without writing code, the free Recent Followers tool shows the latest followers of any public account in the browser. The rest of this guide compares every method honestly, including where an API is overkill.

For anyone doing audience research, lead generation, or competitive analysis, the web interface is a dead end: it lets you scroll followers one screen at a time, with no way to export a structured list of bios, locations, follower counts, or any other metadata. The methods below each solve that, with very different tradeoffs.

Table of Contents

1. Why extract followers in the first place?
2. Method comparison: which approach fits your use case?
3. Method 1: Third-party API (recommended for scale)
4. Method 2: Browser extensions (no-code, small lists)
5. Method 3: DIY scrapers with Selenium or Playwright
6. Method 4: Manual export via X's data download
7. How much does it cost to extract 50,000 followers?
8. What to do with the data once you have it
9. Risks and safety by method
10. FAQ

Why Extract Followers in the First Place?

A follower list is a dataset of people who actively opted in to hear from a specific account, which makes it one of the most targeted audience signals on any social platform. Four use cases drive most extractions.

Lead generation. Export the followers of a competitor's account, filter by bio keywords like "founder" or "VP Marketing," and you have a warm prospect list built in minutes instead of weeks. That filtered list is the starting point for finding leads on Twitter at scale.

Audience research. Who follows an account tells you what its content actually reaches. A brand with 50,000 mostly-bot followers is in a very different position from one with 50,000 active developers who each have a real following of their own.

Influencer vetting. Before paying for a sponsored post, extract the influencer's follower list and check what share are real, active accounts with relevant bios. The pattern we see most often: a chunk of an influencer's audience turns out to be inactive accounts created in the same short window, which is exactly the kind of thing that kills a five-figure deal before it happens. A pass through Twitter bot detection turns that hunch into a measurable share of fake or dormant followers.

Competitive intelligence. Pull follower lists from two or three competitors, find the overlap (accounts that follow all of them), and you have isolated the most engaged people in your niche. They already pay attention to your space, so they convert better than cold audiences. This overlap analysis sits at the heart of ongoing competitor tracking.

Method Comparison: Which Approach Fits Your Use Case?

The four methods diverge most on volume, data richness, account risk, and whether you can automate. Here is how they stack up before we get into each one.

The short version: if you need more than a few hundred followers, want rich profile data, or plan to run extractions on a schedule, an API is the most reliable path. Extensions handle quick one-off exports of small lists. DIY scrapers are a false economy for most teams. Manual export is a last resort for backing up your own account.

Method 1: Third-Party API

An API-based approach sends HTTP requests to a service that returns structured JSON with follower data, with no browser session, no cookies, and no risk to your X account, because you authenticate with an API key rather than your Twitter login. This is the method that scales.

Sorsa's /followers endpoint returns up to 200 full user profiles per request. Each profile includes username, display name, bio, location, follower count, following count, tweet count, verified status, profile image URL, bio URLs, and more. You page through the complete list using cursors.

If you have already settled on the API route and want the full developer walkthrough (endpoints, authentication, pagination, and production patterns), our Twitter followers API guide covers it in depth. This section is the short version.

Quick start: fetch the first page

curl "https://api.sorsa.io/v3/followers?username=stripe" \
  -H "ApiKey: YOUR_API_KEY"

That single request returns up to 200 follower profiles with full metadata. No OAuth flow, no app approval, no bearer tokens. One header, one parameter.

Python: extract and save a complete follower list

This loop pages through the entire list, handles the rate limit, and caps total pages so a runaway job cannot silently drain your quota.

import requests
import time
import csv

API_KEY = "YOUR_API_KEY"

def extract_followers(username, max_pages=50):
    """Fetch the complete follower list of a public account."""
    all_users = []
    cursor = None

    for page in range(max_pages):
        params = {"username": username}
        if cursor:
            params["next_cursor"] = cursor

        resp = requests.get(
            "https://api.sorsa.io/v3/followers",
            headers={"ApiKey": API_KEY},
            params=params,
            timeout=30,
        )
        resp.raise_for_status()
        data = resp.json()

        users = data.get("users", [])
        all_users.extend(users)
        print(f"Page {page + 1}: {len(users)} followers (total: {len(all_users)})")

        cursor = data.get("next_cursor")
        if not cursor:
            break

        time.sleep(0.05)  # stay well within the 20 req/s limit

    return all_users

# Extract
followers = extract_followers("stripe", max_pages=100)

# Save to CSV
with open("followers.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["username", "display_name", "followers_count", "bio", "location"])
    for u in followers:
        writer.writerow([
            u.get("username", ""),
            u.get("display_name", ""),
            u.get("followers_count", 0),
            (u.get("description", "") or "").replace("\n", " "),
            u.get("location", ""),
        ])

print(f"Saved {len(followers)} followers to followers.csv")

At a flat 20 requests per second, the math works out to roughly 4,000 followers per second of wall-clock time, so a 100,000-follower account finishes in under half a minute.

JavaScript: same extraction in Node.js

const fs = require("fs");

const API_KEY = "YOUR_API_KEY";

async function extractFollowers(username, maxPages = 50) {
  let allUsers = [];
  let cursor = null;

  for (let page = 0; page < maxPages; page++) {
    const url = new URL("https://api.sorsa.io/v3/followers");
    url.searchParams.set("username", username);
    if (cursor) url.searchParams.set("next_cursor", cursor);

    const resp = await fetch(url, { headers: { ApiKey: API_KEY } });
    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
    const data = await resp.json();

    const users = data.users || [];
    allUsers = allUsers.concat(users);
    console.log(`Page ${page + 1}: ${users.length} (total: ${allUsers.length})`);

    cursor = data.next_cursor;
    if (!cursor) break;

    await new Promise((r) => setTimeout(r, 50));
  }

  return allUsers;
}

extractFollowers("stripe", 100).then((followers) => {
  fs.writeFileSync("followers.json", JSON.stringify(followers, null, 2));
  console.log(`Saved ${followers.length} followers`);
});

Getting the following list (who an account follows)

Swap the endpoint from /followers to /follows. Everything else stays identical. The /follows endpoint returns the same user-profile structure with the same 200-per-page pagination.

Following lists are often more revealing than follower lists. A founder's following list shows which investors, competitors, and thought leaders they track; an influencer's following list reveals their information sources.

Verified followers only

If you care only about verified accounts (Blue, Gold, or Gray checkmarks), use the /verified-followers endpoint. Same request format, same response structure, but pre-filtered to verified users. Useful for isolating high-profile followers without post-processing the full list.

Method 2: Browser Extensions

Browser extensions like X Follow Exporter and XExporter run inside Chrome, using your active X session to scroll the follower list and capture data, with no coding required. They are the closest thing to a one-click export, and for small lists they are fine.

How they work: you open a profile, click the extension icon, and it automates the scrolling, capturing profile data as it loads. Results export to CSV, JSON, or Excel.

Practical limits:

• Speed. Extensions add delays between scrolls to avoid tripping X's rate limits, so extracting 10,000 followers takes 30 to 90 minutes, against under a minute via API.
• Volume caps. Free tiers usually limit exports to around 200 records. Paid tiers (typically in the $5 to $10 per month range) cap at 50,000 per export. Accounts with hundreds of thousands of followers hit a wall.
• Session dependency. Extensions use your logged-in X session. Unusual scrolling patterns can prompt X to throttle your account or serve CAPTCHAs. The account at risk is yours, not a separate API key.
• No automation. You cannot schedule recurring extractions or wire them into a data pipeline. Each export is a manual, browser-bound process.

When extensions make sense: a one-time export of a few thousand followers, when you do not write code and do not need to automate. For a marketing manager pulling 500 followers from a niche account once a quarter, an extension is perfectly fine. For a no-code option that does not lean on your own X session, the free Recent Followers tool and the API Playground run against a separate data layer instead.

Method 3: DIY Scrapers with Selenium or Playwright

Open-source scrapers use browser automation to log into X, navigate to a follower page, and scroll while parsing HTML. The appeal is obvious: free, open-source, full control. The reality is less appealing, and the economics rarely work out.

• Fragile by design. These scrapers parse X's HTML, which changes without notice. Most public repos in this space have not been updated in one to three years. When X renames a CSS class or restructures the DOM, the scraper breaks silently or returns garbage.
• Authentication risk. Every scraper needs your X session cookie or login. You are handing account access to a script that automates behavior X explicitly prohibits in its terms of service. Suspensions here are not theoretical.
• Slow. Selenium loads full browser pages, waits for JavaScript to render, then parses the DOM. Extracting 10,000 followers can take one to four hours.
• Maintenance cost. Even a scraper that works today needs someone to fix it when it breaks next month. The ongoing engineering time often exceeds the cost of a paid API.

There is also a freshness trap worth naming: the best-known free Python library for this, Twint, stopped working after X locked down the endpoints it depended on in 2023, so any guide still recommending it is out of date. Teams routinely sink 40-plus hours into building and maintaining a Selenium-based Twitter scraper only to abandon it after X's third DOM change in six months. The upfront cost is zero; the total cost rarely is.

When DIY scrapers make sense: you are learning web scraping as a skill, you need a tiny one-off extraction, or you are under constraints where no paid tool is an option.

Method 4: Manual Export via X's Data Download

X lets you request an archive of your own account data through Settings, then Your Account, then Download an archive of your data. The archive includes a followers.js file with the user IDs of your followers and a following.js file for accounts you follow. This is the only method that needs no tool at all, and also the most limited.

What you get: user IDs in JSON. No usernames, no bios, no follower counts, no profile data. Just numeric IDs.

What you do not get: anything about other accounts' followers. It works for your own account only. And even for your own followers, you would still have to resolve each ID to a username and profile, which means API calls anyway. The ID conversion endpoints handle that step if you go this route.

The conversion workaround: people commonly convert the followers.js file to CSV with an online JSON-to-CSV tool after stripping the leading window.YTD.follower.part0 = wrapper. It works, but the output is still only IDs.

When this makes sense: you are leaving X and want a personal backup of who followed you. That is about it.

How Much Does It Cost to Extract 50,000 Followers?

Cost is where the methods diverge most sharply. Here is what 50,000 followers actually runs with each approach.

The official X API is the line that catches people out, because it bills per profile returned. Reading another account's 50,000 followers is 50,000 non-owned reads at roughly $0.010 each, which is about $500 for a single pull. For a full breakdown of how Twitter API pricing works after the 2026 pay-per-use shift, see our dedicated pricing guide.

The gap widens at scale. Extracting followers from 20 competitor accounts at 25,000 followers each is 500,000 profiles. On the Sorsa Enterprise plan ($899/mo) that is 2,500 requests at $0.0018 each, about $4.50 total. The same job on the official API, at per-resource billing, runs into the thousands; with a browser extension it is days of manual work; with Selenium it needs a multi-account rotation to avoid detection.

What to Do with the Data Once You Have It

Extracting the list is step one. The value is in what you do next.

Filter by profile criteria

Every follower profile from an API extraction carries bio text, location, follower count, and tweet count, so you can segment the raw list immediately.

# Find high-value accounts: 1K+ followers, active, with a website in bio
qualified = [
    u for u in followers
    if u.get("followers_count", 0) >= 1000
    and u.get("tweets_count", 0) >= 100
    and u.get("bio_urls")
]
print(f"Qualified leads: {len(qualified)} / {len(followers)}")

Common filters for lead generation: bio keywords matching job titles ("founder," "CTO," "head of growth"), location strings matching target markets, a minimum follower count to screen out bots, and a website URL in the bio.

Find audience overlap between competitors

Pull follower lists from several competitors and keep the accounts that follow two or more of them. These are the most engaged people in your space.

from collections import Counter

competitors = ["competitor_a", "competitor_b", "competitor_c"]
all_ids = []

for handle in competitors:
    handle_followers = extract_followers(handle, max_pages=25)
    all_ids.extend(u["id"] for u in handle_followers)

counts = Counter(all_ids)
overlap = {uid: c for uid, c in counts.items() if c >= 2}
print(f"Users following 2+ competitors: {len(overlap)}")

For a deeper version of this workflow, see the competitor analysis and target audience discovery guides in the docs.

Feed into CRMs and ad platforms

A CSV of filtered followers imports straight into HubSpot, Pipedrive, or Salesforce as a lead list, and the same data builds Custom Audiences on ad platforms for targeted campaigns. Pairing follower data with engagement metrics (the engagement calculator is a quick way to gauge it) lets you prioritize the segments worth contacting first.

Map follower geography

If you need country-level data beyond the freeform location field, the audience geography workflow uses the /about endpoint to resolve the country tag X attaches to each account.

Risks and Safety by Method

Not all extraction methods carry the same risk. Here is what each one actually exposes.

API-based extraction. Zero risk to your X account. An API authenticates through its own key, fully separate from your Twitter login, so you never share cookies or credentials. Exceed the rate limit and you get a 429 response to retry after a second, with no account flags, CAPTCHAs, or suspensions.

Browser extensions. Moderate risk. Extensions run through your logged-in X session. Reputable ones add delays to mimic human scrolling, but unusual activity can still trigger rate limiting on your account, and your session cookie is readable by the extension code.

DIY scrapers. High risk. These automate a browser using your credentials or session cookies, and X actively detects automated browsing, restricting or suspending accounts that trip its defenses. Running a scraper on a server around the clock is close to guaranteed to draw account action.

Manual X export. No risk. You are using X's own data-download feature on your own account.

Legal context. Public follower data is, by definition, visible on X, and extracting it for research, marketing, or competitive intelligence is standard practice. The lines not to cross: do not resell raw scraped data, do not send unsolicited bulk messages to extracted followers, and comply with GDPR or equivalent rules when handling data on EU users.

In Practice

A roughly 10-person market-research team came to us already pulling follower lists for about 40 mid-size competitor accounts on the official X API, billed per profile read. At around $0.010 per follower, those non-owned reads turned a routine monthly refresh into a four-figure invoice, and the cost grew every time a tracked account did. They moved the same job to flat per-request pricing and the bill dropped by more than 30x for identical data, because one request returning 200 profiles counts as a single request rather than 200 separate reads. The saving came straight from the billing model, not a discount or a data tradeoff.

FAQ

Can I extract followers from any public account, or only my own?

Any public account. If a profile's follower list is visible when you open it on x.com, an API or extension can extract it. The one exception is protected (private) accounts, whose follower lists are hidden from everyone except approved followers, and which no tool or official API can read.

How many data fields do I get per follower?

With an API like Sorsa, each follower profile carries over 15 fields: user ID, username, display name, bio, location, follower count, following count, tweet count, media count, verified status, account creation date, profile image URL, banner URL, bio URLs, pinned tweet IDs, and flags such as protected and can_dm. A browser extension typically returns fewer, and a manual X export returns only numeric user IDs.

What is the cheapest way to extract a large follower list in 2026?

For any list beyond a few thousand, a flat per-request API is the cheapest path. The official X API bills per profile returned (around $0.010 per non-owned user read), so 50,000 followers costs about $500. On Sorsa's flat per-request pricing the same 50,000 followers is roughly $0.50 on the Pro plan, because one request returning 200 profiles counts as a single request against your quota.

How do I extract the following list instead of followers?

Swap the endpoint from /followers to /follows. The request parameters, response format, and pagination are identical. Following lists are usually smaller than follower lists and extract faster, which makes them practical for mapping who an account tracks. Full details are in the Sorsa /follows endpoint reference.

Can I extract followers without writing code?

Yes, in two ways. Browser extensions run entirely through a Chrome interface with no coding. Alternatively, the free Sorsa Recent Followers tool and API Playground let you preview follower data through a web interface before writing anything, running against a separate data layer rather than your own X session.

Is the follower order consistent, and will I get the same results each time?

The follower list comes back in the order X provides it, which is generally newest first, so the first pages always hold the most recently acquired followers. That order is consistent across requests, but the actual list changes as people follow and unfollow, so two extractions days apart will differ at the edges.

Why doesn't the extracted count match the profile's follower count?

The follower count on a profile is a real-time counter maintained by X, while the extractable list can be slightly smaller because suspended, deactivated, or recently removed accounts may still sit in the counter without appearing in the list. Expect a few percent of drift on large accounts, and do not write strict equality checks against the displayed count.

Can I use extracted follower data for ad targeting?

Yes. Export your filtered follower list to CSV, then upload it as a Custom Audience in X's ad platform or any platform that accepts username- or email-based audiences. Pairing this with engagement data helps you weight the highest-value segments first instead of treating the whole list equally.

Getting Started

If you want to test follower extraction before committing to a method, the fastest path is short:

1. Preview without code. Open the Recent Followers tool, enter any public handle, and see the latest followers with full profile data. No API key needed.
2. Try the API playground. The Sorsa API Playground lets you call the /followers and /follows endpoints through a browser and see the exact JSON before writing code.
3. Get an API key. When you are ready to scale, grab a key from the dashboard. The quickstart guide walks through authentication and your first request in a few minutes.
4. Read the docs. The full followers and following documentation covers pagination, filtering, and production-scale extraction.

A flat 20 requests per second on every plan, around $0.50 to pull 50,000 followers on the Pro plan, and a setup that takes a few minutes with no approval queue. That is the case for using an alternative Twitter/X API over the official one for follower data at any real volume.

Reviewed by Keksich, founder of Sorsa, marketer and X API researcher.

How we put this together: the method comparisons and cost figures draw on our own work running an alternative Twitter/X API, the official X API per-resource pricing published after the April 20, 2026 update, and Sorsa's current rate card. We reviewed the live crop of follower-export tools, extensions, and open-source scrapers for this revision and confirmed that scrapers built on the old public endpoints (Twint among them) no longer function. Endpoint names, fields, and limits come from the live Sorsa API documentation and were checked against the running endpoints; questions about our setup go to the about page or contacts@sorsa.io. Last verified June 15, 2026.