How to Export Twitter Followers via API in 2026 ($0.001/Call, No OAuth)

Exporting a Twitter (X) follower list at scale used to mean one of two paths. The first was the official X Enterprise tier, starting at $42,000 per month for commercial access to user-level data. The second was a headless browser stack with residential proxies and CAPTCHA-bypass infrastructure -- fragile, expensive at volume, and a maintenance treadmill every time the X frontend shipped a redesign.

GetXAPI collapses both paths. One GET request returns 200 followers with full profile data. Each call is $0.001. A 100,000-follower account exports in 500 calls for $0.50. A 1,000,000-follower account exports in 5,000 calls for $5.

This guide covers the endpoint, the response shape, the pagination model, and the code patterns that actually ship.

The Endpoint

GET https://api.getxapi.com/twitter/user/followers

Required parameter:

• userName (string) -- Screen name without the @ symbol

Optional parameter:

• cursor (string) -- Pagination cursor returned on the previous call

Cost: $0.001 per call. Each call returns ~200 followers ordered by follow time descending.

Auth: Bearer token in the Authorization header. Sign up at /signup for an API key and $0.10 in free credit (covers 100 calls = ~20,000 followers).

The Response Shape

Every call returns the same envelope structure:

{
  "userName": "elonmusk",
  "user_count": 200,
  "has_more": true,
  "next_cursor": "1809-...",
  "followers": [
    {
      "type": "user",
      "id": "1234567890",
      "userName": "examplehandle",
      "name": "Example Display Name",
      "url": "https://twitter.com/examplehandle",
      "isVerified": false,
      "isBlueVerified": true,
      "profilePicture": "https://...",
      "coverPicture": "https://...",
      "description": "Founder building something",
      "location": "San Francisco",
      "followers": 4321,
      "following": 1234,
      "tweets": 567,
      "listed": 8,
      "createdAt": "2018-04-12T...",
      "canDm": true
    }
  ]
}

Sixteen fields per follower. Enough for ICP filtering (followers > 1K, location ~= "SF", description ~= "founder"), lead scoring (account age + post count + listed memberships), outbound preparation (canDm: true), and audience analysis (verified ratio, follower-of-follower distribution).

Python: Export All Followers

The minimum viable follower exporter with no dependencies beyond requests:

import os
import time
import requests

API_KEY = os.environ["GETXAPI_KEY"]
BASE_URL = "https://api.getxapi.com/twitter"

def export_followers(user_name: str, max_followers: int | None = None) -> list[dict]:
    """Pull all followers (or up to max_followers) for a given Twitter handle."""
    all_followers = []
    cursor = None
    while True:
        params = {"userName": user_name}
        if cursor:
            params["cursor"] = cursor
        response = requests.get(
            f"{BASE_URL}/user/followers",
            headers={"Authorization": f"Bearer {API_KEY}"},
            params=params,
            timeout=60,
        )
        response.raise_for_status()
        data = response.json()
        all_followers.extend(data["followers"])
        if max_followers and len(all_followers) >= max_followers:
            return all_followers[:max_followers]
        if not data.get("has_more"):
            break
        cursor = data["next_cursor"]
        time.sleep(0.1)  # gentle pacing
    return all_followers

# Export the first 1,000 followers of @stripe
followers = export_followers("stripe", max_followers=1000)
print(f"Pulled {len(followers)} followers")
print(f"First follower: {followers[0]['userName']} ({followers[0]['followers']} followers)")

The function paginates automatically using the next_cursor, stops at max_followers or when has_more is false, and returns the full list with all 16 fields per follower.

Node.js: Same Thing, Async

const API_KEY = process.env.GETXAPI_KEY!;
const BASE_URL = "https://api.getxapi.com/twitter";

interface Follower {
  id: string;
  userName: string;
  name: string;
  followers: number;
  following: number;
  description: string;
  location: string;
  isVerified: boolean;
  isBlueVerified: boolean;
  canDm: boolean;
  createdAt: string;
}

async function exportFollowers(
  userName: string,
  maxFollowers?: number,
): Promise<Follower[]> {
  const all: Follower[] = [];
  let cursor: string | null = null;
  while (true) {
    const params = new URLSearchParams({ userName });
    if (cursor) params.set("cursor", cursor);
    const r = await fetch(`${BASE_URL}/user/followers?${params}`, {
      headers: { Authorization: `Bearer ${API_KEY}` },
    });
    if (!r.ok) throw new Error(`Followers API ${r.status}`);
    const data = await r.json();
    all.push(...data.followers);
    if (maxFollowers && all.length >= maxFollowers) {
      return all.slice(0, maxFollowers);
    }
    if (!data.has_more) break;
    cursor = data.next_cursor;
  }
  return all;
}

const followers = await exportFollowers("stripe", 1000);
console.log(`Pulled ${followers.length} followers`);

Same shape, async/await pattern. Both implementations finish at 30 lines or less.

