Export Twitter Followers & Following Lists: 6 Ways (2026)

By Sorsa Editorial

Published April 6, 2026. Updated September 23, 2026: rebuilt around six export methods, with why X hides parts of follower lists, what X's own archive contains, and current extension, scraper, and API prices. Official X API pay-per-use rates verified September 2026.

Exporting Twitter followers means turning an account's followers or following list into a file you can sort, filter, and reuse: a CSV of usernames, bios, and follower counts. X makes this harder than it looks. There is no export button, the lists generally require a login and often stop loading partway, and the free data archive covers only your own account, as bare account IDs.

This guide compares the six methods that work in September 2026: X's archive, browser extensions, follower analytics tools, scraper services, the official X API, and a third-party API. Each comes with current prices, limits, account risk, and working code where it helps. It is published by Sorsa Editorial, and Sorsa API, a read-only X data API, is one of the six; where another method fits a job better, the guide says so.

Contents

• The six ways to export Twitter followers at a glance
• Why X doesn't show someone's full follower or following list
• 1. Download your own followers from X's data archive
• 2. Export with a browser extension (XFollowExporter and alternatives)
• 3. Use a follower analytics tool (Circleboom, Fedica)
• 4. Run a scraper service (Apify, PhantomBuster, Bright Data)
• 5. Pull followers from the official X API
• 6. Export followers to CSV with Sorsa API
• How much does it cost to export 50,000 followers?
• What to do with an exported follower list
• Is exporting Twitter followers safe and allowed?
• FAQ
• Getting started

The six ways to export Twitter followers at a glance

Every method below returns the same kind of list; they differ in whose lists they reach, what each row contains, and what they ask of you. As of September 2026:

The short version:

• Your own followers: request X's data archive. It is free but holds IDs only, so convert them with a batch profile lookup.
• A quick look at recent follows: the free Recent Followers tool shows the 20 newest followers or follows of any public account, with no X login.
• One competitor's list, once: a browser extension, if the list fits its per-export cap and you accept running it in your own X session.
• Large, repeated, or automated exports: an API. The official X API charges $10 per 1,000 profiles; third-party APIs list roughly $0.005 to $0.025 per 1,000, with Sorsa from $0.01 on its Pro plan.
• Filters and dashboards without code: a follower analytics tool such as Circleboom or Fedica.

Why X doesn't show someone's full follower or following list

X lets you scroll through anyone's followers and following, but the list on screen is rarely the whole list. Several things cut it short:

• You usually have to be logged in. Logged out, X generally asks you to sign in before it shows a follower or following list.
• Long lists stop loading. X publishes no limit, but tools that read its web app report that another account's follower list ends far short of the total. PhantomBuster says its collector can reach only the 70 most recent followers of an account, a restriction it attributes to X itself, and other reports range from about 50 to about 800. Following lists appear to be less restricted.
• Heavy use is rate limited. In July 2023, Twitter (now X) introduced daily limits on how many posts an account could read, which Elon Musk said addressed "extreme levels of data scraping." A relaxed version still applies, so heavy scrolling can end in a temporary rate limit message.
• Spam, locked, and suspended accounts drop out. On your own list, X hides suspected spam accounts unless you turn off the quality filter in your settings. Locked accounts are removed from follower counts, and suspended or deactivated accounts disappear from lists.
• Protected accounts are closed. Only approved followers can see a protected account's lists.
• There are no dates. Lists generally run newest first, and X shows no follow date in follower lists, the archive, or the API; the only timing signal is the new-follower notification on your own account.

The Verified Followers tab next to Followers narrows the list to accounts with a checkmark, which helps on large accounts but is no easier to copy out.

So the practical way to get someone's full following list is to export it, though how complete the file is depends on the method: the archive covers only your own account, one scraper tool stops at the 70 newest followers, and API-based exports page through the list until the cursor runs out. Comparing the row count with the profile count shows whether an export finished. For a quick look at the 20 newest followers or follows of any public account, the Recent Followers tool needs no X login and no signup.

1. Download your own followers from X's data archive

X has no follower export button, but its data archive includes a list of your followers and of the accounts you follow. It is free and official, and it covers only your own account.

1. On the web, open More in the left menu, go to Settings and privacy, then Your account, and choose Download an archive of your data.
2. Enter your password, verify your identity with the code X sends to your email or phone, and select Request data.
3. Wait for the email saying the archive is ready. X says it may take a few days to prepare, and the .zip file has to be downloaded while you are logged in.
4. Open data/follower.js for your followers and data/following.js for the accounts you follow.

