ScrapingBee Pricing in 2026: Plans, Credit Costs and Alternatives
- Five self-serve plans: Hobby $19/month (75,000 credits), Freelance $49/month (250,000), Startup $99/month (1,000,000), Business $249/month (3,000,000), Business + $599/month (8,000,000). Enterprise runs from $999/month to $5,799/month.
- Credits per request, 1 to 75: 1 without JavaScript, 5 with
render_js(on by default), 10 / 25 withpremium_proxy, 75 for the top proxy tier with JavaScript;ai_queryadds 5; the Google Search API costs 10 or 15. - Real cost per 1,000 pages ranges from $0.37 (Business +, default JS) to $19.00 (Hobby, 75-credit tier): the request options matter more than the plan.
- Billing rules: 200, 404, 410 and 413 are billed; 400, 401, 403, 429 and 500 are not. Credits last one month and do not roll over. Trial: 1,000 free credits, no card.
- On X, ScrapingBee is a quiet brand: 44 posts by 33 other accounts mentioned it over 69 days, and 70.5% of them were replies (collected in 2026).
- For X data, bill per tweet: a structured X API returns JSON tweets at $0.15 per 1,000 on TwitterAPI.io vs $5 per 1,000 post reads on X's pay-per-usage card, about 33x apart.
This page answers one question first: what does ScrapingBee cost? It lists every plan and credit rule as ScrapingBee shows them on scrapingbee.com/pricing and in its API documentation, turns the credit multipliers into a dollar price per 1,000 pages for each plan, and then compares the scraping APIs people weigh against it. It covers ScrapingBee's credit model in depth and its peers in compact rows; for the wider question of whether to scrape or call an API at all, and for the Firecrawl-style crawlers, we link our existing guides instead of repeating them.
Then it takes the angle most ScrapingBee buyers on our side care about: X (Twitter) data. We measured how X talks about ScrapingBee and how active ScrapingBee and four scraping-API peers are on X, using a small real-data study collected in 2026, and we show why a per-page bill is the wrong unit when the thing you want is tweets.
70.5% of 44 posts by 33 other accounts over 69 days (collected in 2026); 22.7% mention price, credits or plans.
ScrapingBee plans and prices in 2026
ScrapingBee sells a monthly pool of API credits. Every self-serve plan includes the same features (JavaScript rendering, rotating and premium proxies, geotargeting, screenshots, extraction rules and the dedicated scraping APIs); the plans differ in credits and in concurrency, which is how many requests you may have in flight at once. Business and above add priority email support, a dedicated account manager and team management. Prices are shown monthly and exclude VAT; the pricing page shows no annual price.
The Enterprise ladder is also public: Enterprise 14 at $999/month (14,000,000 credits, 500 concurrent), Enterprise 24 at $1,599/month (24,000,000, 600), Enterprise 41 at $2,399/month (41,000,000, 700, marked recommended), Enterprise 69 at $3,599/month (69,000,000, 800) and Enterprise 120 at $5,799/month (120,000,000, 900).
Price per 1,000 credits. Dividing the plan price by its credits gives the unit you actually buy: $0.2533 on Hobby, $0.196 on Freelance, $0.099 on Startup, $0.083 on Business and $0.0749 on Business +. The step from Hobby to Startup cuts the unit price by more than half, which is why Startup is the plan ScrapingBee itself labels as recommended.
Free trial. New accounts get 1,000 free API credits with no credit card. At the default 5 credits per page that is 200 JavaScript-rendered pages, enough to test your targets, not to run a job. ScrapingBee states you can cancel anytime.
How ScrapingBee credits work: 1 to 75 credits per request
The plan only buys credits. What each request burns depends on two switches: whether the page is rendered in a headless browser (render_js, which is on unless you turn it off) and which proxy pool the request goes through. ScrapingBee's documentation states the range plainly: it costs 1 to 75 credits to make a request.
The default is not the floor. Because JavaScript rendering is on by default, a plain call costs 5 credits, not 1. If the target page serves its content in the HTML, adding render_js=false divides the bill by five. This is the single biggest lever on a ScrapingBee invoice.
Add-ons. The AI extraction parameters (ai_query and ai_extract_rules) add 5 credits on top of the request cost. The dedicated Google Search API costs 10 credits per search with light_request and 15 without it.
Auto mode. With mode=auto, ScrapingBee tries configurations in turn and charges only the one that worked, 1, 5, 10, 25 or 75 credits; if every configuration fails the request costs 0 credits. It saves you guessing, but on hard targets the request can land on the expensive tier without you choosing it, so watch the cost field and the /usage endpoint.
What 1,000 pages really cost on each plan
Combine the two tables and you get the number buyers actually need: dollars per 1,000 successful page loads, by plan and request type. The formula is plan price divided by plan credits, times credits per page, times 1,000.
Capacity, not just price. The same plans expressed as pages: Freelance covers 50,000 default pages, 10,000 premium pages or 3,333 pages on the 75-credit tier in a month. Startup covers 200,000, 40,000 or 13,333. If your targets need premium proxies, size the plan on the 25-credit column, not the headline credit count.
The spread is wide. A page on the 75-credit tier bought through Hobby costs $19.00 per 1,000; a default page on Business + costs $0.37. Picking the lightest request type that still returns your data saves more than moving up a plan.
The calculator below reproduces the table and picks the smallest plan for a monthly page count. It runs offline; change the page count and mode to match your job.
# ScrapingBee cost calculator: plan price / plan credits x credits per page.
# Plan prices and credit costs as shown on scrapingbee.com/pricing and /documentation.
PLANS = { # name: (USD per month, credits per month)
"Hobby": (19, 75_000),
"Freelance": (49, 250_000),
"Startup": (99, 1_000_000),
"Business": (249, 3_000_000),
"Business +": (599, 8_000_000),
}
CREDITS_PER_PAGE = {
"classic_no_js": 1,
"classic_js": 5, # render_js is on by default
"premium_no_js": 10,
"premium_js": 25,
"top_tier_js": 75,
}
def monthly_capacity(plan: str, mode: str) -> int:
usd, credits = PLANS[plan]
return credits // CREDITS_PER_PAGE[mode]
def usd_per_1k_pages(plan: str, mode: str) -> float:
usd, credits = PLANS[plan]
return usd / credits * CREDITS_PER_PAGE[mode] * 1000
def smallest_plan_for(pages: int, mode: str):
for plan in PLANS: # ordered small to large
if monthly_capacity(plan, mode) >= pages:
return plan
return "Enterprise (quote the 14M-120M credit tiers)"
if __name__ == "__main__":
for mode in ("classic_js", "premium_js", "top_tier_js"):
need = 50_000
plan = smallest_plan_for(need, mode)
print(f"{need:,} pages in {mode}: {plan}")
print(f"Startup, premium_js: ${usd_per_1k_pages('Startup', 'premium_js'):.2f} per 1,000 pages")
What ScrapingBee bills, and what it does not
ScrapingBee's documentation lists, status code by status code, which responses consume credits. The rule of thumb: you pay when the target answered, even with a not-found page, and you do not pay when ScrapingBee could not get an answer or refused the call.
Transparent status codes. With transparent_status_code=true, ScrapingBee passes the target's status through and bills anything below 500; 5xx responses stay free. Turn it on only if you handle the target's error pages yourself.
Concurrency. A 429 means you exceeded your plan's concurrency, not a rate per second. The /usage endpoint reports max_concurrency and current_concurrency and can be called 6 times a minute without counting toward concurrency.
Expiry. Credits are valid for one month and do not roll over, so a plan sized for a peak month wastes credits in quiet months. Buy for the steady load and handle bursts with a temporary upgrade.
ScrapingBee alternatives: how the credit models compare
Most general-purpose scraping APIs copy the same idea: a monthly credit pool, with JavaScript rendering and premium proxies as multipliers. The table puts the entry plans side by side as each vendor shows them; every vendor below is a scraping-API seller we name but do not link.
ZenRows (zenrows.com) uses the same 1 / 5 / 10 / 25 credit ladder and splits each tier into several sizes: Build from $19/month for 45,000 credits up to $39/month for 120,000, Launch from $69/month for 250,000, Growth from $199/month for 1,200,000 and Scale from $549/month for 5,000,000. Its free plan gives 5,000 credits a month at 5 concurrent requests, five times ScrapingBee's one-off trial.
Scrapfly (scrapfly.io) lists Discovery at $30/month for 200,000 credits (5 concurrent), Pro at $100/month for 1,000,000 (20), Startup at $250/month for 2,500,000 (50) and Enterprise at $500/month for 5,500,000 (100), plus a free tier of 1,000 credits. Note the concurrency: ScrapingBee's $99 Startup allows 100 concurrent requests, Scrapfly's $100 Pro allows 20.
ScraperAPI (scraperapi.com) runs a similar credit model; its pricing page did not load for us when we checked, so we give it one row and no numbers rather than repeat third-party figures.
Crawlers and actor platforms. If what you want is whole sites turned into markdown for an LLM, the Firecrawl-style crawlers are the closer match, and our Firecrawl alternatives guide covers them with a live x.com test. If you want ready-made scrapers per site, Apify's marketplace bills compute units; our Apify pricing guide breaks that down.
When none of them is the answer. If the site you need has a structured API, page scraping costs you parsing work and breaks when the HTML changes. That trade-off is the subject of our web scraping vs API guide; for X it decides the bill, as the next section shows.
Scraping X (Twitter) with ScrapingBee vs calling an X API
ScrapingBee bills per page. X data is consumed per tweet. The two units do not line up, and on x.com the page is the weak link: in the x.com test in our Firecrawl alternatives guide, a logged-out fetch of a public profile showed 5 of the account's 20 latest posts with rounded counts, and x.com/search returned a login page. A generic scraper, however good its proxies, fetches what a logged-out browser sees; search results, reply threads and full timelines sit behind X's login wall, in place since the June 30, 2023 change.
What a structured X API returns instead. GET /twitter/tweet/advanced_search takes the same query syntax as X search and returns JSON tweets with exact likeCount, retweetCount, replyCount, viewCount, createdAt, lang and a nested author object, 20 per page, with has_next_page and next_cursor for paging. GET /twitter/user/last_tweets returns an account's timeline the same way. No X account is needed for reads, and there is no HTML to parse.
The X data bill. TwitterAPI.io charges 15 credits per tweet returned, which is $0.15 per 1,000 tweets; you pay only for the data returned, with a 15-credit minimum ($0.00015) for a request that comes back empty. X's own pay-per-usage rate card (docs.x.com/x-api/getting-started/pricing) charges $0.005 per post read, $5 per 1,000, capped at 3 million post reads a month before Enterprise. That is about 33x apart per 1,000 tweets. Profiles cost 18 credits ($0.18 per 1,000) against X's $0.010 per user read.
Our own study as a receipt. The 524 tweets we pulled for the study below cost $0.08 at $0.15 per 1,000. The same 524 post reads at X's $0.005 would be $2.62.
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); purchased credits never expire. Requests are limited to 0.2 per second before the first payment and 20 per second once paid. Plans and volume pricing are on the pricing page.
What X says about ScrapingBee: a real-data look
Pricing pages tell you the rate card; X tells you what users say about it. We pulled every post the newest-first search returned for scrapingbee: 51 posts over 69 days, of which 7 came from ScrapingBee's own account and 44 from 33 other accounts.
Mostly replies. 70.5% of the mentions are replies inside other conversations, typically a developer naming ScrapingBee as the tool they use or recommend, rather than standalone reviews. About one in five (22.7%) touches price, credits or plans, which matches the search intent behind this page: people compare credit costs before they commit.
English-first. 38 of the 44 posts by other accounts are in English. The volume is small: for a tool sold to developers, X is a side channel, and that is itself useful to know if you want buyer feedback before choosing.
ScrapingBee and its peers on X
We also read the recent timelines of five scraping-API vendors' official X accounts. ScrapingBee's timeline is sparse: its last 114 posts reach back years, while each peer's recent posts span months, weeks or days.
ScrapingBee posts rarely. Its 114 sampled posts span about 2,282 days, 0.05 a day, with 39 in the most recent 365 days. ScraperAPI (0.67 a day) and ZenRows (0.58) post several times a week, mostly replies; Apify posts 14.91 times a day, half of it replies.
Attention goes to the AI-crawler angle. Firecrawl's original posts drew a median of 337 likes, against 14 for Apify and 3 for ScrapingBee. None of the five vendors' original posts in the sample mentions Twitter or X data.
How we collected this
Question. How does X talk about ScrapingBee, how active are ScrapingBee and four scraping-API peers on X, and what would the same tweets cost through a structured X API? The protocol was written before collection.
Accounts and query. Timelines (/twitter/user/last_tweets, replies included) of @scrapingbee, @scraperapi, @ZenrowsHQ, @firecrawl and @apify, each handle confirmed with /twitter/user/info first; and /twitter/tweet/advanced_search with query=scrapingbee, queryType=Latest.
Window and sample. The most recent posts of each account and every search result the API returned, collected in 2026: 524 tweets in 47 requests. We had planned a sixth account for Bright Data but dropped it: the handle we found was a small, long-dormant account we could not confirm as official.
Prices. ScrapingBee, ZenRows and Scrapfly plans and credit costs were read from each vendor's own pricing page and documentation in 2026; per-1,000-page costs are our arithmetic on those numbers. X prices are from docs.x.com.
What the sample cannot show. A few dozen mentions are not a satisfaction survey, keyword matching misses context, and timeline activity says nothing about product quality or uptime. We did not run ScrapingBee requests ourselves, so success rates on any target are not measured here.
Privacy. Aggregates only. Search results, whose authors are mostly private individuals, were never stored in the repository; the de-identified rows we kept have no ids, URLs, text or handles. Only organization accounts are named.
"""scrapingbee_on_x.py - pull every recent X post that mentions a vendor (here ScrapingBee),
count replies / price talk / links, and print what the pull cost.
pip install requests
export TWITTERAPI_IO_KEY=... # from https://twitterapi.io/dashboard
python scrapingbee_on_x.py
"""
import os
import re
import requests
BASE = "https://api.twitterapi.io"
HEADERS = {"X-API-Key": os.environ["TWITTERAPI_IO_KEY"]}
PRICE = re.compile(r"pric|credit|\bplan\b|\$\d|\bcost|expensive|per month|/mo\b", re.I)
ALT = re.compile(r"alternative|\bvs\.?\b|versus|instead of|switch", re.I)
def search_all(query: str, max_pages: int = 25):
"""Newest-first search; follows next_cursor until has_next_page is false."""
cursor, tweets = "", []
for _ in range(max_pages):
r = requests.get(
f"{BASE}/twitter/tweet/advanced_search",
headers=HEADERS,
params={"query": query, "queryType": "Latest", "cursor": cursor},
timeout=30,
)
r.raise_for_status()
page = r.json()
tweets.extend(page.get("tweets", []))
if not page.get("has_next_page"):
break
cursor = page.get("next_cursor", "")
return tweets
def main():
tweets = search_all("scrapingbee")
others = [t for t in tweets if t["author"]["userName"].lower() != "scrapingbee"]
n = len(others) or 1
replies = sum(1 for t in others if t.get("isReply"))
price = sum(1 for t in others if PRICE.search(t.get("text") or ""))
alt = sum(1 for t in others if ALT.search(t.get("text") or ""))
links = sum(1 for t in others if (t.get("entities") or {}).get("urls"))
views = sorted(t.get("viewCount") or 0 for t in others)
print(f"{len(tweets)} posts, {len(others)} by other accounts")
print(f"replies {replies / n:.0%} | price words {price / n:.0%} | alternative words {alt / n:.0%} | links {links / n:.0%}")
if views:
print(f"median views {views[len(views) // 2]:,}")
# 15 credits per tweet returned; $1 = 100,000 credits -> $0.15 per 1,000 tweets
print(f"cost of this pull: ${len(tweets) * 15 / 100_000:.4f}")
if __name__ == "__main__":
main()
Researching this?Free starter credits cover end-to-end testing — Google sign-in, no card. Get a key.
Questions readers ask
Does ScrapingBee have a free plan?
Not an ongoing one. New accounts get a free trial of 1,000 API credits with no credit card. At the default 5 credits per JavaScript-rendered request that is 200 pages, or 1,000 pages with render_js=false. After that the smallest plan is Hobby at $19/month for 75,000 credits.
How many credits does a ScrapingBee request cost?
1 to 75. A request without JavaScript costs 1 credit, with JavaScript rendering (the default) 5, with premium proxies 10 (no JavaScript) or 25 (with JavaScript), and the top proxy tier with JavaScript 75. AI extraction adds 5 credits; the Google Search API costs 10 credits with light_request and 15 without.
Do ScrapingBee credits roll over?
No. ScrapingBee states that API credits are valid for one month and do not roll over, so unused credits are lost at the end of each cycle. Size the plan for your steady monthly volume.
Does ScrapingBee charge for failed requests?
It depends on the failure. Its documentation bills 200, 404, 410 and 413 responses and does not bill 400, 401, 403, 429 (too many concurrent requests) or 500 (could not scrape). In auto mode a request where every configuration fails costs 0 credits.
Is there annual pricing for ScrapingBee?
The pricing page shows monthly prices only, excluding VAT, and no annual discount. Enterprise plans from $999/month to $5,799/month are also listed monthly.
Which ScrapingBee plan should I pick?
Work out your monthly pages and the request type your targets need, then divide. Startup ($99/month, 1,000,000 credits) covers 200,000 default JavaScript pages but only 40,000 premium-proxy pages. If most targets work without JavaScript, render_js=false cuts every page to 1 credit and a smaller plan may do.
Can ScrapingBee scrape Twitter (X)?
It fetches whatever a logged-out browser sees on x.com, billed per page. Search results, reply threads and full timelines sit behind X's login wall, and the HTML still needs parsing. For tweets, a structured X API is the usual route: TwitterAPI.io returns JSON tweets at $0.15 per 1,000 with no X account needed, against $5 per 1,000 post reads on X's own pay-per-usage card.
What are the main ScrapingBee alternatives?
ZenRows (same 1/5/10/25 credit ladder, a 5,000-credit monthly free plan, paid plans from $19/month), Scrapfly (from $30/month for 200,000 credits), ScraperAPI, and for LLM-ready crawling Firecrawl-style tools or Apify's actor marketplace. For a specific site with an API, such as X, an API is usually simpler than any page scraper.
Continue
- X API docs: pay-per-usage pricing ($0.005 per post read, $0.010 per user read, 3M post-read cap)
- TwitterAPI.io docs: advanced search endpoint (query, queryType, cursor)
- TwitterAPI.io docs: user last tweets endpoint
- TwitterAPI.io docs: user info endpoint
- RFC 9110 HTTP Semantics: status codes 404, 410, 413 and 500
- RFC 6585: HTTP 429 Too Many Requests
- X (Twitter) API overview: endpoints, pricing and limits
- Web scraping vs API: when each one makes sense
- Firecrawl alternatives and what each reads from x.com
- Twitter scraping guide for 2026
- Apify pricing: plans, compute units and X data costs
- How to get Twitter data without the official API
- TwitterAPI.io pricing: $0.15 per 1,000 tweets
- 01Pipedream Pricing in 2026: Connect Plans, Credits and the Workflows Shutdown
- 02Cloudflare Pay per Crawl: How the HTTP 402 Handshake Works, and What It Means for Twitter (X) Data
- 03Firecrawl Pricing: Plans, Credit Costs and What an X (Twitter) URL Costs
- 04LunarCrush API: What It Returns, What It Costs, and When Raw Twitter (X) Data Is the Better Input
- 05SerpApi Pricing: Every Plan, the Real Cost per Search, and the Alternatives
- 06Apify Pricing in 2026: Plans, Compute Units and What Twitter (X) Data Really Costs
- 07RapidAPI Pricing in 2026: How Plans, Overages and the 25% Fee Work, and What Twitter (X) APIs Cost There
- 08Lovable pricing in 2026: plans, credits, and what an app that pulls Twitter (X) data really costs
Writing about something you built with TwitterAPI.io? Our community rewards program pays API credits for honest tutorials, build logs and videos.
Stop reading. Start building.
Starter credits cover real testing on real data. Google sign-in, no card, no application queue.
Get an API keyAlready building with TwitterAPI.io? Publish an honest tutorial or build log about it and earn up to $200 a month in API credits.