How does Twitter API pagination work?
Last updated July 25, 2026
Twitter API pagination works with cursors. Each response returns a page of results plus a next_cursor token and a has_more flag. You leave the cursor empty on the first request, feed next_cursor back on every following request, and stop once has_more turns false. On TwitterAPIs each page is one call at $0.0008, so paging a 1,000-record list runs about 15 to 20 calls.
Every rate here is the pricing TwitterAPIs publishes, $0.0008 per call and $0.04 per 1,000 tweets (source: twitterapis.com/pricing).
What cursor pagination means
A cursor is a pointer to your place in a result set. Instead of asking for page five by number, you hand back the token the last response gave you, and the API returns the next slice. This survives new items being added mid-scroll, which numbered pages do not, so nothing is skipped or repeated between requests.
The next_cursor and has_more loop
Every TwitterAPIs list response carries two fields: next_cursor, the token for the following page, and has_more, a boolean. Leave the cursor parameter empty on the first call, copy next_cursor into it on each subsequent call, and keep looping while has_more stays true. When has_more turns false the list is complete.
Which endpoints paginate
The follower graph and timeline endpoints page this way: user/followers and followers_v2, user/following and following_v2, verified_followers, plus user tweets and likes. Each uses the identical cursor mechanic, so one loop written once works across all of them, and no state is pinned on the server between calls.
Page size and cost
Follower endpoints return about 70 records on the first page and fewer after that, and the count parameter is currently ignored, so page size is fixed. Because every page is one flat call at $0.0008, cost scales with the number of pages, not a subscription: a 1,000-record export is roughly $0.012 to $0.016.
Cursor pagination versus numbered pages
| Aspect | Cursor pagination | Numbered pages |
|---|---|---|
| Position marker | Opaque next_cursor token | Page number |
| Handles new items | Yes, no skips or repeats | No, results can shift |
| Stop signal | has_more turns false | An empty page returned |
| On TwitterAPIs | $0.0008 per page | Not used |
In order to perform pagination we must supply a page/cursor parameter with each of our requests.
Questions and answers
- What is a cursor in the Twitter API?
- A cursor is an opaque token that marks your position in a result set. Each response returns a next_cursor value, and passing it back on the next request returns the following page. It replaces numbered pages and keeps a scroll consistent when new items are added mid-read.
- How do I get the next page of results?
- Copy the next_cursor token from the current response into the cursor parameter of your next request. On the first request leave cursor empty to land on page one. Repeat while the has_more flag stays true, and stop when it turns false. Each page is one call at $0.0008.
- How do I know when pagination is finished?
- Watch the has_more flag. Every TwitterAPIs list response returns it alongside next_cursor. While has_more is true there are more pages to fetch, and once it turns false you have the complete list and can stop looping. No end-of-list guesswork is needed.
- How many records come back per page?
- Follower endpoints return about 70 records on the first page and fewer on later pages, and the count parameter is currently ignored, so page size is fixed. Because each page is a single flat call at $0.0008, a 1,000-record list is roughly 15 to 20 calls, about $0.012 to $0.016.
- Do all endpoints use the same pagination?
- The follower graph and timeline endpoints share one mechanic: user/followers, following, verified_followers, and their v2 variants, plus user tweets and likes. Because the cursor loop is identical across them, one function written once pages every endpoint, with no server-side state between calls.
- Is cursor pagination better than page numbers?
- For a live feed, yes. Numbered pages can skip or repeat records when new items arrive between requests. A cursor points at a fixed spot in the stream, so nothing is missed or duplicated. It is the model the Twitter API and TwitterAPIs both use.
Keep reading
Start with $0.50 in free credits
No credit card. Roughly 12,500 tweets to test every endpoint.