How to export all Twitter followers

#How exporting Twitter followers works

Since X offers no export for any account's followers, your own included, a follower list leaves X in one of four ways: your data archive, a browser extension, a free web tool such as Export Twitter Followers to CSV, or an API. They differ in whose list they reach and how much of it.

• Your X data archive is free but holds only your own account, lists each follower as an account ID and a link without a name, and takes days to arrive.
• A browser extension reads the list as it scrolls through your logged-in X session; free tiers stop at a few hundred rows, and every export runs as your account.
• A free web tool saves the newest 200 followers, follows or verified followers of any public account as CSV, Excel or JSON.
• An API pages through the whole list of any public account: each request returns one page and a cursor, and the list ends when no cursor comes back. The official X API does it through GET /2/users/{id}/followers (opens in a new tab), up to 1,000 per page, once you open a developer account and set up OAuth, and bills $10.00 per 1,000 followers.

Protected accounts are the one list no route reaches: X shows their followers only to the people they approved. Every other list is public, and each follower arrives as a public profile you can sort and filter in a spreadsheet.

#Export the whole follower list with Sorsa API in four steps

For the whole list of any public account, use Sorsa API: GET /followers returns up to 200 followers per request, each a full public profile, plus a cursor to the next page, at 20 requests per second on every plan and with no developer account. A cursor is a bookmark the API returns with each page; send it back with the next request and the next 200 followers arrive.

1. Get a key. Sign up and copy your API key from the dashboard. The first 100 requests are free and need no card.

2. Request the first page. Send the account's username to GET /followers (opens in a new tab) with your key in the ApiKey header. A user_id or a profile link in user_link works too.

   curl -G "https://api.sorsa.io/v3/followers" \
     -H "ApiKey: YOUR_API_KEY" \
     --data-urlencode "username=northwind_roasters"
   

   {
     "users": [
       {
         "id": "1592041833471827968",
         "username": "harbor_street_coffee",
         "display_name": "Harbor Street Coffee",
         "description": "Small-batch roaster. Open 7 to 3.",
         "location": "Portland, OR",
         "created_at": "2022-11-14T06:28:46Z",
         "followers_count": 1840,
         "followings_count": 312,
         "tweets_count": 2741,
         "verified": false,
         "can_dm": true,
         "protected": false,
         "bio_urls": ["https://hsc.example"]
       }
     ],
     "next_cursor": "1849212213712385091"
   }
   

   Show full response

3. Follow the cursor. Read next_cursor from the response and send it back as the next_cursor parameter. When it comes back empty or missing, the list is complete.