Each file is a JavaScript array with one entry per account:

window.YTD.follower.part0 = [
  {
    "follower" : {
      "accountId" : "783214",
      "userLink" : "https://twitter.com/intent/user?user_id=783214"
    }
  }
]

That is the whole record: an account ID and a link, with no username, bio, follower count, or follow date.

Turn archive IDs into full profiles

A batch profile lookup turns the IDs into usernames, bios, and counts. Sorsa's /info-batch endpoint takes up to 100 IDs per request, so a 5,000-follower archive is 50 requests, inside the 100 free requests a new account gets:

import json

import requests

HEADERS = {"ApiKey": "YOUR_API_KEY"}

raw = open("data/follower.js", encoding="utf-8").read()
ids = [entry["follower"]["accountId"] for entry in json.loads(raw[raw.index("["):])]

profiles = []
for i in range(0, len(ids), 100):
    r = requests.get("https://api.sorsa.io/v3/info-batch", headers=HEADERS,
                     params={"user_ids": ids[i:i + 100]}, timeout=30)
    r.raise_for_status()
    profiles.extend(r.json().get("users", []))
print(f"Resolved {len(profiles)} of {len(ids)} followers")

For following.js, replace "follower" with "following". Accounts suspended or deleted since the archive was made will not resolve, so expect slightly fewer profiles than IDs. If you already have an X developer account, the official API can skip the archive: calling the followers endpoint for your own account, authenticated as that account from a developer app it owns, is billed as an owned read at $0.001 per user.

2. Export with a browser extension (XFollowExporter and alternatives)

Chrome extensions are the most common no-code route. You open a profile's followers or following page while logged in to X, start the export, and the extension collects the list through your logged-in session and saves a file. List prices in September 2026:

• XFollowExporter (AddonsNext): 200 accounts per export at no cost, or $9.99 a month for up to 50,000 per export as CSV, XLSX, or JSON, with 26 fields including emails found in bios.
• XExporter (ExtensionsBox): 300 per export at no cost, or $15 a month for up to 50,000.
• Export Twitter Followers (Yue Apps): 150 per export at no cost in each of three lists (followers, verified followers, following), or $14.99 a month ($124.99 a year) for up to 100,000 per export, as an 18-field CSV.
• TwFollowExporter: 500 per export at no cost, or $12.99 a month for exports it advertises as unlimited, including X List members.
• TwExporter (ToolMagic): 300 per export at no cost, or $15 a month ($108 a year).

What they have in common:

• They act as you. Every export pages through X in your own browser session. X's automation rules list "non-API-based forms of automation, such as scripting the X website" among the things not to do and warn that they "may result in the permanent suspension of your account." Yue Apps' own store listing suggests using a dedicated X account for exports to avoid being flagged.
• They are slow on big lists. They collect only as fast as X serves a logged-in browser, so most offer pause and resume, and some let you set the delay between requests.
• Completeness is not guaranteed. Advertised caps from 50,000 accounts to unlimited sit far above what scrolling shows, and TwExporter warns that X's rate limits and platform restrictions can affect how complete an export is.
• They can see your X session. Install only extensions you trust, and check the permissions they request.

Sorsa does not publish a browser extension. A Chrome Web Store listing that uses the Sorsa name comes from a third-party developer and is not a follower export tool; Sorsa's no-install routes are the Playground and the API, both covered below.

3. Use a follower analytics tool (Circleboom, Fedica)

Social media management tools export follower lists as one feature among many, next to filters, audience analytics, and scheduling. You connect your X account and export from their dashboard:

• Circleboom exports the followers or following of any public account to CSV or Excel, with filters such as verified-only, and charges exports in tokens in proportion to the number of accounts. Its own guide notes that on large accounts the row count may come in below the follower count.
• Fedica, now home to Followerwonk, exports up to 1,000 accounts on its Grow plan ($29 a month, or $19 a month billed annually) and up to 150,000 on Research ($129 a month, or $79 a month billed annually), which also includes analysis of accounts totaling up to 2 million followers. Fedica notes that exports remain subject to X's limits, which it puts at 50,000 records a day.

These suit marketers who want segmentation and reports built around the list. For raw data at volume they cost more per profile than third-party APIs, though less than the official X API, and every export sits behind a plan limit.

4. Run a scraper service (Apify, PhantomBuster, Bright Data)

