How to Scrape Twitter (X) Followers (2026)

How to scrape Twitter followers is the question I field most from teams doing audience research, and the honest answer shifted in 2023. In July 2026 I ran every route that still returns a Twitter (X) follower list against live public accounts and kept the code that worked. The short version: the anonymous, no-login tricks in older tutorials are dead for follower and following lists, but three routes still pull them. Below is what I ran, what each one returns, and what it costs in money and upkeep.

A follower list behaves nothing like a public tweet. X hands a profile’s recent tweets to logged-out visitors in a limited way, but the /followers and /following pages sit behind the login wall, and X’s robots.txt disallows automated access to both paths. That single fact decides every method here.

Can you still scrape Twitter (X) followers in 2026?

You can still scrape Twitter followers in 2026, but every working route needs a logged-in X session somewhere, because follower and following lists are login-gated and no anonymous tool reaches a full list. The guest-token trick that pulls public tweets does not carry over here: X demands an authenticated session to page through a follower list at all.

That leaves three practical routes, and the rest of this guide walks each one with code you can run.

The real difference between them is who holds the logged-in session and the proxies: you, or a service. Before you pick one, it helps to know exactly which fields a follower list hands back, because that decides whether a given route gives you enough.

What data is in a Twitter follower and following list?

A Twitter follower and following list returns one user object per account, and the fields that matter are the username, numeric user ID, display name, bio, follower count, verified flag, and join date. A follower list is the set of accounts that follow your target, and a following list is the set of accounts your target follows. Both arrive in the same user-object shape, so one parser handles either.

The bio field is the one lead-generation workflows lean on, since a public email or company link in a follower’s description is the raw input an outreach list is built from. One limit applies to every field above: it exists only for public accounts. A protected account hides its follower list, so no method reaches it. With the target fields defined, here is the DIY route in Python.

How do you scrape Twitter followers with Python?

You scrape Twitter followers with Python by using a cookie-auth library that replays X’s internal GraphQL API with a logged-in account’s session cookies, because the login wall on follower lists rules out the anonymous guest-token method that works for public tweets. Two maintained libraries do this in 2026: twscrape and Scweet. Both need the auth_token and ct0 cookies from a real, logged-in X account, so a dedicated throwaway account, never your personal one, is standard practice.

twscrape with an account pool

twscrape scrapes followers by managing a pool of logged-in accounts and rotating them when X rate-limits the follows endpoint, which is what lets it page through a list larger than one account can pull. You add each account’s cookies once, resolve the target handle to its numeric ID, then call the followers method. The twscrape repo documents followers and following taking a user_id:

import asyncio
from twscrape import API, gather

async def main():
    api = API()  # local SQLite account store
    # Add a dedicated throwaway account's cookies once (auth_token + ct0).
    await api.pool.add_account(
        "user", "pass", "user@mail.com", "mail_pass",
        cookies="auth_token=...; ct0=...",
    )
    await api.pool.login_all()

    user = await api.user_by_login("nasa")               # resolve handle -> id
    followers = await gather(api.followers(user.id, limit=500))
    following = await gather(api.following(user.id, limit=500))

    for f in followers:
        print(f.username, "-", f.displayname, "-", f.followersCount)

asyncio.run(main())

twscrape keeps accounts in SQLite and tracks rate-limit state per account per endpoint, so the pool keeps collecting while one account cools down. I keep working accounts out of a public guide, so the cookies above are placeholders, but the call shape matches the maintained README. The maintainer notes that X’s terms discourage running multiple accounts, so the pool approach carries a real suspension risk you take on knowingly.

Scweet with a single session

Scweet scrapes followers and following through the same web endpoints using one logged-in account’s cookies, and it is the cleaner pick when you would rather not run a pool. Per the Scweet documentation, the current methods take a list of handles and a limit:

# `s` is a Scweet client configured with your logged-in cookies (see the README).
followers = s.get_followers(["nasa"], limit=1000)
following = s.get_following(["nasa"], limit=1000)

print(len(followers), "followers")
print(followers[0])   # username, display name, bio, follower count

Scweet derives the ct0 token from auth_token alone and can rotate several accounts, each behind its own proxy, from a cookies.json file, which is what lifts its ceiling past a single session. The cookie and proxy setup is the fiddly part, and I walk through capturing auth_token in my guide on scraping Twitter with Python. Both libraries share one weakness: they break whenever X rotates its internal query IDs, so the upkeep never really ends. When that upkeep outgrows the value, the next route removes it entirely.

How do you scrape followers and following without managing accounts?