4. Write each page to the file. Append the rows as the pages arrive, so even a million-follower export never holds the whole list in memory.

   import csv
   import requests
   
   URL = "https://api.sorsa.io/v3/followers"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   FIELDS = ["id", "username", "display_name", "description",
             "location", "followers_count", "created_at"]
   RISKY = ("=", "+", "-", "@", "\t", "\r")
   
   
   def cell(value):
       if isinstance(value, list):
           value = " ".join(value)
       if isinstance(value, str) and value.startswith(RISKY):
           value = "'" + value  # opens as text, never a formula
       return value
   
   
   def export(username, path="followers.csv"):
       params = {"username": username}
       with open(path, "w", newline="", encoding="utf-8-sig") as f:
           out = csv.writer(f)
           out.writerow(FIELDS)
           while True:
               r = requests.get(URL, headers=HEADERS, params=params)
               r.raise_for_status()
               page = r.json()
               for user in page.get("users", []):
                   out.writerow([cell(user.get(k)) for k in FIELDS])
               cursor = page.get("next_cursor")
               if not cursor:
                   break
               params["next_cursor"] = cursor
   
   
   export("northwind_roasters")
   

   // export.mjs, Node.js 18 or later
   import { createWriteStream } from "node:fs";
   
   const URL = "https://api.sorsa.io/v3/followers";
   const KEY = "YOUR_API_KEY";
   const FIELDS = ["id", "username", "display_name", "description",
     "location", "followers_count", "created_at"];
   
   function cell(value) {
     let s = Array.isArray(value) ? value.join(" ") : String(value ?? "");
     if (/^[=+\-@\t\r]/.test(s)) s = "'" + s;
     return '"' + s.replace(/"/g, '""') + '"';
   }
   
   const out = createWriteStream("followers.csv");
   out.write("" + FIELDS.join(",") + "\n");
   let cursor = "";
   do {
     const q = new URLSearchParams({ username: "northwind_roasters" });
     if (cursor) q.set("next_cursor", cursor);
     const res = await fetch(`${URL}?${q}`, { headers: { ApiKey: KEY } });
     if (!res.ok) throw new Error(`HTTP ${res.status}`);
     const page = await res.json();
     for (const user of page.users ?? []) {
       out.write(FIELDS.map((k) => cell(user[k])).join(",") + "\n");
     }
     cursor = page.next_cursor ?? "";
   } while (cursor);
   out.end();
   

Both scripts write followers.csv with seven columns, save it as UTF-8 that Excel reads correctly, and put an apostrophe before any bio that starts like a spreadsheet formula; the Excel section below explains both. A 403 means the key is missing or its requests have run out. A 429 means more than 20 requests landed in one second: wait a second and send the request again.

#Export a following list or only verified followers

To get the list of accounts a user follows, call GET /follows instead; for followers with a verified badge only, call GET /verified-followers. Both take the same input and cursor as GET /followers and return the same profile fields, so the script changes in one line: the URL.

Four Sorsa API endpoints cover every list in this guide: three page through a list with a cursor, and one takes a batch of handles or IDs.

• Accounts that follow an account

  Endpoint

  GET /followers

  Per request

  up to 200 followers

• Accounts an account follows

  Endpoint

  GET /follows (opens in a new tab)

  Per request

  up to 200 accounts

• Its verified followers only

  Endpoint

  GET /verified-followers (opens in a new tab)

  Per request

  one page, same cursor

• Profiles for a list of handles or IDs

  Endpoint

  GET /info-batch

  Per request

  up to 100 profiles

A following list shows who an account reads: the creators, rivals and news sources it keeps an eye on. Exported next to the follower list, it tells you who follows back, and the overlap between two accounts' audiences is a match on id in any spreadsheet. For the audience work that comes after the export, from filtering to overlap across many accounts, the Twitter followers API guide goes deeper.

#What a full export costs

A full follower export on Sorsa API costs from $0.007 per 1,000 followers; the official X API bills $10.00 per 1,000 for the same public list, 1,000x more.

At those rates, 10K followers cost from $0.07 on Sorsa API and $100 on the official X API; 100K cost from $0.70 against $1,000; 1M from $7 against $10,000; and 10M from $70 against $100,000. Even X's lower rate for reading your own followers through your own developer app, $0.001 each, comes to $1.00 per 1,000 (X API pricing (opens in a new tab)).

Sorsa API bills per request, not per profile: one call returns up to 200 followers, failed requests are never charged, and checking your balance with GET /key-usage-info (opens in a new tab) is free. The 100 free requests cover the first 20K followers, which exports any account of up to 20K followers end to end before you pick a plan.

#Open the file in Excel or Google Sheets without losing data

Import the CSV rather than double-clicking it: Excel keeps only 15 significant digits, so a 19-digit X account ID such as 1592041833471827968 turns into 1.59204E+18, and its last four digits become zeros (Microsoft Support (opens in a new tab)).

• Excel: choose Data, then From Text/CSV, pick the file, set Data Type Detection to "Do not detect data types" and load it. Every column arrives as text, with the IDs intact.
• Google Sheets: choose File, then Import, upload the file and untick "Convert text to numbers, dates, and formulas" before you import (Google's import help (opens in a new tab)).

Both scripts in this guide save the file as UTF-8 with a byte order mark, an invisible marker at the start of the file that tells Excel how to read it, so emoji and names in Japanese, Arabic or Cyrillic display as written. Treat id as the key for everything that follows: usernames change, account IDs never do. To feed the same lists into a sheet on a schedule, see how to export Twitter data to Google Sheets.

Good to know

Bios are free text, and a bio that starts with =, +, - or @ opens in Excel as a formula, a risk OWASP calls CSV injection (opens in a new tab). The scripts put an apostrophe in front of such cells, so they open as plain text. Drop that guard only when the file goes to code or a database instead of a person with a spreadsheet.

#Choose the columns for your file

Each follower comes back as a full public profile with 19 fields; keep the ones your job needs, and always keep id.

Thirteen of those fields carry what most audience work needs: who the account is, how far it reaches, how active it is and whether you can reach it.

• id

  What it holds

  Permanent account ID, sent as a string; match files on it

  Example

  1592041833471827968

• username

  What it holds

  Handle without @; it can change

  Example

  harbor_street_coffee

• display_name

  What it holds

  Name shown on the profile

  Example

  Harbor Street Coffee

• description

  What it holds

  Bio text

  Example

  Small-batch roaster.

• location

  What it holds

  Location as the user typed it

  Example

  Portland, OR

• followers_count

  What it holds

  Its own followers

  Example

  1840

• followings_count

  What it holds

  Accounts it follows

  Example

  312

• tweets_count

  What it holds

  Posts it has published

  Example

  2741

• created_at

  What it holds

  Account creation date, ISO 8601

  Example

  2022-11-14T06:28:46Z

• verified

  What it holds

  Has a verified badge

  Example

  false

• can_dm

  What it holds

  Accepts direct messages

  Example

  true

• protected

  What it holds

  Its posts are protected

  Example

  false

• bio_urls

  What it holds

  Links in the bio, as a list

  Example

  https://hsc.example

The other six are favourites_count, media_count, profile_image_url, profile_background_image_url, pinned_tweet_ids and possibly_sensitive.

Good to know

Neither X's app nor its API records when one account followed another, so no follower file carries a follow date. To see who joined or left, export the list on a schedule and compare the files by id: new IDs are new followers, and missing ones have gone.

The builder below rewrites the script from step 4 for your list, your columns and the place where the file will open.

import csv
import requests

URL = "https://api.sorsa.io/v3/followers"
HEADERS = {"ApiKey": "YOUR_API_KEY"}
FIELDS = ["id", "username", "display_name", "description",
          "location", "followers_count", "created_at"]
RISKY = ("=", "+", "-", "@", "\t", "\r")


def cell(value):
    if isinstance(value, list):
        value = " ".join(value)
    if isinstance(value, str) and value.startswith(RISKY):
        value = "'" + value  # opens as text, never a formula
    return value


def export(username, path="followers.csv"):
    params = {"username": username}
    with open(path, "w", newline="", encoding="utf-8-sig") as f:
        out = csv.writer(f)
        out.writerow(FIELDS)
        while True:
            r = requests.get(URL, headers=HEADERS, params=params)
            r.raise_for_status()
            page = r.json()
            for user in page.get("users", []):
                out.writerow([cell(user.get(k)) for k in FIELDS])
            cursor = page.get("next_cursor")
            if not cursor:
                break
            params["next_cursor"] = cursor


export("northwind_roasters")

#Get follower counts for a list of accounts

To extract follower counts for many accounts at once, send up to 100 usernames or user IDs per request to GET /info-batch (opens in a new tab): every profile comes back with followers_count, followings_count and tweets_count, from $0.014 per 1,000 profiles.

Put one handle per line in handles.txt and run the script; it writes counts.csv with one row per account.

import csv
import requests

URL = "https://api.sorsa.io/v3/info-batch"
HEADERS = {"ApiKey": "YOUR_API_KEY"}
COLUMNS = ["username", "followers_count", "followings_count",
           "tweets_count"]

with open("handles.txt", encoding="utf-8") as f:
    handles = [h.strip().lstrip("@") for h in f if h.strip()]

with open("counts.csv", "w", newline="", encoding="utf-8-sig") as f:
    out = csv.writer(f)
    out.writerow(COLUMNS)
    for i in range(0, len(handles), 100):
        batch = {"usernames": handles[i:i + 100]}
        r = requests.get(URL, headers=HEADERS, params=batch)
        r.raise_for_status()
        for user in r.json().get("users", []):
            out.writerow([user.get(k) for k in COLUMNS])

Ten thousand accounts take 100 requests, which the free 100 cover whole; the official X API bills $0.010 per user, $100 for the same list.

Turn your X archive into a full follower list

X's data archive (opens in a new tab) includes your own followers, but its data/follower.js file lists each one only as an accountId and a link: no name, no bio, no counts. Send those IDs to GET /info-batch as user_ids, 100 at a time, and every row becomes a full profile.

import json

with open("data/follower.js", encoding="utf-8") as f:
    raw = f.read()
rows = json.loads(raw[raw.index("["):])
ids = [row["follower"]["accountId"] for row in rows]
# send ids[i:i + 100] as "user_ids" to GET /info-batch

The archive covers only the account you sign in with and can take days to arrive, so it suits a one-off backup of your own list. The API route reaches any public account today.

#How the ways to export followers compare

Only an API reaches the end of any public account's list; the ways differ in setup, in what each row holds and in the price per 1,000 followers.

• Sorsa API

  Whose list

  Any public account, every page

  What you get

  19 profile fields per follower, no X account at risk

  Cost per 1,000 followers

  From $0.007

• Official X API

  Whose list

  Any public account

  What you get

  Profiles, after a developer account and an OAuth token

  Cost per 1,000 followers

  $10.00

• Browser extension

  Whose list

  Any public account, while your session lasts

  What you get

  Rows read through your logged-in X account; free tiers stop at a few hundred

  Cost per 1,000 followers

  A subscription past the free tier

• X data archive

  Whose list

  Only your own account

  What you get

  Account IDs and links, no names, ready in days

  Cost per 1,000 followers

  Free

A browser extension scrolls the list inside your own X session, so every export runs as your account, and one popular extension's store page advises a separate X account just for exporting. Sorsa API never asks for your X login or cookies, so an export puts no X account of yours at risk, and there is nothing to install in your browser.

#Start with 20K followers, free

For the whole follower list of any public account, use Sorsa API: 200 followers per request, from $0.007 per 1,000, and the first 20K followers free with no card. Get a key, paste the script from step 4 and open the file with the import steps above. The same cursor loop exports an account's posts as well, as the guide to download all tweets from a user shows.

#FAQ