Cohere Parse 5: what it is, how it works, and what it costs

What Cohere Parse 5 actually is

Cohere is the enterprise AI company known for its Command language models, its Embed and Rerank search models, and a heavy focus on private, sovereign deployment. Parse is its entry into document parsing, and Parse 5 (parse-v5.0) is the current version, announced on August 27, 2026 under the line "enterprise document intelligence at scale."

The job it does is narrow and specific: you give it a page, it gives you back structured, machine-readable data. Cohere describes it as going "beyond OCR" because it doesn't just transcribe characters, it understands tables, forms, diagrams, and embedded images, then returns everything as clean Markdown ready for downstream processing. That output is the point. Markdown is what you feed into a search index, a RAG pipeline, or an AI agent.

Under the hood it's a compact model: 2.3 billion parameters, about 4.6GB, with an 8,192-token context, built on Cohere's north-micro-vision-instruct architecture. That small size is deliberate. A 2.3B model is cheap to run and fast to serve, and Cohere leaned into both.

How Parse 5 works

The mechanics are simpler than most parsing stacks, because the model does the heavy lifting in one pass. You send a page image, encoded as a base64 data URI, to the co.parse endpoint on Cohere's v2 API. It returns Markdown by default, or a blocks array if you want each text, table, and image region broken out separately with its coordinates.

A minimal call looks like this:

import base64, cohere

co = cohere.ClientV2("COHERE_API_KEY")

with open("document.png", "rb") as f:
    b64 = base64.b64encode(f.read()).decode("utf-8")

response = co.parse(
    model="parse-v5.0",
    document={"type": "image_url", "image_url": f"data:image/png;base64,{b64}"},
)

for page in response.pages:
    print(page.markdown.content)

A few details worth knowing before you build against it. The docs list PDF, PowerPoint, and JPEG as supported formats, but the live endpoint currently takes images only, a data URI or a remote image URL, so raw PDF uploads aren't wired up yet. Image inputs cap out at 20MB, 50 megapixels, or 200MB decoded. And bounding boxes come back only for tables and images, not for every line of text, which is an intentional choice: the model preserves reading order in the Markdown rather than dumping a cloud of coordinates you'd have to reassemble.

It's stable across nine languages (Arabic, English, French, German, Italian, Japanese, Korean, Portuguese, and Spanish), with zero-shot handling of others at lower accuracy. Cohere trained it on business documents from finance, insurance, and scientific work, which is a tell about who it's for.

The benchmark story: it loses on points, wins on price

Here's the part everyone latched onto. Cohere published a benchmark, ParseBench, that scores parsers on three things: how well they extract tables, how faithfully they reproduce text without omissions or hallucinations, and how well they preserve semantic formatting like strike-throughs and italics. And Cohere's own chart shows Parse 5 sitting behind three larger models.

Publishing a benchmark you don't top is an unusual move, and it's the honest one. Parse 5 is strong on tables and content faithfulness (87.0 and 86.6, close to the frontier models) and weaker on semantic formatting (64.0). It clears the specialist parsers, with what Cohere calls an "over 20-point improvement" on both AWS Textract and Google Document AI. It just isn't the sharpest tool in the shed on raw accuracy.

The argument lives on the second chart. Once you plot score against price, Parse 5 moves into the corner nobody else occupies.

GPT-5.5 and Opus 4.8 score three to five points higher, but they sit way over on the right, at roughly 40 to 50 times the per-page cost. For a one-off contract review, pay for the accuracy. For an ingestion pipeline chewing through a million invoices a month, five points of formatting fidelity is not worth a 40x bill. That's the bet Parse 5 is making, and for high-volume document processing it's a reasonable one.

The enterprise-tech journalist Sean Kerner summed up the mood around the launch:

"Text, document parsing should be a solved problem at this point right? But it's not.. every few weeks there is another option that claims to make it better. This week it's @cohere Parse 5."

Sean Kerner, X

