By use case · Pricing comparison

Web scraping API pricing for AI teams: what 11 scraper API pricing plans really charge per page

The short answer

Web scraping API pricing in 2026 starts around $16 to $49 a month for an entry plan and rises to roughly $300 to $1,000 a month for volume tiers, with most vendors billing in credits rather than requests. The headline price is rarely what you pay: rendering JavaScript, retrying blocked pages and stealth mode all consume extra credits, so the number that matters is your cost per successfully extracted page, not the plan price. ClawEngine is $39 a month for Hobby, $99 for Startup and $399 for Scale, with rendering and schema extraction included in one call rather than billed as add-ons. For an AI startup or agent team, the practical budget is $39 to $99 a month during build, moving to the $300 to $500 band once a RAG corpus or agent fleet runs continuously, because those workloads render almost every page and rendering is where the multipliers bite. All prices below were checked in August 2026 on each vendor's own pricing page.

Clean markdown & JSON · JavaScript rendered · robots.txt respected

Last updated August 2026

Live Extraction

Endpoint · POST /v1/extract

POST

try:

Hit Extract to turn this page into clean, LLM-ready data.

robots.txt respected · public data only

Markdown · JSON · structured fields, from one API call. Crawling, rendering and extracting ...

Comparing web scraping APIs on their monthly price is how teams end up over budget in month two. Almost every vendor in this category sells credits, and a credit is not a page. A plain fetch might cost one credit, the same page with JavaScript rendering might cost five, a request that needs a residential proxy or stealth mode might cost ten, and a failed request may or may not be refunded depending on the vendor. Two APIs with identical $99 tiers can differ by 5x in what you actually get through them.

The honest way to compare is to take a sample of the pages you really need, count how many of them require rendering, estimate a realistic failure rate, and divide the plan price by the number of pages you expect to successfully extract. Then add the second bill nobody puts on the pricing page: the engineering time spent parsing the result. An API that returns raw HTML for half the price of one that returns clean typed JSON is not cheaper if a developer has to write and maintain a parser per site.

The table below is every vendor we track, with the entry price, the published tier ladder and the free allowance, taken from each vendor's own pricing page rather than from a review aggregator. Aggregator sites in this category are frequently wrong, and we have found invented tiers on more than one of them. Where a vendor is usage-priced with no simple list price, we describe the billing model instead of guessing a figure.

We include ourselves in the table and we are not the cheapest line on it. Firecrawl starts lower, ScrapeGraphAI starts lower, and Crawl4AI has no license cost at all if you are willing to run the browsers, proxies and retries yourself. What ClawEngine prices is one call that crawls, renders and returns typed JSON, on public and permitted pages only, so the pipeline after the API is smaller. If you are scraping a handful of static pages a month, a cheaper tool or a free library is the correct decision and we would rather say so here than sell you a plan you do not need.

CRAWL RENDER JS EXTRACT MARKDOWN JSON

Any URL in LLM-ready data out

robots.txt respected public data only

Why it works

What you get with Pricing comparison

Rendering is included, not an add-on

JavaScript rendering and typed schema extraction happen in the same call at the same price, so your plan does not shrink the moment you point it at a single page app.

Cost per page, not cost per credit

One request returns a finished, boilerplate-free document. There is no separate crawl, scrape and extract billing to reconcile before you know what a page cost you.

The parser bill you never see

Typed JSON out of the API means no per-site parser to write and maintain, which is usually the larger line item once you count developer time honestly.

What it handles

Any URL in, clean structured data out

Point ClawEngine at a public page and it crawls, renders the JavaScript and extracts clean markdown or typed JSON in one call. Define a schema for structured fields, and respect robots.txt and Terms of Service by default.

Published US list prices, checked August 2026
Entry, mid and volume tiers side by side
What each vendor's credits really buy
Where a cheaper tool is the right call
How to model your own cost per page
Usage-priced vendors described, never guessed

POST /v1/extract extraction result

200 · JSON

