Twitter followers API for any account

#How the official X API returns followers in 2026

The official X API returns followers through GET /2/users/{id}/followers, up to 1,000 per page, and bills every follower it returns as a $0.010 read on its pay-per-use rate card: $10.00 per 1,000. To glance at the 20 newest followers of a public account without code, the free Twitter Recent Followers Tracker shows them in a browser.

In short, the official route takes a numeric ID, a developer account and OAuth, and charges for every follower it returns; the details below come from docs.x.com, read on November 2, 2026:

• Endpoints

  Official X API

  /followers and /following, both under GET /2/users/{id}

• Which account

  Official X API

  The numeric user ID only, not a handle

• Access

  Official X API

  A developer account, prepaid credits, and an OAuth 2.0 user token with follows.read or an app bearer token

• Page size

  Official X API

  Up to 1,000 (max_results); the next page comes by pagination_token

• Rate limit

  Official X API

  300 requests per 15 minutes, per app and per user

• Price

  Official X API

  $0.010 per follower read; $0.001 when the list is your own app owner's

Many answers, Google's AI summaries among them, still say the endpoint is for Enterprise customers only. That was the rule from June 26, 2023, when X removed follows lookup from its Basic and Pro tiers, and it is stale now: pay-per-use, open to every new developer since February 6, 2026, lists follower reads on its public rate card.

Two more rules shape the job. X bills the same follower once per UTC day, however often you read it, and since April 20, 2026 self-serve apps can no longer follow or unfollow accounts through the official X API. The rate limit caps one app at 300 pages of up to 1,000 per 15 minutes, which is 300K followers; the guide to X API rate limits covers every other endpoint.

#Get followers with Sorsa API in four steps

For an account's followers in code, use Sorsa API, a Twitter (X) API and scraper: GET /followers returns up to 200 follower profiles per request from $0.007 per 1,000, takes a handle instead of a numeric ID, and needs one API key with no developer account or OAuth. Every plan runs at 20 requests per second per key.

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 a username, user_id or user_link to GET /followers (opens in a new tab) with the key in the ApiKey header.

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

   {
     "users": [
       {
         "id": "1718233069912377344",
         "username": "quietpine_studio_co",
         "display_name": "Quiet Pine Studio",
         "description": "Ceramics and slow coffee. Ships from Asheville.",
         "location": "Asheville, NC",
         "created_at": "2023-10-28T11:04:52Z",
         "followers_count": 3120,
         "followings_count": 418,
         "tweets_count": 1876,
         "verified": false,
         "protected": false,
         "bio_urls": ["https://quietpine.example"]
       }
     ],
     "next_cursor": "1846521730994411520"
   }
   

   Show full response

3. Send the cursor back. Pass next_cursor from each response as the next_cursor parameter of the next request. A response where it is empty or missing is the last page.

4. Loop until the list ends. The function below reads any list endpoint to the end and waits a second whenever the key goes past 20 requests per second.

   import time
   import requests
   
   API = "https://api.sorsa.io/v3"
   HEADERS = {"ApiKey": "YOUR_API_KEY"}
   
   
   def get_page(path, params):
       """One GET request; on 429 it waits a second and tries again."""
       while True:
           r = requests.get(API + path, headers=HEADERS, params=params,
                            timeout=30)
           if r.status_code == 429:  # more than 20 requests in one second
               time.sleep(1)
               continue
           r.raise_for_status()
           return r.json()
   
   
   def all_users(path, username):
       """Every account in a list endpoint, one page of 200 at a time."""
       params = {"username": username}
       while True:
           page = get_page(path, params)
           yield from page.get("users", [])
           cursor = page.get("next_cursor")
           if not cursor:
               return
           params["next_cursor"] = cursor
   
   
   followers = list(all_users("/followers", "lumen_kitchen_labs"))
   print(len(followers), "followers")
   

   // followers.mjs, Node.js 18 or later
   const API = "https://api.sorsa.io/v3";
   const headers = { ApiKey: "YOUR_API_KEY" };
   const pause = (ms) => new Promise((done) => setTimeout(done, ms));
   
   async function* allUsers(path, username) {
     const query = new URLSearchParams({ username });
     for (;;) {
       const res = await fetch(`${API}${path}?${query}`, { headers });
       if (res.status === 429) {
         await pause(1000); // more than 20 requests in one second
         continue;
       }
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       const page = await res.json();
       yield* page.users ?? [];
       if (!page.next_cursor) return;
       query.set("next_cursor", page.next_cursor);
     }
   }
   
   const followers = [];
   for await (const user of allUsers("/followers", "lumen_kitchen_labs")) {
     followers.push(user);
   }
   console.log(followers.length, "followers");
   

