Twitter (X) Retweet API: List Who Retweeted a Tweet, Retweet and Undo by API

"Retweet API" is used for three different calls. Reading the list of accounts that retweeted a tweet is a plain data read. Retweeting and undoing a retweet are write actions that run as a specific X account. The two providers developers usually compare split them the same way.

Retweet count vs retweeter list. Every tweet object already carries retweetCount (and quoteCount, likeCount, replyCount). If you only need the number, read it from /twitter/tweets?tweet_ids=... or any search result. You need the retweeter list only when you need the accounts themselves.

Retweets vs quotes. A quote post is a retweet with added text and is counted in quoteCount, not retweetCount. Quotes come back as tweets from the quotes endpoint, so they are priced and handled like any other tweet; this page is about plain retweets (X now labels them reposts).

Send GET https://api.twitterapi.io/twitter/tweet/retweeters with one required query parameter, tweetId, and your key in the X-API-Key header. No X account, OAuth app or developer approval is involved. The response is a top-level users array plus has_next_page and next_cursor; pass next_cursor back as cursor to get the next page. The documentation at docs.twitterapi.io/api-reference/endpoint/get_tweet_retweeter states the order: newest retweet first ("Order by retweet time desc").

Page size. Each page returns about 20 retweeters, and in our 128 retweeter requests every full page held exactly 20 users, so budget pages as retweetCount / 20. The end of the list is signaled by has_next_page: false; in all 8 lists we read to the end, the final page was an empty users array with has_next_page false.

Fields you get per user. The objects we received carried: canDm, coverPicture, createdAt, description, favouritesCount, followers, following, id, location, mediaCount, name, profilePicture, protected, statusesCount, url, userName, verified. Note verified (not isBlueVerified) on these objects, and createdAt in ISO 8601 form (2022-07-22T12:28:28.000000Z), which differs from the Thu Oct 16 12:34:56 +0000 2026 format on tweet objects. Parse both if you join retweeters with tweet data.

Duplicates. Across 2,345 records we saw 29 repeated user ids inside the same tweet's list (cursor pages can overlap slightly while new retweets arrive). Deduplicate on id, as the code below does.

Price. Retweeter lists are billed at the tweet-endpoint rate: 15 credits per retweeter returned, $0.15 per 1,000, with a 15-credit minimum per request. A full 20-user page costs $0.003; the empty closing page costs the $0.00015 minimum. Listing everyone who retweeted a tweet with 1,000 retweets is about 50 full pages plus one empty page, roughly $0.15.

X documents the official endpoint as Get Reposted By: "Retrieves a list of Users who reposted a specific Post by its ID" (docs.x.com/x-api/posts/get-reposted-by). It is GET https://api.x.com/2/tweets/{id}/retweeted_by and accepts an OAuth 2.0 user token or an app Bearer token.

Parameters. max_results takes 1 to 100 (default 100); pagination_token carries the next page; user.fields, expansions and tweet.fields choose which fields come back. The response has data (users), includes, errors and meta. The reference page lists no total cap on how many reposters you can page through.

Rate limits. The rate-limit table at docs.x.com/x-api/fundamentals/rate-limits lists GET /2/tweets/:id/retweeted_by at 75 requests per 15 minutes per app and 75 per 15 minutes per user. At 100 users per page that is at most 7,500 reposters per 15-minute window per app. The write side, POST /2/users/:id/retweets and DELETE /2/users/:id/retweets/:tweet_id, is 50 requests per 15 minutes per user.

Price. X's pay-per-usage rate card (docs.x.com/x-api/getting-started/pricing) charges reads per resource returned: User: Read is $0.010 per resource and Posts: Read is $0.005. Reposters come back as user objects, so a 1,000-reposter list is about $10 on that card, versus about $0.15 on TwitterAPI.io (roughly 67x). New paying X accounts get $20 in credits on a first card purchase plus a match of the first auto-recharge up to $50, and pay-per-usage is capped at 3 million post reads per monthly billing cycle, with Enterprise above that.

Reposts of me. X also offers GET /2/users/reposts_of_me (75 requests per 15 minutes per user, 100 max results), which returns reposts of the authenticated user's own posts. It needs that user's token, so it only helps when the tweets are yours.

We pulled the retweeter list of 11 recent original tweets from six organization accounts and compared the number of distinct accounts returned with the retweetCount on the tweet at collection time. Eight lists ran to the end (has_next_page: false); for three larger tweets our 20-page study budget ended the pull first, so their percentages are a floor, not a measured ceiling.

The headline. Across the 8 complete lists the API returned 1,135 of 1,243 counted retweets, 91.3% pooled (median 91.2%). The low point, 66.7%, is a tweet with only 6 retweets where 2 missing accounts swing the ratio.

Why the list is shorter than the count. The count is a running total; the list is the accounts that can be shown now. Plausible gaps are retweets from protected accounts (none of the 2,178 accounts we received was protected, which is consistent with protected reposts not being listed publicly), suspended or deactivated accounts, and retweets undone after the count updated. In our complete lists, roughly one in eleven counted retweets had no account we could retrieve.

Large tweets need a budget. @NASA's 1,223-retweet tweet returned 400 accounts in the 20 pages we allowed (32.7% of the count, still climbing). At 20 users per page a full pull would need about 62 pages. Plan retweetCount / 20 + 1 requests per tweet.

