> ## Documentation Index
> Fetch the complete documentation index at: https://usefulai.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Best Document OCR & Parsing Models in 2026

export const models = [{
  rank: 1,
  name: "LlamaParse",
  dev: "LlamaIndex",
  icon: "/images/icons/llamaindex.ai.png",
  url: "https://www.llamaindex.ai/llamaparse",
  bestFor: "Agentic parsing for RAG",
  score: "100",
  price: "$12.50 / 1K pages",
  license: "Proprietary",
  custom: "Specialized parser",
  customLabel: "Parser type"
}, {
  rank: 2,
  name: "KDL-Frontier-Parser-nano",
  dev: "KoreaDeep / KDLAI",
  icon: "/images/icons/huggingface.co.png",
  url: "https://huggingface.co/KDLAI/KDL-Frontier-Parser-nano",
  bestFor: "Open-weight visual grounding",
  score: "88",
  price: "Self-hosted",
  license: "Open weight",
  custom: "Open-weight VLM",
  customLabel: "Parser type"
}, {
  rank: 3,
  name: "Gemini 3 Flash",
  dev: "Google",
  icon: "/images/icons/google.com.png",
  url: "https://ai.google.dev/gemini-api/docs/gemini-3",
  bestFor: "Fast general-purpose parsing",
  score: "86",
  price: "$24.10 / 1K pages",
  license: "Proprietary",
  custom: "VLM API",
  customLabel: "Parser type"
}, {
  rank: 4,
  name: "Infinity-Parser2-Pro",
  dev: "infly",
  icon: "/images/icons/huggingface.co.png",
  url: "https://huggingface.co/infly/Infinity-Parser2-Pro",
  bestFor: "Highest-accuracy open weights",
  score: "85",
  price: "Self-hosted",
  license: "Open weight",
  custom: "Open-weight VLM",
  customLabel: "Parser type"
}, {
  rank: 5,
  name: "Reducto",
  dev: "Reducto",
  icon: "/images/icons/reducto.ai.png",
  url: "https://reducto.ai/",
  bestFor: "Auditable enterprise extraction",
  score: "83",
  price: "$47.60 / 1K pages",
  license: "Proprietary",
  custom: "Specialized parser",
  customLabel: "Parser type"
}, {
  rank: 6,
  name: "MinerU2.5-Pro",
  dev: "OpenDataLab",
  icon: "/images/icons/opendatalab.com.png",
  url: "https://huggingface.co/opendatalab/MinerU2.5-Pro-2605-1.2B",
  bestFor: "Local technical-document parsing",
  score: "83",
  price: "Self-hosted",
  license: "Open weight",
  custom: "Open-weight VLM",
  customLabel: "Parser type"
}, {
  rank: 7,
  name: "Claude Fable 5",
  dev: "Anthropic",
  icon: "/images/icons/anthropic.com.png",
  url: "https://www.anthropic.com/news/claude-fable-5-mythos-5",
  bestFor: "Reasoning-heavy extraction",
  score: "80",
  price: "$156.00 / 1K pages",
  license: "Proprietary",
  custom: "VLM API",
  customLabel: "Parser type"
}, {
  rank: 8,
  name: "Chandra OCR 2",
  dev: "Datalab",
  icon: "/images/icons/datalab.to.png",
  url: "https://huggingface.co/datalab-to/chandra-ocr-2",
  bestFor: "Tables, forms, and handwriting",
  score: "79",
  price: "Self-hosted",
  license: "Open weight",
  custom: "Open-weight VLM",
  customLabel: "Parser type"
}, {
  rank: 9,
  name: "Datalab Parser",
  dev: "Datalab",
  icon: "/images/icons/datalab.to.png",
  url: "https://documentation.datalab.to/",
  bestFor: "Low-cost hosted parsing",
  score: "79",
  price: "$10.00 / 1K pages",
  license: "Proprietary",
  custom: "Specialized parser",
  customLabel: "Parser type"
}, {
  rank: 10,
  name: "Mistral OCR 4",
  dev: "Mistral AI",
  icon: "/images/icons/mistral.ai.png",
  url: "https://docs.mistral.ai/capabilities/document_ai/ocr/",
  bestFor: "High-volume OCR at scale",
  score: "76",
  price: "$5.00 / 1K pages",
  license: "Proprietary",
  custom: "Cloud OCR API",
  customLabel: "Parser type"
}, {
  rank: 11,
  name: "GPT-5.5",
  dev: "OpenAI",
  icon: "/images/icons/openai.com.png",
  url: "https://developers.openai.com/api/docs/models/gpt-5.5",
  bestFor: "Versatile document reasoning",
  score: "76",
  price: "$130.90 / 1K pages",
  license: "Proprietary",
  custom: "VLM API",
  customLabel: "Parser type"
}, {
  rank: 12,
  name: "PaddleOCR-VL",
  dev: "Baidu / PaddlePaddle",
  icon: "/images/icons/baidu.com.png",
  url: "https://huggingface.co/PaddlePaddle/PaddleOCR-VL-1.6",
  bestFor: "Multilingual local parsing",
  score: "75",
  price: "Self-hosted",
  license: "Open weight",
  custom: "Open-weight VLM",
  customLabel: "Parser type"
}, {
  rank: 13,
  name: "Surya OCR 2",
  dev: "Datalab",
  icon: "/images/icons/datalab.to.png",
  url: "https://huggingface.co/datalab-to/surya-ocr-2",
  bestFor: "Lightweight local OCR",
  score: "71",
  price: "Self-hosted",
  license: "Open weight",
  custom: "Open-weight VLM",
  customLabel: "Parser type"
}, {
  rank: 14,
  name: "Azure Document Intelligence",
  dev: "Microsoft",
  icon: "/images/icons/microsoft.com.png",
  url: "https://azure.microsoft.com/en-us/products/ai-services/ai-document-intelligence",
  bestFor: "Prebuilt form extraction",
  score: "64",
  price: "$10.00 / 1K pages",
  license: "Proprietary",
  custom: "Cloud OCR API",
  customLabel: "Parser type"
}, {
  rank: 15,
  name: "AWS Textract",
  dev: "Amazon Web Services",
  icon: "/images/icons/aws.amazon.com.png",
  url: "https://aws.amazon.com/textract/",
  bestFor: "Forms and table extraction",
  score: "47",
  price: "$15.00 / 1K pages",
  license: "Proprietary",
  custom: "Cloud OCR API",
  customLabel: "Parser type"
}];

