Every comparison of an LLM against a document parser is run on input tokens. Input is the half of the bill the parser already includes, and putting the output back turns the cheapest model on the market from 7.75x cheaper than the going page rate into twice its price.

The price that has not moved since 2022

Cohere put Parse 5 into general availability on August 27, 2026 and priced it, in its own words, at $1.50 per 1,000 pages. The interesting part is not the number. It is that three other companies had already picked it.

We are not claiming a cartel, and there is a duller explanation available. One vendor set an anchor years ago, $0.0015 is a memorable figure, and nobody has had a commercial reason to break it. It is also not a true floor: LlamaParse's Fast tier works out at $1.25 per 1,000 pages, and Azure has a Content Understanding meter at $0.01 per 1,000 pages in a different product line that we could not map onto a comparable call. The convergence of four large vendors on one figure is the fact worth pointing at, not the existence of an absolute minimum.

The contrast is what makes it strange. Token prices are the most volatile numbers in this industry. Anthropic cancelled a scheduled Sonnet 5 increase five days ago and made $2.00 and $10.00 the standard price. Gemini 3.8 Flash sits on an introductory $0.75 that becomes $1.50 on January 1. Against that, the price of reading a page has not moved since before ChatGPT shipped, and the one vendor here that did move it moved it upward: Mistral OCR 4.1 is $4.00 per 1,000 pages, 2.67x the number everyone else picked.

The same page, thirteen prices

$1.50 buys the characters. Everything else you might want from a document is a separate meter, and the meters are not close together. Every row here bills per page, for the same page.

Two structural notes. AWS sells Layout on its own at $4.00 and then gives it away free with any combination of Forms, Tables and Queries, so the standalone price is a trap for anyone buying one feature who was always going to buy two. Azure has no standalone layout meter at all: layout is inside the $10.00 prebuilt bundle alongside receipts, invoices and W-2s. Same capability, opposite packaging, and a 2.5x difference in what it costs to get it.

One number we have left out of the table on purpose. Azure's retail price feed still returns a meter called S0 Query Pages at $200.00 per 1,000 pages, effective March 2023, alongside a Query Fields meter at $10.00 effective November 2024. They are 20x apart, the older one is presumably superseded, and Microsoft does not say so anywhere we could find. Printing $200.00 as a live price would have made the spread look like 133x. We think the honest number is 46.67x.

The comparison everyone runs, and why it is wrong

Here is the calculation you see in every thread on this. Take a model's input price, multiply by the tokens a page costs, compare against $1.50. Anthropic documents 1,500 to 3,000 tokens a page. Google documents 258 on one page of its docs and 560 on another, which we come back to below.

Two rows deserve a pause. Claude Haiku 4.5 at Anthropic's lower bound of 1,500 tokens costs $1.50 per 1,000 pages, which is the going page rate to the cent, and we did not engineer that: it falls out of $1.00 per million times 1,500. And GPT-6 Astra cannot go in this table at all. OpenAI publishes a patch formula for images and says plainly that PDFs are sent as extracted text and page images together, but it publishes no tokens-per-page figure and Astra appears in none of its own image multiplier or sizing tables. The most expensive frontier model on the market is the one you cannot cost per page from published numbers.

Now the part that breaks the comparison. Every figure above is input only. When you pay Cohere $0.0015 you get Markdown back and the price is finished. When you pay Gemini $0.19 per 1,000 pages of input, you have paid the model to look at the page and nothing else. The Markdown is output, and output is where these models make their money.

That table rests on an assumption we have to own: 750 tokens of Markdown per parsed page. No vendor publishes this figure. Not Cohere, not Google, not Anthropic, not Mistral, not Reducto, not LlamaIndex. We picked 750 because a moderately dense page of prose runs about 500 to 800 words and its Markdown lands near there. If your pages are sparse forms the number is lower and the models look better. If they are dense tables, which Cohere returns as inline HTML, it is higher and they look worse.