Scraper platforms run the collection on their own servers and hand back a dataset, usually priced per result:

• Apify hosts follower actors built and maintained by independent developers. Pay-per-result actors mostly list about $0.06 to $0.42 per 1,000 followers. Some need no X login, others ask you to paste in your logged-in X session (a few of those charge far more per result), and one stops at 500 visible rows per profile. Quality varies by actor, so check recent runs and reviews before relying on one.
• PhantomBuster's follower collector needs your X session and, per its documentation, can collect only the 70 most recent followers of an account; its following collector states no such cap. Plans start at $69 a month, and without a paid plan exports stop at 10 rows.
• Bright Data sells a followers scraper at $1.50 per 1,000 records pay-as-you-go, with 5,000 free records a month and a $499 Scale plan that includes 384,000 records.
• Open-source libraries are the free route. twscrape supports followers and following but needs logged-in X accounts, and its own documentation notes that X's terms discourage using multiple accounts. Twint was archived in 2023 and no longer works. The breakdown of Twitter scrapers tracks what still runs.

5. Pull followers from the official X API

X's own API returns follower and following lists through GET /2/users/:id/followers and GET /2/users/:id/following, both on pay-per-use pricing since February 2026. Per X's pricing documentation:

• Price: $0.010 per user returned, so 1,000 followers cost $10 and 50,000 cost $500. Since April 20, 2026, requests for your own account's followers or following, authenticated as that account from a developer app it owns, count as owned reads at $0.001 per user, or $50 for 50,000.
• Pages and limits: up to 1,000 users per request and 300 requests per 15 minutes per app, so a 1 million follower account takes 1,000 requests and about 45 minutes of paging.
• Billing details: the same user returned twice within one UTC day is billed once, and credits are prepaid.
• Setup: an X developer account, an app with its keys, and credits loaded in advance.

The data is first-party and the documentation is thorough, but there are no follow dates or follower histories, and the per-profile price makes large or repeated exports expensive. The Twitter API pricing guide breaks down every endpoint, and the Twitter followers API guide covers pagination and edge cases for developers.

6. Export followers to CSV with Sorsa API

Sorsa is a read-only X data API with dedicated follower endpoints. You authenticate with one ApiKey header, you do not need an X developer account or your X login, and you pay per request rather than per profile:

You identify the account by username, numeric user ID, or profile URL. Each profile carries the ID, username, display name, bio, location, follower, following, and post counts, verified and protected flags, the account's creation date, the profile image, and links from the bio. Results come in the order X provides them, generally newest followers first. There is no follow date, because X does not expose one, and a protected account returns an error because its lists are not public.

Each page is one request, which works out from $0.01 per 1,000 profiles on the Pro plan and about $0.025 on Starter, and the 100 free requests cover about 20,000 profiles.

Export a full follower list to CSV (Python)

The script pages with next_cursor until the list ends, retries rate limits and server errors with backoff, skips duplicate IDs (lists shift while you page), and writes a CSV that opens in Excel or Google Sheets. max_pages caps what a test run can spend.

import csv
import time

import requests

API_KEY = "YOUR_API_KEY"
BASE = "https://api.sorsa.io/v3"
HEADERS = {"ApiKey": API_KEY}
FIELDS = ["id", "username", "display_name", "description", "location", "followers_count",
          "followings_count", "tweets_count", "verified", "protected", "created_at"]


def get(path, params, max_retries=5):
    """GET with exponential backoff on rate limits and server errors."""
    for attempt in range(max_retries + 1):
        r = requests.get(f"{BASE}/{path}", headers=HEADERS, params=params, timeout=30)
        if (r.status_code == 429 or r.status_code >= 500) and attempt < max_retries:
            time.sleep(2 ** attempt)
            continue
        r.raise_for_status()
        return r.json()


def export_list(username, endpoint="followers", path="followers.csv", max_pages=None):
    """Page through followers, follows, or verified-followers and write a CSV."""
    cursor, seen_cursors, seen_ids, pages = None, set(), set(), 0
    # utf-8-sig adds a BOM so Excel reads emoji and non-Latin names correctly
    with open(path, "w", newline="", encoding="utf-8-sig") as f:
        writer = csv.DictWriter(f, fieldnames=FIELDS, extrasaction="ignore")
        writer.writeheader()
        while True:
            params = {"username": username}
            if cursor:
                params["next_cursor"] = cursor
            data = get(endpoint, params)
            pages += 1
            users = [u for u in data.get("users", []) if u.get("id") not in seen_ids]
            seen_ids.update(u.get("id") for u in users)
            writer.writerows(users)
            cursor = data.get("next_cursor")
            if not cursor or cursor in seen_cursors or pages == max_pages:
                return len(seen_ids)
            seen_cursors.add(cursor)


