§6

Document parsing, scraping and AI search APIs

This category covers the three services that sit between raw sources and an LLM's context window: document parsers that turn PDFs, scans and Office files into markdown or JSON; web scrapers that turn URLs into clean text while handling JavaScript and anti-bot defences; and search APIs that return ranked, LLM-ready results or grounded answers. They are the highest-variance part of most RAG and agent stacks — a parser that mangles a table or a search API with a stale index degrades everything downstream, and neither failure shows up in your model evals.

Data checked 2026-09-06

Pricing is fragmented across per-page, per-credit, per-request, per-record and per-token units, which makes headline numbers nearly incomparable until you normalise them against your own document mix. The document-parsing half has moved decisively toward VLM-based parsing (Reducto, LlamaParse agentic tiers, Mistral OCR, GraniteDocling), which improves table and chart fidelity but raises per-page cost 3-10x over classic OCR. The search half has split between independent-index providers (Brave, Exa) and agent-shaped wrappers over other indexes (Tavily, Perplexity, Firecrawl Search).

A How to choose

Four axes decide almost every choice here: unit economics at your real volume, whether data may leave your network, how bad your worst documents are, and whether you own the index. On parsing, start by running your ten ugliest pages through Docling locally before you pay anyone — if MIT-licensed Docling or MinerU handles them, the hosted parsers are a recurring bill for something you already have, and at 100k+ pages/month self-hosting on a single GPU is usually cheaper than $10/1k pages. Pay for Reducto ($10/1k parse) or LlamaParse's agentic tiers only when you have genuinely adversarial layouts — dense financial tables, multi-column scans, handwriting, charts you need read as data — because for clean digital PDFs Mistral Document AI at $4/1k or Textract at $1.50/1k does the same job for a fraction of the cost.

Unstructured earns its price on breadth (65+ types, 30+ source and destination connectors) rather than per-page accuracy, so pick it when the hard part is the pipeline, not the page; pick Azure Document Intelligence or Textract when procurement, regional residency or an existing cloud commit matters more than parse quality, and when you need trainable custom field extraction rather than generic markdown. On search, Brave and Exa are the two that own an index — Brave for cheap broad coverage with an independent crawl, Exa for embedding-based queries where you are describing the kind of page you want rather than typing keywords; Tavily and Perplexity's Search API are convenience layers whose value is that they return short, deduplicated, agent-shaped payloads you don't have to post-process, which is worth real money in token savings but leaves you exposed to their upstream. Do not use Perplexity's Sonar chat-completions endpoint for anything new: it is retired 27 September 2026 in favour of the Agent API.

On scraping, match the tool to the adversary — Firecrawl or Jina Reader for cooperative sites (Jina is close to free for prototypes), ScrapingBee or Zyte when you are being blocked and want someone else to own the proxy problem, Bright Data or Apify when you want per-record results from named sites (Amazon, LinkedIn) rather than raw HTML you still have to parse. The common expensive mistake is buying a per-record or agentic-parse product for a workload that a $19/month proxy or a free local library would have handled.

B At a glance