export const Fav = ({icon, size = "h-4 w-4"}) => <img src={icon} alt="" noZoom className={"relative -top-px mr-1 inline rounded-sm object-contain " + size} />;

export const LicenseBadge = ({license}) => license === "Open weight" ? <span className="inline-flex items-center rounded bg-emerald-50 px-1.5 py-[2px] text-xs font-medium leading-4 text-emerald-700 dark:bg-emerald-500/10 dark:text-emerald-400">Open weight</span> : <span className="inline-flex items-center rounded bg-zinc-100 px-1.5 py-[2px] text-xs font-medium leading-4 text-zinc-600 dark:bg-white/10 dark:text-zinc-300">Proprietary</span>;

export const BestForChip = ({children}) => <span className="inline-flex min-w-0 max-w-full items-center rounded bg-sky-50 px-1.5 py-[2px] dark:bg-sky-500/10">
    <span className="truncate text-xs font-medium leading-4 text-sky-700 dark:text-sky-400">{children}</span>
  </span>;

export const HeaderTip = ({label, tip}) => <span className="inline-flex items-center gap-1.5">
    <span>{label}</span>
    <Tooltip tip={tip}>
      <span className="relative top-0.5 inline-flex cursor-pointer text-zinc-500 transition-opacity hover:opacity-70 dark:text-zinc-400">
        <Icon icon="circle-info" size={12} color="currentColor" />
        <span className="sr-only">About {label.toLowerCase()}</span>
      </span>
    </Tooltip>
  </span>;

export const ModelCard = ({model, children}) => <section className="not-prose my-5 rounded-lg border border-zinc-200 bg-white p-5 shadow-sm dark:border-white/10 dark:bg-white/[0.03]">
    <div className="mb-3"><BestForChip>{model.bestFor}</BestForChip></div>
    <div className="flex items-center gap-3">
      <img src={model.icon} alt={model.dev + " logo"} noZoom className="h-10 w-10 shrink-0 rounded-lg object-contain" />
      <div className="min-w-0 flex-1">
        <h2 className="m-0 max-w-full text-xl font-semibold leading-7 tracking-normal">
          <a href={model.url} target="_blank" rel="noreferrer" className="group inline-flex min-w-0 max-w-full items-center gap-1.5 no-underline text-zinc-950 dark:text-white">
            <span className="min-w-0 break-words"><span className="underline-offset-4 group-hover:underline group-focus-visible:underline">{model.name}</span> <span className="font-normal text-zinc-500 dark:text-zinc-400">({model.dev})</span></span>
            <span aria-hidden="true" className="flex shrink-0 text-zinc-400 transition-colors group-hover:text-zinc-900 group-focus-visible:text-zinc-900 dark:text-zinc-500 dark:group-hover:text-white dark:group-focus-visible:text-white"><Icon icon="arrow-up-right" size={12} color="currentColor" /></span>
          </a>
        </h2>
        <div className="mt-1 flex flex-wrap items-center gap-x-2 gap-y-1 text-[13px] leading-5 uai-ink-muted">
          <LicenseBadge license={model.license} />
          <span aria-hidden="true">∙</span>
          <span>Score <span className="tabular-nums text-zinc-950 dark:text-white">{model.score}</span></span>
          <span aria-hidden="true">∙</span>
          <span>Price <span className="tabular-nums text-zinc-950 dark:text-white">{model.price}</span></span>
          {model.custom && <><span aria-hidden="true">∙</span><span>{model.customLabel} <span className="tabular-nums text-zinc-950 dark:text-white">{model.custom}</span></span></>}
        </div>
      </div>
    </div>
    {children}
  </section>;

export const Take = ({children}) => <div className="not-prose mt-4 text-sm leading-[22px] text-zinc-700 dark:text-zinc-300">{children}</div>;

export const ST = ({label, children}) => <div className="not-prose mt-4">
    <div className="text-sm font-semibold text-zinc-950 dark:text-white">{label}</div>
    <div className="mt-1 flex flex-col gap-2.5 text-sm leading-[22px] text-zinc-700 dark:text-zinc-300">{children}</div>
  </div>;

export const AccessBullets = ({rows}) => <div className="not-prose mt-4 text-sm leading-[22px] text-zinc-700 dark:text-zinc-300">
    <div className="font-semibold text-zinc-950 dark:text-white">How to access</div>
    <div className="mt-1.5 flex flex-col gap-1.5">
      {rows.map(([key, body]) => <span key={key} className="flex items-baseline gap-2.5"><span aria-hidden="true" className="relative -top-0.5 inline-block h-1.5 w-1.5 shrink-0 rounded-full bg-zinc-700 dark:bg-zinc-300" /><span><span className="font-semibold text-zinc-950 dark:text-white">{key}</span> — {body}</span></span>)}
    </div>
  </div>;