print(export_list("nasa", max_pages=50), "followers saved")  # 50 requests, up to 10,000 profiles
# Following list: export_list("nasa", endpoint="follows", path="following.csv", max_pages=50)
# Verified followers: export_list("nasa", endpoint="verified-followers", path="verified.csv")

Drop max_pages to export the whole list. A 100,000-follower account is 500 requests; paged one after another at typical response times, that takes a few minutes, and the flat 20 requests per second only comes into play when you export several accounts in parallel.

Export without code in the Playground

The API Playground runs the most-used endpoints from a browser form. Paste your API key, choose the Followers List action, enter a handle, set how many pages to fetch (50 pages is up to 10,000 profiles for 50 requests), run the query, and export the result as CSV or JSON. It needs a free Sorsa account and key, and there is nothing to install.

Export only verified followers

/verified-followers returns only followers with a verified badge (blue, gold, or gray checkmark), with the same fields and pagination as /followers. That matters on big accounts: finding the 5,000 verified followers of a 10 million follower account means walking 50,000 pages of the full list, or about 25 requests on the verified endpoint.

Get follower counts for a list of accounts

If you need follower counts rather than follower lists, for an influencer shortlist or a competitor set, /info-batch returns followers_count, followings_count, and tweets_count for up to 100 handles or IDs per request, so 1,000 accounts take 10 requests. Pass usernames instead of user_ids to the call shown in the archive section.

How much does it cost to export 50,000 followers?

For another account's followers, at list prices in September 2026:

For your own account, owned reads cut the official price to $1.00 per 1,000, or $50 for 50,000, which is reasonable for a one-off export if you already have a developer account.

Cheaper routes exist. For a one-off job, a month of a browser extension costs $9.99 to $15, with advertised per-export caps from 50,000 accounts to unlimited, and Apify's pay-per-result actors mostly list $0.06 to $0.42 per 1,000 ($3 to $21 for 50,000). Per-call APIs can cost less per profile: GetXAPI lists about $0.005 per 1,000 followers, and TwitterAPI.io about $0.01, which matches Sorsa's Pro rate without a monthly plan; both bill by usage. Sorsa's 100 free requests cover about 20,000 profiles once, and after that a $49 Starter month covers up to about 2 million profiles, which suits teams that want a fixed monthly quota across follower lists, verified followers, profile lookups, and the rest of the API rather than the lowest possible price per profile. For a wider view of providers, see the Twitter API alternatives comparison.

What to do with an exported follower list

• Build a lead list. Filter a competitor's followers by bio keywords, location, and follower count to find prospects already interested in your category; the guide to finding leads on Twitter covers qualification and outreach.
• Measure audience overlap. Two exports and a few lines of pandas show how many accounts follow both you and a competitor, a core metric in competitor tracking:

import pandas as pd

a = pd.read_csv("brand_a_followers.csv", dtype={"id": str})
b = pd.read_csv("brand_b_followers.csv", dtype={"id": str})
shared = a[a["id"].isin(b["id"])]
print(f"{len(shared)} accounts follow both, {len(shared) / len(a):.1%} of brand A's followers")

• Audit fake followers. Default avatars, empty bios, brand-new accounts, and extreme follow ratios show up fast in a spreadsheet; the bot detection guide turns those signals into a score.
• Map where followers are. Sorsa's /about endpoint returns the country X associates with an account, one account per request, so sample large lists before building an audience geography breakdown.
• Send it to Google Sheets or a CRM. The Google Sheets export guide automates the refresh.
• Track follows over time. X shows no follow dates, so export on a schedule and compare snapshots by account ID to see who followed and who left. For a single pair of accounts, the free follow checker shows whether one follows the other.

Is exporting Twitter followers safe and allowed?

The answer depends on the method and on what you do with the data:

