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.

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 GetXAPI 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

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.

Export to CSV

Most downstream workflows (CRM import, spreadsheet analysis, Airtable) need CSV output. Add a CSV writer to the Python example:

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

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

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.

Async Export for Multiple Accounts

When you need to pull followers from several accounts simultaneously, async requests cut the wall-clock time significantly:

import asyncio
import aiohttp

API_KEY = os.environ["GETXAPI_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.getxapi.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 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.

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.50 per run. Running it against 5 competitor accounts costs $2.50 per day, or $75 per month. That $75 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

The follower export endpoint sees different usage patterns by industry:

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:1 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 supports two symmetric endpoints: /twitter/user/followers and /twitter/user/following. Both return the same 16-field user object; the difference is direction.

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.001 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. GetXAPI'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

The follower export becomes most valuable when it connects to your existing sales and marketing infrastructure. A basic pipeline pattern:

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 $1.00 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 $1 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 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. For the DM send workflow once you have the filtered list, see the Twitter DM API guide.

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

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, GetXAPI returns 200 full follower profiles (not just IDs) per call with no platform-level rate cap and no subscription requirement. At $0.001 per call, pulling 1,500 followers costs $0.0075 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. GetXAPI'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

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. GetXAPI's /twitter/user/followers endpoint returns 200 followers per call at $0.001, with pagination via a cursor. A 100K-follower account exports in 500 calls for $0.50. A 1M-follower account exports in 5,000 calls for $5. 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; GetXAPI uses simple Bearer token auth that works with any HTTP client.

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

GetXAPI charges $0.001 per API call. Each call returns up to 200 followers. The math: a 10K-follower account costs $0.05 to export, a 100K account costs $0.50, a 1M account costs $5. 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?

GetXAPI 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.001 per call, pulling the first 5,000 followers from 10 accounts costs $0.25 and takes under a minute with concurrency. The async export function in the code section above is a starting point.