export const Alt = ({icon, name, dev, url, children}) => <span className="flex items-baseline gap-2.5">
    <span aria-hidden="true" className="relative -top-0.5 inline-block h-1.5 w-1.5 shrink-0 rounded-full bg-zinc-300 dark:bg-zinc-600" />
    <span><Fav icon={icon} /><a href={url} target="_blank" rel="noreferrer" className="font-medium text-zinc-950 underline underline-offset-2 dark:text-white">{name}</a> <span className="uai-ink-muted">({dev})</span> — {children}</span>
  </span>;

<div className="not-prose -mt-2 mb-8 flex flex-wrap items-center gap-x-2 text-sm text-zinc-800 dark:text-zinc-200 lg:-mt-5" style={{ paddingLeft: "2px" }}>
  <span className="inline-flex items-center gap-1.5"><Icon icon="clock-rotate-left" size={10} color="currentColor" /> Updated <time dateTime="2026-07-12">July 12, 2026</time></span>
</div>

Document OCR and parsing models turn PDFs, scans, and images into clean, structured text software can use. The catch: a model can nail clean invoices and fall apart on dense tables or handwriting. The 15 picks below are ordered by normalized ParseBench score and practical access tradeoffs.

## Best Document OCR & Parsing Models

<div className="uai-overview-breakout not-prose my-5">
  <input type="checkbox" id="models-more" className="fy-more-toggle sr-only" aria-label={"Show all 15 document ocr & parsing models"} />

  <div className="fy-more-table overflow-x-auto rounded-lg border border-zinc-200 bg-white dark:border-white/10 dark:bg-white/[0.03]">
    <div className="table text-sm" style={{ width: "100%" }}>
      <div className="table-header-group bg-zinc-50/60 dark:bg-white/[0.02]">
        <div className="table-row">
          <span className="table-cell whitespace-nowrap px-4 py-2.5 text-left text-[13px] font-medium leading-5 text-zinc-500 dark:text-zinc-400">#</span>
          <span className="table-cell whitespace-nowrap px-4 py-2.5 text-left text-[13px] font-medium leading-5 text-zinc-500 dark:text-zinc-400">Model</span>
          <span className="table-cell whitespace-nowrap px-4 py-2.5 text-left text-[13px] font-medium leading-5 text-zinc-500 dark:text-zinc-400">Best for</span>

          <span className="table-cell whitespace-nowrap px-4 py-2.5 text-right text-[13px] font-medium leading-5 text-zinc-500 dark:text-zinc-400">
            <HeaderTip label="Score" tip={"UsefulAI's 0-100 document score is normalized from ParseBench Overall across the extracted leaderboard. Higher is better."} />
          </span>

          <span className="table-cell whitespace-nowrap px-4 py-2.5 text-right text-[13px] font-medium leading-5 text-zinc-500 dark:text-zinc-400">
            <HeaderTip label="Price" tip={"Comparable USD per 1,000 processed pages. Modes, page complexity, subscriptions, and feature charges can change the real cost."} />
          </span>

          <span className="table-cell whitespace-nowrap px-4 py-2.5 text-left text-[13px] font-medium leading-5 text-zinc-500 dark:text-zinc-400">
            <HeaderTip label="License" tip="Proprietary means no public model weights. Open weight means weights are available, though exact licenses and commercial-use terms vary." />
          </span>

          <span className="table-cell whitespace-nowrap px-4 py-2.5 text-left text-[13px] font-medium leading-5 text-zinc-500 dark:text-zinc-400">
            <HeaderTip label={"Parser type"} tip={"Whether the entry is a specialized parser, VLM API, open-weight VLM, cloud OCR API, or local parser."} />
          </span>
        </div>
      </div>

      <div className="table-row-group">
        {models.map((model, index) => (
                        <a key={model.name} href={model.url} target="_blank" rel="noreferrer" className={"table-row no-underline transition-colors hover:bg-zinc-50/60 dark:hover:bg-white/[0.02]" + (models.length > 9 && index >= 7 ? " fy-more-row" : "")}>
                          <span className="table-cell w-8 whitespace-nowrap border-t border-zinc-100 px-4 py-3 align-middle text-[13px] tabular-nums dark:border-white/5"><span className="sr-only">Rank </span><span className="uai-ink-muted">{model.rank}</span></span>
                          <span className="table-cell whitespace-nowrap border-t border-zinc-100 px-4 py-3 align-middle dark:border-white/5"><span className="flex items-center gap-2.5"><Fav icon={model.icon} /><span className="text-sm font-semibold leading-5 text-zinc-950 dark:text-white">{model.name}</span></span></span>
                          <span className="table-cell whitespace-nowrap border-t border-zinc-100 px-4 py-3 align-middle text-[13px] leading-5 text-zinc-950 dark:border-white/5 dark:text-white"><span className="sr-only">Best for: </span>{model.bestFor}</span>
                          <span className="table-cell whitespace-nowrap border-t border-zinc-100 px-4 py-3 text-right align-middle text-[13px] leading-5 tabular-nums text-zinc-950 dark:border-white/5 dark:text-white"><span className="sr-only">Score: </span>{model.score}</span>
                          <span className="table-cell whitespace-nowrap border-t border-zinc-100 px-4 py-3 text-right align-middle text-[13px] leading-5 tabular-nums dark:border-white/5"><span className="sr-only">Price: </span><span className="uai-ink-muted">{model.price}</span></span>
                          <span className="table-cell whitespace-nowrap border-t border-zinc-100 px-4 py-3 align-middle dark:border-white/5"><span className="sr-only">License: </span><LicenseBadge license={model.license} /></span>
                          <span className="table-cell whitespace-nowrap border-t border-zinc-100 px-4 py-3 align-middle text-[13px] leading-5 text-zinc-950 dark:border-white/5 dark:text-white"><span className="sr-only">Parser type: </span>{model.custom}</span>
                        </a>
                      ))}
      </div>
    </div>
  </div>

  {models.length > 9 && <div className="fy-more-pill mt-3 flex justify-center">
      <label htmlFor="models-more" className="inline-flex cursor-pointer items-center gap-1.5 rounded-full border border-zinc-200 px-4 py-1.5 text-[13px] font-medium text-zinc-600 transition-colors hover:text-zinc-900 dark:border-white/15 dark:text-zinc-300 dark:hover:text-white">
        <span className="fy-more-open inline-flex items-center gap-1.5">Show {models.length - 7} more <Icon icon="chevron-down" size={13} /></span>
        <span className="fy-more-close items-center gap-1.5">Show less <Icon icon="chevron-up" size={13} /></span>
      </label>
    </div>}
