Best Structured Data Extraction Tools for AI Agents in 2026

Short version: pick by layer first. Then pick by whether your agent has to prove where a value came from. Web and document extraction are converging on one API surface. Search still hands you sources rather than fields. The schema-enforcement libraries guarantee shape, never truth.

Structured data extraction tools all sell the same promise. Hand one a schema, get typed fields back.

Now point an agent at a receipt. The schema says quantity is a number. The row reads 0.46 kg of bananas. BAML documented gpt-5.2 returning "quantity": 1 under structured outputs. The same model answering in free form got 0.46 right. The JSON validated. The invoice total did not.

That gap is why marketing pages are the wrong place to pick from. Every vendor publishes an accuracy number. Every one of those numbers was produced by the vendor. Independent benchmarks measuring the same product do not agree.

Sources: Mistral, OmniDocBench, olmOCR-Bench, retrieved August 18, 2026. The self-reported figures are for Mistral OCR 2503, a generation Mistral now marks deprecated. The three metrics are not identical, so read the direction of the gap rather than the exact delta.

Mistral concedes the framing on its own OCR 4 announcement. A single aggregate number, it says, "can both understate and overstate real-world performance."

So this comparison grades on what you can verify without anyone's eval harness. Published limits. Published prices. Third-party boards. Where a vendor benchmark is the only number available, it is labelled as one. That includes ours.

Structured data extraction turns an unstructured source into typed fields an application can act on. The source is a web page, a PDF, a scan, or a model's own prose. For an agent it means handing a tool a JSON Schema and getting back an object shaped like it. The next step reads filing.revenue instead of re-parsing a paragraph.

The distinction that matters is shape versus truth. Schema enforcement guarantees the first. Nothing guarantees the second. That is why grounding and cost per retry belong in the evaluation alongside accuracy.

An agent calls these tools differently than a batch pipeline does. One document at a time, inside a loop, against a latency budget. It also cannot glance at the output and notice something is off. Five axes follow from that.

1. Schema surface. Arbitrary JSON Schema, or only the fixed types the vendor trained? A fixed product schema is useless when your agent needs warranty_terms.
2. Guarantee. Grammar-constrained sampling, retry on validation failure, post-hoc parsing, or nothing. Each fails differently and costs differently.
3. Grounding. Citations or bounding boxes let an agent check its own answer. Without them, a wrong value looks exactly like a right one.
4. Agent surface. A first-party MCP server, real SDKs, async jobs. These decide how much glue code you write.
5. Cost and caps. Price per 1,000 pages. Then the synchronous page ceiling, which decides whether your agent blocks or polls.

That last axis hides the biggest surprise in the category. The three hyperscalers charge an identical price to read a page. They charge wildly different prices to structure it.

Sources: AWS Textract, Azure AI Document Intelligence, Google Document AI, retrieved August 18, 2026.

Reading the page costs $1.50 per 1,000 pages at all three. Structuring it costs $30 at Google and $30 at Azure. AWS charges $50 for Analyze Document Forms.

That is a 20x to 33x premium on the step your agent needs. Budget from OCR pricing and you will be off by an order of magnitude.

A web data extraction API earns its place with an agent by returning typed fields instead of HTML. These four differ mostly in whether the fields are yours to define.

Firecrawl covers the web and document layers behind one surface. That matters the moment an agent hits a landing page that links a PDF. Scrape takes an OpenAI-format JSON Schema, a Pydantic model, or a Zod schema. /parse takes an uploaded file up to 50 MB across 20 extensions, including .pdf, .docx, .xlsx, and .epub. One API key, one schema shape, both content types.

Firecrawl is also one of the fastest-growing open-source scraping projects on GitHub. The core repo sits above 60,000 stars, ships weekly, and is already wired into MCP, LangChain, LlamaIndex, CrewAI, and most of the agent frameworks people ask about.

JSON schema extraction stacks onto a scrape call rather than sitting in a separate product. Scraping costs 1 credit per page. On the $99 Standard plan that is $0.99 per 1,000 pages of markdown and $4.95 per 1,000 for schema JSON. Search is 2 credits per 10 results, or $0.198 per 1,000 results.

The docs are direct about where extraction breaks. JSON extraction runs on the markdown conversion, so HTML attributes are stripped before the model sees them. The same page warns that minItems: 20 "will not make the LLM return more items, it may instead hallucinate entries," and recommends splitting schemas over 30 fields. That kind of honesty about failure modes is rare in this category.

