How to Export Twitter Followers via API in 2026 ($0.0008/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.

TwitterAPIs collapses both paths. One GET request returns 200 followers with full profile data. Each call is $0.0008. A 100,000-follower account exports in 500 calls for $0.40. A 1,000,000-follower account exports in 5,000 calls for $4.00. The full endpoint reference lives on the Twitter followers API page.

This guide covers the endpoint, the response shape, the pagination model, and the code patterns that actually ship. For the product overview and pricing of the followers endpoint itself, see the Twitter Followers API page; this post is the how-to that walks through exporting a list end to end.

Why Follower Data Matters in 2026

Follower data has become one of the highest-signal datasets for B2B teams. When a prospect follows a competitor, a conference account, or a category-defining product, that follow is a behavioral signal that no survey or intent data tool captures as cleanly.

Behavioral-signal targeting is widely cited in B2B GTM playbooks as faster to convert than list-based prospecting, because social graph proximity captures intent that surveys and firmographic data miss. Follower exports are one of the cheapest ways to build a behavioral signal dataset.

The three most common follower export workflows TwitterAPIs teams run:

Competitor follower mapping. Pull the follower lists of 3-5 direct competitors. Intersect the lists. Accounts that follow multiple competitors in your space are likely decision-makers actively evaluating the category. These are your highest-priority outbound targets.

Conference and event audience capture. Major B2B conferences (SaaStr, Dreamforce, TNW) run Twitter accounts with tens of thousands of engaged followers. Pull the follower list of a conference account to build a pre-qualified list of founders and operators attending in your vertical. Filter by followers > 500 and description keyword match to remove noise.

KOL audience verification. Before paying for an influencer placement, export the KOL's followers and run quality checks: bot ratio (accounts with 0 tweets, 0 following, created within the last 30 days), geographic distribution, engagement-to-follower ratio. A 100K-follower account with 80% bot followers is worth far less than a 20K-follower account with genuine engagement.

Each of these workflows costs under $5 in API calls for accounts up to 1M followers.

The Endpoint

The follower export endpoint is GET https://api.twitterapis.com/twitter/user/followers. It accepts a userName parameter (the handle without @), returns up to 200 followers per call ordered by follow time descending, costs $0.0008 per call, and paginates via a next_cursor string in the response. Bearer token auth only, no developer app required.

GET https://api.twitterapis.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.0008 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.50 in free credit (covers ~625 calls = ~125,000 followers).

The Response Shape

Every call returns a JSON envelope with userName, user_count, has_more, next_cursor, and a followers array. Each follower object includes 16 fields: id, handle, display name, bio, location, follower count, following count, tweet count, listed memberships, account creation date, verification status, profile picture URLs, and a canDm boolean indicating whether DMs are open.

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 Python implementation below is the minimum viable follower exporter, using only the standard requests library. It paginates automatically via next_cursor, respects the has_more flag, applies a 100ms sleep between calls for gentle pacing, and returns the full follower list with all 16 fields per account.

import os
import time
import requests

API_KEY = os.environ["TWITTERAPIS_KEY"]
BASE_URL = "https://api.twitterapis.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

The TypeScript version below mirrors the Python pagination logic using async/await and typed interfaces. It accepts a userName and optional maxFollowers cap, paginates with a cursor, and returns a typed Follower[] array. Compatible with Node 18+ native fetch or a drop-in node-fetch import.

const API_KEY = process.env.TWITTERAPIS_KEY!;
const BASE_URL = "https://api.twitterapis.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.

Export to CSV

Most downstream workflows need CSV output for CRM import, spreadsheet analysis, or Airtable ingestion. The Python snippet below adds a save_followers_csv function that writes all 16 follower fields as columns, with extrasaction="ignore" so future API additions do not break the writer. A 5,000-follower export to stripe_followers.csv runs in about 3 seconds.

import csv

def save_followers_csv(followers: list[dict], filename: str) -> None:
    """Save follower list to CSV with all 16 fields."""
    if not followers:
        return
    fields = ["id", "userName", "name", "url", "isVerified", "isBlueVerified",
              "description", "location", "followers", "following", "tweets",
              "listed", "createdAt", "canDm"]
    with open(filename, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=fields, extrasaction="ignore")
        writer.writeheader()
        writer.writerows(followers)
    print(f"Saved {len(followers)} rows to {filename}")

followers = export_followers("stripe", max_followers=5000)
save_followers_csv(followers, "stripe_followers.csv")

The extrasaction="ignore" ensures extra fields from future API versions do not break the writer.

The Cost Math

Pricing is $0.0008 per call and each call returns roughly 200 followers, so the cost scales directly with account size. A 10,000-follower account exports in 50 calls for $0.04, a 100,000-follower account in 500 calls for $0.40, and a 1,000,000-follower account in 5,000 calls for $4.00. Compare that to the official X API where commercial-tier follower access starts at an Enterprise contract floor of $42,000 per month.

Target account size	Calls needed	Cost
1,000 followers	5	$0.004
10,000 followers	50	$0.04
100,000 followers	500	$0.40
1,000,000 followers	5,000	$4
10,000,000 followers	50,000	$40
100,000,000 followers (@elonmusk tier)	500,000	$400

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.

For a complete breakdown of API call costs across all endpoints, see the TwitterAPIs pricing page.

Filter Client-Side for ICP

The endpoint returns all followers ordered by follow time, not pre-filtered. Client-side filtering after the pull gives you the ICP slice you need. The filter_icp function below accepts minimum follower count, bio keywords, location string, and a canDm flag; typical "tech founder" criteria on a 100K-follower B2B account yields a 2-6% match rate, meaning 2,000-6,000 qualified profiles per export.

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 TwitterAPIs 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.

Async Export for Multiple Accounts

When pulling followers from several accounts simultaneously, running requests concurrently with aiohttp and asyncio.gather cuts total wall-clock time to roughly the time of the single largest account, not the sum. The pattern below fans out across any number of accounts and collects results in a dictionary keyed by username.

import asyncio
import aiohttp

API_KEY = os.environ["TWITTERAPIS_KEY"]

async def fetch_page(session: aiohttp.ClientSession, user_name: str, cursor: str | None) -> dict:
    params = {"userName": user_name}
    if cursor:
        params["cursor"] = cursor
    async with session.get(
        "https://api.twitterapis.com/twitter/user/followers",
        headers={"Authorization": f"Bearer {API_KEY}"},
        params=params,
    ) as resp:
        resp.raise_for_status()
        return await resp.json()

async def export_account(session: aiohttp.ClientSession, user_name: str) -> list[dict]:
    followers = []
    cursor = None
    while True:
        data = await fetch_page(session, user_name, cursor)
        followers.extend(data["followers"])
        if not data.get("has_more"):
            break
        cursor = data["next_cursor"]
        await asyncio.sleep(0.05)
    return followers

async def export_multiple(accounts: list[str]) -> dict[str, list[dict]]:
    async with aiohttp.ClientSession() as session:
        tasks = {name: export_account(session, name) for name in accounts}
        results = await asyncio.gather(*tasks.values(), return_exceptions=True)
    return dict(zip(tasks.keys(), results))

# Pull first 5K followers from 3 accounts simultaneously
accounts = ["stripe", "linear", "vercel"]
results = asyncio.run(export_multiple(accounts))
for name, followers in results.items():
    print(f"@{name}: {len(followers)} followers")

With 3 accounts running concurrently, the total time is roughly equal to the time for the single largest account, not the sum.

Common Production Issues

Three issues appear consistently in production follower export pipelines: private accounts returning empty results because their follower list is hidden at the platform level, suspended-account follower entries that point to accounts X later removed, and rate-limit collisions when stacking more than 10 parallel requests per second against the same target account.

• 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 TwitterAPIs best practices guide.

Building a Follower Delta Monitor

One of the highest-value follower pipeline variants is not a one-time export but a daily delta monitor: pull today's follower list, diff against yesterday's, and surface new followers for immediate outreach.

The pattern works because new followers are warm leads. Someone who just followed your account or your competitor's account has taken a voluntary action indicating interest. The average response rate to DMs sent within 24 hours of a follow event is significantly higher than cold DM outreach to lists assembled weeks earlier.

A basic delta monitor stores follower IDs with timestamps and computes the set difference:

The logic: store a snapshot of follower IDs each day. On the next run, pull the current list and compute the difference. New IDs that appear in the current list but not in the previous snapshot are new followers. IDs that disappear are unfollows.

For a 100K-follower account, a daily delta export costs $0.40 per run. Running it against 5 competitor accounts costs $2.00 per day, or $60 per month. That $60 buys you a daily list of decision-makers who just followed your competitors, qualified with ICP filters and DM-eligibility checks, ready for same-day outreach.

The key operational detail: run the delta pull at the same time each day to keep the comparison window consistent. New follows in the first few hours of a day will appear in the next day's delta if you are consistent about timing.

Follower Export Across Industries

Follower export usage patterns split by industry: B2B SaaS teams use competitor follower mapping as their primary outbound signal; VC analysts map portfolio company followers to find connected founders; developer-tool companies filter by bio keywords like "engineer" and "backend"; event marketers pull prior conference follower lists to build pre-registration audiences; and influencer buyers export a KOL's followers to check bot ratio before signing a placement deal.

B2B SaaS. The most common use is competitor follower mapping. SaaS teams export followers of 3-5 competitors, filter by job titles in bio (founder, VP, director, head of), then route to their outbound sequence. The description field gives a rough job title for 40-60% of accounts.

Venture capital and investment. VC analysts export followers of portfolio companies to find connected founders building adjacent products. The following count combined with listed memberships signals whether a follower is a passive observer or an active ecosystem participant.

Developer tools and APIs. Developer-tool companies export followers of developer-facing accounts (GitHub, Vercel, Stripe, etc.) filtered by bio keywords like "engineer," "developer," "backend," "fullstack." These are warm prospects for developer tool outreach with very high relevance.

Event marketing. Event organizers export followers of prior conference accounts (SaaStr, CES, etc.) to build pre-registration lists for similar events. Filtering by location narrows to geographic attendees.

Influencer marketing. Brands export a potential influencer's followers before signing a sponsorship deal. The export takes 5 minutes and gives a quality signal (bot ratio, follower-of-follower count, geographic distribution) that is far more reliable than third-party follower-count tools.

Each of these use cases is a few lines of Python on top of the follower export endpoint. The API cost is consistently under $10 for any practical workload.

Quality Control: Identifying Bot Accounts in Follower Lists

Raw follower exports from any large account contain a percentage of bot or low-quality accounts. Before using a follower list for outreach or analysis, a basic quality filter improves the signal:

A reliable bot-detection heuristic uses five fields from the follower response: account age, tweet count, follower-to-following ratio, listed memberships, and whether the account has a profile description. Accounts that fail three or more of these checks are likely bots or low-quality:

Account age below 90 days is a bot signal. Fresh accounts created in bulk for follow-back schemes or spam typically have createdAt within the past three months.

Tweet count below 10 is a bot signal. Real users tweet. An account that has existed for two years with fewer than 10 tweets is almost certainly inactive or a placeholder.

Following-to-follower ratio above 10

is a bot signal. Accounts that follow thousands but have few followers back are typically using follow-back farming strategies.

Zero listed memberships combined with zero tweets is a near-certain bot signal. Real accounts that are genuinely active in a community get added to lists by other users.

Empty description field is a mild signal on its own (many real users skip bio), but combined with the other indicators it adds weight to the bot classification.

Applying these five checks to a 10,000-follower export typically removes 15-35% of accounts as low-quality. The remaining 6,500-8,500 accounts are substantially higher quality for any downstream use. For outbound campaigns specifically, targeting the quality subset and leaving bot accounts untouched improves deliverability scores because you are not sending to accounts that will never respond.

Exporting Followers vs Exporting Following

The API provides two symmetric endpoints: /twitter/user/followers returns the accounts that follow a given user, while /twitter/user/following returns the accounts that user follows. Both return the same 16-field object at $0.0008 per call. Follower exports build outreach lists; following exports map the target's intellectual graph, revealing suppliers, advisors, and strategic partners through the CEO or founder's following list.

Follower export (who follows the target account) is useful for building outreach lists: these are people who have self-selected interest in the target.

Following export (who the target account follows) is useful for mapping the target's intellectual graph: who they learn from, which communities they participate in, which influencers they trust. For competitive intelligence, the following list of a competitor's CEO often reveals their suppliers, advisors, and strategic partners.

Both directions cost $0.0008 per call and return ~200 accounts per page. The pagination and response shape are identical. Most teams pull both directions when building a comprehensive contact profile for high-value target accounts.

Data Freshness and Staleness Considerations

Follower data from any API is a snapshot, not a live view. The moment you export a follower list, some accounts will follow and some will unfollow. For most downstream uses (outreach, analysis, segmentation), staleness within 24-48 hours is acceptable. For use cases requiring real-time follower state (checking whether a specific person follows before taking an action), re-query the individual user or use the follower list freshness heuristic below.

A simple freshness strategy: tag each exported follower record with an exported_at timestamp. When using the list for outreach, skip records older than your freshness threshold (7 days is reasonable for most campaigns). Run a daily delta pull to refresh recent followers and mark previously exported accounts as stale.

The practical implication is that large account exports (1M+ followers) should not be treated as single-run jobs. Export in batches, update incrementally, and maintain a timestamped record. TwitterAPIs's cursor-based pagination is stable across sessions: you can pause a large export mid-way, store the cursor value, and resume the next day without losing your position or receiving duplicates.

For follow-up communication with accounts identified through follower export, the window matters. A follower who joined three months ago is less warm than one who joined last week. Sorting by createdAt in descending order and working from the most-recently-followed end of the list consistently produces higher response rates than working through a stale bulk export from oldest to newest.

Connecting Follower Data to Your CRM

Connecting follower export data to a CRM involves four steps: export and filter to the ICP slice, enrich with email and company data via a service like Clay or Apollo at $0.10-$0.50 per contact, import the enriched records as leads, then trigger your existing outbound sequence. The follower data contributes three fields most B2B CRMs lack: social graph signal, behavioral intent from which accounts were recently followed, and DM channel viability via canDm.

First, export followers and apply ICP filters to get your qualified list. Second, enrich the list with additional data points (email lookup, LinkedIn URL, company information) using a data enrichment service. Third, import the enriched list into your CRM as leads or contacts. Fourth, trigger your existing outbound sequence from the CRM.

The Twitter follower data contributes three fields that most B2B CRMs lack on imported contacts: the account's actual social graph signal (follower count, listed memberships), behavioral intent data (which accounts they recently followed), and DM channel viability (the canDm field). These fields are meaningless to most CRM systems on their own, but they are valuable input to lead scoring models that rank prospects by engagement likelihood.

The export cost at scale: pulling 10,000 qualified followers from 10 competitor accounts (assuming ~5% ICP match rate across 200K total followers) costs $0.80 in API calls. The enrichment cost to turn those 10,000 handles into business email addresses is typically $0.10-$0.50 per enriched contact using tools like Clay or Apollo. The total data acquisition cost for 10,000 qualified, enriched contacts is $200-$600 in enrichment plus $0.80 in API calls -- far below the cost of purchasing a comparable contact list from a B2B data provider.

Use Cases This Unlocks

The follower export endpoint is the foundation for five recurring workflows: B2B lead generation from competitor follower lists, influencer audience quality checks before paying for a placement, audience overlap analysis by intersecting follower sets across multiple target accounts, account age cohorting using createdAt as a bot-detection heuristic, and DM-open audits filtering for canDm: true to scope outbound to reachable accounts.

• 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

Migrating from the official X v2 /2/users/:id/followers endpoint requires two changes: swap the base URL from api.x.com/2/users/:id/followers to api.twitterapis.com/twitter/user/followers, and change the id path parameter to a userName query parameter. Field names map directly with minor renames, and pagination changes from next_token to next_cursor. Most migrations finish in under an hour.

# 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 (TwitterAPIs, $0.0008 per 200-follower page)
url = "https://api.twitterapis.com/twitter/user/followers"
headers = {"Authorization": f"Bearer {TWITTERAPIS_KEY}"}
params = {"userName": user_name}  # username, not user_id
# Returns ~200 followers per page, paginates via "next_cursor"

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

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

Getting Started

The fastest path to a working follower export: sign up at /signup for an API key and $0.50 in free credits covering about 625 calls (roughly 125,000 followers), run the Python example above against any public account, and pipe the output to CSV. End-to-end, including signup, the first export typically takes about 15 minutes.

• Sign up at /signup and grab the $0.50 free credit (covers ~625 calls = ~125,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.

Scoring and Enriching Follower Data

Raw follower data from the API is useful, but adding a simple scoring layer turns it into a prioritized outbound list. A basic engagement-signal score using the 16 available fields:

from datetime import datetime, timezone

def score_follower(f: dict) -> float:
    """
    Score a follower from 0-100 based on engagement signals.
    Higher = more likely to be a qualified, active account.
    """
    score = 0.0

    # Follower count: log-scaled, caps at 30 points
    fc = f.get("followers", 0)
    if fc > 0:
        score += min(30, 10 * (fc ** 0.3 / 10))

    # Tweet activity: log-scaled, caps at 20 points
    tc = f.get("tweets", 0)
    if tc > 0:
        score += min(20, 5 * (tc ** 0.3 / 5))

    # List memberships: strong signal of recognized expertise
    listed = f.get("listed", 0)
    score += min(15, listed * 1.5)

    # Verification signals
    if f.get("isVerified"):
        score += 10
    elif f.get("isBlueVerified"):
        score += 5

    # Account age: older accounts are more trusted
    created = f.get("createdAt", "")
    if created:
        try:
            age_days = (datetime.now(timezone.utc) - datetime.fromisoformat(created)).days
            score += min(15, age_days / 365 * 5)
        except ValueError:
            pass

    # DM eligibility: practical signal for outreach
    if f.get("canDm"):
        score += 10

    return round(min(100, score), 1)

def rank_followers(followers: list[dict]) -> list[dict]:
    """Add score field and sort by score descending."""
    for f in followers:
        f["score"] = score_follower(f)
    return sorted(followers, key=lambda x: x["score"], reverse=True)

# Score and rank
ranked = rank_followers(followers)
top_100 = ranked[:100]
print(f"Top prospect: @{top_100[0]['userName']} (score {top_100[0]['score']})")

This scoring function weights account credibility (followers, listed memberships, verification, age) and outreach viability (canDm). Adjust weights for your ICP. A B2B SaaS team might weight listed higher; a consumer brand might weight follower count higher.

Understanding the Official X API Follower Restrictions

The official X API v2 restricts follower access. According to X's developer documentation, reading followers is capped at 100 follower IDs per call with 15 calls per 15-minute window, totaling ~1,500 followers per 15 minutes. Higher per-call limits and uncapped access are reserved for the most expensive negotiated Enterprise contracts, and on top of any access you pay roughly $0.005 per read under the pay-per-use model.

For reference, TwitterAPIs returns 200 full follower profiles (not just IDs) per call with no platform-level rate cap and no subscription requirement. At $0.0008 per call, pulling 1,500 followers costs $0.006 and takes under 10 seconds.

The follower data available through the official API also returns fewer fields by default. The v2 /followers endpoint requires explicit user.fields expansions to get profile data beyond ID and name, and some fields (like DM eligibility) are not available through any official API tier. TwitterAPIs's response includes all 16 fields in every call without additional parameters.

According to the official X developer samples repository, client-library updates ship alongside API tier restructuring, and the popular tweepy Python wrapper has had multiple breaking changes across major versions since 2021. Third-party adapters absorb these changes server-side, leaving your code unchanged.

Frequently Asked Questions

The questions below cover the most common follower export scenarios: how to paginate correctly, cost calculations at different account sizes, whether private accounts are accessible, how to handle large exports without rate-limit issues, and how to filter the raw data for specific use cases like ICP targeting or bot removal.

How do you export Twitter followers programmatically in 2026?

Use a REST API endpoint that accepts a username and returns the follower list with full profile data. TwitterAPIs's /twitter/user/followers endpoint returns 200 followers per call at $0.0008, with pagination via a cursor. A 100K-follower account exports in 500 calls for $0.40. A 1M-follower account exports in 5,000 calls for $4.00. No OAuth, no developer app required -- just a standard Bearer token in the Authorization header.

Can you export Twitter followers without OAuth?

Yes. A third-party REST adapter ships its own bearer token. You sign up, get an API key, set the Authorization header on a GET request, and start pulling followers. No developer-app registration, no client ID/secret pair, no OAuth callback URL. The official X API requires OAuth 2.0 for user-level data; TwitterAPIs uses simple Bearer token auth that works with any HTTP client.

How much does it cost to export Twitter followers via API?

TwitterAPIs charges $0.0008 per API call. Each call returns up to 200 followers. The math: a 10K-follower account costs $0.04 to export, a 100K account costs $0.40, a 1M account costs $4.00. Compare to the official X API where the same data requires an Enterprise contract starting at $42,000 per month. Use the cost calculator to estimate your specific workload.

What data do you get for each Twitter follower?

Each follower object returns 16 fields: id, userName (handle), name (display name), url, isVerified, isBlueVerified, profilePicture, coverPicture, description (bio), location, followers (their follower count), following, tweets (their post count), listed, createdAt (account age), and canDm (whether DMs are open). Enough for full ICP filtering, lead scoring, or audience analysis.

How many followers per page does the API return?

200 followers per call. Each response includes a next_cursor string and a has_more boolean. Pass next_cursor as the cursor parameter on the next call to get the following page. Pagination is stable across calls -- new follows added between calls do not shift your offset. This is 2x the page size of the official X API v2, which returns ~100 followers per page.

Can I filter followers by criteria before exporting?

The API returns all followers in follow-time descending order. Filter client-side after pulling. Common filters: minimum follower count (greater than 1K), location string match, bio keyword match (e.g., "founder"), verified-only, account-age threshold (createdAt earlier than a certain date), or DM-open (canDm: true) for outbound campaigns. The filter_icp() function in the code section above covers the most common combinations.

How do I export the followers of a private account?

You cannot. The API only returns followers of public Twitter/X accounts. Private/protected accounts hide their follower list at the platform level, and no third-party API can return data that the platform itself does not expose. If the account was previously public and recently went private, cached data may be stale.

How do I handle rate limits when exporting large follower lists?

TwitterAPIs does not impose platform-level rate limits on standard endpoints. For very large accounts (1M+ followers), add a 100ms sleep between calls to stay within comfortable concurrency. At 10 parallel requests per second, a 1M-follower export completes in about 8 minutes. Build exponential backoff on any 429 response. The async Python example above shows a safe concurrency pattern for multi-account exports.

What is the fastest way to export followers from multiple accounts?

Use async Python with aiohttp or Node with Promise.all to fan out concurrent requests across accounts. Each account's follower pages are independent, so you can pull 10 accounts simultaneously. At $0.0008 per call, pulling the first 5,000 followers from 10 accounts costs $0.40 and takes under a minute with concurrency. The async export function in the code section above is a starting point.