</div>

***

<ModelCard model={models[0]}>
  <Take>The strongest all-round parser here, turning messy PDFs into clean, RAG-ready Markdown that holds structure where cheaper tools quietly drop it.</Take>

  <ST label="Strengths:">
    <div>Its agentic mode runs multi-step vision reasoning to rebuild tables, charts, and multi-column layouts into clean Markdown ready for a RAG pipeline.</div>
    <div>On dense enterprise pages it holds structure where lighter parsers drop rows or scramble reading order, which makes it a dependable default.</div>
  </ST>

  <ST label="Tradeoffs:">
    <div>Even the best parsers still omit or hallucinate content on a small share of pages, so high-stakes fields need a verification pass.</div>
    <div>The top mode is pricey per page, and if you want field-level citations for audit, Reducto is built more directly for that.</div>
  </ST>

  <AccessBullets
    rows={[
["App", <span>Available in <a href="https://cloud.llamaindex.ai/" target="_blank" rel="noreferrer" className="underline underline-offset-2">LlamaCloud</a>.</span>],
["API", <span>Accessible via <a href="https://developers.llamaindex.ai/llamaparse/" target="_blank" rel="noreferrer" className="underline underline-offset-2">LlamaParse API</a>.</span>],
]}
  />
</ModelCard>

<ModelCard model={models[1]}>
  <Take>The open-weight parser to beat when you need precise on-page coordinates, not just clean text, and you have a GPU to run it.</Take>

  <ST label="Strengths:">
    <div>It excels at visual grounding, locating exactly where each element sits on the page, which matters when you need to link extracted values back to their source region for review or highlighting.</div>
    <div>As a compact open-weight model, it gives self-hosting teams frontier-level structure without sending documents to anyone else.</div>
  </ST>

  <ST label="Tradeoffs:">
    <div>You need a high-end GPU and your own serving stack, so it is not a drop-in API.</div>
    <div>General VLMs like Gemini 3 Flash are easier to call, and if you want self-hosting on lighter hardware, MinerU2.5-Pro is the easier route.</div>
  </ST>

  <AccessBullets
    rows={[
["Run locally", <span>If you have a high-end machine, you can run it with <a href="https://docs.vllm.ai/" target="_blank" rel="noreferrer" className="underline underline-offset-2">vLLM</a> after downloading weights from <a href="https://huggingface.co/KDLAI/KDL-Frontier-Parser-nano" target="_blank" rel="noreferrer" className="underline underline-offset-2">Hugging Face</a>.</span>],
]}
  />
</ModelCard>

<ModelCard model={models[2]}>
  <Take>The most capable general VLM for parsing at speed - not a purpose-built parser, but fast, cheap enough for volume, and rarely embarrassing.</Take>

  <ST label="Strengths:">
    <div>A strong all-purpose route when you want parsing plus reasoning in one call: ask questions, extract fields, and summarize in the same request.</div>
    <div>Its very large context handles long documents in one pass, and you can dial visual detail up or down to trade accuracy against cost per page.</div>
  </ST>

  <ST label="Tradeoffs:">
    <div>As a general model it trails purpose-built parsers on the hardest tables and dense layouts, where LlamaParse and Reducto pull ahead.</div>
    <div>For steady structured extraction at volume, a dedicated OCR API like Mistral OCR 4 can be more predictable and cheaper.</div>
  </ST>

  <AccessBullets
    rows={[
["API", <span>Accessible via <a href="https://ai.google.dev/gemini-api/docs/document-processing" target="_blank" rel="noreferrer" className="underline underline-offset-2">Gemini API</a>.</span>],
]}
  />
</ModelCard>