• Nothing tells the other account. X has no documented feature that notifies an account when someone views or exports its follower list.
• Your own X account carries the risk with session-based tools. Extensions, PhantomBuster, login-based Apify actors, and twscrape all act through a logged-in X account, and X's automation rules say scripting the X website may lead to permanent suspension. If you use them, keep exports small and paced, or use a separate account as some vendors advise.
• The archive and API-based methods do not script the X website with your account. The archive is X's own feature, the official API runs on developer credentials, and with Sorsa you authenticate with an API key.
• X's terms prohibit scraping. X's terms have long barred scraping without consent, and since September 29, 2023 they have prohibited crawling or scraping the service "in any form, for any purpose" without X's prior written consent.
• Follower lists are personal data. Under laws such as the GDPR and the CCPA, keep only the fields you need, delete exports you no longer use, and do not turn a list into unsolicited bulk messages, which X's spam rules also prohibit.

Sorsa is an independent data provider and is not affiliated with, endorsed by, or sponsored by X Corp. Customers are responsible for making sure their collection and use of data comply with the laws and terms that apply to them, and nothing here is legal advice.

FAQ

Can you export someone else's Twitter followers?

Yes, if the account is public. X has no export button, but browser extensions, scraper services, the official X API, and third-party APIs such as Sorsa can export the followers or following list of any public account to CSV. Protected accounts are the exception: their lists are visible only to approved followers, and tools that work with public data cannot return them.

How can you see someone's full following list on X?

Not reliably inside X. X generally shows follower and following lists only to logged-in users and often stops loading long lists partway, and tools that read the web app report caps between about 50 and 800 accounts on follower lists. To get the complete list, export it through an API that pages to the end of the list and compare the row count with the profile count, since extensions and scrapers that run in an X session may stop early. Sorsa's free Recent Followers tool shows the 20 newest followers or follows of any public account without an X login.

Is there a free way to export Twitter followers?

For your own account, yes: X's data archive includes your followers and following at no cost, but only as account IDs and profile links. For other accounts, browser extensions export 150 to 500 accounts per run at no cost, Bright Data includes 5,000 free records a month, and Sorsa's 100 free requests cover about 20,000 follower profiles, once, with no card.

What does X's data archive include about followers?

Two files, follower.js and following.js, list an account ID and a profile link for every follower and every account you follow. They contain no usernames, bios, follower counts, or follow dates. X says the archive may take a few days to prepare, and it covers only your own account, so turning the IDs into full profiles takes a batch lookup through an API.

Why doesn't an exported follower count match the profile?

The number on a profile and the list behind it drift apart. X removes locked accounts from follower counts, hides suspected spam accounts behind its quality filter, and drops suspended or deactivated accounts, and large accounts gain and lose followers during a long export. Expect a small gap on big accounts; a much larger gap usually means the export stopped early.

Can you see when someone followed an account?

No. X shows no follow date in follower lists, its data archive, or its follower endpoints; the only timing signal is the new-follower notification on your own account. Lists generally come back newest first, so position hints at recency, and the created_at field in an export is the date the follower's account was created, not the date of the follow. To know when follows happen, export the list on a schedule and compare snapshots by account ID.

Can exporting followers get your X account banned?

It depends on the method. Browser extensions and scraper services that run in your logged-in X session act as your account, and X's automation rules say scripting the X website may result in permanent suspension, which is why some vendors advise using a separate account. X's own archive and API-based methods do not script the X website with your account.

How much does the official X API charge for follower lists?

$0.010 per user returned under pay-per-use pricing, which is $10 per 1,000 and $500 for 50,000 followers. Requests for your own account's followers, authenticated as that account from a developer app it owns, count as owned reads at $0.001 per user. Each request returns up to 1,000 users, apps are limited to 300 requests per 15 minutes, and access needs an X developer account with prepaid credits.

Getting started

The quickest test costs nothing. Create a Sorsa account and run the script above with max_pages=5 on an account you know: that spends 5 of the 100 free requests (no card, no expiry) and returns up to 1,000 profiles. The quickstart gets you to a first call in a few minutes, and the followers and following guide in the documentation covers pagination, verified followers, and edge cases.

When the numbers look right, per-request pricing runs from $0.01 per 1,000 profiles on follower lists, every plan allows 20 requests per second, and you do not need an X developer account or wait in an approval queue.

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

This guide draws on primary sources checked in September 2026: X's Help Center pages on the data archive, following issues, and automation rules; X's developer documentation for the follower endpoints and pay-per-use pricing; each tool's own store listing, pricing page, or documentation for extension, analytics, and scraper limits; and Sorsa's API documentation. Prices are list prices at the time of checking. More on our team is on the about page. Verified September 2026.