Name	Input formats	Output	Table/OCR quality	Price unit	Latency	Pricing
LlamaParse	130+ types: PDF, DOCX, PPTX, XLSX, HTML, JPEG, PNG, XML, EPUB	Markdown, plain text, JSON, spatial text	Tier-dependent; agentic tiers target complex tables and charts, Fast tier is text-only	Credits per page (1,000 credits = $1.25)	Async job API; Fast tier is the low-latency option, agentic tiers are markedly slower (no published SLA)	1,000 credits = $1.25. Free tier 10,000 credits/month. Starter $50/mo (40,000 credits, PAYG up to 400,000 more). Pro $500/mo (400,000 credits, PAYG up to $5,000/mo). Basic parsing 'as low as 1 credit' per page (~$0.00125/page); agentic tiers cost multiple credits per page — the exact per-tier credit table was not retrievable from the docs site at time of writing.
Unstructured	50-65+ types: PDF, DOCX, PPTX, XLSX, HTML, EML, images, spreadsheets	JSON document elements (typed), chunked and optionally embedded; markdown/HTML per element	Good on ordinary documents; table and image enrichment is a paid-platform feature, weaker than VLM parsers on dense tables	Per page ($0.015)	Async pipeline/workflow model, not a low-latency request API; OSS hi_res mode is seconds per page on CPU	Free: 10,000 pages, no card, all features. Pay-as-you-go: $0.015/page after the free 10,000. Business: custom pricing with multi-user accounts and dedicated instance/VPC deployment. Compliance: HIPAA, SOC 2 Type 2, GDPR, ISO 27001.
Reducto	30+ types: PDF, images, spreadsheets, presentations	Markdown/JSON with bounding boxes, table structure, table summaries; schema-shaped JSON via Extract	Among the strongest on dense/nested tables and multilingual scans; bounding boxes returned for citation and audit	Per 1,000 pages, priced separately per operation	Async API; Deep Extract and Deep Split are markedly slower than Parse (no published SLA)	Standard PAYG with $150 free credits. Per 1,000 pages: Parse (r-1) $10, Extract $20, Deep Extract $40, Split $20, Deep Split $40, Classify $7.50, Edit $60 ($15 pre-filled). 200 concurrent pages, up to 5 Studio seats. Growth: custom, 350 concurrent, BAA + ZDR + EU/AU endpoints. Enterprise: custom, 500+ concurrent, VPC/on-prem, SSO/SAML. Startup program (under $15M raised / $3M revenue / 50 employees) and up to $5,000 in migration credits.
Docling	PDF, DOCX, PPTX, XLSX, HTML, EPUB, Apple Pages, LaTeX, EML/MSG, images (PNG/TIFF/JPEG), audio (WAV/MP3), video (MP4/MOV/MKV/WebM)	Markdown, HTML, JSON, DocTags, DocLang, WebVTT	Strong table-structure recognition and OCR for its class; GraniteDocling VLM adds chart-to-table conversion	Free (self-hosted compute only)	Local; fast on digital PDFs, slow on CPU for scans/VLM pipelines — GPU strongly recommended for volume	Free. MIT license on the codebase (individual model weights carry their own licenses). You pay only for the CPU/GPU you run it on.
MinerU	PDF, DOCX, PPTX, XLSX, images, web pages	Markdown and JSON; formulas as LaTeX, tables as HTML	Strong on formulas and multi-column scientific layouts; 109-language OCR incl. handwriting (PP-OCRv6)	Free (self-hosted compute only)	Local; CPU-only supported but slow — GPU (Volta+ or Apple Silicon) recommended	Free. MinerU Open Source License (Apache 2.0 derivative) since v3.1.0 — previously AGPLv3. Self-hosted compute only.
Mistral Document AI (OCR)	PDF and images (page-based); document URLs or base64 uploads	Per-page markdown with paragraph bounding boxes, structural block labels, block confidence scores; JSON annotations	Strong general OCR and layout; per-block confidence scores enable triage. Below Reducto on dense nested tables	Per 1,000 pages ($4, $0.40 cached)	Synchronous API, typically seconds per document; no published SLA	$4.00 per 1,000 pages input; $0.40 per 1,000 pages cached input. Same rate for OCR 4.1 and OCR 4.0. Billed per page, not per token.
Datalab (Marker / Surya)	PDF, images, and common office documents	Markdown, JSON, HTML; schema-shaped JSON via Extraction; filled PDFs via Form Fill	Strong for the price on equations and tables (Surya OCR); accurate tier closes much of the gap to premium parsers	Per 1,000 pages, by processor and speed tier	Fast tier is the low-latency path; accurate tier trades seconds per page for fidelity. Rate limits raised on Team plan	Free: $20/month allowance for work-email accounts, $10 for personal, then pay-as-you-go. Per 1,000 pages — Convert (fast/balanced) $4, Convert (accurate) $10, Extraction fast $6 / balanced $15+ / accurate $20+, Form fill $10. Add-ons +$3 to +$6 per 1,000 pages. EU processing +25%. Data-retention opt-in -25%. Team plan $400/month. Startup discount 33% for year one; up to $5,000 migration credits.
Azure AI Document Intelligence	PDF, images (JPEG/PNG/BMP/TIFF), and Office formats for selected models	JSON with paragraphs, roles, tables, key/value pairs, selection marks, barcodes, formulas; Layout emits markdown; searchable PDF add-on	Solid, mature OCR with high-resolution add-on for small text; table extraction is reliable rather than best-in-class	Per 1,000 pages, tiered by volume and region	Async analyze-then-poll operation; seconds to tens of seconds per document depending on model and add-ons	Free F0 tier: 500 pages/month. Pay-as-you-go rates are per 1,000 pages and tiered by volume (0-1M pages vs 1M+) for Read, prebuilt, custom extraction, classification and generative extraction — the specific per-1,000-page dollar figures did not render on the public pricing page at time of writing and are region-specific; verify in the Azure pricing calculator. Custom neural model training is $3/hour after 10 free hours; template model training is free. Monthly commitment tiers available at 20,000 / 100,000 / 500,000 pages.
Amazon Textract	PDF, TIFF, JPEG, PNG	JSON blocks with geometry, relationships, confidence; no native markdown	Very good raw OCR incl. handwriting; table extraction is competent but reading-order reconstruction is left to you	Per page, priced per API and per feature	Synchronous API for single-page documents (sub-second to seconds); async job API required for multi-page PDFs	US West (Oregon): Detect Document Text $0.0015/page first 1M pages, $0.0006/page after. Analyze Document — Forms $0.05/page, Tables $0.015/page (first 1M), Queries $0.015/page. Analyze Expense $0.01/page first 1M, $0.008/page after. Analyze ID $0.025/page first 100K, $0.01/page after. Analyze Lending $0.07/page first 1M, $0.055/page after. Free tier: 3 months, monthly 1,000 pages Detect Document Text, 100-1,000 pages Analyze Document by feature, 100 pages each Expense and ID.
Firecrawl	URLs (HTML with JS rendering), plus PDFs and DOCX encountered while crawling	Markdown, HTML, structured JSON (schema-guided), screenshots, links	HTML-to-markdown tables are good; document OCR is a secondary capability, not competitive with dedicated parsers	Credits (1 credit = 1 page scraped)	Single scrape typically a few seconds; crawls are async jobs whose duration scales with site size and concurrency limits	Free: 1,000 credits/month, no card. Hobby $16/mo billed yearly (5,000 credits/mo). Standard $83/mo yearly (100,000). Growth $333/mo yearly (500,000). Scale $599/mo yearly (1,000,000). Enterprise custom. Credit costs: scrape/crawl/map/monitor 1 per page; search 2 per 10 results; interact 2 per browser-minute. PAYG top-ups on paid plans only, $5 per increment (1,000-5,000 credits by plan). Annual discount 16.7% (Hobby/Standard/Growth), 20% (Scale).
Jina Reader	URLs (HTML, with PDF support); search queries via s.jina.ai	Markdown (default), JSON, structured JSON via x-json-schema/x-instruction, streaming mode	Reasonable HTML table conversion; not a document OCR product	Output tokens (search billed from a ~10,000-token floor per request)	Typically a few seconds per URL; stream mode for large pages. Bounded by RPM tier, not by an SLA	10 million free tokens with each new API key. Billing is per output token for r.jina.ai and a fixed floor of ~10,000 tokens per s.jina.ai search request; tokens are bought via Stripe and failed requests are not charged. Rate limits: no key 20 RPM (reader only, search blocked); free key 500 RPM reader / 100 RPM search; premium 5,000 RPM reader / 1,000 RPM search. The USD-per-token rate is behind the authenticated dashboard and could not be verified at time of writing.
Exa	Natural-language or keyword queries; URLs for contents retrieval	Ranked results with URLs, titles, published dates; full page text, highlights, AI summaries; cited answers	n/a — search and page-text API, not a document parser	Per 1,000 requests (search) and per 1,000 pages (contents)	Search is sub-second to a couple of seconds; Deep Search and Agent runs take substantially longer by design	Pay-as-you-go, no subscription or minimum. Search $7/1,000 requests (up to 10 results); Deep Search $12-15/1,000; Contents $1/1,000 pages; Answer $5/1,000 requests; Monitors $15/1,000; Agent $0.012-$1.00 per fixed-effort run or usage-metered. Results beyond the first 10 cost $1/1,000 results; AI page summaries $1/1,000 pages on any endpoint. New accounts get $20 in credits (~2,800 searches) plus $10/month on the free tier. Enterprise plans offer volume discounts, custom indexes and SLAs.
Tavily	Natural-language queries; URLs for Extract/Crawl/Map	JSON with ranked snippets, relevance scores, optional LLM answer; markdown page content from Extract/Crawl	n/a — search and HTML extraction; no document OCR	API credits ($0.008 each; 1 credit per basic search)	Basic search typically 1-2 seconds; advanced search and crawl noticeably slower. Rate limits differ by plan	Free: 1,000 API credits/month, no card. Pay-as-you-go: $0.008/credit. Project plan: adjustable monthly subscription starting at 4,000 credits/month with higher rate limits (base price is set by an on-page slider and was not captured). Enterprise: custom. Credit costs — basic search 1, advanced search 2; basic extract 1 per 5 URLs, advanced extract 2 per 5; map 1 per 10 pages (2 with instructions); crawl = map + extract combined. Credits reset monthly and do not roll over. Free access for students.
Brave Search API	Keyword and natural-language queries; Goggles files for custom reranking	JSON SERP results (web, news, images, video), LLM-context payloads, schema-enriched results, cited streaming answers	n/a — search API, not a document parser	Per 1,000 requests ($5 Search, $4 Answers + $5/M tokens)	Search is fast at 50 QPS sustained; Answers is capped at 2 QPS and streams responses	Search plan: $5 per 1,000 requests, 50 queries/second, with $5/month in free credits applied automatically. Answers plan: $4 per 1,000 requests plus $5 per million input/output tokens, 2 queries/second, also with $5/month free credits. Enterprise: custom pricing with full-funnel zero data retention, custom agreements and invoicing. Endpoints included: Web, LLM Context, Answers, Image, Video, News, Suggest, Spellcheck.
Perplexity Search & Agent API (formerly Sonar)	Natural-language queries and chat messages; multi-query search supported	Ranked search results JSON (Search API); grounded prose with citations, streaming, tool calls (Agent API); embeddings	n/a — search and answer API, not a document parser	Per 1,000 requests (Search) and per million tokens + per tool invocation (Agent)	Search API is sub-second to seconds; Agent responses take seconds and deep-research runs take minutes	Search API: $5.00 per 1,000 successful requests. Agent API: no per-request fee — model tokens at each provider's published rate ($0.13-$25 per million in/out), tools $0.0005-$0.005 per invocation (web search, fetch URL, people search, finance search), sandbox sessions $0.03 each. Router API: token-based at each model's published rate, no per-request fee. Legacy Sonar models: sonar $1/$1 per million in/out, sonar-pro $3/$15, sonar-reasoning-pro $2/$8, sonar-deep-research $2/$8, plus per-request search fees of $5-6/1K (low context), $8-10/1K (medium), $12-14/1K (high).
ScrapingBee	URLs (HTML), with optional JS rendering, custom JS scenarios and geotargeting	Raw HTML, screenshots, JSON via CSS/XPath extraction rules; dedicated Google/search endpoints	n/a — returns HTML; no OCR or markdown conversion	API credits (1 plain / 5 JS / 10-25 premium proxy / 75 stealth)	Plain requests are sub-second to seconds; JS rendering adds seconds. Failed URLs are retried for up to 30 seconds	Hobby $19/mo (75,000 credits, 25 concurrent). Freelance $49/mo (250,000, 50 concurrent). Startup $99/mo (1,000,000, 100 concurrent). Business $249/mo (3,000,000, 200 concurrent). Business+ $599/mo (8,000,000, 400 concurrent). Trial: 1,000 free API credits, no card. Credit costs: 1 default, 5 with render_js, 10 premium proxy without JS, 25 premium proxy with JS, 75 stealth proxy (requires JS). Auto-Mode charges only the tier that succeeded; failed requests cost 0 credits. Prices exclude VAT.
Apify	URLs and site-specific inputs (search terms, profile URLs, categories) defined per Actor	JSON, CSV, XML, Excel datasets via API or dataset export; key-value store for files	n/a — structured web records; no document OCR	Platform credits, drawn by compute units ($0.13-$0.20/CU) plus per-event or per-result Actor fees	Actor runs are async jobs from seconds to hours depending on scope; not suited to synchronous request-time use	Free $0 (about $5 of platform credits/month). Starter $19/mo ($17 annual, $19 credits). Scale $199/mo ($179 annual, $199 credits). Business $999/mo ($899 annual, $999 credits). Compute units: $0.20/CU on Free and Starter, $0.16/CU on Scale, $0.13/CU on Business, where 1 CU = 1 GB RAM for 1 hour. Actors bill either pay-per-event (fixed price per developer-defined action, usually inclusive of platform usage) or pay-per-usage (compute + data transfer). Paid users are billed for overage; free users are blocked until the next cycle. Unused credits expire monthly with no rollover.
Zyte API	URLs, with HTTP or browser request modes, browser actions and session handling	Raw HTTP body or rendered browser HTML, screenshots, automatic structured extraction (product, article, job posting schemas)	n/a — returns HTML/structured records; no document OCR	Per successful request, priced by site-specific tier 1-5 and request type	HTTP-tier requests are fast; browser-tier and action-heavy requests add seconds. Failed and rate-limited requests are free	$5 free credit for your first billing month. Standard pay-as-you-go with a $100/month spending limit and no commitment; Standard with commitment carries $200-$2,500/month limits; Enterprise is custom. Per-request cost depends on target site, request type (HTTP or browser) and an automatically assigned tier 1-5, so there is no single headline rate — use the dashboard cost estimator. Add-ons: screenshots $0.002, extraction $0.0004-$0.0016, browser actions billed on CPU/network. Volume discounts: 25% at $100 commitment, 52% at $500. Only successful responses are billed.
Bright Data Web Scraper API	Target URLs, search terms and site-specific inputs for 100+ supported domains	Structured JSON or CSV records with validation; also raw unlocked HTML via companion Web Unlocker product	n/a — structured web records; no document OCR	Per 1,000 records delivered ($1.50 PAYG, $1.30 at scale)	Batch/async collection jobs; unlimited concurrency but delivery is minutes-scale, not request-time	Free tier: 5,000 records/month, no credit card. Pay-as-you-go: $1.50 per 1,000 records with customisable spend limits. Scale: $499/month including 384,000 records, then $1.30 per 1,000 additional records. Enterprise: custom with volume discounts and a dedicated account manager. All plans include automated proxy management, full browser rendering, CAPTCHA solving, unlimited concurrent requests, batch scheduling and JSON/CSV output. No charge for failed deliveries.