{
  "url": "https://example.com/products/atlas",
  "title": "Atlas Field Notebook",
  "markdown": "# Atlas Field Notebook\n\nDurable...",
  "data": {
    "name": "Atlas Field Notebook",
    "price": 24.00,
    "currency": "USD",
    "rating": 4.7
  },
  "links": [ "/products", "/cart" ],
  "metadata": { "rendered": true }
}

JS rendered · boilerplate stripped ✓ robots.txt respected

Side by side

11 web scraping API prices compared

Published US list prices, checked in August 2026 on each vendor's own pricing page. We include ourselves, and we say where a cheaper tool is the right call.

Swipe to compare all columns →

Web scraping API	Entry price	Published tiers	Free tier
ClawEngine	$39/mo	Hobby $39, Startup $99, Scale $399, Enterprise custom	No free plan
Firecrawl	$16/mo	Free 1,000 credits (2 concurrent), Hobby $16 (5k credits, 5 concurrent), Standard $83 (100k, 25), Growth $333 (500k, 50), Scale $599 (1M, 100), Enterprise by quote. Prices shown are the billed-yearly rate	Yes, 1,000 credits
Bright Data	Usage-based	Web Scraper API billed per record: free tier 5,000 records a month, pay-as-you-go $1.50 per 1,000, Scale $499 a month for 384,000 records then $1.30 per 1,000, Enterprise by quote. You pay only for successful deliveries	Trial credits
Apify	$29/mo	Free ($5 usage), Starter $29, Scale $199, Business $999, each including that dollar value of usage. Actor compute is billed per compute unit at $0.20 (Free and Starter), $0.16 (Scale) or $0.13 (Business), with proxies charged on top	Yes, $5 credits
ScrapingBee	$19.99/mo	Hobby $19.99 (75k credits), Freelance $49.99 (250k), Startup $99.99 (1M), Business $249.99 (3M), Business+ $599.99 (8M), then an Enterprise ladder from $999.99 (14M) to $5,799.99 (120M). Concurrency runs from 25 threads to 900	1,000 free API credits, no card
ScraperAPI	$49/mo	Free plan 1,000 credits at 5 threads, plus a 7-day trial of 5,000. Hobby $49 (100k credits, 20 threads), Startup $149 (1M, 50), Business $299 (3M, 100), Scaling $475 (5M, 200), Professional $975 (10.5M, 300), Advanced $1,975 (21.5M, 500), Enterprise by quote above 22M. Annual billing takes 10 percent off every tier	1,000 credits a month, plus a 7-day 5,000-credit trial
ZenRows	$16/mo	Free tier (5,000 credits, 5 concurrent), Build $16 (45,000 credits, 20 concurrent), Launch $57 (250,000, 50), Growth $165 (1.2M, 100), Scale $456 (5M, 200), Enterprise custom (400 to 1000+ concurrent)	Yes, 5,000 credits
Oxylabs	$49/mo	Web Scraper API: Micro $49, Starter $99, Business $999, Custom+ by quote. Proxies are priced separately, residential from $6/GB	Trial, up to 2,000 results
Crawl4AI	Free, open source	Apache-2.0, no license cost. You pay for your own servers, proxies and engineering time	Yes, fully open source
Diffbot	$299/mo	Free 10,000 credits a month, Startup $299 (250k credits), Plus $899 (1M credits), Enterprise custom	Yes, 10,000 credits a month
ScrapeGraphAI	$20/mo	Free 500 credits one-time, Starter $20 (10k credits), Growth $100 (100k), Pro $500 (750k), Enterprise custom. The Python library is MIT licensed and free to self-host.	Yes, 500 credits

What you actually pay with Firecrawl

The headline 1 credit a page is the plain scrape only. Asking for structured JSON adds 4 credits, so a page you want back as typed fields is 5 credits, which turns Standard from $0.83 into $4.15 per 1,000 pages. PDF parsing adds 1 credit a PDF page, a prompt injection check adds 4, zero data retention adds 1, Map is 1 credit a call, Search is 2 per 10 results, and Interact is 2 to 7 credits a browser minute. Credits are charged whenever the request is processed, regardless of what the target returns.