A 403 means the key is missing or its requests have run out; a protected account returns an error as well, and failed requests are never charged. Pages come newest first, so page one always holds the latest followers, which the tracking section below puts to work.

#Get the list of accounts a user follows

To get the list of accounts a user follows on X, call GET /follows (opens in a new tab) with the same handle, ID or profile link: Sorsa API returns up to 200 followed accounts per request, newest first, with the same cursor, so the loop from step 4 changes in one word.

following = list(all_users("/follows", "lumen_kitchen_labs"))
following.sort(key=lambda u: u["followers_count"], reverse=True)
for user in following[:10]:  # the biggest accounts it follows
    print(user["username"], user["followers_count"])

A following list is usually far shorter than a follower list, so it is cheap to read whole: an account that follows 1,500 others takes 8 requests. It shows whom the account reads, from suppliers and rivals to the creators and news sources it watches. Read next to the follower list, it also shows who follows back: the IDs that sit in both. For a quick look without code, the Recent Followers Tracker above also lists the 20 accounts it followed most recently.

To save either list as a CSV or Excel file, the guide to export Twitter followers covers files that open cleanly.

#Which endpoint answers which follower question

Sorsa API answers each common follower question with its own endpoint, and bills every one per request, never per profile returned.

• Who follows this account?

  Endpoint

  GET /followers

  Per request

  Up to 200 followers

• Whom does it follow?

  Endpoint

  GET /follows

  Per request

  Up to 200 accounts

• Which of its followers are verified?

  Endpoint

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

  Per request

  One page, same cursor

• Does account B follow account A?

  Endpoint

  POST /check-follow (opens in a new tab)

  Per request

  One answer: follow true or false

• How many followers does it have?

  Endpoint

  GET /info (opens in a new tab)

  Per request

  One profile with followers_count

• Follower counts for many accounts

  Endpoint

  GET /info-batch (opens in a new tab)

  Per request

  Up to 100 profiles

• Who is on an X List, or follows it?

  Endpoint

  GET /list-members (opens in a new tab), GET /list-followers (opens in a new tab)

  Per request

  One page, same cursor

Only the verified followers

GET /verified-followers takes the same input and cursor as GET /followers and returns only accounts with a verified badge. On a large account that skips most of the pages, because verified accounts are a small minority of most audiences: you never read the rows you would filter out anyway.

Check one follow relationship

POST /check-follow answers whether one account follows another in a single request, from $0.0014 per check, however long either list is. username_1 is the account that should be followed and username_2 the account you check; a user_id_* or user_link_* works on either side.

curl -X POST "https://api.sorsa.io/v3/check-follow" \
  -H "ApiKey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"username_1": "lumen_kitchen_labs",
       "username_2": "quietpine_studio_co"}'

The answer covers one direction, so a mutual follow takes two calls with the sides swapped. Checks for giveaways and campaigns, with retweets, quotes and replies next to follows, are in the guide to the Twitter verification API. Members and followers of X Lists have their own guide: the Twitter List API.

#What each follower record contains

Each follower arrives as a full public profile with 19 fields, the same object every Sorsa API profile endpoint returns, so filtering and scoring need no second request.

The fields fall into six groups, and most audience work uses the first four:

• Identity

  Fields

  id, username, display_name, created_at

• Reach

  Fields

  followers_count, followings_count

• Activity

  Fields

  tweets_count, media_count, favourites_count, pinned_tweet_ids

• Topic and place

  Fields

  description, bio_urls, location

• Flags

  Fields

  verified, protected, can_dm, possibly_sensitive

• Images

  Fields

  profile_image_url, profile_background_image_url

Three rules keep the data honest:

• Key everything on the ID. Account IDs in id never change and arrive as strings; handles change whenever their owner likes. If you need only follower IDs, keep the id of each record: they come with the full profiles at no extra cost. Keep IDs as strings in JavaScript too: X IDs run to 19 digits, and JavaScript numbers stay exact only to 16.
• Expect the list to differ from the count by a few percent. followers_count is X's live total, while the list leaves out accounts that were suspended or deactivated.
• Read profiles as they are today. Each record shows the follower's current bio and counts, not the state on the day they followed.

Good to know

GET /followers carries no follow date, because X's public follower list doesn't show when a follow happened. To date new followers, check on a schedule and record the day each ID first appears; the next section shows how.

#Track new followers and unfollowers

To track new followers by API, keep the follower IDs you saw last time and compare: since pages come newest first, a check reads only until it meets an ID it already knows, so it costs one request whenever fewer than 200 followers arrived since the last one.

Unfollowers need the whole list: an ID present in last week's full read and missing from today's has gone. Run the cheap check daily or hourly, and the full read weekly or monthly. Both functions reuse get_page and all_users from step 4.

def new_followers(username, known):
    """Followers added since the last check. Pages come newest first,
    so the loop stops at the first page that holds a known ID."""
    params, found = {"username": username}, []
    while True:
        page = get_page("/followers", params)
        users = page.get("users", [])
        fresh = [u for u in users if u["id"] not in known]
        found += fresh
        cursor = page.get("next_cursor")
        if len(fresh) < len(users) or not cursor:
            return found
        params["next_cursor"] = cursor


def unfollowed(username, last_full_read):
    """IDs from the last full read that no longer follow."""
    now = {u["id"] for u in all_users("/followers", username)}
    return last_full_read - now, now

Before you count an ID as an unfollow, look it up with GET /info-batch: an account that was suspended or deleted drops out of every follower list too. The checks run on your schedule, and the cost stays small: 25 accounts of 50K followers each, checked daily and read in full once a month, take about 7,000 requests a month.

#Filter followers and find audience overlap

Every follower record already carries its counts, bio and flags, so filtering a list is a few lines of code and no extra requests. Its location is whatever the user typed; for the country X itself assigns, the Twitter location API guide maps an audience by country with GET /about.

followers = list(all_users("/followers", "lumen_kitchen_labs"))
shortlist = [
    u for u in followers
    if u["followers_count"] >= 1000          # some reach
    and u["tweets_count"] >= 100             # posts regularly
    and not u["protected"]
    and "coffee" in (u.get("description") or "").lower()
]

The accounts that follow two or more of your rivals are the most engaged people in your market. Read each rival's list once and count how often every ID appears:

from collections import Counter

rivals = ["lumen_kitchen_labs", "copperleaf_cookware", "saltmarsh_pantry"]
lists = {h: {u["id"] for u in all_users("/followers", h)} for h in rivals}
seen = Counter(i for ids in lists.values() for i in ids)
core = {i for i, n in seen.items() if n >= 2}
smallest = min(len(ids) for ids in lists.values())
print(f"{len(core)} accounts follow 2+ rivals, "
      f"{len(core) / smallest:.1%} of the smallest audience")

Measure overlap against the smallest audience, not the total: a shared slice of 2,000 means a lot to a 5K account and little to a 2M one. To compare two accounts without code, the free Twitter Audience Overlap Checker does it in a browser, and turning those core accounts into prospects is the subject of how to find leads on Twitter.