<ModelCard model={models[3]}>
  <Take>The open-weight pick when raw parsing accuracy matters most, especially across English and Chinese documents, if you can host it yourself.</Take>

  <ST label="Strengths:">
    <div>Reinforcement-tuned specifically for parsing, it is one of the most accurate open-weight models for tables, formulas, and reading order, and it handles English and Chinese documents equally well.</div>
    <div>Self-hosting keeps sensitive files in-house, and a lighter Flash variant trades some accuracy for faster throughput when you need it.</div>
  </ST>

  <ST label="Tradeoffs:">
    <div>It wants a high-end GPU and hands-on serving, so it is not a fast start for small teams.</div>
    <div>If you want self-hosting on modest hardware, MinerU2.5-Pro or PaddleOCR-VL run more easily; skip it entirely if you would rather not host a model at all.</div>
  </ST>

  <AccessBullets
    rows={[
["Run locally", <span>If you have a high-end machine, you can run it with <a href="https://docs.vllm.ai/" target="_blank" rel="noreferrer" className="underline underline-offset-2">vLLM</a> or <a href="https://docs.docker.com/model-runner/" target="_blank" rel="noreferrer" className="underline underline-offset-2">Docker Model Runner</a> after downloading weights from <a href="https://huggingface.co/infly/Infinity-Parser2-Pro" target="_blank" rel="noreferrer" className="underline underline-offset-2">Hugging Face</a>.</span>],
]}
  />
</ModelCard>

<ModelCard model={models[4]}>
  <Take>Built for regulated, high-stakes extraction where every value needs a citation, and the safe choice when a wrong field has real consequences.</Take>

  <ST label="Strengths:">
    <div>It re-examines low-confidence regions and returns bounding boxes, per-field citations, and confidence scores, so a reviewer can trace every extracted value back to the page.</div>
    <div>That auditability, plus on-prem deployment and strong compliance support, makes it a natural fit for finance, insurance, and healthcare workflows.</div>
  </ST>

  <ST label="Tradeoffs:">
    <div>It is among the priciest options per page, so it is overkill for casual or low-stakes parsing.</div>
    <div>For clean Markdown to feed a RAG pipeline, LlamaParse scores higher for less money, and general VLMs cost far less when you do not need citations.</div>
  </ST>

  <AccessBullets
    rows={[
["App", <span>Available in <a href="https://reducto.ai/" target="_blank" rel="noreferrer" className="underline underline-offset-2">Reducto</a>.</span>],
["API", <span>Accessible via <a href="https://docs.reducto.ai/api-reference/parse" target="_blank" rel="noreferrer" className="underline underline-offset-2">Reducto API</a>.</span>],
]}
  />
</ModelCard>

<ModelCard model={models[5]}>
  <Take>The best open-weight parser you can actually run on normal hardware, and a standout on dense academic and technical documents.</Take>

  <ST label="Strengths:">
    <div>A compact model that punches well above its size on scientific and technical PDFs, where formulas, nested tables, and multi-column layouts come through cleanly.</div>
    <div>Because it runs on a typical machine through the MinerU toolkit, you get strong parsing offline, with no per-page fees and nothing leaving your device.</div>
  </ST>

  <ST label="Tradeoffs:">
    <div>It is a self-hosted toolkit, not a managed API, so you own setup, updates, and scaling.</div>
    <div>For hands-off parsing, LlamaParse or Mistral OCR 4 are simpler, and for the very hardest enterprise layouts the top hosted parsers still hold an edge.</div>
  </ST>

  <AccessBullets
    rows={[
["Run locally", <span>You can run it locally with <a href="https://github.com/opendatalab/MinerU" target="_blank" rel="noreferrer" className="underline underline-offset-2">MinerU</a> after downloading weights from <a href="https://huggingface.co/opendatalab/MinerU2.5-Pro-2605-1.2B" target="_blank" rel="noreferrer" className="underline underline-offset-2">Hugging Face</a>.</span>],
]}
  />
</ModelCard>

<ModelCard model={models[6]}>
  <Take>Reach for it when parsing bleeds into judgment: reading a document, reasoning over it, and extracting structured answers in one step.</Take>

  <ST label="Strengths:">
    <div>Its strength is document understanding, not just transcription. It follows complex instructions, reasons across pages, and returns structured output that reflects what the document means, not only what it says.</div>
    <div>For messy, ambiguous documents that need interpretation rather than literal extraction, it is unusually reliable.</div>
  </ST>

  <ST label="Tradeoffs:">
    <div>It is one of the most expensive options here and is a general model, not a dedicated parser, so for high-volume plain OCR it is hard to justify.</div>
    <div>For pure layout and table extraction, LlamaParse and Mistral OCR 4 do more per dollar.</div>
  </ST>

  <AccessBullets
    rows={[
["App", <span>Available in <a href="https://claude.ai/" target="_blank" rel="noreferrer" className="underline underline-offset-2">Claude</a>.</span>],
["API", <span>Accessible via <a href="https://docs.anthropic.com/en/api/overview" target="_blank" rel="noreferrer" className="underline underline-offset-2">Anthropic API</a>.</span>],
]}
  />
</ModelCard>