C Entries

LlamaParse

Converts 130+ file types into markdown, plain text, JSON or spatial text, with four accuracy tiers (Fast, Cost Effective, Agentic, Agentic Plus) that trade credits per page against layout fidelity. A Cost Optimizer routes individual pages to different tiers so simple pages don't pay VLM prices. Distinguishing feature versus Reducto or Mistral is the tight coupling to the LlamaIndex ecosystem — parsed output drops straight into LlamaCloud indexes and LlamaIndex retrievers, and you can steer parsing with natural-language instructions per document.

Input formats	130+ types: PDF, DOCX, PPTX, XLSX, HTML, JPEG, PNG, XML, EPUB
Output	Markdown, plain text, JSON, spatial text
Table/OCR quality	Tier-dependent; agentic tiers target complex tables and charts, Fast tier is text-only
Price unit	Credits per page (1,000 credits = $1.25)
Latency	Async job API; Fast tier is the low-latency option, agentic tiers are markedly slower (no published SLA)

Watch out: The credit abstraction makes real cost hard to predict before you run a representative sample — the same 1,000-page corpus can differ ~10x in spend depending on tier routing, and the per-tier credit table is not clearly published. The Fast tier returns no markdown at all (text and spatial text only), which surprises people who benchmark on it. Wrong choice if you want a parser decoupled from a framework, or if you need an on-prem deployment without an Enterprise contract.

