By use case · Pricing comparison

Web scraping API pricing: what 11 web scraping APIs cost, and how to work out your real price per page

The short answer

Web scraping API pricing in 2026 starts around $16 to $69 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. All prices below were checked in July 2026 on each vendor's own pricing page.

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

Last updated July 2026

Live Extraction

Endpoint · POST /v1/extract

GET

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 July 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 July 2026 on each vendor's own pricing page. We include ourselves, and we say where a cheaper tool is the right call.

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	Hobby $16, Standard $83 (100k credits), Growth $333, Scale $599	Yes, 1,000 credits
Bright Data	Usage-based	Web Scraper API billed per record, roughly $0.75 to $3 per 1,000 depending on product and tier, with pay-as-you-go and no monthly commitment	Trial credits
Apify	$29/mo	Free tier with $5 credits, Starter $29, Scale $199, Business $999, plus per-Actor usage	Yes, $5 credits
ScrapingBee	$49/mo	Freelance $49, Startup $99, Business $249	1,000 free API calls
ScraperAPI	$49/mo	Hobby $49 (100k credits), Business $299 (3M credits), Enterprise $475 (14M credits)	Trial credits
ZenRows	$69/mo	Developer $69, Startup $129, Business $299	Trial 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, Startup $299 (250k credits), Plus $899 (1M credits), Professional $3,999 (5M credits), Enterprise custom	Yes, 10,000 credits
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

Credits do not roll over, and stealth mode bills 5 credits per page instead of 1, which changes the real cost on protected sites.

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 (platform plan plus per-Actor compute or per-result fees), and output is generic JSON rather than LLM-ready markdown.

What you actually pay with ScrapingBee

You 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

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

Protected requests consume far more credits than plain ones, so the effective price depends heavily on your targets.

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 $69 a month in 2026, mid tiers land between $99 and $333, and volume tiers reach $475 to $999. Diffbot is the outlier at $299 to start. Usage-priced vendors such as Bright Data bill per record instead, roughly $0.75 to $3 per 1,000 records depending on product and tier. 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.

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 July 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