<ModelCard model={models[7]}>
  <Take>A top open-weight OCR model for the ugly stuff - complex tables, dense forms, and handwriting - with a hosted option if you skip self-hosting.</Take>

  <ST label="Strengths:">
    <div>It handles the documents that break simpler OCR: intricate tables, structured forms, and handwriting, all while preserving full page layout.</div>
    <div>Rare among open-weight models, it stays competitive with proprietary parsers, which makes it a strong choice when you want frontier-level extraction without a closed API.</div>
  </ST>

  <ST label="Tradeoffs:">
    <div>Running the weights yourself needs a high-end GPU, so the hosted route is realistic for most teams.</div>
    <div>On clean printed text it is close to lighter models like Surya OCR 2 that run on far less hardware, so save it for genuinely hard pages.</div>
  </ST>

  <AccessBullets
    rows={[
["App", <span>Available in <a href="https://www.datalab.to/platform" target="_blank" rel="noreferrer" className="underline underline-offset-2">Datalab</a>.</span>],
["API", <span>Accessible via <a href="https://documentation.datalab.to/" target="_blank" rel="noreferrer" className="underline underline-offset-2">Datalab API</a>.</span>],
["Run locally", <span>If you have a high-end machine, you can run it with <a href="https://github.com/datalab-to/chandra" target="_blank" rel="noreferrer" className="underline underline-offset-2">chandra-ocr</a> after downloading weights from <a href="https://huggingface.co/datalab-to/chandra-ocr-2" target="_blank" rel="noreferrer" className="underline underline-offset-2">Hugging Face</a>.</span>],
]}
  />
</ModelCard>

<ModelCard model={models[8]}>
  <Take>A low-cost hosted parser from the team behind Surya and Chandra that quietly does the job and offers strong value for everyday document work.</Take>

  <ST label="Strengths:">
    <div>It delivers solid, well-structured parsing at one of the lowest hosted prices here, which makes it easy to run at volume without watching the meter.</div>
    <div>For standard business documents like invoices, reports, and contracts, it hits a practical accuracy-to-cost balance most projects can build on.</div>
  </ST>

  <ST label="Tradeoffs:">
    <div>It is a pragmatic middle option, not a top scorer, so the hardest layouts still favor LlamaParse or Reducto.</div>
    <div>And because it is a managed API, it does not give you the offline control of the open-weight models from the same team.</div>
  </ST>

  <AccessBullets
    rows={[
["App", <span>Available in <a href="https://www.datalab.to/platform" target="_blank" rel="noreferrer" className="underline underline-offset-2">Datalab</a>.</span>],
["API", <span>Accessible via <a href="https://documentation.datalab.to/" target="_blank" rel="noreferrer" className="underline underline-offset-2">Datalab API</a>.</span>],
]}
  />
</ModelCard>

<ModelCard model={models[9]}>
  <Take>A fast, low-cost OCR API built for volume, and the pick when you need to process a lot of pages cheaply and reliably.</Take>

  <ST label="Strengths:">
    <div>It collapses OCR, layout, and structured extraction into a single fast call, with bounding boxes and structured output that drop cleanly into a pipeline.</div>
    <div>Low per-page cost and steady throughput make it well suited to high-volume workloads where you need predictable results without managing infrastructure.</div>
  </ST>

  <ST label="Tradeoffs:">
    <div>It stumbles on math, scientific notation, and complex multi-column pages, and outputs sometimes need manual review.</div>
    <div>For those harder documents, LlamaParse or MinerU2.5-Pro are safer, and general VLMs handle unusual layouts more gracefully.</div>
  </ST>

  <AccessBullets
    rows={[
["App", <span>Available in <a href="https://mistral.ai/solutions/document-ai/" target="_blank" rel="noreferrer" className="underline underline-offset-2">Mistral Studio Document AI</a>.</span>],
["API", <span>Accessible via <a href="https://docs.mistral.ai/studio-api/document-processing/basic_ocr/" target="_blank" rel="noreferrer" className="underline underline-offset-2">Mistral OCR API</a>.</span>],
]}
  />
</ModelCard>

<ModelCard model={models[10]}>
  <Take>The versatile generalist - not the sharpest on pure OCR benchmarks, but flexible, strong on handwriting, and easy to fold into wider workflows.</Take>

  <ST label="Strengths:">
    <div>As a frontier general model it parses, reasons, and answers questions about a document in one call, and it is among the better options for handwriting.</div>
    <div>When parsing is one step inside a larger reasoning or agent task, doing it all in a single model keeps the pipeline simple.</div>
  </ST>

  <ST label="Tradeoffs:">
    <div>On raw parsing accuracy it sits mid-pack, behind dedicated parsers like LlamaParse and even strong open-weight models.</div>
    <div>It is also expensive for high-volume OCR, so for pure extraction at scale, Mistral OCR 4 or a self-hosted parser makes more sense.</div>
  </ST>

  <AccessBullets
    rows={[
["App", <span>Available in <a href="https://chatgpt.com/" target="_blank" rel="noreferrer" className="underline underline-offset-2">ChatGPT</a>.</span>],
["API", <span>Accessible via <a href="https://platform.openai.com/docs/models" target="_blank" rel="noreferrer" className="underline underline-offset-2">OpenAI API</a>.</span>],
]}
  />
</ModelCard>

<ModelCard model={models[11]}>
  <Take>An ultra-compact open-weight parser with unusually broad language coverage that runs on ordinary hardware, making it a strong pick for multilingual work.</Take>

  <ST label="Strengths:">
    <div>Despite its tiny size, it delivers strong document parsing across a very wide set of languages, which makes it a standout for non-English and mixed-language documents.</div>
    <div>It runs on a typical machine, so you get multilingual extraction offline, with no per-page cost and full control over your data.</div>
  </ST>

  <ST label="Tradeoffs:">
    <div>The compact size shows on the most complex enterprise layouts, where larger parsers pull ahead.</div>
    <div>If you need the highest ceiling and can host bigger weights, Infinity-Parser2-Pro or MinerU2.5-Pro are stronger; for hands-off use, a hosted API is simpler.</div>
  </ST>

  <AccessBullets
    rows={[
["Run locally", <span>You can run it locally with <a href="https://github.com/PaddlePaddle/PaddleOCR" target="_blank" rel="noreferrer" className="underline underline-offset-2">PaddleOCR</a> after downloading weights from <a href="https://huggingface.co/PaddlePaddle/PaddleOCR-VL-1.6" target="_blank" rel="noreferrer" className="underline underline-offset-2">Hugging Face</a>.</span>],
]}
  />