1,000 credits = $1.25. Free tier 10,000 credits/month. Starter $50/mo (40,000 credits, PAYG up to 400,000 more). Pro $500/mo (400,000 credits, PAYG up to $5,000/mo). Basic parsing 'as low as 1 credit' per page (~$0.00125/page); agentic tiers cost multiple credits per page — the exact per-tier credit table was not retrievable from the docs site at time of writing.

Unstructured

An ETL layer rather than a pure parser: it ingests from 30+ sources (S3 to Zendesk to Confluence), partitions documents into typed elements, chunks and optionally embeds them, then writes to 30+ destinations including vector databases. The open-source `unstructured` Python library (Apache 2.0, ~15.4k stars) does the partitioning locally and remains maintained; the paid Platform adds the connectors, orchestration, table/image enrichment and better throughput. Choose it when your problem is pipeline plumbing across many systems, not squeezing accuracy out of one hard PDF.

Input formats	50-65+ types: PDF, DOCX, PPTX, XLSX, HTML, EML, images, spreadsheets
Output	JSON document elements (typed), chunked and optionally embedded; markdown/HTML per element
Table/OCR quality	Good on ordinary documents; table and image enrichment is a paid-platform feature, weaker than VLM parsers on dense tables
Price unit	Per page ($0.015)
Latency	Async pipeline/workflow model, not a low-latency request API; OSS hi_res mode is seconds per page on CPU

Watch out: Raw parse quality on hard tables and scans lags the VLM-first parsers (Reducto, LlamaParse Agentic Plus) — you are buying breadth, not page fidelity. The open-source library's high-resolution PDF strategy is slow and pulls heavy model dependencies (detectron/YOLO-class layout models plus Tesseract), so local throughput is poor without tuning. At $0.015/page it is the most expensive option in this list for plain digital PDFs where Textract costs $0.0015.

Free: 10,000 pages, no card, all features. Pay-as-you-go: $0.015/page after the free 10,000. Business: custom pricing with multi-user accounts and dedicated instance/VPC deployment. Compliance: HIPAA, SOC 2 Type 2, GDPR, ISO 27001. · open source

Reducto

A document-processing API split into discrete priced operations — Parse, Extract, Deep Extract, Split, Deep Split, Classify and Edit — rather than one monolithic parse call, so you pay per capability instead of per tier. Parse returns markdown with bounding boxes and table structure; Extract pulls a JSON schema you define; Split and Classify handle the common enterprise case of a 400-page scanned bundle containing 30 different document types. It targets accuracy-critical domains (financial filings, insurance, healthcare) and ships BAAs, zero-data-retention agreements and EU/AU endpoints on the Growth tier.

Input formats	30+ types: PDF, images, spreadsheets, presentations
Output	Markdown/JSON with bounding boxes, table structure, table summaries; schema-shaped JSON via Extract
Table/OCR quality	Among the strongest on dense/nested tables and multilingual scans; bounding boxes returned for citation and audit
Price unit	Per 1,000 pages, priced separately per operation
Latency	Async API; Deep Extract and Deep Split are markedly slower than Parse (no published SLA)

Watch out: Roughly 6-8x the per-page cost of Mistral Document AI or Textract for text extraction, which is wasted money on clean digital PDFs. The unbundled pricing means a realistic pipeline (split + parse + extract) can hit $50-70 per 1,000 pages, well above the $10 headline. Concurrency is capped by plan (200 pages on Standard), so large backfills need a Growth contract, and self-hosting requires Enterprise.

Standard PAYG with $150 free credits. Per 1,000 pages: Parse (r-1) $10, Extract $20, Deep Extract $40, Split $20, Deep Split $40, Classify $7.50, Edit $60 ($15 pre-filled). 200 concurrent pages, up to 5 Studio seats. Growth: custom, 350 concurrent, BAA + ZDR + EU/AU endpoints. Enterprise: custom, 500+ concurrent, VPC/on-prem, SSO/SAML. Startup program (under $15M raised / $3M revenue / 50 employees) and up to $5,000 in migration credits.

Docling

An MIT-licensed Python library (~66k GitHub stars) that parses PDF, Office, HTML, EPUB, images, audio and video into markdown, HTML, JSON or its DocTags format, with layout analysis, table-structure recognition and OCR for scans. It runs entirely locally on macOS, Linux and Windows including CPU-only, and optionally uses the GraniteDocling VLM for chart understanding and harder layouts. Originated at IBM Research Zurich and is now hosted by the LF AI & Data Foundation, with first-class LangChain and LlamaIndex integrations plus a CLI, REST server and MCP server.

Input formats	PDF, DOCX, PPTX, XLSX, HTML, EPUB, Apple Pages, LaTeX, EML/MSG, images (PNG/TIFF/JPEG), audio (WAV/MP3), video (MP4/MOV/MKV/WebM)
Output	Markdown, HTML, JSON, DocTags, DocLang, WebVTT
Table/OCR quality	Strong table-structure recognition and OCR for its class; GraniteDocling VLM adds chart-to-table conversion
Price unit	Free (self-hosted compute only)
Latency	Local; fast on digital PDFs, slow on CPU for scans/VLM pipelines — GPU strongly recommended for volume

Watch out: Throughput is your problem: CPU-only parsing of scanned PDFs is slow, and the VLM pipeline needs a GPU to be practical, so at scale you are trading a per-page bill for an ops burden. Accuracy on genuinely adversarial tables still trails the best hosted VLM parsers. Requires Python 3.10+ (3.9 dropped in v2.70.0), and the MIT badge covers the code, not every model it downloads — check weights licensing before commercial deployment.

Free. MIT license on the codebase (individual model weights carry their own licenses). You pay only for the CPU/GPU you run it on. · open source

MinerU

Converts PDF, DOCX, PPTX, XLSX and images into markdown and JSON, with specific strengths Docling does not match out of the box: formulas converted to LaTeX, tables emitted as HTML, and OCR across 109 languages including handwriting and multi-column scientific layouts. Version 3.4 (June 2026) ships PP-OCRv6 with an ~11% accuracy gain. Critically, it relicensed at v3.1.0 from AGPLv3 to the Apache-2.0-based MinerU Open Source License, which removed the copyleft blocker that kept it out of commercial products.

