---
title: "Cheapest Web Scraping APIs (Aug 2026): Real Cost per 1,000 Pages"
dek: "The real August 2026 cost per 1,000 pages across nine scraping and search-plus-extraction APIs, credit multipliers, the antibot cost ladder, concurrency, and the one-call vs two-call math that decides the bill."
category: "guide"
tags: [web-scraping, pricing, comparison, 2026]
author: "Dave"
published: 2026-08-15T12:00:00+00:00
updated: 2026-08-15T12:00:00+00:00
url: https://keirolabs.cloud/blogs/guide/cheapest-web-scraping-apis-aug-2026
---
The cheapest web scraping API in August 2026 is not the one with the lowest number on its pricing page. It is the one whose real cost per 1,000 pages, after credit multipliers, JavaScript rendering, antibot escalation, and retries, is lowest for the workload you actually run. I pulled the current pricing for nine providers (Firecrawl, Bright Data, ScraperAPI, ScrapingBee, ScrapingAnt, ZenRows, Apify, Oxylabs, and Keiro), cross-checked it against independent benchmark runs, and rebuilt the per-1,000-page math so the comparison is apples to apples.
The short version, which the numbers below back up: **for raw page-capture at volume, Bright Data and ZenRows have the deepest antibot and the most predictable bill on protected sites, but the most common 2026 workload, "give me clean content for RAG", is roughly 3x cheaper with a one-call search-plus-extraction API than with the search-then-scrape stack most teams bolt together.** Keiro's `/search/content` at 3 credits a call lands around $3 per 1,000 calls (about $0.60 per 1,000 pages, since each call returns up to five clean pages with embeddings), and it replaces the search API, the scraper, and the embedding step in one request.
This is a cost-focused companion to the feature-first [best web scraping APIs for AI agents](https://keirolabs.cloud/blogs/guide/best-web-scraping-apis-for-ai-agents-2026) guide. Prices are list prices from each vendor's pricing page or API docs, accessed August 2026, and where an independent benchmark exists I cite it so you can audit the success-rate math rather than take my word for it.
$0.60Keiro /search/content per 1k pages, all-in
$0.20cheapest base rate (ScrapingBee, JS off)
125xworst credit multiplier (ScrapingAnt stealth)
$2.50Bright Data flat /1k on protected targets
3.2xone-call vs two-call gap at 100k q/day
TL;DR · cheapest by workload, August 2026
- **Cheapest raw capture of simple pages:** ScrapingBee at ~$0.20/1k and ZenRows at ~$0.23/1k in base configuration, but both multiply steeply the moment you need JS rendering or premium proxies.
- **Cheapest on protected targets:** Bright Data, flat $2.50/1k on Walmart/Lowe's/Costco-grade sites with a 98.9% independent success rate; ZenRows premium (25 credits/request) is the budget alternative at ~$5.70/1k.
- **Cheapest for the RAG workload (search + clean text + embeddings):** Keiro `/search/content`, ~$3/1k calls (≈$0.60/1k pages), one call, no separate extraction or embedding line items.
- **Cheapest-looking is often the most expensive:** ScrapingAnt's $0.49/1k base becomes ~$61/1k when a target needs its stealth + JS config, a 125x multiplier, and its independent success rate is 33–68%.
- **The two-call trap:** search-then-scrape stacks cost ~$9.50 per 1k questions at 2026 mid-tier rates; Keiro does the same job for $3.00. The gap is 3.2x and widens with volume.
- **Rule:** test the API against your target site through the free tier before you buy. Success rate is the price.
## What "cheap" actually means: the four numbers that decide the bill
Every scraping API in this comparison has the same skeleton: a headline price, a set of per-feature credit multipliers, a concurrency or rate-limit ceiling, and a success rate. Only the first of those is on the pricing page. The other three decide the invoice. Before the per-1k tables, here is the cost model I used, because "cost per 1,000 pages" is meaningless unless the method is on the table.
Cost formula Cost per 1,000 pages = (credits per page × credit price) × 1,000, computed at the plan tier where the credit rate is lowest, then adjusted for the configuration actually run. JS rendering, premium proxies, stealth mode, and extraction are applied as separate multiplier columns, not folded into one number.
Credit price Each provider's per-1,000-credit rate from its published pricing page, August 2026, entry-to-mid tiers. Where a provider is usage-based (Bright Data, Oxylabs, Apify), I use the published per-1k rate or the independent benchmark's measured average.
Success-rate adjustment Effective cost = list cost ÷ success rate. A 60%-success API needs ~1.67 billed requests per good page; a 98%-success API needs ~1.02. Independent benchmark numbers come from the Scrape.do 16-provider run ([scrape.do/blog/best-web-scraping-api](https://scrape.do/blog/best-web-scraping-api/)) and the Scrapeway runs ([scrapeway.com](https://scrapeway.com/web-scraping-api/scrapingant)).
Pricing source Every price below is from the provider's pricing page or API docs, accessed August 2026, linked inline beside each claim. Vendors change credit costs more often than plan prices; verify before committing.
Why does the method matter? Because the four numbers compound. A provider at $0.20/1k with a 75-credit stealth tier and a 60% success rate is not a $0.20 API, it is a $0.20 API only for pages that never hit any multiplier and never fail. The moment your target is a React app behind Cloudflare, the multiplier applies to every request, and the failures add retries on top. **The cheapest API on a pricing page and the cheapest API on your pipeline are rarely the same company, and the divergence is what this guide quantifies.**
## Cost per 1,000 pages: the August 2026 table
Here is the base configuration, one credit per request, standard (datacenter) proxy, no premium multipliers, no JavaScript rendering where the provider lets you turn it off. This is the number on the pricing page, and it is the floor. Keiro is in this table as a category note, because its 3-credit `/search/content` call is search plus extraction, not raw capture.
| Provider | Base $/1k pages | Plan / tier used | Notes |
|---|---|---|---|
| ScrapingBee | $0.20 | Freelance $49/mo, 250k credits | classic proxy, JS off; JS is on by default and costs 5cr |
| ZenRows | $0.23 | Launch $57/mo, 250k credits | basic fetch, 1cr/request |
| ScraperAPI | $0.49 | Hobby $49/mo, 100k credits | basic request, 1cr |
| ScrapingAnt | $0.49 | ~$49/mo tier, 100k requests | basic + datacenter proxy, 1cr |
| Keiro `/search/content` | $0.60 | Startup $50/mo, $1.00/1k credits | 3cr/call, ≤5 clean pages/call; bundles search + markdown + embeddings |
| Apify | ~$0.67 | Starter $29/mo, $0.20/CU | browser-actor estimate, ~300 pages/CU; Cheerio actors ~10x cheaper |
| Firecrawl | $0.83 | Standard $83/mo, 100k credits | scrape 1cr/page ([pricing](https://www.firecrawl.dev/pricing)) |
| Oxylabs | $1.15 | Micro $49/mo | non-Amazon targets, no JS ([pricing](https://oxylabs.io/products/scraper-api/web/pricing)) |
| Bright Data | ~$1.50 | Usage-based | average across target mix; flat $2.50/1k on protected sites ([benchmark](https://scrape.do/blog/best-web-scraping-api/)) |
Sources for the credit math: [Firecrawl pricing](https://www.firecrawl.dev/pricing), [ZenRows pricing](https://www.zenrows.com/pricing), [ScrapingBee pricing](https://www.scrapingbee.com/pricing/) and [ScrapingBee credit docs](https://help.scrapingbee.com/en/article/credit-system-explained-1h2ackp/), [ScraperAPI pricing](https://www.scraperapi.com/pricing), [ScrapingAnt credit docs](https://docs.scrapingant.com/credits-cost), [Apify pricing](https://apify.com/pricing), and [Keiro pricing](https://keirolabs.cloud/pricing).
Base-configuration cost per 1,000 pages, August 2026. Keiro /search/content at $0.60 also bundles the search step, clean markdown, and embeddings, line items every scraping-only row here bills separately.
Read this chart carefully, because the ordering is not the story. ScrapingBee and ZenRows look like the clear winners, and at base configuration they are, for a static page behind no protection, with no rendering. **The moment the workload needs JavaScript rendering or residential proxies, those two cheapest rows multiply by 5x to 125x, and the ordering inverts.** Keiro sits mid-pack on raw capture because it is not competing on raw capture; it competes on the bundled RAG workload, which the one-call section below prices.
Two notes on table fairness. Apify bills compute time, not requests, so its base number is an estimate: Apify's own benchmarks put Cheerio-based scraping around 3,000 pages per compute unit and browser-based scraping around 300 pages per CU ([Apify pricing](https://apify.com/pricing)); at $0.20/CU that is ~$0.07 to ~$0.67 per 1k pages. I use the conservative browser figure here, and the independent benchmark measured Apify at $5.48/1k effective across hard targets, the spread is real and workload-dependent. Bright Data and Oxylabs are usage-based, so their rows are averages, not list prices.
## What $100 buys you in August 2026
The per-1k table reads abstract until you invert it into volume. Here is the same math expressed as pages per $100 at base configuration, with the honest asterisk for each provider:
| Provider | $/1k pages (base) | Pages per $100 | The asterisk |
|---|---|---|---|
| ScrapingBee | $0.20 | ~500,000 | JS on by default → ~100k pages if you don't disable it |
| ZenRows | $0.23 | ~435,000 | base config only; premium targets at $5.70/1k → ~17,500 |
| ScraperAPI | $0.49 | ~204,000 | entry tiers cap concurrency, throttling throughput |
| ScrapingAnt | $0.49 | ~204,000 | 33–68% success → 67k–139k good pages |
| Keiro `/search/content` | $0.60 | ~167,000 | includes search + clean text + embeddings; ≤5 pages/call |
| Apify | ~$0.67 | ~149,000 | browser-actor estimate; Cheerio actors ~10x more |
| Firecrawl | $0.83 | ~120,000 | JSON+Enhanced at 9cr → ~13,000 pages |
| Oxylabs | $1.15 | ~87,000 | non-Amazon targets, no JS |
| Bright Data | ~$1.50 | ~67,000 | flat $2.50 on protected targets → ~40,000 there |
The inversion is the point. **At base configuration the cheapest providers deliver 5–7x the volume of the most expensive per dollar, and the multiplier table erases most of that advantage the moment targets harden.** A $100 budget buys ~500k simple pages on ScrapingBee or ~40k protected pages on Bright Data; the workload, not the provider, decides which $100 you spend. This is also why the "cheapest per page" answer and the "cheapest for my job" answer diverge so often in this category, the job determines which column of the multiplier table you live in.
## The per-credit multipliers hiding in "per 1,000"
Every credit-based provider in this comparison multiplies the base request cost when you turn on features. The multiplier table is the single most important page in any scraping vendor's docs, and it is the least read. Here is August 2026, in one table:
| Provider | Base | JS rendering | Premium / residential | Stealth / ultra | Extraction |
|---|---|---|---|---|---|
| Firecrawl | 1 | Enhanced +4 | +4 | 5 (Stealth Mode) | JSON +4 (JSON+Enhanced = 9) |
| ScrapingBee | 1 | 5 | 10 (premium no-JS) / 25 (premium+JS) | 75 | AI query +5 |
| ScraperAPI | 1 | 5–10 | 25 (premium + render) | 75 (ultra premium) |, |
| ScrapingAnt | 1 | 10 | 25 (residential) | 125 (JS + premium) | AI extract, ~1cr/30 chars |
| ZenRows | 1 | 5 | 10 | 25 (JS + premium) | Extract = fetch cost |
Sources: [Firecrawl](https://www.firecrawl.dev/pricing), [ScrapingBee credit docs](https://help.scrapingbee.com/en/article/credit-system-explained-1h2ackp/), [ScraperAPI credit docs](https://docs.scraperapi.com/) and [Spider's breakdown](https://spider.cloud/blog/spider-alternative-to-scraperapi/), [ScrapingAnt credit docs](https://docs.scrapingant.com/credits-cost), [ZenRows credit costs](https://docs.zenrows.com/credit-costs).
A few multipliers deserve their own callouts, because they are the ones that empty credit balances.
**ScrapingBee turns JS rendering on by default.** The [credit system docs](https://help.scrapingbee.com/en/article/credit-system-explained-1h2ackp/) list classic-proxy-no-JS at 1 credit, but the API defaults `render_js` to true, so every request you send without explicitly disabling rendering costs 5 credits, and a premium-plus-JS request costs 25. [Spider's analysis](https://spider.cloud/blog/spider-alternative-to-scrapingbee/) puts the real-world consequence plainly: on the $49/mo Freelance plan's 250,000 credits, stealth-proxy requests at 75 credits each buy about 3,333 pages, an effective ~$14.70 per 1,000 pages, not the $0.20 the headline implies.
**ScraperAPI's ultra-premium tier is a 75x multiplier.** The credit table in [ScraperAPI's docs](https://docs.scraperapi.com/) prices a basic request at 1 credit, JS rendering at 5–10, premium-plus-rendering at 25, and the ultra-premium configuration that handles Cloudflare/DataDome at 75. On the Hobby plan's $0.49/1k credit rate, a Cloudflare-protected page costs ~$36.75 per 1,000 pages before retries.
**ScrapingAnt's ladder tops out at 125.** The [credit cost docs](https://docs.scrapingant.com/credits-cost) price a simple request at 1 credit, headless-browser JS rendering at 10, premium residential at 25, and the full JS-plus-residential configuration at 125, a 125x multiplier. At ~$0.49/1k, a hard target runs ~$61/1k. That is not a typo, and it is the reason the cheap-looking providers in the base table are expensive in production.
**ZenRows is the most predictable credit ladder.** The [ZenRows docs](https://docs.zenrows.com/credit-costs) keep it simple: basic fetch 1, JS rendering 5, premium proxies 10, both together 25. On the Launch plan's $0.23/1k rate, that is $0.23, $1.14, $2.28, and $5.70 per 1k pages. **ZenRows charges flat per successful request regardless of plan, which makes it the easiest provider in this set to model, and the cleanest budget answer for protected sites short of Bright Data.**
Firecrawl's multipliers compound differently: JSON extraction adds +4 credits and Enhanced Mode adds +4, so a JSON-plus-Enhanced scrape costs 9 credits per page on the Standard tier's $0.83/1k rate, about $7.47 per 1k pages, over 8x the base $0.83. Stealth Mode (Firecrawl's antibot layer) is another 5 credits per page on top. The [independent benchmark](https://scrape.do/blog/best-web-scraping-api/) measured Firecrawl at $9.59/1k effective, which is consistent with a workload where a share of pages hits these multipliers.
The takeaway from the multiplier table is not that multipliers are evil, it is that they are the product. **A scraping API's real price is the base rate times the multiplier for the hardest configuration your target mix actually requires, and the spread between base and real is 5x to 125x across this set.** Budget the multiplied number, never the headline.
## The antibot ladder: what solving Cloudflare actually costs
Anti-bot defense is where the base-price ordering inverts, and it is the category where two providers separate themselves from the pack. "Does it solve Cloudflare?" is the question every team asks, and the honest answer differs by configuration, so here is the ladder with prices attached.
The antibot cost ladder, log scale. Base prices converge low; protected-target prices diverge by up to two orders of magnitude. Bright Data's flat $2.50 on hard targets is why it wins the protected-site category outright.
**Bright Data is the deepest antibot network in this comparison, full stop.** It runs 150M+ residential IPs across 195 countries, and in the [independent 16-provider benchmark](https://scrape.do/blog/best-web-scraping-api/) it hit a 98.9% average success rate, 100% on Indeed, GitHub, Zillow, and Google, while charging a flat $2.50/1k on heavily protected targets like Walmart, Lowe's, and Costco regardless of complexity. That flatness is the differentiator: competitors' unpredictable variable rates on hard targets routinely exceed Bright Data's flat price once retries are counted. The catch is that you pay the enterprise premium on easy pages too (~$1.50/1k average), and the entry is usage-based with no meaningful free tier.
**ZenRows is the budget antibot answer.** Its premium tier (25 credits/request for JS plus residential) is the cheapest genuinely-protected configuration in the set at ~$5.70/1k on the Launch plan, with a 96.3% independent success rate and the simplest credit ladder to model. It is not Bright Data-deep, the Scrapeway benchmark puts ZenRows at 58% on the hardest blocked targets in one run, but for most anti-bot work it is the value pick.
**ScrapingBee's stealth tier works but bills like a surgical procedure.** 75 credits per request for stealth proxies plus rendering, on top of the JS-on-by-default gotcha, makes its protected-site price ~$14.70/1k, roughly 74x its base rate. [Its own docs](https://help.scrapingbee.com/en/article/credit-system-explained-1h2ackp/) are explicit about the 75-credit stealth cost.
**Firecrawl and ScraperAPI solve Cloudflare selectively.** Firecrawl's Stealth Mode (5 credits/page) and Enhanced mode are real, but the [independent benchmark](https://scrape.do/blog/best-web-scraping-api/) measured Firecrawl at a 60.5% success rate across hard targets, the weakest in the set, which is the other half of its $9.59/1k effective price. ScraperAPI's ultra-premium tier exists (75 credits) but its measured success was 72.6%, so you pay a large multiplier for a coin-flip on the hardest targets.
**ScrapingAnt and Oxylabs round out the ladder.** ScrapingAnt advertises unlimited concurrency and a 125-credit stealth config, but its independent success rates are the worst in the set, 68.1% in the Scrape.do run and 33% in the [Scrapeway August 2026 run](https://scrapeway.com/web-scraping-api/scrapingant), which makes its cheap base price effectively moot on protected sites. Oxylabs is the opposite shape: strong network (95.4% success), premium pricing (from $1.15/1k base, [pricing](https://oxylabs.io/products/scraper-api/web/pricing)), and enterprise sales motion.
**Keiro is not in this chart, and that is the honest placement.** Keiro is a search-plus-extraction API, not an antibot bypass tool. If your job is "get me this specific Cloudflare-protected URL," Keiro is the wrong tool, that is Bright Data or ZenRows territory. If your job is "get me clean content from the live web," Keiro's indexed retrieval returns it without any antibot multiplier at all, which is why its cost curve is flat where every scraper's steepens. **The choice is workload-shaped, not just price-shaped: buy antibot depth when you know the target domain; buy a flat cost curve when you only know the question.**
## Concurrency and rate limits: can your workload actually run?
Price per 1,000 pages is only half the bill. The other half is whether the plan you can afford can actually move that volume, and rate limits are where the cheap plans stop being cheap. Here is the August 2026 picture:
| Provider | Concurrency / rate | Free tier | Notes |
|---|---|---|---|
| Bright Data | Unlimited concurrency |, | usage-based, no free pool; pay-per-success |
| ScrapingAnt | Unlimited concurrency | Trial | but 33–68% success makes throughput moot |
| ScrapingBee | 50–400 concurrent | 1,000 credits | by plan (Freelance → Business+) |
| ZenRows | 5–200 concurrent | 5,000 credits | Free 5, Build 20, Launch 50, Growth 100, Scale 200 |
| Firecrawl | 2–150 concurrent | 1,000 credits | 2 free, 150 Scale |
| Apify | 25–256 concurrent runs | $5/mo credits | Free 25 runs, Starter 32, Scale 128, Business 256 |
| ScraperAPI | ~5–25 concurrent (entry) | 1,000 credits | scales with plan |
| Oxylabs | 10–50 requests/s | 2,000-result trial | Micro 10 rps, Starter+ 50 rps |
| Keiro | 30–1,000 req/min | 500 credits/mo | Free 30/min, Essential 60/min, Pro 300/min, Startup 1,000/min |
Sources: [ZenRows pricing](https://www.zenrows.com/pricing), [ScrapingBee pricing](https://www.scrapingbee.com/pricing/), [Firecrawl pricing](https://www.firecrawl.dev/pricing), [Apify pricing](https://apify.com/pricing), [Oxylabs pricing](https://oxylabs.io/products/scraper-api/web/pricing), [Bright Data](https://brightdata.com/pricing/serp), [Keiro pricing](https://keirolabs.cloud/pricing).
The pattern that matters: the cheapest per-page providers are also the most tightly rate-limited, and the math of getting to volume on a cheap plan is usually a plan upgrade. **A $49/mo plan at 5 concurrent requests delivers roughly one page every couple of seconds per worker, a 100k-page job that the price per page suggests should cost ~$49 instead costs the upgrade tier you need to finish it this month.** ScrapingBee's Freelance plan (50 concurrent, $49) and ZenRows' Launch plan (50 concurrent, $57) are the sweet spots for a real workload; the sub-$0.25/1k headline rates only become reachable on those mid tiers anyway, so the effective price and the concurrency ceiling are the same purchase.
Keiro's rate limits are per-minute rather than per-concurrent-browser, which is a different shape: 30 req/min on the free tier is enough for light agent traffic, and the Startup tier's 1,000 req/min is the headroom figure. **Because a `/search/content` call returns up to five pages, Keiro's per-minute request ceiling translates to roughly 5x as many pages per minute as the same request count on a scraping API, the rate limit and the content bundle compound together.**
## The free tiers, and why they are the real test
Every provider in this guide ships a free grant, and the grants are the cheapest benchmarking tool in the industry, they exist to run the 500-request test against your own target site. Here is what August 2026 actually hands out:
| Provider | Free grant | Rate limit on free | What you can test |
|---|---|---|---|
| Firecrawl | 1,000 credits/mo | 2 concurrent | ~1,000 simple scrapes; enough for a 500-request test |
| ScrapingBee | 1,000 credits |, | ~1,000 pages with JS off; ~200 with JS on |
| ZenRows | 5,000 credits/mo | 5 concurrent | largest pure scraping grant; full feature access |
| Apify | $5/mo in credits | 25 runs | compute credits; generous for small jobs |
| ScrapingAnt | Trial | unlimited concurrency | whether its success rate holds on your target |
| Oxylabs | 2,000-result trial | 10 req/s | real scrape results on your domains before paying |
| Bright Data |, |, | pay-per-success only; no meaningful free pool |
| Keiro | 500 credits/mo | 30 req/min | ~166 `/search/content` calls; every endpoint exposed |
Sources: [Firecrawl](https://www.firecrawl.dev/pricing), [ScrapingBee](https://www.scrapingbee.com/pricing/), [ZenRows](https://www.zenrows.com/pricing), [Apify](https://apify.com/pricing), [Oxylabs](https://oxylabs.io/products/scraper-api/web/pricing), [Keiro](https://keirolabs.cloud/pricing).
**A provider's free grant is also a signal about its pricing model: ZenRows gives away 5,000 credits a month and Keiro 500, both enough to benchmark real output; Bright Data's absence of a free pool is the flip side of a network that sells per successful request.** One caution: the free tier measures output quality, not production cost. A 500-request test tells you the success rate, which is the critical input to the effective-price formula, but it does not tell you what the plan upgrade for volume costs. Compute that from the multiplier table, not from the free tier.
## One call vs two calls: the search-then-scrape trap
This is the section that changes the answer. Almost every team evaluating "scraping APIs" is actually building the same pipeline: ask a question, find relevant pages, get their clean text, embed it, stuff it into context. That is search plus scrape plus extract plus embed, four operations, and teams price only the middle one.
The two-call architecture is the default because it is what the tooling suggests. A search API (Brave, Serper, Tavily, or Keiro's 1-credit `/search/fast`) returns result URLs. A scraping API (any row in the tables above) fetches each URL and returns content. An embedding call vectorizes it. Three services, three keys, three invoices, three failure modes, two network round-trips per result. At 2026 mid-tier rates the stack costs about this:
| Component | Rate | Per 1k questions (3 pages each) |
|---|---|---|
| Search API | $5.00 / 1k queries | $5.00 |
| Scraping API | $1.00 / 1k pages | $3.00 |
| Embeddings / vector pipeline | $0.50 / 1k pages | $1.50 |
| **Two-call stack total** | | **$9.50 per 1k questions** |
| Keiro `/search/content` (one call) | 3 credits / query, $1.00/1k credits | **$3.00 per 1k questions** |
The scraping rate here ($1.00/1k pages) is the mid-pack August 2026 number, Firecrawl Standard-tier money. Use Firecrawl's JSON-plus-Enhanced config and the stack climbs toward $25–30 per 1k questions. **Keiro's `/search/content` at 3 credits a call returns ranked results plus clean markdown plus optional embeddings in one request, which replaces all three services for $3.00 per 1k questions, a 3.2x cost gap before you count the two extra latencies and the two extra failure modes.**
Daily cost for a live-web RAG agent, 3 pages per question. The one-call stack (Keiro /search/content) is 3.2x cheaper at every volume, and the absolute gap grows from $6.50/day at 1k questions to $650/day at 100k.
The shape of the difference, in code, is two requests versus one:
```python
# The two-call way: search, then scrape, then embed.
results = search_api.query(question, k=10) # $5 / 1k queries
pages = [scrape_api.scrape(u) for u in results[:3]] # $1 / 1k pages
vectors = embed_api.embed(pages) # $0.50 / 1k pages
# → ~$9.50 per 1k questions, two network hops per page, one extra service
# The one-call way: search + content + embeddings together.
payload = keiro.search_content(question, max_results=5) # 3 credits
# → ~$3.00 per 1k questions, one network hop, up to 5 clean pages returned
```
Latency is a cost that never shows up on an invoice but compounds the same way. The two-call stack spends two sequential network round-trips per page, a search round-trip plus a scrape that the [independent benchmark](https://scrape.do/blog/best-web-scraping-api/) measured at anywhere from 3.9 seconds (Firecrawl) to 33.1 seconds (ScrapingAnt) average across hard targets. At 5,000 questions a day with three pages each, the scrape step alone adds hours of wall-clock time the one-call API never spends, because the content arrives in the search response.
The compounding factors are where the trap really bites. **Every extra service in the pipeline adds a failure mode, and in a search-then-scrape pipeline a search failure and a scrape failure both cost a retry, so the real two-call stack multiplies failure probability twice per question.** A search API at 95% success combined with a scraper at 95% success gives a 90.25% per-question success before you count rate limits; the retry cost is baked into the effective price even if it never appears on an invoice. One call collapses that: one request, one success or failure, one retry decision.
There is a second, less obvious saving: the search-then-scrape pipeline scrapes pages you do not end up using. A search call returns ten results; an agent typically reads two or three. The two-call stack bills for the scrape of every page it fetches, including the ones ranked and discarded. **Keiro's `/search/content` returns up to five clean pages per call at a flat 3 credits, so you pay for content you actually receive, there is no per-result scrape bill for the URLs you rank and skip.** That is the "one call" architecture doing cost work, not just latency work.
For a workload that is genuinely URL-in, HTML-out, you have a list of known URLs and you want raw captures, the one-call advantage disappears, and the correct tool is a scraping API with the antibot depth your target domains require. That distinction is the entire verdict below.
## When a scraping API is the right tool (and when it is not)
The honest boundary, drawn with numbers:
**Use a scraping API when you know the URLs and you need the raw page.** Price monitoring on a specific product catalog, monitoring a specific competitor site, crawling a domain you own, or capturing pages behind authentication, these are known-target workloads where URL-in, content-out is the whole job, and the scraping providers' antibot depth earns its price. On protected targets, Bright Data's flat $2.50/1k or ZenRows' $5.70/1k premium config is the honest bill. This is also where the deep-research agents live: when your agent already knows exactly which pages to read, a scraper is the cheapest way to read them.
**Use a search-plus-extraction API when you only know the question.** This is the much larger workload in 2026: agentic research, RAG over the live web, grounded answer generation, competitive intelligence from a query rather than a URL list. The input is a question; the output is clean, ranked, embeddable content. A search-plus-extraction API like Keiro's `/search/content` prices that as one call, and at 3 credits it beats the three-service alternative by 3.2x before engineering time.
**The wrong choice is the middle: a scraping API used as a content layer for an agent.** That is paying scraping rates for pages you will rank and discard, while still paying a search API for the ranking, while still paying an embedder for the vectors, the most expensive way to do the most common job. The benchmark numbers in this guide exist because this specific mistake is how teams end up at $20–40 per 1,000 questions for a workload that costs $3 per 1,000 on the right architecture.
A worked example makes the boundary concrete. Suppose you run a research agent that answers 10,000 questions a day over the live web. The two-call stack at 2026 mid-tier rates costs $95/day; the one-call stack costs $30/day. That $65/day difference is roughly $1,950 a month, more than the junior-engineer time a team typically budgets for "just make the scraper work," and it compounds with every additional page per question. The same team, if it instead needs to capture 10,000 known product pages a day from a specific catalog, is better off with a scraping API: Bright Data at ~$15/day on average targets, ZenRows premium at ~$57/day, versus forcing a search API to fetch URLs it was not built to fetch. **Input shape decides the tool, and the price follows the shape: question-in is a search-plus-extraction problem, URL-in is a scraping problem, and the cheapest API for one is usually not the cheapest API for the other.**
On the accuracy side, one honest caveat: Keiro is not claiming benchmark dominance on answer quality, its published factual-QA figure is 78% on FinanceBench, mid-pack and explicitly not the headline. **This guide is about cost per 1,000 pages, not accuracy; if you are choosing on QA quality, evaluate that separately with your own query set.** The cost argument stands on its own: for the same clean-content-for-RAG output, one call costs $3 and three calls cost $9.50, and the price difference is independent of how good either answer is.
## The verdict, by workload
- **Cheapest raw capture, simple pages:** ScrapingBee ~$0.20/1k (classic proxy, JS disabled) and ZenRows ~$0.23/1k. Both multiply fast on JS; ZenRows' ladder is the more predictable of the two.
- **Cheapest protected-site capture:** Bright Data, flat $2.50/1k with a 98.9% success rate, the deepest antibot in the set and the most predictable bill on hard targets. ZenRows premium (~$5.70/1k) is the budget alternative.
- **Cheapest clean content for RAG:** Keiro `/search/content`, ~$3/1k calls (~$0.60/1k pages), one call, search + clean markdown + embeddings included. 3.2x cheaper than the two-call stack at every volume tested.
- **Most expensive way to do the common job:** a search API plus a scraping API plus an embedder, run as three services. It costs 3.2x more, fails twice as often, and takes twice as long per question.
- **Rule that beats all of the above:** run 500 requests through each candidate's free tier against your actual target site, count the success rate, and compute effective cost per good page. The cheapest API for your pipeline will not be the cheapest on the pricing page, and the 500-request test costs nothing.
## Further reading
- [Scraping at scale](https://www.webscraping.space/blog/scraping-at-scale), the infrastructure side of what the per-1k number buys.
- [Web scraping with Python requests](https://www.webscraping.space/blog/web-scraping-with-python-requests), when you need to get to "send a URL, get a page" without an API.
- [Search API comparison](https://www.agenticsearch.cloud/posts/search-api-comparison/), the search half of the two-call stack, priced separately.
- [Best web scraping APIs for AI agents](https://keirolabs.cloud/blogs/guide/best-web-scraping-apis-for-ai-agents-2026), the feature-first companion to this price-first guide.
More from this series:
- [Top Web Search APIs (Aug 2026)](/blogs/comparisons/top-web-search-apis-aug-2026)
- [Cheapest Web Search APIs (Aug 2026)](/blogs/comparisons/cheapest-web-search-apis-aug-2026)
- [Best Free Web Search API (Aug 2026)](/blogs/guide/best-free-web-search-api-aug-2026)
- [Best Web Search API for AI Agents (Aug 2026)](/blogs/guide/best-ai-search-apis-for-agents-aug-2026)
- [Keiro pricing](/pricing), the exact credit math behind the per-1k figures
## FAQ
### What is the cheapest web scraping API in August 2026?
In base configuration, one credit per request, standard proxy, no JS rendering, ScrapingBee is cheapest at ~$0.20/1k pages (Freelance plan, 250k credits for $49) and ZenRows is close at ~$0.23/1k (Launch plan, 250k credits for $57). Once JavaScript rendering or premium proxies are required, ZenRows' ~$5.70/1k premium config is the cheapest protected-site answer, and Bright Data's flat $2.50/1k on hard targets is the cheapest predictable one.
### How much does it cost to scrape 1,000 pages in 2026?
Between roughly $0.20 and $1.50 per 1,000 pages in base configuration, depending on provider and tier. With JavaScript rendering the range widens to about $1 to $5 per 1k, and on Cloudflare-protected targets with stealth proxies it can reach $15 to $60 per 1k. The spread is the multiplier table, not the headline.
### Why do credit multipliers change the real price so much?
Because a "1 credit per request" base becomes 5 to 125 credits the moment you need JS rendering, premium proxies, stealth mode, or extraction. ScrapingAnt's stealth-plus-JS config is 125 credits per request; ScrapingBee's stealth is 75. The multiplier applies to every page that hits the harder config, so the effective price is base rate × multiplier × (1 ÷ success rate), not base rate.
### Which scraping API actually solves Cloudflare?
Bright Data is the deepest, 98.9% independent success across hard targets with a flat $2.50/1k on the worst sites. ZenRows on its premium tier (25 credits/request) is the budget option at ~$5.70/1k. ScrapingBee's stealth tier works but costs 75 credits/request (~$14.70/1k), and Firecrawl and ScraperAPI both have antibot tiers with independently measured success rates (60.5% and 72.6%) that make their multipliers a gamble on the hardest targets.
### Is Keiro a scraping API?
No. Keiro is a search-plus-extraction API: `/search/fast` (1 credit) returns ranked results, `/search/content` (3 credits) returns ranked results plus clean markdown plus optional embeddings in one call, and `/extract` (3 credits) turns a known URL into clean content. It is not a proxy-rotation, CAPTCHA-solving antibot tool, that category belongs to Bright Data and ZenRows. It is the right tool for "I need clean content from the live web," not for "I need this specific protected URL."
### When should I use a search-plus-extraction API instead of a scraper?
When your input is a question rather than a URL list. Search-plus-extraction APIs return ranked results with clean content in one call, which is the shape of agent research, RAG over the live web, and grounded answers. A scraper is the right tool when you already know the exact URLs and need raw captures, price monitoring, site crawls, domain-owned pages. The boundary is input shape: question-in → search-plus-extraction; URL-in → scraping API.
### What is the cheapest way to get clean content for RAG?
Keiro `/search/content` at 3 credits per call (~$3 per 1k calls, about $0.60 per 1k pages since each call returns up to five clean pages with embeddings). The three-service alternative, a search API at $5/1k, a scraper at $1/1k pages, and an embedder at $0.50/1k pages, costs ~$9.50 per 1k questions for the same output. One call beats three calls on cost, latency, and failure probability.
### Do these scraping APIs charge for failed requests?
Most credit-based providers charge only for successful requests, Firecrawl, ZenRows, and ScrapingBee all bill success-only, and ScrapingBee's docs note that 404 and 410 responses count as usable. Bright Data and Oxylabs are pay-per-success. The catch is that a failed request still costs you a retry, which is a fresh successful request, so a low success rate inflates the effective price even on success-only billing.
### How do I test which API is cheapest for my pipeline?
Run 500 requests through each candidate's free tier against your actual target sites. Count the success rate and the credits consumed per successful page, then compute effective cost = plan credit rate × credits per successful page. Free tiers in this set: Firecrawl 1,000 credits, ScrapingBee 1,000, ZenRows 5,000, Apify $5/mo in credits, Keiro 500 credits/mo, Oxylabs a 2,000-result trial. The test costs nothing and it will change your answer.
### How do Bright Data and Oxylabs compare per 1,000 pages?
Bright Data is ~$1.50/1k average with a flat $2.50/1k on protected targets and unlimited concurrency; Oxylabs is from ~$1.15/1k (non-Amazon, no JS) up to $1.35/1k with JS on the Micro plan, with 10–50 req/s rate limits. On the independent benchmark, Bright Data hit 98.9% success to Oxylabs' 95.4%. For hard targets, Bright Data's flat rate is the better deal; for mid-tier enterprise workloads with predictable targets, Oxylabs' per-result pricing can undercut it.