That skepticism is fair. Parsing isn't "solved," and Parse 5 doesn't claim to solve it. It claims to make the cost of doing it at scale a lot lower, which is a narrower and more defensible promise.

Throughput and self-hosting

The other half of the price story is speed. On a single H100 GPU, Parse 5 processes 4.5 pages per second, which works out to 36 pages per second (about 2,160 per minute) on an 8-GPU node. Cohere benchmarked it against open-source parsers served the same way, on vLLM, and it comes out ahead.

Fast throughput on a small model is what makes the economics work when you self-host. And self-hosting is very much Cohere's angle here. Beyond the standard API, Parse 5 runs as a dedicated Model Vault instance, on Microsoft Foundry, on Amazon SageMaker, or fully private and air-gapped, which matters if you're parsing documents you legally can't send to a third-party API. There's also a free demo Space on Hugging Face if you just want to throw a page at it.

Cohere Parse 5 pricing

Parse 5 has two pricing models, and which one you want depends entirely on volume.

The per-page rate is the headline, and at $1.50 per 1,000 pages it's genuinely one of the cheaper hosted options. The dedicated instances are where the savings compound. Cohere's math: at 50% GPU utilization, Model Vault runs 23% cheaper per page than the API, and at full utilization the gap grows to 61%.

Their worked example makes it concrete. An accounts-payable workflow processing ~13 million pages a month on Model Vault instead of the API saves roughly $12,000 a month, or $144,000 a year. Measured against a hyperscaler parser priced at $10 per 1,000 pages, that single workflow saves around $1.47 million annually. Those are Cohere's numbers on Cohere's assumptions, so treat them as a best case, but the direction is real: at high volume, per-page parsing costs add up fast, and a cheaper model is a big lever.

What it can't do

Being honest about the limits is what makes the price argument trustworthy, so here they are. Parse 5 outputs Markdown only, not structured JSON, so if you need a strict schema you're parsing the Markdown yourself downstream. It returns no confidence scores, so you can't automatically flag low-certainty extractions for human review. And it doesn't classify document elements like headers, footers, or font hierarchy. None of these is a dealbreaker for a bulk-ingestion job, but each one is a gap if you were hoping to drop it into a workflow that needs certainty flags or a rigid output shape.

Where Parse 5 fits (and where it doesn't)

This is the part that trips people up, so it's worth being clear. Parse 5 is a parsing layer. It turns pages into text. On its own it doesn't answer a single question. To get from "documents" to "an AI that helps someone," you chain it into a retrieval stack: parse the docs, embed the chunks into vectors, rerank the matches, then hand the best passages to a model to generate a grounded answer. Cohere sells all three pieces, bundled as its Compass platform.

That's a great toolkit if you're a platform team building bespoke document intelligence and you want maximum control over every stage. It's a lot of assembly if your actual goal is something more everyday, like an AI that reads your help center and past tickets and resolves customer questions. In that case you're not really shopping for a parser at all, you're shopping for the finished worker, and building the parse-embed-rerank-generate pipeline yourself is a detour.

The distinction is the same one that separates a car engine from a car. Parse 5 is a very good, very cheap engine. Whether you want to build the rest of the car around it is the real question.

Try eesel for support that just answers

If your interest in a parsing model comes from a support problem, that engine-versus-car gap is exactly the one eesel closes. eesel is an AI teammate platform, and its AI helpdesk teammate is a ready-to-work version of the whole stack: it connects directly to your help center, Confluence, Google Docs, and past tickets, learns from them, and resolves tickets inside Zendesk, Freshdesk, Gorgias, Slack, or a shareable chat link. No parsing pipeline to wire together, no vector database to run.

The part that's hardest to fake is the confidence to turn it on. We've spent years running AI on live support queues, and we've watched a confident-sounding bot quietly give wrong answers, which is why eesel simulates every rollout against your historical tickets first, so you see the resolution rate and the exact replies it would have sent before it touches a real customer. Parse 5 might be a piece of how a team like ours moves documents around. It isn't the teammate. You can try eesel free.