The direction does not depend on the assumption. Output is priced at 5x input on Gemini 3.8 Flash, on Haiku 4.5, on Sonnet 5 and on Opus 5. Any output at all moves every model up, and the model with the cheapest input has the least room to absorb it. Gemini 3.8 Flash needs about 348 tokens of output per page before it stops being cheaper than $1.50, and only 288 on Google's higher page figure. That is roughly 260 words of Markdown, which is less than half of a dense page.

Two vendor-specific wrinkles push in opposite directions here. Google states that you are not charged for tokens from text it extracts natively out of a PDF, so a clean text-layer PDF can cost less than either of its published page figures implies, by an amount Google never quantifies. OpenAI does the reverse and bills the extracted text and the page images together. And on GPT-5.6 and later the PDF detail setting defaults to high where earlier models defaulted to low, which is a real cost increase that arrives simply by changing model.

One hundred thousand pages, priced twelve ways

A backlog scan is the job people actually have. Here is one, at 100,000 pages, across every meter above. The two output-inclusive rows carry the 750-token assumption and nothing else does.

The distance between the cheapest and dearest row is $6,875.00 on the same 100,000 pages, and most of it is settled before anyone picks a vendor, by which verb got chosen. Reading text and extracting form fields are different products at a 33x ratio, and a fair amount of what gets called document AI in a planning meeting is somebody specifying the second when they needed the first.

Cohere's own benchmark has a price axis it cannot resolve

Cohere published ParseBench results with Parse 5 in fourth place, behind three frontier LLMs and ahead of every dedicated parser. Its framing is that it loses on points and wins on cost per page, which is an unusually candid thing for a launch post to say. Here is that table with a price column added, and the price column is where it comes apart.

Cohere presents this as a Pareto chart of performance against price in dollars per 1,000 pages, and it prices AWS Textract at $10.00. Textract's own page prices Detect Document Text at $1.50 per 1,000, the identical number Cohere charges. We could not find any Textract meter at exactly $10.00; the nearest are Tables above one million pages and the Azure prebuilt bundle, neither of which is Textract's base OCR. If the intended row was Analyze Document, the figure should be $15.00 or $50.00. Either way the cost axis behind the price-performance claim does not match the competitor's published rate card, and it is the axis the whole argument rests on.

The rest of that column has a subtler problem. Three of the bottom four rows name a product rather than a SKU. Azure Document Intelligence is nine meters from $1.50 to $30.00. Google Document AI runs from free to $30.00 across a dozen processors. AWS Textract is eleven APIs from $1.50 to $70.00 that stack when combined. Scoring Textract at 53.3 is a fact about whichever API Cohere called, and the post does not say which. That is why we did not compute a cost-per-point figure for any competitor: there is no single price to divide by.

The three LLM rows have a different issue: all three are a generation old. GPT-5.5 has been succeeded by GPT-6 Astra, Opus 4.8 by Opus 5, Gemini 3.5 Flash by 3.6, 3.7 and 3.8. That is not really a criticism, since a benchmark run has to freeze somewhere and these models shipped within the last six weeks, but it does mean the claim that Parse is only bettered by the frontier LLMs is measured against models that are no longer the frontier. Cohere also states plainly that the evaluation tested neither charts nor visual grounding.

Nobody will tell you what a page is

If the meter is a page, the definition of a page is the entire contract. Here is what each vendor publishes.

Google is the only one treating this as a pricing question rather than a documentation afterthought, and its answers are not guessable: a spreadsheet tab is a page, a slide is a page, and 3,000 characters of a Word document is a page. On a long DOCX that rule alone decides the bill. Cohere publishes nothing, which means a sparse scanned receipt and a dense multi-column financial table both cost $0.0015. For most buyers that is good news and it deserves saying: it is a flat rate on a task whose difficulty varies enormously. Databricks is the one vendor that went the other way and prices a page by how hard it is, from around 10 DBU per thousand simple pages to 90 for engineering diagrams.

