Use code for 1,000 extra pages on your first month of Starter.+1,000 pages on Starter
See Starter →See →HyperAPI ranks first: word boxes, typed blocks, heading levels, table HTML and sections for $1 per 1,000 pages. Nine APIs compared on fields and price.
Short answer: HyperAPI by Hyperbots is our pick for structured output per dollar. Its fast parse costs $1 per 1,000 pages and returns word and line boxes (for PDF and image files), typed blocks, heading levels, tables as HTML with their positions, sections, and links between tables that continue across pages. Below, nine document parsing APIs are ranked on what each returns and its list price per 1,000 pages.
Published by HyperAPI. We rank ourselves first on the criteria below; check them against your own documents. Last updated: 18 November 2026. Vendor prices and docs read on 17 and 18 November 2026.
Try it on your own file. With a free account (30 pages a month, no card) you get back the same boxes, typed blocks, heading levels and sections described in this post.
| # | API | $ per 1,000 pages (structured mode) | Best for |
|---|---|---|---|
| 1 | HyperAPI (fast parse) | $1 | Word boxes (PDF and image files), typed blocks, heading levels, table HTML and sections from one call; parse, extract, classify, split and redact on one key |
| 2 | Reducto (r-1 mini) | $1; $2 with per-word boxes | The lowest list price for markdown with tables ($0.80 in batch); large files and email input |
| 3 | Mistral OCR 4.1 | $4; $2 in batch | Markdown with HTML or markdown tables at $2 in batch; files up to 50 MB and 1,000 pages |
| 4 | LlamaParse (Cost-effective tier) | $4.50 | 130+ input formats and 10,000 free credits a month |
| 5 | Extend (Parse Light) | $5; $20 for the default Performance engine | Table headers repeated after page breaks; SDKs in four languages |
| 6 | Azure AI Document Intelligence (Layout) | $10 | Teams already on Azure; plain text above about 2.25M pages a month (Read) |
| 7 | Google Document AI (Layout Parser) | $10 | Teams already on Google Cloud; plain text above about 11.25M pages a month (Enterprise OCR) |
| 8 | AWS Textract (Tables, Layout included) | $15 | Teams already on AWS; plain text above about 2.25M pages a month (DetectDocumentText) |
| 9 | Unstructured | $15 | One flat rate for every file type, markdown or typed elements |
Not an API, but worth knowing: Docling is free, MIT licensed and runs on your own machines, so it suits markdown conversion where documents can't leave your network. See what Docling is and where it stops.
A document parser that returns only text leaves you to rebuild headings, sections and tables yourself. This table shows what comes back from each API's structured mode. “Not documented” means we did not find it in the vendor's docs on 17 or 18 November 2026, so check before ruling a vendor out.
| API (mode, $/1k) | Word / line boxes | Typed blocks | Heading levels | Tables: HTML + positions | Sections | Tables across pages | Markdown |
|---|---|---|---|---|---|---|---|
| HyperAPI (fast, $1) | Yes, both (PDF and image input) | Yes, 21 types | Yes, numeric (heading) | Yes: HTML by default (best-effort) plus the block's box | Yes (groups) | Linked (cross_page_tables) | No; advanced parse ($50) |
| Reducto (r-1 mini, $1) | Per-word boxes as a $1/1k add-on | Yes, 10 types | No (Title, Section Header) | HTML, markdown, JSON or CSV, plus block box | Not documented | merge_tables, off by default | Yes |
| Mistral OCR 4.1 ($4) | No; paragraph-level boxes | Yes, with include_blocks | No (one label for titles and section headings) | HTML or markdown, plus block box | Not documented | Not documented | Yes |
| LlamaParse (Cost-effective, $4.50) | Option (granular_bboxes); not on the Fast tier | Yes | Yes, 1 to 6 | HTML, plus item box | Not documented | merge_continued_tables | Yes |
| Extend (Light, $5) | Options | Yes | Two types (heading, section_heading) | HTML or markdown, plus box | Output split by section, as an option | Repeats header rows, as an option | Yes |
| Azure Layout ($10) | Yes (not for Office or HTML input) | Roles on paragraphs | Two roles (title, sectionHeading) | Cells with polygons; HTML in the markdown | Yes (sections) | One box per page | Yes |
| Google Layout Parser ($10) | No (Enterprise OCR has them, as a separate processor) | Yes | Yes, 1 to 5 (heading-1 to heading-5) | Rows and cells (no HTML documented); boxes on request | Yes (nested blocks) | “Might be split in two tables” | Not documented |
| AWS Textract (Tables, $15) | Yes, both | Yes (Layout) | No (title, section header) | Cells with geometry; HTML only via the open-source Textractor library | No | Merged only by AWS's open-source response parser | Via Textractor |
| Unstructured ($15) | No; element boxes on request | Yes | Not documented | HTML on request, plus element box | Not documented | One box per page | Yes (default) |
Two patterns stand out. Most vendors return typed blocks and table HTML, but no other mode in this table documents word boxes, numeric heading levels and a section tree together. Two $10 modes come closest: Azure Layout has word boxes and sections but two heading roles instead of levels, and Google Layout Parser has numeric levels and a section tree but no word boxes. Markdown is the reverse: almost everyone returns it, and HyperAPI keeps it in advanced parse.
Here is HyperAPI fast parse on page 35 of the U.S. National Archives and Records Administration's Federal Agency Records Management 2024 Annual Report, a public-domain page with a title, three headings, paragraphs, a bulleted list and a page number. You upload the file to get a document_key, then call parse (full reference in the parse docs):
# 1. POST /v1/documents/upload returns a document_key and an upload_url;
# PUT the file to the upload_url (see /docs/api/upload).
# 2. Parse it:
curl -X POST "https://apis.hyperbots.com/v1/parse?mode=fast" \
-H "X-API-Key: hk_live_your_key_here" \
-F "document_key=550e8400-e29b-41d4-a716-446655440000"Or with the Python SDK, which does the upload for you:
from hyperapi import HyperAPIClient
client = HyperAPIClient(api_key="hk_live_your_key_here")
resp = client.parse("records-report-p35.pdf") # fast mode, $0.001 a page
result = resp["result"]
for block in result["blocks"]:
print(block["type"], block.get("heading"), block["bbox"])
client.close()The response, trimmed to the fields this post compares:
"result": {
"pages": [{
"page_number": 1,
"boxes": [{"text": "CONCLUSION", "bbox": [197, 286, 393, 320], "confidence": 0.9991}, ...],
"word_boxes": [{"text": "CONCLUSION", "bbox": [201, 286, 390, 320], "confidence": 0.9991}, ...]
}],
"blocks": [
{"id": "b1-0", "type": "title", "heading": 1, "group": "g0", "bbox": [558, 203, 1136, 242]},
{"id": "b1-1", "type": "heading", "heading": 2, "group": "g1", "bbox": [194, 285, 396, 323]},
{"id": "b1-2", "type": "text", "group": "g1", "bbox": [190, 365, 1495, 595]},
{"id": "b1-8", "type": "list", "group": "g4", "bbox": [244, 1130, 1481, 1736]},
{"id": "b1-9", "type": "page_number", "group": "g5", "bbox": [799, 2006, 893, 2037]}
],
"groups": [
{"id": "g0", "kind": "section", "level": 1, "heading": "b1-0", "children": ["b1-0", "g1", "g2"]},
{"id": "g1", "kind": "section", "level": 2, "heading": "b1-1", "children": ["b1-1", "b1-2", "b1-3"]},
{"id": "g5", "kind": "page_footer", "children": ["b1-9"]}
],
"cross_page_tables": []
}That one page came back with 29 line boxes, 257 word boxes, 10 typed blocks and 6 groups. The section tree nests “Conclusion” under the page title, and the page number sits in its own page_footer group, so you can drop it before indexing. On a U.S. Census Bureau statistics page with two data tables, the same call returned 581 line boxes, 826 word boxes, two table blocks with their positions and six footnote blocks. By default each table also comes back as HTML; a table it can't parse is marked as such.
request_id, then deleted, and are not used for training. HyperAPI is SOC 2 Type II. Sending the same document again within 24 hours returns the stored result at no charge.Most vendors sell a cheap text mode and a pricier structured mode, and they return different output, so both are listed. Prices are first-tier, pay-as-you-go list prices in USD. See HyperAPI pricing for plans.
| API and mode | What it returns | $ per 1,000 pages |
|---|---|---|
| HyperAPI parse fast | Boxes, typed blocks, heading levels, table HTML, sections | $1.00 |
| HyperAPI parse advanced (Plus plan or higher) | Adds markdown and structured HTML | $50.00 |
| Reducto r-1 mini | Typed blocks, tables, markdown | $1.00 (+$1.00 for per-word boxes) |
| Reducto r-1 | Same, per-word boxes included | $10.00 |
| AWS Textract DetectDocumentText | Text, words and lines | $1.50 |
| Azure Read | Text, words and lines | $1.50 |
| Google Enterprise Document OCR | Text, words and lines | $1.50 |
| LlamaParse Fast | Text, no item-level layout | $1.50 |
| Mistral OCR 4.1 | Markdown, blocks, tables | $4.00 |
| AWS Textract Layout | Typed layout blocks, no tables | $4.00 |
| LlamaParse Cost-effective | Markdown, items with heading levels, tables | $4.50 |
| Extend Parse Light | Markdown, blocks, tables | $5.00 |
| Azure Layout | Roles, sections, tables, markdown | $10.00 |
| Google Layout Parser | Typed nested blocks, tables | $10.00 |
| AWS Textract Tables (Layout included) | Layout blocks and table cells | $15.00 |
| Unstructured | Markdown or typed elements | $15.00 |
| Extend Parse Performance (default engine) | Markdown, blocks, tables | $20.00 |
Volume and batch footnote. These are first-tier rates, and three text modes get cheaper at volume. Azure Read and Textract DetectDocumentText drop to $0.60 per 1,000 pages above 1M pages a month, so for plain text they cost less than HyperAPI fast above about 2.25M pages a month. Google Enterprise Document OCR drops to $0.60 above 5M, which crosses over at about 11.25M.
Batch also lowers some prices: Mistral OCR is $2 per 1,000 pages in batch, and Reducto takes 20% off r-1 and r-1 mini jobs sent through its batch queue (r-1 mini becomes $0.80, before the per-word add-on). Reducto bills its legacy Parse default at $15 to $30 per 1,000 pages until 7 December 2026, so set the model explicitly.
Page counting differs too. A PDF page is one page everywhere, but Azure and Google count each 3,000 characters of a DOCX as a page and each spreadsheet tab as a page, Unstructured counts most non-PDF files per 100 KB, and Extend converts Word and PowerPoint to PDF and bills the pages.
If your files are mostly scans and you only need text, our list of the best PDF OCR software covers that narrower job.
| API | File and page limits | Free tier | Async / batch | Official SDKs |
|---|---|---|---|---|
| HyperAPI | 50 MB per file; advanced parse up to 60 pages per request (Plus plan or higher) | 30 pages a month, 1 request a minute, no card | Batches of up to 1,000 documents | Python (installed from GitHub, not PyPI); any language over REST |
| Reducto | 100 MB (5 GB presigned); no page limit; r-1 mini takes no spreadsheets | $150 of usage, once | Async jobs; batch queue, 20% off | Python, JavaScript, Go (alpha) |
| Mistral OCR | 50 MB, 1,000 pages per file | None for the API | Batch API, 50% off | Python, TypeScript |
| LlamaParse | 512 MB, 10,000 pages; 5 concurrent jobs on pay-as-you-go | 10,000 credits a month | Every parse is a job; Batches on Pro and Enterprise | Python, TypeScript, Go, Java |
| Extend | File size not published; 500 pages in progress | 10,000 credits ($100), once | Async; batches of up to 1,000 files | Python, TypeScript, Java, Go |
| Azure Document Intelligence | 500 MB, 2,000 pages | 500 pages a month; first 2 pages of each file | Always async; batches of up to 10,000 files | .NET, Java, JavaScript, Python |
| Google Document AI | 15 pages online, 500 in batch (Layout Parser); 20 MB online | First 1,000 Enterprise OCR pages; $300 credit for new customers | Online or batch, same price | Eight languages |
| AWS Textract | Sync 10 MB, 1 page; async 500 MB, 3,000 pages; PDF, TIFF, JPEG, PNG only | New AWS customers, 3 months | Async jobs for multi-page files | All AWS SDKs |
| Unstructured | 100 MB per document | 10,000 pages, once | Async with polling | Python, TypeScript |
For structured output per dollar, HyperAPI fast parse: $1 per 1,000 pages for word and line boxes, typed blocks, heading levels, table HTML with positions and sections. For markdown at the lowest price, Reducto r-1 mini ($1, or $0.80 in batch). For plain text above about 2.25M pages a month, Azure Read or Textract.
For structured output, HyperAPI fast and Reducto r-1 mini both list at $1 per 1,000 pages; on Reducto, per-word boxes add $1. Reducto's batch queue takes r-1 mini to $0.80 (before the per-word add-on). For plain text, Azure Read and Textract start at $1.50 and fall to $0.60 above 1M pages a month, and Google Enterprise OCR does the same above 5M.
Mistral OCR, LlamaParse, Reducto, Extend, Azure Layout, Unstructured and HyperAPI advanced parse. Textract returns JSON that its open-source Textractor library can turn into markdown. HyperAPI fast returns JSON, with tables as HTML.
HyperAPI fast (for PDF and image files), Azure, Textract and Google Enterprise OCR return word and line boxes by default. LlamaParse and Extend offer them as options, and Reducto as an add-on on r-1 mini. Mistral OCR returns paragraph-level boxes only.
HyperAPI's free plan gives 30 pages a month with no card. LlamaParse gives 10,000 credits a month and Azure 500 pages a month. Docling is free if you run it yourself.
Prices read on 17 November 2026. Vendors change prices and limits often, so check each vendor's page before you budget.
Want word boxes, heading levels, table HTML and sections at $0.001 a page? Start free with 30 pages a month and no card.