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 first-party developer 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 5 Credits (about $0.05 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, first-party developer 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 5 Credits. Under the published conversion, 1,000 such reads use 5,000 Credits, or about $0.05; a 10,000-read job uses about 50,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 ~5 credits per call at 20+ QPS.
| Task | Endpoint | When to use it |
|---|---|---|
| Fetch recent followers | POST /v3/twitter/users/followers | 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 5 Credits (about $0.05 per 1,000), and qualifying paid plans publish 20+ QPS. As of 2026-08-20, first-party developer API Post and User reads list at $5 and $10 per 1,000 resources; rate limits vary by endpoint.
curl --request POST \
--url https://api.twexapi.io/v3/twitter/users/followers \
--header 'Authorization: Bearer <token>' \
--header 'Content-Type: application/json' \
--data '
{
"username": "elonmusk",
"count": 20,
"cursor": ""
}
'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 5 Credits (about $0.05 per 1,000), and qualifying paid plans publish 20+ QPS. As of 2026-08-20, first-party developer 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 5 Credits (about $0.05 per 1,000), and qualifying paid plans publish 20+ QPS. As of 2026-08-20, first-party developer 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, count: int = 20) -> list[dict[str, Any]]:
13 response = requests.post(
14 f"{BASE_URL}/v3/twitter/users/followers",
15 headers=headers(),
16 json={"username": screen_name, "count": count, "cursor": ""},
17 timeout=30,
18 )
19 response.raise_for_status()
20 data = response.json()
21 return data.get("data", []) if isinstance(data.get("data"), list) else data.get("data", {}).get("users", [])
22
23def get_followers_page(
24 screen_name: str,
25 *,
26 next_cursor: str | None = None,
27) -> dict[str, Any]:
28 payload: dict[str, Any] = {"screen_name": screen_name}
29 if next_cursor:
30 payload["next_cursor"] = next_cursor
31
32 response = requests.post(
33 f"{BASE_URL}/twitter/followers/page",
34 headers=headers(),
35 json=payload,
36 timeout=30,
37 )
38 response.raise_for_status()
39 return response.json()
40
41def normalize_follower(user: dict[str, Any]) -> dict[str, Any]:
42 return {
43 "user_id": user.get("user_id") or user.get("userId") or user.get("id"),
44 "screen_name": user.get("screen_name") or user.get("username"),
45 "name": user.get("name"),
46 "description": user.get("description") or "",
47 "followers_count": user.get("followers_count") or user.get("followersCount") or 0,
48 "verified": bool(user.get("verified")),
49 "protected": bool(user.get("protected")),
50 "created_at": user.get("created_at_datetime") or user.get("createdAtDatetime") or user.get("createdAt"),
51 }
52
53def collect_followers(screen_name: str, max_pages: int = 2) -> list[dict[str, Any]]:
54 rows: list[dict[str, Any]] = []
55 seen_ids: set[str] = set()
56 cursor = None
57
58 for _ in range(max_pages):
59 page = get_followers_page(screen_name, next_cursor=cursor)
60 for user in page.get("data", []):
61 row = normalize_follower(user)
62 user_id = str(row.get("user_id") or "")
63 if user_id and user_id in seen_ids:
64 continue
65 if user_id:
66 seen_ids.add(user_id)
67 rows.append(row)
68
69 cursor = page.get("next_cursor")
70 if not page.get("has_next_page") or not cursor:
71 break
72
73 return rows
74
75if __name__ == "__main__":
76 followers = collect_followers("elonmusk", max_pages=2)
77 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 5 Credits (about $0.05 per 1,000), and qualifying paid plans publish 20+ QPS. As of 2026-08-20, first-party developer API Post and User reads list at $5 and $10 per 1,000 resources; rate limits vary by endpoint.
- Record
screen_name, timestamp, endpoint, and cursor for every retrieved page. - Keep user IDs as the primary deduplication key when available.
- Treat protected flags and empty bios as valid data states, not missing values.
- Never use follower count alone to judge account quality or intent.
- Use follower lists only for permitted research or internal analysis, and apply privacy, retention, and compliance requirements before any downstream use.
Summary
Answer: Summary means using TwexAPI Bearer APIs on api.twexapi.io for this user case. A typical read uses 5 Credits (about $0.05 per 1,000), and qualifying paid plans publish 20+ QPS. As of 2026-08-20, first-party developer API Post and User reads list at $5 and $10 per 1,000 resources; rate limits vary by endpoint.
Use POST /v3/twitter/users/followers 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.