Input formats	PDF, DOCX, PPTX, XLSX, images, web pages
Output	Markdown and JSON; formulas as LaTeX, tables as HTML
Table/OCR quality	Strong on formulas and multi-column scientific layouts; 109-language OCR incl. handwriting (PP-OCRv6)
Price unit	Free (self-hosted compute only)
Latency	Local; CPU-only supported but slow — GPU (Volta+ or Apple Silicon) recommended

Watch out: Hardware requirements are real — 16GB RAM minimum, 32GB+ recommended, 20GB storage for models — so it is not a lightweight dependency you drop into a small container. The license is a custom Apache 2.0 derivative rather than stock Apache 2.0, so legal review is still warranted despite the relicensing. Documentation and issue discussion skew Chinese-language, and the pace of breaking changes across major versions is high.

Free. MinerU Open Source License (Apache 2.0 derivative) since v3.1.0 — previously AGPLv3. Self-hosted compute only. · open source

Mistral Document AI (OCR)

A single-model OCR endpoint (currently OCR 4.1) that returns markdown per page with paragraph-level bounding boxes, structural block labels and block-level confidence scores — the confidence scores are unusual in this category and let you route only low-confidence pages to a human or a more expensive parser. Priced flatly at $4 per 1,000 pages with cached input at $0.40, it undercuts Reducto and LlamaParse's agentic tiers substantially while running on the same VLM approach. Available through La Plateforme and as a deployable model for on-prem under a commercial license.

Input formats	PDF and images (page-based); document URLs or base64 uploads
Output	Per-page markdown with paragraph bounding boxes, structural block labels, block confidence scores; JSON annotations
Table/OCR quality	Strong general OCR and layout; per-block confidence scores enable triage. Below Reducto on dense nested tables
Price unit	Per 1,000 pages ($4, $0.40 cached)
Latency	Synchronous API, typically seconds per document; no published SLA

Watch out: It is an OCR/markdown model, not a pipeline — no connectors, no chunking, no document splitting or classification, so you build the surrounding workflow yourself. Complex nested tables and charts-as-data are still weaker than Reducto's dedicated extraction path. As a fast-moving model line (4.0 to 4.1 within a year), output formatting can shift between versions, so pin the model ID in production.

$4.00 per 1,000 pages input; $0.40 per 1,000 pages cached input. Same rate for OCR 4.1 and OCR 4.0. Billed per page, not per token.

Datalab (Marker / Surya)

The commercial hosting of Marker and Surya, two widely-used open-source PDF-to-markdown and OCR projects, with speed/accuracy tiers you select per request. Convert runs $4 per 1,000 pages on fast or balanced and $10 on accurate; structured Extraction runs $6 to $20 per 1,000 pages plus variable fees, and a Form Fill processor writes values back into PDFs at $10 per 1,000 pages. Notable operational levers: EU-region processing costs 25% more, and opting into data retention gets you 25% off.

Input formats	PDF, images, and common office documents
Output	Markdown, JSON, HTML; schema-shaped JSON via Extraction; filled PDFs via Form Fill
Table/OCR quality	Strong for the price on equations and tables (Surya OCR); accurate tier closes much of the gap to premium parsers
Price unit	Per 1,000 pages, by processor and speed tier
Latency	Fast tier is the low-latency path; accurate tier trades seconds per page for fidelity. Rate limits raised on Team plan

Watch out: The underlying Marker and Surya repos carry revenue-threshold restrictions on commercial self-hosting — if your company is above the threshold you need a paid license, which catches people who assume the GitHub repo is freely usable. Extraction tiers add 'variable fees' on top of the headline per-1,000-page rate, so quoted prices are floors not ceilings. Smaller company than the cloud incumbents, with correspondingly less procurement paperwork available below the $400/month Team plan.

Free: $20/month allowance for work-email accounts, $10 for personal, then pay-as-you-go. Per 1,000 pages — Convert (fast/balanced) $4, Convert (accurate) $10, Extraction fast $6 / balanced $15+ / accurate $20+, Form fill $10. Add-ons +$3 to +$6 per 1,000 pages. EU processing +25%. Data-retention opt-in -25%. Team plan $400/month. Startup discount 33% for year one; up to $5,000 migration credits. · open source

Azure AI Document Intelligence

Microsoft's document-processing service (formerly Form Recognizer), currently on v4.0 / API version 2024-11-30 GA. Offers Read for text and handwriting, Layout for structure with markdown output aimed at RAG, prebuilt models for invoices, receipts, tax forms, ID documents and health insurance cards, and custom extraction/classification models you train on your own samples. The differentiator over pure parsers is trainable field extraction plus Azure's compliance, regional residency and commit-based discounting — this is what you buy when the blocker is procurement, not markdown quality.

Input formats	PDF, images (JPEG/PNG/BMP/TIFF), and Office formats for selected models
Output	JSON with paragraphs, roles, tables, key/value pairs, selection marks, barcodes, formulas; Layout emits markdown; searchable PDF add-on
Table/OCR quality	Solid, mature OCR with high-resolution add-on for small text; table extraction is reliable rather than best-in-class
Price unit	Per 1,000 pages, tiered by volume and region
Latency	Async analyze-then-poll operation; seconds to tens of seconds per document depending on model and add-ons

Watch out: Pricing is genuinely hard to pin down — rates vary by region, volume tier and agreement type, and the public page defers to the calculator, so budget from the calculator not from a blog post. Version churn is real: v2.1 retires 15 September 2027 and v3.0 on 30 March 2029, so anything you build today should target v4.0. Generic markdown quality on messy layouts is respectable but not class-leading versus Reducto or LlamaParse agentic tiers, and custom models need labelled training data you may not have.

Free F0 tier: 500 pages/month. Pay-as-you-go rates are per 1,000 pages and tiered by volume (0-1M pages vs 1M+) for Read, prebuilt, custom extraction, classification and generative extraction — the specific per-1,000-page dollar figures did not render on the public pricing page at time of writing and are region-specific; verify in the Azure pricing calculator. Custom neural model training is $3/hour after 10 free hours; template model training is free. Monthly commitment tiers available at 20,000 / 100,000 / 500,000 pages.

Amazon Textract

Five separate APIs at very different prices: DetectDocumentText for plain OCR at $0.0015/page, AnalyzeDocument for Forms ($0.05/page), Tables ($0.015/page), Queries ($0.015/page), Signatures and Layout, plus AnalyzeExpense for invoices ($0.01/page), AnalyzeID ($0.025/page) and AnalyzeLending ($0.07/page). The Queries feature is the practical highlight — you ask 'what is the invoice total?' in natural language and get a targeted answer without training a model. It is the cheapest credible OCR in this list for plain text by roughly an order of magnitude.