What you actually pay with Bright Data

It is a broad platform rather than a single LLM-ready endpoint, so output usually needs cleaning before you can embed it, and the pricing surface is complex.

What you actually pay with Apify

Costs stack in layers: the plan buys a dollar allowance, Actor compute burns it at $0.13 to $0.20 per compute unit, and residential proxies add $7 to $8 per GB on top. Unused allowance expires monthly, and output is generic JSON rather than LLM-ready markdown.

What you actually pay with ScrapingBee

JavaScript rendering is on by default and costs 5 credits, so a Freelance plan is 50,000 rendered pages rather than the 250,000 the credit count suggests. Premium proxy is 10 credits alone or 25 with rendering, and stealth proxy is 75. You also mostly get HTML back, so the cleaning, chunking and structuring work for an LLM is still yours to do.

What you actually pay with ScraperAPI

The multipliers decide the bill: a plain request is 1 credit, render 10, premium 10, screenshot 10, premium with render 25, ultra premium 30 and ultra premium with render 75, while Amazon, Walmart and eBay cost 5, Google and Bing 25 and LinkedIn 30, and clearing Cloudflare, DataDome or PerimeterX adds 10. Two policies matter more than the rates: credits do not roll over, and pay-as-you-go overage is available only on Scaling and above, so hitting 100 percent on Hobby, Startup or Business stops the pipeline until you upgrade. Only 200 and 404 responses are billed. It is proxy infrastructure first, so an LLM pipeline still needs its own parsing, boilerplate stripping and schema layer.

What you actually pay with ZenRows

The multipliers set the real price, not the headline credit count: a plain fetch is 1 credit, a JavaScript-rendered page is 5, premium proxies are 10, and premium with rendering is 25, which is the ceiling. Residential bandwidth is billed at a flat 25,000 credits per GB, and Browser Sessions add 5 credits a minute on top of bandwidth. Launch at $57 therefore buys about 50,000 rendered pages. You also get HTML back, so the cleaning and structuring work for an LLM is still yours.

What you actually pay with Oxylabs

The headline result counts are best-case for a single cheap target: Oxylabs own FAQ notes the Micro plan's 98,000 results apply to Amazon, and spreading the same plan across mixed targets works out closer to 16,000 per target. Whole-site crawling means buying a second product.

What you actually pay with Crawl4AI

You own the ops: proxy rotation, browser fleet, retries, blocks and upgrades. Free software is not free infrastructure.

What you actually pay with Diffbot

The first paid tier is $299 a month and credits are consumed fast (a Knowledge Graph record costs 25 credits, a data-center proxy request doubles the cost), so for plain RAG ingestion it is expensive and heavier than you need.

What you actually pay with ScrapeGraphAI

The managed API bills per credit and the rate depends on the endpoint (extract costs 5 credits, stealth adds 5, a crawl adds 2 on top of per-page scrape cost), so cost per page is harder to predict. Self-hosting means you supply the LLM key and pay model tokens on every page.

Why ClawEngine

One API that crawls, renders and extracts

Not a raw HTML dump, not a headless browser fleet to run, and not a brittle parser to maintain. One call crawls a public page, renders its JavaScript and returns clean markdown or typed JSON, built for RAG pipelines and AI agents.

LLM-ready output

Clean markdown or typed JSON with the boilerplate stripped, so the data drops straight into a vector store, a prompt or an agent without a cleanup step.

JavaScript rendered

Each page loads in a real browser environment before extraction, so single-page apps and client-rendered content come back complete, not as an empty shell.

Compliance-first

ClawEngine works on public, permitted data only. It respects robots.txt and site Terms of Service and honors crawl-delay, so responsible scraping is the default.

Code examples

Model your real cost per page before you buy