</ModelCard>

<ModelCard model={models[12]}>
  <Take>The lightweight local workhorse, small enough to run almost anywhere including CPU and Apple Silicon, while still covering dozens of languages.</Take>

  <ST label="Strengths:">
    <div>It rolls layout analysis, OCR, and table recognition into one small model that runs on modest hardware, even without a dedicated GPU.</div>
    <div>With coverage across dozens of languages and a genuinely lightweight footprint, it is one of the easiest ways to get solid offline OCR onto a normal laptop.</div>
  </ST>

  <ST label="Tradeoffs:">
    <div>Its small size caps accuracy on complex tables and dense layouts, where Chandra OCR 2 or MinerU2.5-Pro do better.</div>
    <div>The weights also carry usage terms worth checking before you ship it in a commercial product.</div>
  </ST>

  <AccessBullets
    rows={[
["App", <span>Available in <a href="https://www.datalab.to/platform" target="_blank" rel="noreferrer" className="underline underline-offset-2">Datalab</a>.</span>],
["API", <span>Accessible via <a href="https://documentation.datalab.to/" target="_blank" rel="noreferrer" className="underline underline-offset-2">Datalab API</a>.</span>],
["Run locally", <span>You can run it locally with <a href="https://ollama.com/" target="_blank" rel="noreferrer" className="underline underline-offset-2">Ollama</a> or <a href="https://lmstudio.ai/" target="_blank" rel="noreferrer" className="underline underline-offset-2">LM Studio</a> after downloading weights from <a href="https://huggingface.co/datalab-to/surya-ocr-2-gguf" target="_blank" rel="noreferrer" className="underline underline-offset-2">Hugging Face</a>.</span>],
]}
  />
</ModelCard>

<ModelCard model={models[13]}>
  <Take>A mature cloud OCR service with strong prebuilt models for forms and invoices, dependable for structured fields but less so for open-ended parsing.</Take>

  <ST label="Strengths:">
    <div>Years of refinement show in its prebuilt extractors for invoices, receipts, and IDs, plus reliable handling of printed text, forms, and tables.</div>
    <div>For teams that need structured fields out of standardized business documents with minimal custom work, it is a proven, well-supported option.</div>
  </ST>

  <ST label="Tradeoffs:">
    <div>It is built for structured field extraction, not the semantic, RAG-ready parsing that newer VLM parsers do best, so it trails them on complex or free-form layouts.</div>
    <div>For clean Markdown from messy documents, LlamaParse or Gemini 3 Flash are stronger.</div>
  </ST>

  <AccessBullets
    rows={[
["App", <span>Available in <a href="https://documentintelligence.ai.azure.com/" target="_blank" rel="noreferrer" className="underline underline-offset-2">Document Intelligence Studio</a>.</span>],
["API", <span>Accessible via <a href="https://learn.microsoft.com/en-us/azure/ai-services/document-intelligence/" target="_blank" rel="noreferrer" className="underline underline-offset-2">Azure Document Intelligence API</a>.</span>],
]}
  />
</ModelCard>

<ModelCard model={models[14]}>
  <Take>A dependable older-generation OCR service for clean forms and tables, now clearly outclassed on anything requiring semantic document understanding.</Take>

  <ST label="Strengths:">
    <div>For structured, well-scanned documents such as forms with key-value pairs and bordered tables, it is stable, scalable, and predictable.</div>
    <div>If your inputs are clean and your needs are literal extraction rather than layout reconstruction, it does that job reliably at production scale.</div>
  </ST>

  <ST label="Tradeoffs:">
    <div>It sits at the bottom on semantic parsing. It reads text but does not reconstruct document structure or meaning the way modern VLM parsers do.</div>
    <div>For complex layouts, RAG-ready output, or messy scans, nearly everything above it does more.</div>
  </ST>

  <AccessBullets
    rows={[
["API", <span>Accessible via <a href="https://docs.aws.amazon.com/textract/latest/dg/API_Operations.html" target="_blank" rel="noreferrer" className="underline underline-offset-2">Amazon Textract API</a>.</span>],
]}
  />
</ModelCard>

***

## How to Choose

When choosing between these models, consider:

* **Access:** First decide whether you want a hosted app, an API call, or a model you run yourself, because that choice drives cost, privacy, latency, and how much setup you own. Proprietary parsers are the fastest to start; open-weight models keep documents on your own hardware.
* **Quality:** We use the ParseBench overall score as the main measure. It tests how well parsed output preserves tables, charts, content faithfulness, semantic formatting, and on-page visual grounding across real enterprise documents, not just whether the text looks similar to a reference.
* **Price:** We compare on USD per 1,000 pages processed, the cleanest way to line up hosted parsers. Self-hosted open-weight models carry no per-page fee, but you pay in hardware and setup instead.
* **Parser Type:** The field splits into specialized parser APIs, general VLM APIs, open-weight VLMs, and cloud OCR APIs. Specialized parsers and open-weight VLMs lead on hard layouts, cloud OCR APIs stay steady on clean structured forms, and general VLMs add reasoning but are not purpose-built.