The 2,178 distinct retweeters in the sample are mostly ordinary accounts, not influencers. The median retweeter had 306 followers; 90% had 4,023 or fewer; only 87 accounts (4.0%) had 10,000 or more.

Account age. The median retweeting account was 5.7 years old. 41.6% were older than 8 years and 12.9% were created within the last year; a giveaway or campaign that sees a much higher share of very new accounts is worth a closer look for signs of automation.

Flags. 31.1% of the user objects carried verified: true, and 0% were protected. One record had no createdAt, so the age table covers 2,177 accounts.

What to do with it. Sort by followers to find the few large accounts that drove reach, bucket by createdAt to spot a wave of fresh accounts, and join the ids against your own customer or community list. For deeper profiles of the top accounts, batch their ids into /twitter/user/batch_info_by_ids, which costs 1 credit per user at 100 or more ids per call.

Writes on TwitterAPI.io run through an authenticated session for an X account you control. Log in once with POST /twitter/user_login_v2 (body: user_name, email, password, optional totp_secret, and a proxy you supply; 10,000 credits = $0.10). The response contains login_cookies. Then send login_cookies, tweet_id and proxy as JSON to POST /twitter/retweet_tweet_v2 to retweet, or to POST /twitter/unretweet_tweet_v2 to undo. Each call is 60 credits = $0.0006.

Behavior from the docs. Retweeting a tweet the account already retweeted returns success; if X rejects the retweet, status is error with X's reason in the response. Unretweeting a tweet the account never retweeted is a no-op on X's side and still returns success. Billing is per HTTP 200 call, so a call that comes back with X's rejection still counts.

Account safety. Every write acts as that account. X can rate-limit, lock or suspend an account that retweets in bursts, so keep a human pace (seconds between actions, not milliseconds), keep volumes modest, and expect the session to need a fresh login from time to time. Use a high-quality residential proxy you control; the docs warn against free proxies.

Official route. On X's API, retweeting is POST /2/users/:id/retweets with a JSON body {"tweet_id": "..."} and undoing is DELETE /2/users/:id/retweets/:tweet_id, both with a user-context token and both limited to 50 requests per 15 minutes per user. X's write table prices User Interaction: Create at $0.015 per request and Interaction: Delete at $0.010; check your Developer Console usage view to confirm which line your reposts land on.

Bulk undo. If you need to remove many old retweets, list them first (a retweet on your timeline carries a retweeted_tweet object) and loop the unretweet call; the bulk unlike and unretweet guide walks through that run end to end.

Both providers bill reads per item returned. The comparison below uses TwitterAPI.io's published tweet-endpoint rate (15 credits per item, $1 = 100,000 credits) and X's pay-per-usage rate card at docs.x.com/x-api/getting-started/pricing (User: Read $0.010 per resource).

Throughput. On TwitterAPI.io the limit is per account, not per endpoint: 0.2 requests per second before your first payment, 20 once paid, 50 on Scale, 500 on Business, and up to 1,000 on request. At 20 requests per second and 20 users per page that is about 400 retweeters a second. X's endpoint allows 75 requests per 15 minutes per app.

Getting started. New accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days), enough for several thousand retweeters. Purchased credits never expire. Subscriptions (Starter $29, Builder $99, Pro $199, Scale $499, Business $1,499 a month) add bonus credits; see the pricing page for the details.

Question. When you ask an API who retweeted a tweet, how much of the tweet's retweet count do you get back, how fast does the list fill page by page, and what do the retweeting accounts look like in aggregate?

Accounts and tweets. One page of recent posts (/twitter/user/last_tweets) from @NASA, @SpaceX, @nvidia, @github, @vercel and @OpenAIDevs, then 11 original (non-repost) tweets chosen to span retweet counts from 6 to 1,223.

Method. /twitter/tweet/retweeters with tweetId, following next_cursor until has_next_page was false or 20 pages were read. Coverage = distinct user ids returned divided by the tweet's retweetCount from the timeline read moments earlier. 134 requests in total (128 retweeter pages), 2,345 records, 2,178 distinct accounts, collected in 2026.

What the sample cannot show. Eleven tweets from six well-known accounts are not a census: retweeters of a small personal account or of a viral post may look different, coverage can drift as counts update, and three of the eleven lists were cut by our page budget, so their coverage is a lower bound. We did not test the official X endpoint with a paid key; its limits and prices above are quoted from X's documentation.

Privacy. Retweeters are mostly private individuals. Raw retweeter pages were kept out of the published dataset; only aggregates and de-identified buckets (no ids, handles, names, bios or links) are published. Only the organization accounts that posted the tweets are named.

The script below is the whole read workflow: fetch the tweet with /twitter/tweets to get retweetCount, page through /twitter/tweet/retweeters with deduplication, print coverage and follower stats, and write a CSV you can sort or join. It needs only an API key.

Useful extensions. Run it for every tweet in a campaign (read the IDs from /twitter/user/last_tweets), store each tweet's retweeter ids to see which accounts repost you again and again, or schedule it daily for a launch post to watch the list grow. To collect quote posts as well, add the quotes endpoint; to collect replies, see the reply API tutorial.

Next step. Create a key on the dashboard (new accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days)), then read the endpoint reference at docs.twitterapi.io for the full parameter list.