You scrape followers and following without managing accounts by sending an X username to a managed scraper API and getting the parsed list back as JSON, with the logged-in session, pagination cursors, and proxy rotation all handled server-side. You send one authenticated GET request and receive structured user objects, so none of the cookie or account work lands on you. The request is a plain GET with your API key as a query parameter:

curl "https://chocodata.com/api/v1/twitter/followers?username=nasa&api_key=$CHOCO_API_KEY"

The Python version is the same shape and drops straight into pandas, then writes the follower list to CSV for analysis:

import requests
import pandas as pd

resp = requests.get(
    "https://chocodata.com/api/v1/twitter/followers",
    params={"username": "nasa", "count": 200, "api_key": "YOUR_CHOCO_API_KEY"},
    timeout=30,
)
resp.raise_for_status()
followers = resp.json()["data"]["followers"]

df = pd.DataFrame(followers)[["username", "name", "followers_count", "verified"]]
df.to_csv("nasa_followers.csv", index=False)
print(df.head())

To pull the following list instead, you change the resource to /api/v1/twitter/following and read resp.json()["data"]["following"] the same way. When I benchmarked follower scrapers in June 2026, the managed route returned the full follower and following lists as complete user objects, with pagination through a large list handled on the server, so I never touched a cursor or a cookie. You can start on ChocoData with a free tier and drop your key into the snippet above.

The cost case is why this route exists at all. Reading follows through the official X API runs about $0.010 per follows resource for other users’ accounts, per the X API pricing, which works out to roughly $10 per 1,000 followers. A managed scraper returns the same fields at a fraction of that at any real scale. For a ranked head-to-head of the managed options, see my best Twitter scrapers in 2026 roundup. Whichever route you choose, the wall you actually hit is rate-limiting, which is worth understanding before a large pull.

Why do Twitter follower scrapers get rate-limited or blocked?

Twitter follower scrapers get rate-limited or blocked because the logged-in account behind the request hits X’s follows-lookup ceiling fast, and a single account stalls after a few thousand followers. The block is enforced on the account and its session, not on the User-Agent string, so a DIY scraper running one account cannot brute-force a large list.

The numbers set the ceiling. The X rate-limits documentation puts the follows-lookup endpoint at 15 requests per 15 minutes, with up to 1,000 users per page, which caps a single app at roughly 15,000 followers a quarter hour before pricing even applies. The unofficial web route hits a different wall: X soft-limits a logged-in account after a few thousand records in one session, then starts returning partial pages or challenges.

Two things push past that ceiling. Rotating multiple accounts, cooling each one after it trips the limit, is what twscrape’s pool does and what a managed API does across a larger fleet. And spreading requests over residential proxies keeps any single IP from being flagged. Running both yourself is a maintenance project, and handing them to a service is the trade a managed API makes. Rate limits are the technical wall, but there is also a legal one specific to follower data.

Is it legal to scrape Twitter followers?

Scraping Twitter followers sits on shakier ground than scraping public tweets, because follower and following lists are login-gated and X’s robots.txt explicitly disallows automated access to /*/followers and /*/following. US courts have protected logged-out scraping of public data, in hiQ v. LinkedIn and in the Bright Data rulings against Meta and X, but a follower list read from behind a login is a weaker position than a public, logged-out page. The favorable case law is thinnest exactly where follower scraping lives.

Two limits stack on top of that. A follower list is personal data, so data-protection rules apply, and regulators have said there is no blanket exemption for information just because it is publicly visible. X’s Terms of Service also set liquidated damages of $15,000 for accessing more than 1,000,000 posts in 24 hours by automated means without permission. None of this makes reading a public follower list a criminal act, but it does mean scale, resale, and logged-in collection carry real exposure. I go through the platform rules in full in my guide on the X Terms of Service and scraping.

Sources

• X robots.txt - live-read July 2026, disallows /*/followers, /*/following, /*/media, /search/realtime - https://x.com/robots.txt
• X API pricing - per-resource cost of about $0.010 for other users’ follows resources - https://docs.x.com/x-api/getting-started/pricing
• X API rate limits - follows-lookup limit of 15 requests per 15 minutes, up to 1,000 users per page - https://docs.x.com/x-api/fundamentals/rate-limits
• twscrape (vladkens/twscrape) - api.followers / api.following account-pool API for follower lists - https://github.com/vladkens/twscrape
• Scweet (Altimis/Scweet) - get_followers / get_following cookie-auth library with proxy rotation - https://github.com/Altimis/Scweet
• X Terms of Service - $15,000 liquidated damages for automated access above 1,000,000 posts in 24 hours - https://x.com/en/tos