Best for: agents that need web pages and uploaded files through one schema-driven call. The MCP server and CLI are already wired for tool loops. Watch out: the hosted API ships new extraction features ahead of the self-hosted AGPL build.

Bright Data's Web Scraper API runs $1.50 per 1,000 records pay-as-you-go, or $1.30 on a Scale plan starting at $499. The first 5,000 records each month are free. Web Unlocker converts pages to markdown in flight through a data_format: 'markdown' parameter. The official MCP exposes 69 tools.

The catch for agents: structured output relies on pre-built per-site extractors rather than your own schema. When Bright Data has a collector for the site, the JSON matches that catalogue shape. When it does not, you are back to markdown and your own parsing.

Best for: high-volume collection from sites with heavy anti-bot defenses. Watch out: no arbitrary schema, and render: true "significantly increases response time" by their own documentation.

Apify bills compute units at $0.20 each on the free and Starter plans, down to $0.13 on Business. One unit is 1 GB of RAM for one hour.

Apify estimates the Website Content Crawler at $0.20 per 1,000 pages over raw HTTP, and $0.50 to $5.00 through a headless browser. The RAG Web Browser doubles as an MCP server over SSE.

Cost tracks memory multiplied by runtime rather than pages read. So the same 1,000 pages can vary tenfold between sites. Credits also expire at the end of the billing cycle rather than rolling over.

Best for: reaching for an existing actor instead of building a scraper. Watch out: unpredictable per-page cost, and a plan gap from $199 straight to $999.

Zyte publishes ten AI extraction types, including product, article, jobPosting, and forumThread. It will also accept your own HTML through extractFrom, up to 2.5 MiB. Extraction adds $0.0004 to $0.0016 per data type on top of the request, with serp exempt.

The request itself is where cost modeling gets hard. Zyte sorts every site into one of five difficulty tiers you cannot see until you enter the URL.

The published range runs from $0.06 to $16.08 per 1,000. The floor is a simple HTTP fetch on a $500 commitment. The ceiling is browser-rendered Advanced at pay-as-you-go. That is a 268x spread on one product.

Best for: e-commerce and article extraction where the fixed types match your fields. Watch out: one structured type per request, fixed schemas, and a price you cannot forecast from the URL alone.

Every document extraction API on this list reads a page competently. Tables are where they fail. An independent board makes that concrete in a way no vendor page does.

Source: OmniDocBench leaderboard, retrieved August 18, 2026. 1,651 PDF pages across 10 document types and 5 language types. Ten of the 32 methods on the board, re-sorted by Table TEDS, which is not the column the board ranks on.

Two things stand out. A 0.9B-parameter model tops the board at 94.76, while GPT-5.2 scores 82.95. Parameter count does not predict rank.

Star count does not predict it either. Marker has 38,828 of them and ranks last here. Unstructured has 15,325, and version 0.17.2 scored a Table TEDS of 0 on the archived v1.0 board.

Reducto returns schema extraction with citations back to source spans, plus layout and bounding boxes. That is the shape an agent needs when a human will later ask where a number came from.

Pricing is free to the first 15,000 credits, then $0.015 per credit. Parse Standard is 1 credit per page, so roughly $15 per 1,000. Agentic Complex parsing at 4 credits a page lands near $60.

Their RD-TableBench reports an average table similarity score of 90.2% for Reducto. Azure's 82.7 and Unstructured's 60.2 are legible only on Reducto's own chart image. It is a vendor-run benchmark on which the vendor wins. Weight it accordingly.

Best for: regulated workflows where every field needs a provenance trail. Watch out: VPC and SSO are Enterprise-only, and direct uploads cap at 100 MB.

At $4 per 1,000 pages, or $2 through the batch API, Mistral is the cheapest hosted OCR API here. It is also the fastest. Crowd voting on OCR Arena puts it mid-table on quality and far ahead on speed.

Source: OCR Arena leaderboard, retrieved August 18, 2026, across 16,314 crowd-voted head-to-head battles. The arena is built by Extend, which also appears in the pricing table below.

OCR 4 added include_blocks. It returns paragraph-level bounding boxes and 13 structural block labels in reading order, plus confidence scores at page, block, and word granularity.

Build on those confidence scores, because hallucination is the recurring complaint. One practitioner on Hacker News now runs a second pass. Mistral OCR 4.0, they wrote, was "just completely making up new sentences in the middle of a page."

The arena publishes latency next to ELO, which is the pairing most vendor pages omit. Source: ocrarena.ai/leaderboard, retrieved August 18, 2026.

