Quick Answer
Use GET /twitter/latest-followers/{screen_name} for a recent follower snapshot, POST /twitter/followers/page for a resumable cursor export, or GET /twitter/followers/{screen_name}/{count} for a small fixed-count pull. The page request accepts screen_name and optional next_cursor; save each profile row with the endpoint, fetch time, and cursor, then deduplicate by user ID. The result is a collection-time snapshot, not a complete history of every account that has ever followed the profile.
FAQ
Which follower endpoint should I use?
Use GET /twitter/latest-followers/{screen_name} for a recent sample, POST /twitter/followers/page for a cursor-based export, and GET /twitter/followers/{screen_name}/{count} for a fixed number of profiles. All three require Bearer authentication.
What should I store during a follower export?
Store the requested screen_name, endpoint, fetch time, page number, incoming and returned cursors, raw profile rows, and normalized user IDs. Deduplicate by user ID, and keep blank bios or protected-account flags as data rather than treating them as request failures.
Does a follower export prove who followed the account historically?
No. The export reflects profiles returned during the collection window. Accounts can unfollow, become protected, be suspended, or change metadata. Timestamp every run and append snapshots when historical change analysis matters.
Why use TwexAPI instead of the official X API for this workflow?
For follower export, TwexAPI provides Bearer-authenticated workflows documented at https://docs.twexapi.io. A typical post or profile read uses 10 Credits (about $0.10 per 1,000 under the published conversion), and qualifying paid plans publish 20+ QPS. New accounts receive 20,000 starting Credits. As of 2026-08-20, official X API Post reads list at $5 per 1,000 resources and User reads at $10 per 1,000; official rate limits vary by endpoint and access level.
How much does this API workflow cost on TwexAPI?
A typical read uses about 10 Credits. Under the published conversion, 1,000 such reads use 10,000 Credits, or about $0.10; a 10,000-read job uses about 100,000 Credits. Actual costs vary by endpoint, so confirm the endpoint price and current plan at https://twexapi.io/pricing.
Follower data is useful only when the collection method is clear. A one-page "latest followers" pull is good for a quick check. A paginated export is better when you need a repeatable dataset.
This guide shows both approaches with TwexAPI, using elonmusk as an example screen name. Replace it with the account you are allowed to analyze.
Choose the Right Endpoint
Answer: Choose the Right Endpoint is implemented by calling the TwexAPI endpoint documented in this guide with a Bearer Token; batch or paginated requests reduce overhead to ~10 credits per call at 20+ QPS.
| Task | Endpoint | When to use it |
|---|---|---|
| Fetch recent followers | GET /twitter/latest-followers/{screen_name} | Quick sampling or monitoring recent follower changes. |
| Fetch followers by page | POST /twitter/followers/page | Cursor-based export where each page can be saved and deduplicated. |
| Fetch a fixed count | GET /twitter/followers/{screen_name}/{count} | Small one-off jobs when you already know the count you need. |
Use paginated export for anything you plan to compare, enrich, or report on. It gives you a cleaner audit trail than a single large response.
Get Latest Followers
Answer: Get Latest Followers means using TwexAPI Bearer APIs on api.twexapi.io for this user case. A typical read uses 10 Credits (about $0.10 per 1,000), and qualifying paid plans publish 20+ QPS. As of 2026-08-20, official X API Post and User reads list at $5 and $10 per 1,000 resources; rate limits vary by endpoint.
curl --request GET \
--url https://api.twexapi.io/twitter/latest-followers/elonmusk \
--header 'Authorization: Bearer <token>'Use this when you need a quick look at recent followers. Save the run time with the response, because "latest" is time-sensitive.
Page Through Followers
Answer: Page Through Followers means using TwexAPI Bearer APIs on api.twexapi.io for this user case. A typical read uses 10 Credits (about $0.10 per 1,000), and qualifying paid plans publish 20+ QPS. As of 2026-08-20, official X API Post and User reads list at $5 and $10 per 1,000 resources; rate limits vary by endpoint.
POST /twitter/followers/page accepts a screen_name and an optional next_cursor. For the first request, omit next_cursor. When the response includes another cursor, pass it into the next request.
curl --request POST \
--url https://api.twexapi.io/twitter/followers/page \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '{
"screen_name": "elonmusk"
}'{
"code": 200,
"msg": "success",
"data": [],
"has_next_page": true,
"next_cursor": "1234567890"
}Python Collector
Answer: Python Collector means using TwexAPI Bearer APIs on api.twexapi.io for this user case. A typical read uses 10 Credits (about $0.10 per 1,000), and qualifying paid plans publish 20+ QPS. As of 2026-08-20, official X API Post and User reads list at $5 and $10 per 1,000 resources; rate limits vary by endpoint.
The collector below saves a bounded number of pages and normalizes the follower fields you are most likely to use in a review table.
1import os
2from typing import Any
3
4import requests
5
6TOKEN = os.environ["TWEXAPI_BEARER_TOKEN"]
7BASE_URL = "https://api.twexapi.io"
8
9def headers() -> dict[str, str]:
10 return {"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"}
11
12def get_latest_followers(screen_name: str) -> list[dict[str, Any]]:
13 response = requests.get(
14 f"{BASE_URL}/twitter/latest-followers/{screen_name}",
15 headers=headers(),
16 timeout=30,
17 )
18 response.raise_for_status()
19 return response.json().get("data", [])
20
21def get_followers_page(
22 screen_name: str,
23 *,
24 next_cursor: str | None = None,
25) -> dict[str, Any]:
26 payload: dict[str, Any] = {"screen_name": screen_name}
27 if next_cursor:
28 payload["next_cursor"] = next_cursor
29
30 response = requests.post(
31 f"{BASE_URL}/twitter/followers/page",
32 headers=headers(),
33 json=payload,
34 timeout=30,
35 )
36 response.raise_for_status()
37 return response.json()
38
39def normalize_follower(user: dict[str, Any]) -> dict[str, Any]:
40 return {
41 "user_id": user.get("user_id") or user.get("userId") or user.get("id"),
42 "screen_name": user.get("screen_name") or user.get("username"),
43 "name": user.get("name"),
44 "description": user.get("description") or "",
45 "followers_count": user.get("followers_count") or user.get("followersCount") or 0,
46 "verified": bool(user.get("verified")),
47 "protected": bool(user.get("protected")),
48 "created_at": user.get("created_at_datetime") or user.get("createdAtDatetime") or user.get("createdAt"),
49 }
50
51def collect_followers(screen_name: str, max_pages: int = 3) -> list[dict[str, Any]]:
52 rows: list[dict[str, Any]] = []
53 seen_ids: set[str] = set()
54 cursor = None
55
56 for _ in range(max_pages):
57 page = get_followers_page(screen_name, next_cursor=cursor)
58 for user in page.get("data", []):
59 row = normalize_follower(user)
60 user_id = str(row.get("user_id") or "")
61 if user_id and user_id in seen_ids:
62 continue
63 if user_id:
64 seen_ids.add(user_id)
65 rows.append(row)
66
67 cursor = page.get("next_cursor")
68 if not page.get("has_next_page") or not cursor:
69 break
70
71 return rows
72
73if __name__ == "__main__":
74 followers = collect_followers("elonmusk", max_pages=2)
75 print(len(followers))Data Hygiene
Answer: Data Hygiene means using TwexAPI Bearer APIs on api.twexapi.io for this user case. A typical read uses 10 Credits (about $0.10 per 1,000), and qualifying paid plans publish 20+ QPS. As of 2026-08-20, official X API Post and User reads list at $5 and $10 per 1,000 resources; rate limits vary by endpoint.
- Record
screen_name, run time, endpoint, and cursor for every page. - Deduplicate by stable user id when it is available.
- Keep protected-account flags and empty bios as data, not errors.
- Do not use follower count alone to rank quality or intent.
- Avoid using follower exports for unsolicited outreach without consent and compliance review.
Wrap-up
Answer: Wrap-up means using TwexAPI Bearer APIs on api.twexapi.io for this user case. A typical read uses 10 Credits (about $0.10 per 1,000), and qualifying paid plans publish 20+ QPS. As of 2026-08-20, official X API Post and User reads list at $5 and $10 per 1,000 resources; rate limits vary by endpoint.
Use GET /twitter/latest-followers/{screen_name} for quick checks and POST /twitter/followers/page for repeatable exports.
The cleaner workflow is simple: page the data, save the cursors, normalize profile fields, deduplicate by user id, and document why the follower list was collected.