***

## Other Models We Considered

<div className="not-prose my-4 flex flex-col gap-1.5 text-sm text-zinc-700 dark:text-zinc-300">
  <Alt icon={"/images/icons/google.com.png"} name={"Gemini 3.5 Flash"} dev={"Google"} url={"https://ai.google.dev/gemini-api/docs/models/gemini-3.5-flash"}>Fast and capable, but overlaps closely with Gemini 3 Flash.</Alt>
  <Alt icon={"/images/icons/google.com.png"} name={"Gemini 3.1 Pro"} dev={"Google"} url={"https://ai.google.dev/gemini-api/docs/models/gemini-3.1-pro-preview"}>Stronger for reasoning-heavy parsing, but pricier and slower than Gemini 3 Flash.</Alt>
  <Alt icon={"/images/icons/huggingface.co.png"} name={"Extend"} dev={"Extend"} url={"https://www.extend.ai/"}>Capable extraction API, but narrower than the leading parsers here.</Alt>
  <Alt icon={"/images/icons/huggingface.co.png"} name={"Nanonets OCR-3"} dev={"Nanonets"} url={"https://nanonets.com/research/nanonets-ocr-3"}>Popular hosted OCR for extraction, but outscored by the main picks.</Alt>
  <Alt icon={"/images/icons/qwen.ai.png"} name={"Qwen3-VL-8B-Instruct"} dev={"Alibaba"} url={"https://huggingface.co/Qwen/Qwen3-VL-8B-Instruct"}>A solid open multimodal baseline, but not a purpose-built parser.</Alt>
  <Alt icon={"/images/icons/google.com.png"} name={"Google Document AI"} dev={"Google"} url={"https://cloud.google.com/document-ai"}>A familiar cloud baseline for structured docs, now behind newer parsers.</Alt>
  <Alt icon={"/images/icons/huggingface.co.png"} name={"Dots.mocr"} dev={"RedNote HiLab"} url={"https://huggingface.co/rednote-hilab/dots.mocr"}>An open OCR model for experiments, but well behind the leaders.</Alt>
  <Alt icon={"/images/icons/huggingface.co.png"} name={"Docling Models"} dev={"IBM"} url={"https://huggingface.co/docling-project/docling-models"}>A handy offline conversion toolkit, but weaker on complex layouts.</Alt>
  <Alt icon={"/images/icons/huggingface.co.png"} name={"LandingAI ADE"} dev={"LandingAI"} url={"https://landing.ai/ade"}>A hosted extraction platform, but low parsing accuracy on hard documents.</Alt>
  <Alt icon={"/images/icons/deepseek.com.png"} name={"DeepSeek-OCR-2"} dev={"DeepSeek"} url={"https://huggingface.co/deepseek-ai/DeepSeek-OCR-2"}>Interesting for document compression, but low general parsing accuracy.</Alt>
</div>

***

## Frequently Asked Questions

<AccordionGroup>
  <Accordion title={"What is the best document OCR and parsing model right now?"}>
    LlamaParse in its agentic mode is the strongest all-round pick. It reconstructs complex layouts into clean, RAG-ready Markdown more reliably than anything else, and it is available as a simple API. If you need every extracted value to carry a citation for audit, Reducto is the more specialized choice.
  </Accordion>

  <Accordion title={"What is the best document parser for most people?"}>
    For a hosted default, LlamaParse is the safest starting point. If you are processing large volumes and want to keep costs down, Mistral OCR 4 or Datalab Parser give you most of the quality for far less per page. Test two or three on your own documents before committing.
  </Accordion>

  <Accordion title={"What is the best open-weight parser you can run locally?"}>
    MinerU2.5-Pro and PaddleOCR-VL are the standouts because they run well on a typical machine, MinerU for technical documents and PaddleOCR-VL for multilingual work. Surya OCR 2 is the lightest option, even on CPU or Apple Silicon. KDL-Frontier-Parser-nano, Infinity-Parser2-Pro, and Chandra OCR 2 score higher but need a high-end GPU.
  </Accordion>

  <Accordion title={"Should I use a general model like GPT-5.5 or Gemini 3 Flash, or a dedicated parser?"}>
    Use a dedicated parser when parsing is the whole job, since purpose-built models handle hard tables and dense layouts more reliably. Reach for a general VLM when parsing is one step inside a larger reasoning or agent task and you want everything in a single call.
  </Accordion>

  <Accordion title={"Do these benchmark scores match real-world use?"}>
    Roughly, but not perfectly. Scores predict which models handle complex layouts, tables, and faithfulness well, yet performance swings with your specific document types, scan quality, and languages. Even the best parsers miss or invent content on a small share of pages, so verify critical fields and run a short test on your own files.
  </Accordion>

  <Accordion title={"What should I use instead of AWS Textract or Azure Document Intelligence?"}>
    They are still fine for clean, structured forms and key-value extraction. But if you need semantic, RAG-ready output from messy or complex documents, a VLM parser like LlamaParse, Gemini 3 Flash, or an open-weight model like MinerU2.5-Pro will serve you much better.
  </Accordion>

  <Accordion title={"What matters most when choosing a model for document parsing?"}>
    Three things: how you want to access it (app, API, or self-hosted), the kind of documents you actually process, and your tolerance for cost versus accuracy. Match the model to your hardest real documents, not the cleanest ones, because that is where the differences show up.
  </Accordion>
</AccordionGroup>