Best for: high-volume page reading where 2.4 seconds a page and $4 per 1,000 beat a few accuracy points. Watch out: feature gating by model version. include_blocks needs OCR 4 or newer. Also hallucinated text, which a schema will happily accept.

LlamaParse prices credits at $1.25 per 1,000. Four parsing modes spend them at different rates: Fast at 1 credit per page, Cost-effective at 3, Agentic at 10, Agentic Plus at 45. That is $1.25 to $56.25 per 1,000 pages on one product, decided by a parameter.

The schema ceiling is generous and documented. You get 5,000 properties and 7 levels of nesting. Extract caps files at 100 MB and 500 pages.

Best for: teams already on LlamaIndex who want to dial accuracy per document class. Watch out: free-tier organizations are throttled to 20 requests per minute. A parallel agent exhausts that immediately.

Both are the safe institutional pick. Both punish schema extraction.

Google charges $30 per 1,000 pages for a Custom Extractor. On top of that sits a hosting fee its own page prices honestly: "One processor version deployed for a year costs $438." AWS charges $50 per 1,000 pages for Analyze Document Forms, and offers Queries rather than arbitrary schemas.

Textract also carries limits an agent hits before a pipeline does. It does not support vertical text. It covers six languages, with queries and handwriting in English only, and rejects XFA-based PDFs.

Best for: shops already committed to one cloud, with compliance requirements that outrank cost. Watch out: the synchronous ceilings below.

Sources: LlamaParse, Landing AI, Google, AWS, retrieved August 18, 2026.

Textract's synchronous path accepts one page of PDF or TIFF. Google's Custom Extractor accepts 15 online, or 30 with imageless_mode.

All four handle far more asynchronously. But async means job submission and polling, which is a different agent architecture than a tool call that returns.

Docling is MIT-licensed with 64,994 stars. There is no hosted API, so cost is your own compute. It handles PDF, Office formats, HTML, EPUB, audio, and now video. Layout and table structure come from DocLayNet and TableFormer. It ships an MCP server.

Be clear-eyed about tables. Open issues cover merged and split columns, missing columns, and general inaccuracy. Practitioners on r/Rag are blunt about speed and table quality alike.

Best for: documents that cannot leave your infrastructure, on a licence with no revenue threshold. Watch out: you own the GPU bill, the throughput tuning, and the table failures.

Datalab's Marker has 38,828 stars under Apache 2.0. Its newer Chandra model tops olmOCR-Bench at 83.1. The hosted API runs $4 per 1,000 pages for fast or balanced conversion, $10 for accurate. Table-cell bounding boxes are a $6 add-on.

The licence deserves a careful read. The code is Apache 2.0. The model weights are free only for research, personal projects, and startups under $2M in funding or revenue. A separate startup discount program uses looser thresholds, so do not mistake one for the other. Schemas cap at 750 fields.

Best for: self-hosted throughput when you clear the revenue threshold, or hosted parsing at a low rate. Watch out: open code and open weights are not the same licence here.

Landing AI's Agentic Document Extraction returns markdown with visual grounding. Every extracted value maps to a region on the page. Credits cost 1 cent each, and a typical business document uses a median of 1.5 credits on the standard tier. That is roughly $15 per 1,000 documents.

Parse caps at 100 pages per document. The MCP server is community-built rather than first-party, because Landing AI's own vision-agent-mcp repo is deprecated.

Best for: agents that must render a highlight over the source region to a human reviewer. Watch out: free credits expire 90 days after account creation.

Prices are list rates retrieved August 18, 2026. Note how little the choice of PDF extraction API tracks price. On the independent board above, the $4 option and the $50 option sit within a few points of each other.

Before you commit to any of these rates, run one of your own documents through a parser. Firecrawl's free PDF to JSON converter takes a PDF URL and returns structured JSON with no signup and no card. It is the fastest way to see how a parser handles your worst table.

For a deeper pass on this layer alone, see our document parsing API comparison and PDF parser roundup.

Extraction is worthless if the agent points it at the wrong URL. Three of these tools return content you can extract from. Two return links.

Firecrawl Search costs 2 credits per 10 results, or $0.198 per 1,000 results on the $99 Standard plan. It returns query-relevant markdown in the same call, and full-page markdown through scrape_options. Our own SimpleQA benchmark puts agents at 94.7% using it, which is a vendor number and should be read as one.

Exa prices search at $7 per 1,000 requests and contents at $1 per 1,000 pages. Latency is "configurable: 180ms to 1s." Its agent mode scales from $0.012 to $1.00 per request by effort level.