Input formats	PDF, TIFF, JPEG, PNG
Output	JSON blocks with geometry, relationships, confidence; no native markdown
Table/OCR quality	Very good raw OCR incl. handwriting; table extraction is competent but reading-order reconstruction is left to you
Price unit	Per page, priced per API and per feature
Latency	Synchronous API for single-page documents (sub-second to seconds); async job API required for multi-page PDFs

Watch out: Output is coordinate-based block JSON, not markdown — you write your own reading-order and table-reconstruction logic, which is a real engineering cost that erases some of the price advantage for RAG use cases. Combining features multiplies price fast (Forms + Tables + Queries on the same page stacks charges). Regional price variation is significant, and it does not do chart understanding or document-level semantic structure the way VLM parsers do.

US West (Oregon): Detect Document Text $0.0015/page first 1M pages, $0.0006/page after. Analyze Document — Forms $0.05/page, Tables $0.015/page (first 1M), Queries $0.015/page. Analyze Expense $0.01/page first 1M, $0.008/page after. Analyze ID $0.025/page first 100K, $0.01/page after. Analyze Lending $0.07/page first 1M, $0.055/page after. Free tier: 3 months, monthly 1,000 pages Detect Document Text, 100-1,000 pages Analyze Document by feature, 100 pages each Expense and ID.

Firecrawl

An open-source-core scraping API on v2 endpoints covering scrape, crawl, map, search, extract, monitor and browser interaction. One credit equals one page for scrape/crawl/map, search costs 2 credits per 10 results, and browser interaction costs 2 credits per browser-minute — so a 10,000-page crawl on the $83/month Standard plan uses 10% of your allowance. It handles JavaScript rendering, PDFs and structured JSON extraction against a schema, and ships an MCP server, which has made it the default scraping tool in a lot of agent stacks.

Input formats	URLs (HTML with JS rendering), plus PDFs and DOCX encountered while crawling
Output	Markdown, HTML, structured JSON (schema-guided), screenshots, links
Table/OCR quality	HTML-to-markdown tables are good; document OCR is a secondary capability, not competitive with dedicated parsers
Price unit	Credits (1 credit = 1 page scraped)
Latency	Single scrape typically a few seconds; crawls are async jobs whose duration scales with site size and concurrency limits

Watch out: Anti-bot capability is mid-tier — on aggressively defended commercial sites (retail, social, ticketing) it fails where ScrapingBee stealth proxies or Zyte succeed, so it is the wrong choice for adversarial targets. The open-source core is AGPL-3.0, which many companies cannot self-host without legal sign-off. Pay-as-you-go top-ups are unavailable on the free plan, so a burst mid-month means a plan upgrade, and API surface has churned across v0/v1/v2.

Free: 1,000 credits/month, no card. Hobby $16/mo billed yearly (5,000 credits/mo). Standard $83/mo yearly (100,000). Growth $333/mo yearly (500,000). Scale $599/mo yearly (1,000,000). Enterprise custom. Credit costs: scrape/crawl/map/monitor 1 per page; search 2 per 10 results; interact 2 per browser-minute. PAYG top-ups on paid plans only, $5 per increment (1,000-5,000 credits by plan). Annual discount 16.7% (Hobby/Standard/Growth), 20% (Scale). · open source

Jina Reader

The lowest-friction tool in this category: prepend `https://r.jina.ai/` to any URL and get LLM-ready markdown back, no SDK and no account required at 20 requests per minute. A companion `s.jina.ai` endpoint runs a web search and returns the top five results already converted to markdown. Headers control the output — Accept for JSON, `x-json-schema` or `x-instruction` for structured extraction, plus a streaming mode for large pages. Billing is token-based against a shared Jina API key that also covers their embeddings and reranker models.

Input formats	URLs (HTML, with PDF support); search queries via s.jina.ai
Output	Markdown (default), JSON, structured JSON via x-json-schema/x-instruction, streaming mode
Table/OCR quality	Reasonable HTML table conversion; not a document OCR product
Price unit	Output tokens (search billed from a ~10,000-token floor per request)
Latency	Typically a few seconds per URL; stream mode for large pages. Bounded by RPM tier, not by an SLA

Watch out: Token-based billing makes cost per page unpredictable — a long page costs far more than a short one, unlike Firecrawl's flat credit — and the dollar rate is not published outside the logged-in dashboard. Anti-bot handling is weak: paywalled, login-gated and Cloudflare-protected pages routinely fail. The keyless 20 RPM tier is fine for testing and unusable for production, and there is no crawl primitive, only single-URL fetches.

10 million free tokens with each new API key. Billing is per output token for r.jina.ai and a fixed floor of ~10,000 tokens per s.jina.ai search request; tokens are bought via Stripe and failed requests are not charged. Rate limits: no key 20 RPM (reader only, search blocked); free key 500 RPM reader / 100 RPM search; premium 5,000 RPM reader / 1,000 RPM search. The USD-per-token rate is behind the authenticated dashboard and could not be verified at time of writing.

Exa

Runs its own crawl and embedding index, so you can search by meaning — 'startups building agent observability tooling' — rather than by keyword, and get back pages that a keyword engine would miss. Endpoints are priced separately: Search $7/1k requests, Deep Search $12-15/1k, Contents $1/1k pages for full text, Answer $5/1k for a cited LLM response, Monitors $15/1k for scheduled recurring searches, and an Agent endpoint at $0.012-$1.00 per fixed-effort run. Owning the index is the structural difference from Tavily and Perplexity, which sit on top of other people's results.

Input formats	Natural-language or keyword queries; URLs for contents retrieval
Output	Ranked results with URLs, titles, published dates; full page text, highlights, AI summaries; cited answers
Table/OCR quality	n/a — search and page-text API, not a document parser
Price unit	Per 1,000 requests (search) and per 1,000 pages (contents)
Latency	Search is sub-second to a couple of seconds; Deep Search and Agent runs take substantially longer by design

Watch out: At $7 per 1,000 searches it is the most expensive general search API here, roughly 40% above Brave and Perplexity's $5, and costs climb further once you add contents and summaries. Its own index is narrower and refreshes less aggressively than Google or Bing derivatives, so it underperforms on breaking news and long-tail navigational queries where you know exactly the page you want. Neural search also makes result quality harder to debug — you cannot reason about why a page ranked the way keyword operators let you.

Pay-as-you-go, no subscription or minimum. Search $7/1,000 requests (up to 10 results); Deep Search $12-15/1,000; Contents $1/1,000 pages; Answer $5/1,000 requests; Monitors $15/1,000; Agent $0.012-$1.00 per fixed-effort run or usage-metered. Results beyond the first 10 cost $1/1,000 results; AI page summaries $1/1,000 pages on any endpoint. New accounts get $20 in credits (~2,800 searches) plus $10/month on the free tier. Enterprise plans offer volume discounts, custom indexes and SLAs.