#Find and vet Twitter influencers with the API

To find and vet Twitter influencers by API, search for creators by bio keywords and topics, enrich their profiles in batches, then score each one on recent engagement and audience quality. Sorsa API covers every step read-only, from public metrics: likes, replies, reposts, quotes and views.

Discover creators by niche

• By bio and name: POST /search-users (opens in a new tab) finds accounts by keyword, bios included, about 20 per page; filter by follower tier, verification status, location and post count.
• By the topics they drive: POST /search-tweets (opens in a new tab) runs X's search operators, and the authors of the top posts on a topic are its active voices.
• From curated lists: GET /list-members reads X Lists that someone already built for a niche, and GET /info-batch enriches any candidate list 100 profiles at a time.

Vet them on real engagement

Engagement rate is the interactions on recent posts (likes, replies, reposts and quotes) per post, divided by followers or by views. POST /user-tweets (opens in a new tab) returns about 20 recent posts per request with every count, and POST /tweet-info-bulk (opens in a new tab) reads up to 100 chosen posts at once. There is no black-box score: the inputs are X's public counts, and the formula is yours to tune.

def engagement_rate(username):
    """Interactions per post, per follower and per view."""
    # the latest page of posts; API and HEADERS come from step 4
    r = requests.post(API + "/user-tweets", headers=HEADERS,
                      json={"username": username}, timeout=30)
    r.raise_for_status()
    posts = r.json().get("tweets", [])
    if not posts:
        return None
    acts = sum(p["likes_count"] + p["reply_count"] + p["retweet_count"]
               + p["quote_count"] for p in posts)
    views = sum(p.get("view_count") or 0 for p in posts)
    followers = max(posts[0]["user"]["followers_count"], 1)
    return {"by_followers": acts / len(posts) / followers,
            "by_views": acts / views if views else None}

For a quick check of one account without code, the free Twitter Engagement Rate Calculator runs the same arithmetic.

Catch fake followers and bought engagement

Read one or two pages of a creator's newest followers and look for the signals that rarely appear together by chance:

• engagement far below what the follower count suggests;
• a follower sample full of accounts created last month, with empty bios, the default avatar or no posts;
• lopsided accounts that follow thousands and are followed by few;
• recent posts with plenty of views but almost no likes or replies.

The full method, with ten signals and a script that scores a whole follower list, is in the guide to Twitter bot detection.

Check the campaign after the deal

POST /user-tweets follows the creator's posts, POST /mentions (opens in a new tab) finds posts that mention your brand with min_likes and a since_date to until_date range, and POST /check-quoted (opens in a new tab) and GET /check-comment (opens in a new tab) confirm that a required quote or reply went live, from $0.0014 per check.

The whole run over 500 creators takes about 540 requests: 25 search pages, 5 batch calls, 500 timeline pulls and 10 follower pages. That is about $0.76 at Sorsa API's lowest rate and a small slice of the 10K requests in its smallest plan; the same reads at official X API rates cost about $75.

#What follower data costs per 1,000 followers

Sorsa API reads followers from $0.007 per 1,000, against $10.00 per 1,000 on the official X API: 1,000x less for the same public list.

At those rates 100K followers cost from $0.70 against $1,000, and 1M cost from $7 against $10,000. Even X's $0.001 rate for your own app's followers comes to $1.00 per 1,000. Sorsa API bills per request, not per profile: a page of 200 followers is one request, failed requests cost nothing, and checking your balance with GET /key-usage-info (opens in a new tab) is free. Every official price is broken down in the guide to X API pricing.

Recurring jobs cost what their reads add up to in a month. The planner below turns the accounts you watch and how often you check them into requests and money on both APIs.

#Fetch your first 20K followers today

For followers, following lists and follow checks in code, use Sorsa API: 200 followers per request, from $0.007 per 1,000, one API key and no developer account. Your 100 free requests read the first 20K followers; run the loop from step 4 against any public account and see the whole list come back.

#FAQ