Tavily sits in between. Basic search costs 1 credit, and extract covers 5 URLs per credit, at $0.008 a credit. That is $8 per 1,000 searches and $1.60 per 1,000 extracted pages.

Serper and Brave are the contrast. Serper runs $0.30 to $1.00 per 1,000 queries and Brave $5.00 per 1,000 requests. Both return SERP JSON with no page content. Brave's Answers endpoint is also rate-limited to 2 QPS, which is low for a parallel agent.

The pattern across all five is the same. Search that hands back links forces a second extraction call. That call is where the real cost and latency live. Our search tools comparison for agents and web search API roundup go deeper here.

The last layer is not an extraction API at all. It is the machinery that makes a model's output conform. The four approaches fail differently.

OpenAI Structured Outputs allows up to 5,000 object properties across 10 levels of nesting. Every field must be marked required. allOf, not, and conditional keywords are rejected.

Anthropic's strict tool use states the guarantee plainly. Setting strict: true "guarantees Claude's tool inputs match your JSON Schema by constraining the model's token sampling." That is grammar-constrained sampling.

It also drops numeric and string constraints, so minimum and maxLength return a 400 on the raw API. The official SDKs strip them for you instead, so you may never see the error. We walked through the OpenAI side in our JSON strict mode guide.

Instructor takes the retry path: Pydantic validation, then re-prompt on failure. Outlines constrains decoding directly, reformulating generation as transitions between the states of a finite-state machine. BAML argues for neither. It accepts whatever the model emits and error-corrects it with a least-cost edit against the schema, which leaves chain-of-thought unblocked.

Whether constraining the decoder costs you accuracy is unsettled.

Source: Tam et al., "Let Me Speak Freely?", EMNLP 2024 Industry Track, retrieved August 18, 2026.

That paper reports "a significant decline in LLMs' reasoning abilities under format restrictions." Claude-3-Haiku loses 63 points on GSM8K.

The authors of Outlines measured the opposite direction on the same benchmark. Across eight models they report improvement in every case, and a lift greater than 70% at the top end. Neither engages with the other. The same paper also finds Gemini-1.5-Flash gaining 6.9 points on a different task under the same restriction.

Practitioners have mostly stopped waiting for a verdict. The pattern that keeps surfacing on Hacker News is two-pass. Let the model answer in free form. Then run a cheap second call that structures that answer.

One commenter reports 99.7% of extracted fields correct across several hundred receipts this way, while adding that it still needs human review. It costs an extra call and sidesteps the whole argument.

• Web pages and files through one API: Firecrawl. Strongest fit when the agent already speaks MCP or CLI.
• Provenance for every field: Reducto for citations. Landing AI ADE for bounding boxes.
• Cheapest hosted page reading: Mistral OCR at $4 per 1,000 pages. Pair it with the confidence scores and a verification pass.
• Documents that cannot leave your network: Docling under MIT. Datalab if you clear its revenue threshold.
• Sites with pre-built collectors: Bright Data, when its catalogue already covers the domain you need.
• Finding the source before extracting it: Firecrawl Search or Exa, which both return content. Serper and Brave only return links, so budget a second call.
• Locked into one cloud by compliance: Google Document AI or AWS Textract. Budget for the structured-extraction premium.
• Schema conformance in your own loop: Anthropic strict tool use or OpenAI Structured Outputs for shape. BAML or a two-pass call when reasoning quality matters more.

Want a broader survey with ETL and no-code options? See our data extraction tools roundup. For the LLM-side mechanics, read extracting data with LLMs and our agentic OCR explainer.

Firecrawl exists so an agent does not need one tool for a URL and another for a file. Three endpoints cover the range. /scrape with a JSON schema handles a page you already know. /agent handles async extraction when the source has to be found first. /parse handles local files that never touch a public URL.

Firecrawl JSON mode docs, retrieved August 18, 2026.

Wire it into a coding agent in one command:

npx -y firecrawl-cli@latest init --all --browser

The pricing math is public. Check it against the table above. The $99 Standard plan gives you 100,000 credits, so markdown is $0.99 per 1,000 pages and schema JSON is $4.95. That sits below every hosted structured-extraction option here. Only raw OCR is cheaper, and raw OCR does not give you fields.

Start on the free tier with 1,000 credits a month and no card. Or read how Parse handles documents on a Rust engine the docs put at up to 5x faster.

Every number here came from a pricing page, a limits page, or a benchmark somebody other than the vendor ran. That is a low bar. It still eliminated most of what gets published about this category.

Pick the layer you need. Check the synchronous cap before the accuracy score. Assume the JSON will be well-formed and occasionally wrong.