Tavily

A search API built specifically to be an LLM tool call: it returns short, deduplicated, relevance-scored snippets rather than raw SERP JSON, so you spend fewer tokens post-processing. Five endpoints — Search, Extract, Crawl, Map and a Research agent — share one credit pool with granular pricing: basic search 1 credit, advanced 2; basic extract 1 credit per 5 URLs; map 1 credit per 10 pages; crawl bills map plus extract. At $0.008 per credit a basic search is $8 per 1,000, close to Brave and Perplexity, but you can drop the extract cost to ~$1.60 per 1,000 URLs.

Input formats	Natural-language queries; URLs for Extract/Crawl/Map
Output	JSON with ranked snippets, relevance scores, optional LLM answer; markdown page content from Extract/Crawl
Table/OCR quality	n/a — search and HTML extraction; no document OCR
Price unit	API credits ($0.008 each; 1 credit per basic search)
Latency	Basic search typically 1-2 seconds; advanced search and crawl noticeably slower. Rate limits differ by plan

Watch out: Tavily does not own an index — it aggregates upstream sources, so coverage, freshness and pricing sit on someone else's foundation, and result diversity is narrower than a raw SERP API. The pre-summarised snippets that save tokens also throw away context you sometimes need, forcing a second extract call and a second charge. Advanced search doubles the credit cost for a quality gain that is modest on ordinary queries, and credits expire monthly with no rollover.

Free: 1,000 API credits/month, no card. Pay-as-you-go: $0.008/credit. Project plan: adjustable monthly subscription starting at 4,000 credits/month with higher rate limits (base price is set by an on-page slider and was not captured). Enterprise: custom. Credit costs — basic search 1, advanced search 2; basic extract 1 per 5 URLs, advanced extract 2 per 5; map 1 per 10 pages (2 with instructions); crawl = map + extract combined. Credits reset monthly and do not roll over. Free access for students.

Brave Search API

One of the very few genuinely independent web indexes available by API — not a Google or Bing reseller — which matters for antitrust exposure, terms-of-service risk and result diversity. The Search plan is $5 per 1,000 requests at 50 QPS and returns web, news, image, video, LLM-context and schema-enriched results, plus Goggles for custom reranking of results against your own rules. A separate Answers plan gives cited, streaming, OpenAI-SDK-compatible summaries at $4 per 1,000 requests plus $5 per million tokens, but is throttled to 2 QPS.

Input formats	Keyword and natural-language queries; Goggles files for custom reranking
Output	JSON SERP results (web, news, images, video), LLM-context payloads, schema-enriched results, cited streaming answers
Table/OCR quality	n/a — search API, not a document parser
Price unit	Per 1,000 requests ($5 Search, $4 Answers + $5/M tokens)
Latency	Search is fast at 50 QPS sustained; Answers is capped at 2 QPS and streams responses

Watch out: Index coverage is smaller than Google's, and it shows on long-tail, non-English and hyper-local queries — expect to backfill with a SERP proxy for those. The Answers plan's 2 QPS ceiling makes it unusable for any concurrent agent workload without an enterprise agreement, a 25x gap versus the Search plan's 50 QPS. Raw results are SERP-shaped, so you do the snippet cleanup and dedup that Tavily and Exa do for you.

Search plan: $5 per 1,000 requests, 50 queries/second, with $5/month in free credits applied automatically. Answers plan: $4 per 1,000 requests plus $5 per million input/output tokens, 2 queries/second, also with $5/month free credits. Enterprise: custom pricing with full-funnel zero data retention, custom agreements and invoicing. Endpoints included: Web, LLM Context, Answers, Image, Video, News, Suggest, Spellcheck.

Perplexity Search & Agent API (formerly Sonar)

Perplexity's API has been restructured into four products: a Search API returning ranked results at $5 per 1,000 successful requests, an Agent API giving web-grounded answers with citations across multiple model providers (OpenAI, Anthropic, Google, xAI, Perplexity), a Router API for OpenAI/Anthropic-compatible access to open-weight models, and an Embeddings API. The Sonar chat-completions endpoint that this category is usually named after is now the Agent API; Sonar remains supported only until 27 September 2026, so new builds should target `/v1/agent` or `/search` directly.

Input formats	Natural-language queries and chat messages; multi-query search supported
Output	Ranked search results JSON (Search API); grounded prose with citations, streaming, tool calls (Agent API); embeddings
Table/OCR quality	n/a — search and answer API, not a document parser
Price unit	Per 1,000 requests (Search) and per million tokens + per tool invocation (Agent)
Latency	Search API is sub-second to seconds; Agent responses take seconds and deep-research runs take minutes

Watch out: The Sonar chat-completions API is retired on 27 September 2026 — three weeks from this writing — so anything built on `sonar`/`sonar-pro` model IDs needs migrating to the Agent API now; this is the biggest live migration risk in this chapter. Agent API pricing is genuinely hard to forecast because it stacks model tokens, per-invocation tool fees and sandbox charges. You also cannot inspect or tune the retrieval step, which makes quality regressions opaque, and sonar-deep-research can cost dollars per query if you let it run.

Search API: $5.00 per 1,000 successful requests. Agent API: no per-request fee — model tokens at each provider's published rate ($0.13-$25 per million in/out), tools $0.0005-$0.005 per invocation (web search, fetch URL, people search, finance search), sandbox sessions $0.03 each. Router API: token-based at each model's published rate, no per-request fee. Legacy Sonar models: sonar $1/$1 per million in/out, sonar-pro $3/$15, sonar-reasoning-pro $2/$8, sonar-deep-research $2/$8, plus per-request search fees of $5-6/1K (low context), $8-10/1K (medium), $12-14/1K (high).

ScrapingBee

A single-endpoint scraping API that abstracts proxy rotation, headless Chrome and CAPTCHA handling behind a credit cost that scales with how hard the target fights back: 1 credit plain, 5 with JavaScript rendering, 10 or 25 with premium proxies, 75 for stealth proxy. Auto-Mode escalates through those tiers and charges only for the configuration that succeeded, and failed requests cost nothing. That failure-free billing plus explicit difficulty pricing makes cost modelling far more honest than flat-rate competitors.

Input formats	URLs (HTML), with optional JS rendering, custom JS scenarios and geotargeting
Output	Raw HTML, screenshots, JSON via CSS/XPath extraction rules; dedicated Google/search endpoints
Table/OCR quality	n/a — returns HTML; no OCR or markdown conversion
Price unit	API credits (1 plain / 5 JS / 10-25 premium proxy / 75 stealth)
Latency	Plain requests are sub-second to seconds; JS rendering adds seconds. Failed URLs are retried for up to 30 seconds