There is also a live contradiction inside Cohere's own documentation. The Parse model page lists PDF, PPT and JPEG as supported file types. The API reference, on the same site, says the endpoint currently accepts image URLs only and that PDF and file URL inputs are not yet supported. Both pages are up today. If the reference is the operative one, you are rasterising the PDF yourself, which means the number of images you send is the number of pages you are billed for. You define the page. That is either reassuring or alarming depending on how your pipeline handles a fold-out engineering drawing.

One more oddity worth recording. Cohere's canonical explanation of how its pricing works describes three bases: tokens for generation, quantity of searches for Rerank, and tokens embedded. It does not mention Parse or per-page billing at all. The company is running a meter its own pricing documentation has not been updated to describe, and the $1.50 on the pricing page itself is rendered client-side from a data blob where the unit field has to be explicitly overridden from 1M tokens to 1K pages.

Google cannot agree with itself about a PDF page

Every token-based estimate in this post depends on tokens per page, and for Google that input is broken. One live page of Google's documentation says each document page is equivalent to 258 tokens. Another live page, in a table headed for Gemini 3 models, gives 560 tokens for a PDF page by default, 280 at low media resolution and 1,120 at high. Neither page cross-references the other, and neither scopes itself to a model generation in a way that would let both be true. The string 258 does not appear on the second page at all.

The two figures are 2.17x apart, which is why Gemini appears twice in the tables above rather than once. Our guess is that 258 is leftover Gemini 2.5 text, but Google states that nowhere and we are not going to promote a guess to a fact in a table. The same split exists for images: one page says 258 tokens per 768-pixel tile, another gives a flat 1,120 for a Gemini 3 image. Anthropic is the only vendor here publishing a current, non-contradicted tokens-per-page range, and it is 1,500 to 3,000.

While we were in there: Anthropic's old width times height over 750 formula is gone. The current rule is 28-pixel patches, so an image costs the ceiling of width over 28 times the ceiling of height over 28 visual tokens. Any secondary source still quoting the /750 formula is stale, and there are a lot of them.

The tooling cannot see this meter, ours included

LiteLLM's pricing dataset is the closest thing this industry has to a shared price list, and it carries twenty rows whose mode is OCR. Cohere Parse 5 is one of them. Its input cost per token is null. Its output cost per token is null. The row exists and has nowhere to put the headline price, because the schema was built for tokens and this product is not sold in tokens. The per-page figure lives in a separate field most consumers of that file never read.

We are in no position to be smug. TokenCost ingests that same dataset and drops any row lacking both a token input and a token output price, so Parse 5 has been invisible to our own catalogue since the day it shipped. Every model on this site is a model somebody prices per token, and that is a property of our plumbing rather than a judgement about what is worth comparing. This post is the first time a page meter has appeared on TokenCost at all, and it got here by being typed in by hand.

Since we were in that file anyway, a warning about it. The same dataset carries Mistral model IDs that Mistral does not sell. Rows for mistral-vibe-cli-latest, mistral-vibe-cli-fast and mistral-code-latest appear with plausible-looking rates, and none of those IDs exists on any Mistral page. The rates are real numbers borrowed from Mistral Medium 3.5, Mistral Small 4 and Codestral, and one row carries the card of Devstral 2, which Mistral retired on July 31. Aggregated pricing data is a convenience, not a source. In one week it invented three models and kept a dead one.

What we would actually do

Pick the verb before the vendor. If you need the characters off the page and nothing more, the market has settled on $1.50 per 1,000 pages and four companies will sell it to you at that price, so choose on latency, region, and whether you can tolerate a vendor that will not define a page. If you need form fields you are shopping in an aisle 33x more expensive, and there the choice actually matters.

Reach for an LLM when you want something a parser will not give you: judgement about the content, a schema of your own, an answer instead of a transcript. Do not reach for one because a per-token estimate came in under $1.50, because that estimate almost certainly counted input only, and about 348 tokens of output on the cheapest model available is the entire margin. And if you are budgeting into next year, note which side of the trade has a scheduled increase: Gemini 3.8 Flash doubles on January 1, while $1.50 a thousand pages has survived four and a half years and four independent pricing decisions.