The plan price is an input, not an answer. This script takes your own URL sample, runs it, and reports the cost per successfully extracted page so you can compare vendors on the same basis.

python Cost per successfully extracted page

import os, requests

BASE = "https://api.clawengine.ai/v1"
headers = {"Authorization": f"Bearer {os.environ['CLAWENGINE_API_KEY']}"}

SAMPLE = [...]              # 100 representative URLs from your real target list
PLAN_PRICE = 99             # what the tier costs per month
PLAN_PAGES = 100_000        # pages the tier is sold as covering

ok = 0
for url in SAMPLE:
    r = requests.post(f"{BASE}/extract", headers=headers,
                      json={"url": url, "format": "markdown", "render": True})
    if r.ok and r.json().get("data", {}).get("markdown"):
        ok += 1

success_rate = ok / len(SAMPLE)
real_pages = PLAN_PAGES * success_rate
print(f"success rate      : {success_rate:.0%}")
print(f"effective pages   : {real_pages:,.0f}")
print(f"cost per good page: ${PLAN_PRICE / real_pages:.5f}")

bash Check what a single rendered page consumes

curl -s https://api.clawengine.ai/v1/extract \
  -H "Authorization: Bearer $CLAWENGINE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://example.com/pricing","format":"json","render":true,
       "schema":{"plan_name":"string","monthly_price":"number","currency":"string"}}' \
  | jq '{usage: .usage, data: .data}'

web scraping API pricing: the questions buyers ask

How much does a web scraping API cost?

Entry plans across the major web scraping APIs run roughly $16 to $49 a month in 2026, mid tiers land between $99 and $333, and volume tiers reach $456 to $999. Diffbot is the outlier at $299 to start. Usage-priced vendors such as Bright Data bill per record instead, $1.50 per 1,000 on pay-as-you-go and $1.30 per 1,000 on the $499 Scale plan. Most plans are credit based, so your real cost depends on how many credits each page consumes.

What is the cheapest web scraping API?

On published list price, ScrapeGraphAI at $20 a month and Firecrawl at $16 a month are the lowest paid entry points among the managed APIs, and Crawl4AI is free and open source if you host it. Cheapest on the invoice is not always cheapest overall: with a self-hosted crawler you pay for servers, proxies and the engineering hours to keep a browser fleet alive, which usually costs more than the plan you avoided.

How is web scraping API pricing calculated?

Most vendors sell a monthly bundle of credits and charge a different number of credits per request depending on what the request needs. A plain HTML fetch is typically one credit, JavaScript rendering multiplies it, stealth or anti-bot bypass multiplies it again, and structured extraction may add its own charge. To compare vendors fairly, convert everything to cost per successfully extracted page for your own mix of targets.

What is a credit in web scraping API pricing?

A credit is the vendor's internal billing unit, not a page. The vendor decides how many credits each operation costs, so 100,000 credits might mean 100,000 simple fetches or 20,000 rendered pages on the same plan. Always read the credit table before comparing two plans by credit count, and check whether unused credits roll over, because in most plans they expire at the end of the billing period.

Why do JavaScript rendered pages cost more to scrape?

Rendering runs the page in a real browser so client-side JavaScript can build the content, which uses far more CPU, memory and wall-clock time than fetching raw HTML. A rendered request can occupy a browser instance for several seconds while a plain fetch takes milliseconds. Vendors pass that cost through as a credit multiplier, which is why a plan that looks generous can shrink dramatically once you turn rendering on.

Is a web scraping API cheaper than building your own scraper?

For anything beyond a few static pages, usually yes. The API bill is visible and the build cost is not: a self-hosted crawler needs proxy rotation, browser upgrades, retry logic, block handling and per-site parsers, and each of those is recurring engineering time. A rough test is to compare the annual plan cost against two to three weeks of developer time plus infrastructure, which is what a maintained in-house crawler tends to consume.

What is web scraping API pricing for an AI startup?