Watch out: Feature gating by plan is aggressive and easy to miss: per the pricing page, JavaScript rendering starts at Startup ($99/mo) and rotating/premium proxies and geotargeting at Business ($249/mo), so the $19 Hobby plan is far less capable than the credit count suggests. Stealth proxy at 75 credits per request means a Hobby plan's 75,000 credits buys just 1,000 hard pages. It returns raw HTML or a screenshot with only basic extraction rules — there is no crawl orchestration or markdown conversion, so pair it with your own parser.

Hobby $19/mo (75,000 credits, 25 concurrent). Freelance $49/mo (250,000, 50 concurrent). Startup $99/mo (1,000,000, 100 concurrent). Business $249/mo (3,000,000, 200 concurrent). Business+ $599/mo (8,000,000, 400 concurrent). Trial: 1,000 free API credits, no card. Credit costs: 1 default, 5 with render_js, 10 premium proxy without JS, 25 premium proxy with JS, 75 stealth proxy (requires JS). Auto-Mode charges only the tier that succeeded; failed requests cost 0 credits. Prices exclude VAT.

Apify

Two products in one: a store of thousands of prebuilt, community- and vendor-maintained scrapers ('Actors') for named sites, and a serverless platform for running your own Python or Node scrapers with storage, scheduling, proxies and queues. Billing is a monthly credit balance ($19 plan = $19 of usage) drawn down by compute units at $0.20/CU (1 CU = 1 GB RAM for 1 hour), falling to $0.13/CU on Business, plus whatever the Actor author charges under pay-per-event or pay-per-result. It is the fastest way to get structured data from a specific site without writing selectors.

Input formats	URLs and site-specific inputs (search terms, profile URLs, categories) defined per Actor
Output	JSON, CSV, XML, Excel datasets via API or dataset export; key-value store for files
Table/OCR quality	n/a — structured web records; no document OCR
Price unit	Platform credits, drawn by compute units ($0.13-$0.20/CU) plus per-event or per-result Actor fees
Latency	Actor runs are async jobs from seconds to hours depending on scope; not suited to synchronous request-time use

Watch out: Cost is the least predictable in this chapter — a badly written Actor can burn a month of credits in hours because you pay for wall-clock RAM time, not results, unless the Actor uses pay-per-result. Store Actor quality is uneven and third-party maintained, so a site redesign can silently break a scraper you depend on with no SLA. Credits expire monthly with no rollover, which penalises bursty workloads, and the platform has a real learning curve versus a single-endpoint API like ScrapingBee.

Free $0 (about $5 of platform credits/month). Starter $19/mo ($17 annual, $19 credits). Scale $199/mo ($179 annual, $199 credits). Business $999/mo ($899 annual, $999 credits). Compute units: $0.20/CU on Free and Starter, $0.16/CU on Scale, $0.13/CU on Business, where 1 CU = 1 GB RAM for 1 hour. Actors bill either pay-per-event (fixed price per developer-defined action, usually inclusive of platform usage) or pay-per-usage (compute + data transfer). Paid users are billed for overage; free users are blocked until the next cycle. Unused credits expire monthly with no rollover. · open source

Zyte API

From the team behind Scrapy, an unblocking API that automatically picks the cheapest technique that works for a given target — plain HTTP through to full browser — and assigns each request to a tier from 1 to 5 based on how hard the site is to access. You are charged only for successful responses; rate-limited and failed requests are free, and screenshots (+$0.002) and automatic extraction (+$0.0004-$0.0016) are itemised add-ons. Commitment discounts are unusually steep: 25% at $100/month and 52% at $500/month.

Input formats	URLs, with HTTP or browser request modes, browser actions and session handling
Output	Raw HTTP body or rendered browser HTML, screenshots, automatic structured extraction (product, article, job posting schemas)
Table/OCR quality	n/a — returns HTML/structured records; no document OCR
Price unit	Per successful request, priced by site-specific tier 1-5 and request type
Latency	HTTP-tier requests are fast; browser-tier and action-heavy requests add seconds. Failed and rate-limited requests are free

Watch out: You cannot forecast cost from the public pricing page — per-request price is a function of the target domain and an opaque automatically assigned tier, so budgeting requires running the estimator against your actual URL list. The $100/month default spending cap on pay-as-you-go silently suspends service when hit, which has bitten people mid-crawl. It is oriented around Scrapy and engineering teams; there is no marketplace of ready-made site scrapers the way Apify and Bright Data offer.

$5 free credit for your first billing month. Standard pay-as-you-go with a $100/month spending limit and no commitment; Standard with commitment carries $200-$2,500/month limits; Enterprise is custom. Per-request cost depends on target site, request type (HTTP or browser) and an automatically assigned tier 1-5, so there is no single headline rate — use the dashboard cost estimator. Add-ons: screenshots $0.002, extraction $0.0004-$0.0016, browser actions billed on CPU/network. Volume discounts: 25% at $100 commitment, 52% at $500. Only successful responses are billed.

Bright Data Web Scraper API

Rather than selling you page fetches, Bright Data sells finished records from named sites — e-commerce listings, job postings, social profiles, business directories — with proxy management, browser rendering and CAPTCHA solving hidden behind a delivery guarantee: no charge for failed deliveries. Pay-as-you-go is $1.50 per 1,000 records, dropping to $1.30 on the $499/month Scale plan which includes 384,000 records. The free tier gives 5,000 records a month with no card, which is enough to validate a use case properly.

Input formats	Target URLs, search terms and site-specific inputs for 100+ supported domains
Output	Structured JSON or CSV records with validation; also raw unlocked HTML via companion Web Unlocker product
Table/OCR quality	n/a — structured web records; no document OCR
Price unit	Per 1,000 records delivered ($1.50 PAYG, $1.30 at scale)
Latency	Batch/async collection jobs; unlimited concurrency but delivery is minutes-scale, not request-time

Watch out: Per-record billing is the wrong shape for general crawling — if you need arbitrary URLs turned into markdown rather than schema records from supported sites, Firecrawl or Zyte cost far less. Bright Data's proxy business has drawn sustained scrutiny over how residential IP consent is obtained, which is a genuine procurement and reputational question some legal teams will not clear. The product surface is sprawling (Unlocker, SERP API, Browser API, datasets, proxies) with separate pricing per product, so comparing a quote against a single-purpose competitor takes work.

Free tier: 5,000 records/month, no credit card. Pay-as-you-go: $1.50 per 1,000 records with customisable spend limits. Scale: $499/month including 384,000 records, then $1.30 per 1,000 additional records. Enterprise: custom with volume discounts and a dedicated account manager. All plans include automated proxy management, full browser rendering, CAPTCHA solving, unlimited concurrent requests, batch scheduling and JSON/CSV output. No charge for failed deliveries.