The Cost Math

Pricing is $0.001 per call. Each call returns ~200 followers. Real exports at common account sizes:

Target account size	Calls needed	Cost
1,000 followers	5	$0.005
10,000 followers	50	$0.05
100,000 followers	500	$0.50
1,000,000 followers	5,000	$5
10,000,000 followers	50,000	$50
100,000,000 followers (@elonmusk tier)	500,000	$500

Compare to the official X API where commercial-tier follower access starts at the $42,000/month Standard tier minimum. The third-party path is 100x to 100,000x cheaper depending on volume.

Filter Client-Side for ICP

The endpoint returns all followers ordered by follow time. Filter client-side after the pull for the ICP slice you actually need:

def filter_icp(followers: list[dict], min_followers: int = 1000, bio_keywords: list[str] | None = None,
               must_canDm: bool = False, location_match: str | None = None) -> list[dict]:
    """Filter follower list to ICP shape."""
    out = []
    for f in followers:
        if f.get("followers", 0) < min_followers:
            continue
        if must_canDm and not f.get("canDm"):
            continue
        if location_match and location_match.lower() not in (f.get("location") or "").lower():
            continue
        if bio_keywords:
            desc = (f.get("description") or "").lower()
            if not any(kw.lower() in desc for kw in bio_keywords):
                continue
        out.append(f)
    return out

# Founders in SF with open DMs, 1K+ followers
icp = filter_icp(followers, min_followers=1000, bio_keywords=["founder", "ceo"],
                  must_canDm=True, location_match="San Francisco")
print(f"ICP slice: {len(icp)} / {len(followers)} ({len(icp)/len(followers)*100:.1f}%)")

ICP ratios across the GetXAPI cohort: typical "tech founder" filter on a 100K-follower B2B account yields 2-6% -- so 2,000-6,000 qualified profiles per 100K-follower export.

Common Production Issues

Three issues show up consistently:

• Private accounts return empty. The API only sees public follower lists. Private/protected accounts hide their followers at the platform level.
• Suspended-account followers. Some returned follower entries point to accounts later suspended by X. The data is the snapshot at follow time, not real-time presence. Filter followers > 0 or tweets > 0 as a presence heuristic.
• Rate-limit collisions on high concurrency. Each call is independent, but X's backend rate-limits at high concurrency. If you need > 10 parallel requests per second per target account, batch across multiple accounts instead of stacking on one.

For more depth on production patterns (retries, proxy rotation, cost monitoring), see the GetXAPI best practices guide.

Use Cases This Unlocks

The follower-export endpoint is the foundation for several workflows:

• B2B lead generation. Export followers of a competitor's account, filter for ICP fit, hand off to an outbound stack. Most common use case.
• Influencer audience analysis. Pull a KOL's followers to check for bot-skew, verify audience quality before paying for a placement.
• Audience overlap analysis. Pull followers of 2-3 target accounts, intersect the sets, identify the prospects who follow all three (high-intent signal).
• Account age cohorting. Filter by createdAt to separate established accounts from recently created (anti-bot heuristic).
• DM-open audit. Filter for canDm: true to scope an outbound list to accounts where DM is technically possible.

Each of these is a single Python script on top of the endpoint above.

Migrating from the Official X API

If you have existing code calling the official X v2 /2/users/:id/followers endpoint, the migration is a base-URL swap and a parameter rename:

# OLD (X API v2, requires Enterprise tier for >100 followers/call)
url = f"https://api.x.com/2/users/{user_id}/followers"
headers = {"Authorization": f"Bearer {BEARER_TOKEN}"}
# X v2 returns ~100 followers per page, paginates via "next_token"

# NEW (GetXAPI, $0.001 per 200-follower page)
url = "https://api.getxapi.com/twitter/user/followers"
headers = {"Authorization": f"Bearer {GETXAPI_KEY}"}
params = {"userName": user_name}  # username, not user_id
# Returns ~200 followers per page, paginates via "next_cursor"

Field names map cleanly. user.username → follower.userName. user.public_metrics.followers_count → follower.followers. user.public_metrics.tweet_count → follower.tweets. Most migrations finish in under an hour for code that was already using the v2 followers endpoint.

For a fuller comparison of GetXAPI vs the official v2 API, see the Twitter API v2 vs GetXAPI breakdown.

Getting Started

The fastest path to a working follower export:

• Sign up at /signup and grab the $0.10 free credit (covers 100 calls = ~20,000 followers)
• Run the Python example above against a public account you care about
• Pipe the output to a CSV or your CRM directly
• Layer ICP filters per your audience definition

End-to-end, the first working export takes about 15 minutes including signup. For higher-volume workloads (1M+ followers, multi-account batches, hourly delta exports), the best Twitter API for scraping post covers the production stack patterns. For Python-specific patterns on other endpoints (search, user details, sentiment), see the Python Twitter API tutorial.