Budget $39 to $99 a month while you are building and $300 to $500 once ingestion runs continuously. The reason AI startups overshoot is rendering: a RAG corpus or agent fleet needs the rendered version of nearly every page, and rendering is a credit multiplier on most vendors. Verified August 2026, a rendered page is 5 credits on ScrapingBee and 11 on ScraperAPI, so a 40,000 page month costs 200,000 or 440,000 credits for identical work.

What is managed web scraping API pricing for AI companies?

Managed pricing for AI companies clusters in three bands: $16 to $49 a month for evaluation, $83 to $149 for a first production corpus, and $299 to $599 for continuous ingestion at roughly one to three million credits. Bright Data prices per delivered record instead, $1.50 per 1,000 pay-as-you-go and $1.30 per 1,000 on the $499 Scale plan. Convert every option to cost per successfully extracted page before comparing, because credit counts are not comparable across vendors.

How do web scraping API costs compare for AI agent workloads?

Agent workloads are the most expensive shape in this category because they are unpredictable and almost always rendered. An agent fetching a page on demand cannot batch, cannot cache well, and hits whatever the target happens to be, so it lands on the higher multipliers more often than a scheduled crawl does. Price agents at the rendered rate, not the flat rate, and check whether your vendor bills failed requests. ScraperAPI documents billing only 200 and 404 responses.

What should an enterprise AI team budget for a web scraping API?

Enterprise AI teams typically land between $400 and $1,000 a month on published tiers, above which most vendors move to custom quotes. At that volume the decision stops being unit price and becomes total cost including the parsing layer: an API returning raw HTML needs a maintained parser per source, and that engineering time usually exceeds the difference between any two plans on this page. Ask for cost per successfully extracted page in the quote.

Is there a free web scraping API?

Several vendors include a trial or a small monthly allowance, and Crawl4AI and the ScrapeGraphAI library are genuinely open source. Those allowances are sized for evaluation, not production, and free managed tiers usually come with rate limits and no support. ClawEngine has no free plan on purpose, because it is built for teams running a real pipeline rather than one-off experiments.

Good questions

Questions about Pricing comparison

Four things, in this order: the credit cost of a rendered request rather than a plain one, whether failed and blocked requests are billed, whether unused credits roll over, and what shape the output arrives in. At crawl scale the first two determine your bill and the fourth determines your engineering cost. Comparing monthly plan prices alone tells you almost nothing, because the credit multipliers differ by an order of magnitude between vendors.

Take 100 representative URLs from your real target list, run them on a trial, and record how many needed rendering, how many failed, and how many credits the run consumed. Divide plan price by projected successful extractions per month. Doing this on your own targets is the only reliable method, because a vendor benchmark on one easy site says nothing about a mixed crawl across dozens of layouts.

Most vendors in the table discount annual plans, often by around 20 percent, and the published entry prices are frequently annual-billed rates with a higher month-to-month figure. Committing annually makes sense once you have run a month of real volume and know your credit burn. Before that, month-to-month is worth the premium, because scraping requirements change fast when a target site redesigns.

Because rendering pages costs real compute on every request, and a free tier in this category is either rate-limited to the point of being useless or subsidized by the paying customers. We would rather put the money into render reliability and support. If you need a few pages a month, use a free library like Crawl4AI or Trafilatura instead. That is an honest recommendation, not a sales line.

Every figure was checked in August 2026 on the vendor's own pricing page, and the page is re-verified on a regular schedule. We do not source pricing from review aggregators, because we have repeatedly found tiers on those sites that do not exist. If you spot a figure that has changed, the vendor's own pricing page is the authority and we will correct ours.

Read every web scraping question

Explore more

More ways to turn the web into data with ClawEngine

See every use case See pricing Back to the web scraping API

Stop wrangling raw HTML. Get LLM-ready data.

Point ClawEngine at a public page and one call crawls, renders the JavaScript and extracts clean markdown or typed JSON, ready for your RAG pipeline or AI agent. Public, permitted data only.

See pricing

Crawl · render JS · extract markdown & JSON · robots.txt respected, public data only