Scrape Creators Alternative for Twitter (X) Data: Coverage and Real Cost per 1,000 Tweets
This page is about one vendor: Scrape Creators, and what its Twitter endpoints actually return per credit. It is not the generic how-to in our guide to scraping Twitter without the official API, which compares methods (libraries, headless browsers, hosted APIs), and it is not the Apify comparison, which is about actor-based scraping on a compute-unit platform. Here we read Scrape Creators' own docs endpoint by endpoint, put its per-request pricing next to per-item pricing, and measure how many tweets one request really returns.
People search for Scrape Creators because it covers a lot of platforms behind one key: TikTok, Instagram, YouTube, Facebook, Twitter, LinkedIn, Reddit, Pinterest and Threads are listed on its home page, plus link-in-bio tools and more. If you need that multi-platform spread, it remains a fit. If the job is X data specifically (latest posts, searches, follower lists, replies, real-time alerts, posting), the questions that decide the bill are narrower: which X jobs the seven endpoints cover, and how many tweets each billed request brings back.
Every number below that is not a published price comes from a study we ran in 2026: 62 requests against the TwitterAPI.io API, covering six organization accounts, four keyword searches and two follower lists, for an estimated $0.169 to $0.193 in credits. The method, sample and limits are in the last data section.
How Scrape Creators bills: credits, plans and the request as the unit
Scrape Creators sells prepaid credits. Its pricing section (fetched this session from scrapecreators.com) lists four plans, each with all of its APIs included and credits that never expire.
The unit is the request. Each plan card says 1 credit === 1 request (for most endpoints) and notes that a few endpoints use more, with the exact cost shown in the docs. On the Twitter endpoint pages we read, Profile, User Tweets, Tweet Details, Search Posts, Community and Community Tweets each show 1 credit per request. Transcript is priced separately: 1 credit for native captions or a short AI transcript, and 10 credits per started minute when long AI transcription is switched on.
Why the unit matters. A request is not a fixed amount of data. A profile request returns one profile; a page of search results returns however many tweets the page holds; Search Posts' own page says each successful page costs 1 credit, including empty results. To compare a per-request price with a per-tweet price you need the number of items per request, which is what our study measures.
TwitterAPI.io bills per item returned. Tweet endpoints cost 15 credits per tweet returned ($0.15 per 1,000 tweets), with a 15-credit minimum per request, so a full 20-tweet page costs $0.003. Profiles cost 18 credits each ($0.18 per 1,000). Follower and following pages cost 1 to 3 credits per user returned. $1 = 100,000 credits; purchased credits never expire. 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). There is no $47 or $497 entry purchase: you top up what you use, and subscriptions are optional (see the pricing page).
Scrape Creators' seven Twitter endpoints, one by one
The Twitter section of docs.scrapecreators.com lists seven GET endpoints under the base https://api.scrapecreators.com/v1/twitter/. We read each endpoint page this session. Endpoint names are as the docs list them (for example https://api.scrapecreators.com/v1/twitter/user-tweets for User Tweets). The right-hand column is the closest TwitterAPI.io endpoint.
Profile. Both return the counters most people want (followers, following, post count, verification). Scrape Creators' fields follow X's legacy names (followers_count, friends_count, statuses_count); /twitter/user/info returns followers, following, statusesCount, isBlueVerified, canDm and isAutomated. For many accounts at once, /twitter/user/batch_info_by_ids takes a list of user IDs.
User Tweets. The endpoint page says it fetches tweets from a profile by handle and adds: Twitter publicly returns only ~100 of the user's most popular tweets, not chronological or latest. The page lists handle and trim as parameters and documents no cursor. That is a useful snapshot of an account's best-performing posts. It is not a way to read what an account posted this week, and it cannot go deeper than that single set.
Search Posts. Its own description is unusually direct: it finds public X post URLs through Google Search, it is Google-indexed discovery and not native X search, coverage is incomplete, recent posts can be missing, and results are ranked by Google rather than newest first. Pagination follows Google's pages, cursors 1 through 11, and the same post may appear on more than one page.
Tweet Details, Community, Community Tweets. These map cleanly. The difference is batching: Tweet Details takes one URL per request, while /twitter/tweets takes many IDs in one call (50 per call worked in our run).
Transcript. This is the one Twitter endpoint with no TwitterAPI.io counterpart. If speech-to-text on X videos is the core of your job, Scrape Creators' transcript route does that directly; with TwitterAPI.io you get the video variant URLs and run your own transcription.
X jobs outside the seven endpoints
Most production X pipelines need more than profiles and a tweet lookup. These jobs have no endpoint among Scrape Creators' seven Twitter routes; each has a documented TwitterAPI.io endpoint.
Followers are the big one. Audience research, influencer vetting and competitor tracking all start with a follower list. Our follower pages returned 200 records per request; at 1 to 3 credits per user that is $0.01 to $0.03 per 1,000 followers. On the official X API the rate card lists $0.010 per follower/following read, $10 per 1,000.
Real-time. Instead of re-running a search on a timer, a filter rule pushes matching tweets to your webhook or websocket. That changes the economics of alerting jobs: you are not paying for every empty check.
Write actions are a separate product. Writes run through an authenticated session: one /twitter/user_login_v2 login ($0.10, with a proxy you supply) returns login_cookies, then each post, delete, like, retweet, follow or unfollow is $0.002 (for example /twitter/create_tweet_v2, /twitter/follow_user_v2). Each call acts as that account, so X can rate-limit, lock or suspend it; keep a human pace; the session can need a re-login; and billing is per HTTP 200 call. Reads need no X account at all.
Per 1,000 requests vs per 1,000 tweets: the measured conversion
A per-request price only becomes comparable once you know how many items one request returns. We measured that on our own API for each endpoint a typical Scrape Creators user would migrate to.
What the counts mean. All 20 search pages came back full at 20 tweets. Timeline pages were full except one: for @NASA the cursor ended after two full pages, and the third request returned no tweets with has_next_page false (that empty page is billed at the 15-credit minimum). Both 50-ID /twitter/tweets calls returned all 50 tweets; two calls with 100 IDs were rejected with HTTP 400, so batch in 50s.
Why per-item billing is simpler to budget. On TwitterAPI.io the bill for 1,000 tweets is $0.15 whether they arrive in 50 search pages or 20 batched lookups; page size changes the request count, not the cost. With per-request billing the bill depends on how much each request returns, which varies by endpoint and is not documented for every route (Search Posts' page does not state a page size).
Cost of typical X jobs, side by side
These are the jobs where both services return comparable data, priced at each provider's published rate. Scrape Creators' figures use its two published plan rates; the official X API uses the pay-per-usage rate card on docs.x.com ($0.005 per post read, $0.010 per user read, $0.010 per follower/following read).
Profiles: about 5x to 10x less per item. At $0.18 per 1,000 against $0.99 (Business) or $1.88 (Freelance) per 1,000 profile requests, enriching a list of 50,000 handles is $9 here against $49.50 to $94 as Scrape Creators requests, before any entry purchase.
Tweets by URL: batching is the difference. A list of tweet URLs (a spreadsheet of campaign posts, a set of links collected from a newsletter) is 1,000 Tweet Details requests on Scrape Creators. The same 1,000 tweets are 20 /twitter/tweets calls of 50 IDs and $0.15.
Against the official X API. $5 per 1,000 post reads on the docs.x.com pay-per-usage rate card against $0.15 per 1,000 tweets here is about 33x; per user read, $10 against $0.18 per 1,000 profiles. The X rate card caps pay-per-usage at 3M post reads a month, with Enterprise above that.
Latest vs popular: what about 100 tweets per account covers
Scrape Creators' User Tweets returns up to about 100 popular tweets per account. To see how much of an account that represents, we pulled the latest 100 posts of five organizations with /twitter/user/last_tweets (five 20-tweet pages each) and compared them with each account's lifetime post count from /twitter/user/info.
What it shows. For these accounts, 100 posts is between 0.28% and 5.09% of everything they have posted, and the latest 100 alone reach back a median of 95.9 days (from 41.4 days for @github to 286.0 for @vercel). A fixed popular set drawn from that history will mostly be older posts, and it does not move when the account posts something new.
What it means for a job. Monitoring a competitor's launches, archiving a brand's posts, or measuring engagement on this month's content all need the latest posts and a way to page further back. On /twitter/user/last_tweets each page is 20 posts and each page carries next_cursor; 1,000 posts is 50 requests and $0.15. For a fixed date window on a high-volume account, /twitter/tweet/advanced_search with from:NASA since:... until:... operators is the more reliable route, as our @NASA timeline cursor showed.
Google-indexed search vs native X search: freshness measured
Search Posts' docs say recent posts can be missing because discovery goes through Google. Native search reads X directly. We ran four keyword searches with queryType=Latest, five pages each, and measured how old the newest result was at collection time and how far back 100 results reached.
Results were newest-first in all four searches, and every search still had has_next_page true after five pages, so a longer job simply keeps paging. A busy topic such as ai agents produced 100 tweets in 14.9 minutes; a niche one such as stripe api reached back about 3.0 days. The median age of the newest result across the four was 17.6 minutes.
Operators are the other difference. Native search accepts X's operators: from:, to:, lang:, min_faves:, filter:media, -filter:retweets, since: and until:. That is what makes keyword alerts, brand monitoring and date-bounded research exports possible. A Google-ranked result set, capped at 11 pages, is better suited to discovering well-known posts on a topic than to counting or monitoring it.
How we collected this
Question. When a vendor bills per request, what does one request return? We measured items per request and requests needed for typical X jobs on TwitterAPI.io, how far back an organization's latest 100 posts reach, and how fresh native Latest search results are.
Accounts and queries. Organization accounts @OpenAI, @vercel, @github, @NASA, @stripe and @nvidia (profiles and timelines); keyword searches ai agents, web scraping, stripe api and nextjs with queryType=Latest; follower lists of @vercel and @stripe; two /twitter/tweets calls with 50 IDs taken from the organization timelines.
Sample and window. 62 successful requests plus two rejected 100-ID calls, 1,040 tweets, 1,200 follower records and 6 profiles, collected in 2026; each window is the most recent data at collection time. Estimated cost: $0.169 to $0.193.
What the sample cannot show. We did not call Scrape Creators' API, so its side of the comparison is its documentation and published prices as read this session, not measured behavior; we cannot say which posts its popular set or Google-indexed search would return, or how many posts a Search Posts page holds. Four searches and six accounts are a small sample, and search freshness depends on topic volume.
Privacy. Aggregates only. Organization accounts are named; search results and follower lists were kept out of the committed dataset, and the published sample holds de-identified rows (no IDs, URLs, text or handles).
Moving a Scrape Creators X workload to TwitterAPI.io
Authentication. Both use an API key header: Scrape Creators uses x-api-key, TwitterAPI.io uses X-API-Key against https://api.twitterapi.io. No X account is needed for reads.
Field names. Scrape Creators returns X's raw shapes (rest_id, legacy.full_text, legacy.favorite_count, legacy.retweet_count, followers_count). TwitterAPI.io flattens them: tweets carry id, text, createdAt, likeCount, retweetCount, replyCount, quoteCount, viewCount, bookmarkCount and an author object; /twitter/user/info returns followers, following and statusesCount. Follower pages use snake_case (screen_name, followers_count).
Pagination. Every list endpoint returns has_next_page and next_cursor; pass the cursor back until has_next_page is false. There is no documented page ceiling like Search Posts' 11 cursors.
Rate. Accounts start at 0.2 requests per second before the first payment and move to 20 once paid, 50 on Scale and 500 on Business, up to 1,000 on request.
Decision. For X-only workloads that need latest posts, native search, followers, replies, real-time alerts or posting, TwitterAPI.io covers the jobs and bills per item. If you need one key across TikTok, Instagram, YouTube and other platforms, or video transcripts, Scrape Creators remains a fit for that part of the stack, and the two can run side by side.
The snippet below converts a list of tweet URLs (the Tweet Details pattern) into batched /twitter/tweets calls.
import requests
BASE = "https://api.twitterapi.io"
HEADERS = {"X-API-Key": "YOUR_API_KEY"}
# ScrapeCreators Tweet Details takes one URL per request.
# /twitter/tweets takes a comma-separated list; 50 IDs per call worked in our run.
urls = [
"https://x.com/vercel/status/1234567890123456789",
"https://x.com/github/status/1234567890123456790",
]
ids = [u.rstrip("/").split("/status/")[1].split("?")[0] for u in urls]
tweets = []
for i in range(0, len(ids), 50):
r = requests.get(f"{BASE}/twitter/tweets",
headers=HEADERS,
params={"tweet_ids": ",".join(ids[i:i + 50])},
timeout=40)
r.raise_for_status()
tweets += r.json().get("tweets") or []
for t in tweets:
# ScrapeCreators legacy.full_text / legacy.favorite_count -> text / likeCount
print(t["id"], t["createdAt"], t["likeCount"], t["retweetCount"], t["viewCount"], t["text"][:80])
"""scrapecreators_to_twitterapi.py - the three X jobs from this page on TwitterAPI.io:
the latest N posts of an account, a newest-first keyword search, and a follower list.
Every loop follows has_next_page / next_cursor, so you pay only for the data returned."""
import requests
BASE = "https://api.twitterapi.io"
HEADERS = {"X-API-Key": "YOUR_API_KEY"}
def latest_posts(user_name, limit=200):
"""Newest-first timeline, 20 posts per page (measured)."""
out, cursor = [], ""
while len(out) < limit:
r = requests.get(f"{BASE}/twitter/user/last_tweets", headers=HEADERS,
params={"userName": user_name, "cursor": cursor}, timeout=40)
r.raise_for_status()
body = r.json()
out += (body.get("data") or {}).get("tweets") or []
if not body.get("has_next_page") or not body.get("next_cursor"):
break
cursor = body["next_cursor"]
return out[:limit]
def search_latest(query, limit=200):
"""Native X search with operators, newest first, 20 tweets per page (measured)."""
out, cursor = [], ""
while len(out) < limit:
r = requests.get(f"{BASE}/twitter/tweet/advanced_search", headers=HEADERS,
params={"query": query, "queryType": "Latest", "cursor": cursor}, timeout=40)
r.raise_for_status()
body = r.json()
out += body.get("tweets") or []
if not body.get("has_next_page") or not body.get("next_cursor"):
break
cursor = body["next_cursor"]
return out[:limit]
def followers(user_name, limit=1000):
"""Follower records, about 200 per page (measured), newest followers first."""
out, cursor = [], ""
while len(out) < limit:
r = requests.get(f"{BASE}/twitter/user/followers", headers=HEADERS,
params={"userName": user_name, "cursor": cursor}, timeout=40)
r.raise_for_status()
body = r.json()
out += body.get("followers") or []
if not body.get("has_next_page") or not body.get("next_cursor"):
break
cursor = body["next_cursor"]
return out[:limit]
if __name__ == "__main__":
posts = latest_posts("vercel", limit=100)
print(len(posts), "latest posts; newest:", posts[0]["createdAt"] if posts else None)
for t in posts[:3]:
print(" ", t["createdAt"], t["likeCount"], t["viewCount"], t["text"][:70])
hits = search_latest('"web scraping" -filter:retweets lang:en', limit=100)
print(len(hits), "search results; newest:", hits[0]["createdAt"] if hits else None)
fans = followers("vercel", limit=400)
print(len(fans), "follower records; first followers_count:", fans[0]["followers_count"] if fans else None)
tweet_cost = (len(posts) + len(hits)) * 15 / 100000 # 15 credits per tweet, $1 = 100,000 credits
print(f"tweet cost: ${tweet_cost:.4f}")
Questions readers ask
What is Scrape Creators?
Scrape Creators (scrapecreators.com) is a hosted scraping API for public social media data across TikTok, Instagram, YouTube, Facebook, Twitter, LinkedIn, Reddit, Pinterest, Threads and more, billed in prepaid credits where one credit usually equals one request.
How much does Scrape Creators cost?
Its pricing section lists a free trial of 100 credits, Freelance at $47 for 25,000 credits ($1.88 per 1,000 requests), Business at $497 for 500,000 credits ($0.99 per 1,000 requests) and custom Enterprise plans. Credits never expire. A few endpoints cost more than one credit; Twitter Transcript, for example, bills long AI transcription per started minute.
Which Twitter endpoints does Scrape Creators have?
Seven: Profile, User Tweets, Tweet Details, Search Posts, Transcript, Community and Community Tweets. Its docs do not list follower, following, reply, quote, retweeter, list, real-time or write endpoints.
Does Scrape Creators return a user's latest tweets?
Not through User Tweets. Its endpoint page says it returns up to about 100 of an account's most popular tweets, not chronological or latest, and it documents no cursor. For the latest posts with pagination, /twitter/user/last_tweets returns 20 posts per page newest first.
Is Scrape Creators' Twitter search real-time?
Its docs say Search Posts is Google-indexed discovery, not native X search: coverage is incomplete, recent posts can be missing, results are ranked by Google and cursors run from 1 to 11. Native search with queryType=Latest returned newest-first results in our test, with the newest a median 17.6 minutes old.
How do I compare per-request and per-tweet pricing?
Divide the per-request price by the items one request returns. A profile request returns one profile, so $0.99 to $1.88 per 1,000 requests is $0.99 to $1.88 per 1,000 profiles, against $0.18 per 1,000 here. Our tweets-by-ID call returned 50 tweets, so 1,000 tweets took 20 requests and cost $0.15.
Can I get Twitter followers with Scrape Creators?
No follower endpoint is listed among its seven Twitter endpoints. /twitter/user/followers returned 200 follower records per page in our study, at 1 to 3 credits per user.
Is there a free tier to test TwitterAPI.io?
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). Purchased credits never expire.
Continue
- X API pricing: pay-per-usage rate card (post, user and follower reads)
- TwitterAPI.io docs: user last tweets (newest first, cursor)
- TwitterAPI.io docs: advanced search (Latest / Top, operators)
- TwitterAPI.io docs: get tweets by IDs
- TwitterAPI.io docs: user followers
- TwitterAPI.io docs: introduction and authentication
- X (Twitter) API overview and endpoints
- how to scrape Twitter without the official API
- Apify Twitter scraper alternative comparison
- Twitter scraper comparison for 2026
- Data365 alternative for X data
- advanced search operators through the API
- TwitterAPI.io pricing and credit plans
- 01TweetGrok Twitter (X) Viewer: What It Is, Whether It Works, and Safer Options
- 02Is X.com (Twitter) Down Right Now, or Is It Just You?
- 03Brandwatch API Explained: Consumer Research vs Engage, Access, and What You Get for Twitter (X)
- 04A Meltwater Alternative for Teams That Mainly Need X (Twitter) Mentions
- 05Sprout Social API in 2026: What It Returns, What It Costs, and Where Twitter (X) Data Runs Out
- 06F5Bot for Twitter (X): Keyword Alerts on the Platform F5Bot Skips
- 07TweetDeck (X Pro) Alternatives in 2026: Columns, Monitoring and Scheduling for Twitter (X)
- 08xcancel Not Working? The xcancel Alternatives That Still Work
Stop reading. Start building.
Starter credits cover real testing on real data. Google sign-in, no card, no application queue.
Get an API key