---
title: "LangExtract vs. LlamaIndex: Structured data extraction compared"
canonical_url: "https://www.nutrient.io/blog/langextract-vs-llamaindex-extraction-comparison/"
md_url: "https://www.nutrient.io/blog/langextract-vs-llamaindex-extraction-comparison.md"
last_updated: "2026-08-24T15:04:28.283Z"
description: "How Google’s LangExtract and LlamaIndex’s LlamaExtract differ for structured data extraction — pipeline position, source grounding, deployment, and pricing."
---

**TL;DR**

- **Different layers, not rival tools.** Google’s LangExtract is an open source Python library for grounded extraction from text. LlamaIndex’s LlamaExtract is a managed, schema-driven service for pulling structured fields out of documents.

- **Pick LangExtract** for a self-managed library with a bring-your-own large language model (LLM) and span-level grounding over existing text.

- **Pick LlamaExtract** for a hosted, schema-first extraction step inside a LlamaIndex or retrieval-augmented generation (RAG) stack, document parsing included.

- **Pick [Nutrient](https://www.nutrient.io/api/data-extraction-api/) for production document extraction** — scanned files, tables, and key-value pairs at volume. Output is deterministic and source-grounded, with per-field confidence so a wrong value is catchable, hosted or on-premises.

**LangExtract vs. LlamaIndex** isn’t a head-to-head: The two aren’t direct competitors. LangExtract (from Google) and LlamaExtract (from LlamaIndex) sit at different points in a structured-extraction pipeline, so “which is better” depends on what is being extracted and who runs the infrastructure.

One naming note first, since it causes most of the confusion: LlamaExtract is LlamaIndex’s extraction product. LangExtract, LlamaExtract, and LlamaIndex therefore describe two tools, not three — LangExtract on one side, and LlamaIndex’s extraction offering on the other.

This post covers what each tool does, where they overlap, and how to choose. It then shows where a purpose-built document extraction layer fits when neither library solves the part that breaks in production.

## What is LangExtract?

**LangExtract** is an [open source Python library](https://github.com/google/langextract) (Apache-2.0) from Google, launched in July 2025, for extracting structured information from unstructured text using LLMs. Its defining feature is source grounding: Every extracted value maps back to an exact character span in the source text, which makes outputs auditable. It’s bring-your-own-model — Gemini by default, with support for OpenAI and local open models via Ollama — and it runs wherever the caller deploys it.

## What is LlamaExtract?

**LlamaExtract** is LlamaIndex’s managed structured-extraction product (part of LlamaCloud). A schema is defined with Pydantic or JSON Schema and pointed at documents; the service parses and extracts in one step, returning schema-validated output. It’s designed to slot into LlamaIndex-based RAG and agent pipelines without anyone operating the extraction infrastructure.

## Text or documents: The split that decides it

One difference determines most of this choice, and it isn’t accuracy. Extraction is two jobs, not one: turning a document into text, then turning that text into fields. The two tools start at different points in that sequence.

LangExtract is text-first. It has no OCR, so it operates on text that something else produced. Feed it a clean Markdown file and it works well. Feed it a scanned invoice and nothing happens until a parsing step runs in front — and whatever that step gets wrong is silently inherited, because LangExtract has no way to know the text it received isn’t what the page said.

LlamaExtract takes a document directly. Parsing and OCR are part of the service, built on LlamaParse, so a scanned PDF is a valid input rather than a prerequisite to solve first.

This is why the comparison is often misframed. A team evaluating both on clean text will find them close. The same team evaluating on scanned or multicolumn files is really evaluating two different things: one tool plus whatever OCR was bolted on, versus one tool end to end.

Nutrient runs parsing and OCR inside the extraction step for the same reason — see the [document parsing guide](https://www.nutrient.io/guides/dws-data-extraction/parsing.md) for how it handles scanned and multicolumn input, and [OCR data extraction](https://www.nutrient.io/sdk/ocr/) for why this layer is usually the bottleneck.

## LangExtract vs. LlamaIndex: Feature comparison

| Dimension         | LangExtract (Google)                                            | LlamaExtract (LlamaIndex)                       | Nutrient                                |
| ----------------- | --------------------------------------------------------------- | ----------------------------------------------- | --------------------------------------- |
| Type              | Open source Python library (Apache-2.0)                         | Managed service (LlamaCloud)                    | Managed API + self-hostable SDK         |
| Primary input     | Existing text                                                   | Documents (PDF, images) — parses them itself    | PDFs, images, scans, Office files       |
| Built-in OCR      | No (text-first)                                                 | Yes (LlamaParse-based parsing)                  | Yes                                     |
| Model             | Bring-your-own LLM (Gemini default; OpenAI or local via Ollama) | Managed, tiered extraction modes                | Nutrient AI Document Processing         |
| Schema definition | Prompt + few-shot examples (a maintained, model-tuned set)      | Pydantic or JSON Schema                         | Schema/template-based                   |
| Long documents    | Chunking, multipass recall, parallelism — caller-configured     | Handled by the service                          | Handled by the service or the SDK       |
| Source grounding  | Character-offset spans (core feature)                           | Citations + field-level confidence scores       | Field-level provenance + match labels   |
| Deployment        | Self-managed library                                            | Cloud; self-hosting/BYOC for enterprise         | Cloud or on-premises (CPU)              |
| Best for          | Grounded extraction from text                                   | Schema-driven document extraction in RAG stacks | Production document extraction at scale |

## Source grounding compared

One note on accuracy before comparing mechanisms: Neither LangExtract nor LlamaExtract appears in any public document extraction benchmark, so a head-to-head accuracy table here would be an invented number. The grounding mechanism, on the other hand, is documented behavior — and the difference is categorical, not a matter of degree.

The distinction that matters is what the span points *at*. LangExtract grounds to a character offset in text, which presumes the text is already correct — so on a scanned document, the grounding is only as good as whatever OCR ran upstream, and a confidently cited value can still be wrong. Nutrient’s bounding box points at a region of the page image, so the claim can be checked against the document itself rather than against a transcription of it.

LangExtract also ships an interactive HTML visualization (`lx.visualize()`) that highlights each extraction in the source text, which is genuinely useful for spot-checking grounding by eye during development.

### How to evaluate this on a real document set

The only accuracy figure worth acting on is one measured on the documents in question.

1. Take 50–100 documents representative of the real distribution — including the scanned, multicolumn, and low-contrast cases, not just the clean ones.

2. Define the fields that actually matter downstream, and hand-label them once.

3. Run each candidate over the same set and score field-level exact match, plus how often a wrong value is returned with high confidence.

4. Check grounding by sampling: Does the cited span or box point at the right place on the page?

That last measure — confidently wrong — is usually what decides production fitness, and it’s the one a vendor accuracy percentage never reports.

## Setup and developer experience

LangExtract is `pip install`-and-run: The caller owns the model key, the prompt, the few-shot examples, and the runtime — full control and no hosting cost, in exchange for operating it.

LlamaExtract is the opposite trade. Define a schema, call the service, and schema-validated output comes back with no infrastructure to run. It fits teams already building on LlamaIndex that want extraction as a managed step rather than a component to maintain.

A minimal extraction in each shows the trade concretely. LangExtract is text-first and driven by few-shot examples over a supplied model:

```py

import langextract as lx

examples = [
    lx.data.ExampleData(
        text="Patient takes lisinopril 10mg daily.",
        extractions=[
            lx.data.Extraction(
                extraction_class="medication",
                extraction_text="lisinopril",
                attributes={"dose": "10mg", "frequency": "daily"},
            ),
        ],
    )
]

result = lx.extract(
    text_or_documents="Patient is prescribed metformin 500mg twice daily.",
    prompt_description="Extract medications with dose and frequency.",
    examples=examples,
    model_id="gemini-3.5-flash",
)

```

Model IDs rotate, and Gemini versions carry published retirement dates — check the [LangExtract repository](https://github.com/google/langextract) for the current recommended default before copying this across.

LlamaExtract is schema-first and managed — a schema and a file go in, and the service handles parsing and OCR:

```py

from pydantic import BaseModel
from llama_cloud_services import LlamaExtract

class Invoice(BaseModel):
    invoice_number: str
    total: float

extractor = LlamaExtract()  # set LLAMA_CLOUD_API_KEY.

agent = extractor.create_agent(name="invoice-extractor", data_schema=Invoice)
result = agent.extract("invoice.pdf")
print(result.data)

```

Note what carries the accuracy in each. In LangExtract, it’s the few-shot examples: The extraction quality tracks how well the supplied examples represent the real documents. That set becomes a maintained artifact — it grows as edge cases appear, and it’s tuned against a specific model, so changing a model usually means revisiting it. In LlamaExtract, the schema carries the intent and the service handles the prompting, which removes that tuning work and the control that comes with it.

### Running LangExtract at volume

LangExtract is built for long inputs rather than single passages, and three features matter once documents get large:

- **Chunking** splits long text into windows sized for the model’s context, and results are reassembled afterward.

- **Multiple passes** rerun extraction over the same input to improve recall, on the basis that one pass over a long document tends to miss entities.

- **Parallel processing** runs those chunks and passes concurrently, which is what makes multipass extraction practical rather than merely thorough.

These are real strengths and worth weighing against the managed alternative. They are also configuration the caller owns: chunk size, pass count, and concurrency all become tuning parameters, and they interact with the rate limits and cost of whichever model sits behind them.

## Pricing and deployment

LangExtract is free (open source, Apache-2.0); the only cost is the LLM it calls plus the infrastructure it runs on — or nothing at all with a local model. LlamaExtract is a managed service with a usage-based credit model and free credits to start. Deployment often decides the choice before accuracy does, especially in regulated environments. The options differ in kind: LangExtract is a library to run anywhere, LlamaExtract is a hosted service with self-hosting and bring-your-own-cloud (BYOC) options available for enterprise, and a dedicated extraction engine can run entirely on-premises.

## Is LangExtract better than LlamaIndex?

Neither is strictly “better”; they solve different problems. LangExtract fits a self-managed, grounded extraction library over text for teams comfortable supplying their own model. LlamaExtract fits hosted, schema-driven extraction with parsing included, wired into a LlamaIndex pipeline. A workload of production document extraction at scale (varied layouts, scanned input, tables and key-value pairs with auditable field-level provenance) is a different requirement than either tool is built for, and it’s where a dedicated extraction platform fits.

## Where Nutrient fits

Neither tool above is the wrong choice — they’re simply built for a different problem. The case for a dedicated extraction layer arrives at a specific point: when documents are messy and arriving at volume, and when a wrong value has to be *catchable* rather than merely unlikely. That’s usually a compliance, finance, healthcare, or claims workload, where an extraction that’s right 97 percent of the time is only useful if the remaining 3 percent can be found.

**Determinism is what makes that possible.** For Nutrient, deterministic means the same document produces the same output on every run, so a result can be reproduced and defended months later. LLM-based extraction is probabilistic by construction: rerun it and the output can differ, which is workable for exploration and awkward when an auditor asks why a figure changed. Nutrient’s deterministic and optical character recognition (OCR)/intelligent character recognition (ICR) modes carry no model dependency at all, and AI-augmented modes are available where the flexibility is worth the trade.

**Every value comes back with the information needed to decide whether to trust it** — a bounding box, a confidence score, and an [interpretable match label](https://www.nutrient.io/guides/dws-data-extraction/extract/citations-and-confidence.md): `id_match`, `id_match_multiblock`, `id_match_partial`, `fuzzy_match`, and `not_found`. That combination is what turns review from a manual pass over everything into routing: send `id_match` and high-confidence values straight through, queue `fuzzy_match` and `not_found` for a human, and use the bounding box to check the flagged ones against the original page in the viewer rather than against a transcription. The difference at volume is reviewing a small fraction of fields instead of all of them.

**It runs where the data already lives.** The full extraction engine runs on-premises on CPU, which is a stronger claim than self-hostable — it means grounded extraction with no external model call, viable in air-gapped and data residency environments. Nutrient is SOC 2 Type 2 audited, and the hosted [Data Extraction API](https://www.nutrient.io/guides/dws-data-extraction/getting-started.md) covers the same capability for teams that would rather not operate it.

For context on the deployment track record rather than the extraction claim: Nutrient serves 3,000+ organizations, including 15 percent of Global 500 companies, and processes more than 1 billion document interactions annually.

Underneath, [AI Document Processing](https://www.nutrient.io/sdk/ai-document-processing/) and data extraction handle [tables](https://www.nutrient.io/api/table-extraction-api/), [key-value pairs](https://www.nutrient.io/api/key-value-pair-extraction-api/), and full fields, with OCR for scanned input built in. For a capability-by-capability breakdown, see the full [Nutrient vs. LlamaIndex comparison](https://www.nutrient.io/api/data-extraction-api/vs/llamaindex/).

Nutrient publishes its extraction [benchmark methodology](https://www.nutrient.io/blog/pdf-extraction-benchmark-opendataloader-bench.md) — corpus, harness, and scoring — so its numbers can be checked rather than taken on faith. For this specific three-way comparison, the evaluation procedure above settles accuracy on the documents that actually matter.

**Call to Action**

*The corpus, ground truth, and evaluation harness are public — every number can be rerun independently*

Reproduce the benchmark on GitHub

[Learn More](https://github.com/opendataloader-project/opendataloader-bench)

### Try it on a document

A free API key returns structured elements — each with a bounding box and confidence score — in a few lines:

```py

import requests

response = requests.post(
    "https://api.nutrient.io/extraction/parse",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    files={"file": open("document.pdf", "rb")},
    data={"instructions": '{"mode":"understand","output":{"format":"spatial"}}'},
)
print(response.json())

```

[Get a free API key](https://dashboard.nutrient.io/sign_up/?product=data-extraction). Then follow the [RAG ingestion guide](https://www.nutrient.io/guides/dws-data-extraction/examples/build-rag-ingestion-pipeline.md) to wire Nutrient into an existing pipeline.

## Conclusion

LangExtract vs. LlamaIndex (LlamaExtract) comes down to library vs. managed service and text vs. documents. Choose LangExtract for self-managed grounded extraction from text; choose LlamaExtract for hosted schema-driven extraction in a RAG stack. But if the workload is real-world documents at volume — scans, tables, fields that must be right and provably so — that’s a third problem, and [Nutrient](https://www.nutrient.io/api/data-extraction-api/) is built for exactly that. The fastest way to settle the question is the evaluation above, run on the documents in question.

**Call to Action**

*Deterministic extraction with a bounding box and a confidence score on every field*

Run Nutrient against your own documents

[Learn More](https://dashboard.nutrient.io/sign_up/?product=data-extraction)

## FAQ

#### What is the difference between LangExtract and LlamaIndex?

LangExtract is an open source Python library from Google for extracting structured data from text, with character-level source grounding and a bring-your-own-LLM design. LlamaIndex’s LlamaExtract is a managed service that parses documents and extracts structured fields against a schema you define. LangExtract is a self-run library focused on text; LlamaExtract is a hosted service focused on documents.

#### What is the difference between LangExtract, LlamaExtract, and LlamaIndex?

LlamaIndex is the framework; LlamaExtract is its managed structured-extraction product, so what looks like a three-way comparison is a two-way one: LangExtract (Google’s library) versus LlamaIndex’s LlamaExtract service. LangExtract runs locally over text with bring-your-own-model grounding; LlamaExtract runs in the cloud, parses documents itself, and extracts against a Pydantic or JSON schema.

#### Does LangExtract work on scanned PDFs?

Not directly. LangExtract is text-first and has no built-in OCR, so a scanned PDF needs a parsing/OCR step in front of it. LlamaExtract parses documents (including scans) as part of the service. For image-heavy or degraded scans, the accuracy of the document extraction layer caps the whole pipeline — which is why production systems often use a dedicated extraction platform with built-in OCR.
---

## Related pages

- [The business case for accessibility: Five ways it drives enterprise value](/blog/5-ways-accessibility-drives-enterprise-value.md)
- [Accessibility Untangled Why It Matters Guide](/blog/accessibility-untangled-why-it-matters-guide.md)
- [Advanced Techniques For React Native Ui Components](/blog/advanced-techniques-for-react-native-ui-components.md)
- [`vector_store` holds your indexed documents (see the multimodal RAG post](/blog/agentic-rag.md)
- [Ai Document Automation Extraction To Action](/blog/ai-document-automation-extraction-to-action.md)
- [Ai Legal Assistant Document Authoring](/blog/ai-legal-assistant-document-authoring.md)
- [Amazon Textract Alternatives](/blog/amazon-textract-alternatives.md)
- [Start (clears any prior buffer), navigate the document, then stop into a file.](/blog/android-faster-pdf-rendering.md)
- [Android Pdf Out Of Memory Handling](/blog/android-pdf-out-of-memory-handling.md)
- [Angular File Viewer Pdf Image Office Files](/blog/angular-file-viewer-pdf-image-office-files.md)
- [Auto Tagging And Document Accessibility In Dotnet Sdk](/blog/auto-tagging-and-document-accessibility-in-dotnet-sdk.md)
- [Best Document Ai Platforms](/blog/best-document-ai-platforms.md)
- [Best Document Viewers](/blog/best-document-viewers.md)
- [Build Vs Buy Document Extraction](/blog/build-vs-buy-document-extraction.md)
- [The CEO’s AI playbook: Why decision architecture beats model selection](/blog/ceo-ai-playbook-decision-architecture.md)
- [1. Extract and chunk the PDF.](/blog/chat-with-pdf.md)
- [Complete Guide To Pdfjs](/blog/complete-guide-to-pdfjs.md)
- [Construction Document Data Extraction](/blog/construction-document-data-extraction.md)
- [Convert One Drive Files To Pdf In Sharepoint](/blog/convert-one-drive-files-to-pdf-in-sharepoint.md)
- [Create And Edit Pdfs In Flutter](/blog/create-and-edit-pdfs-in-flutter.md)
- [Create Pdfs With React](/blog/create-pdfs-with-react.md)
- [Creating A Document Scanner With Ocr In Python](/blog/creating-a-document-scanner-with-ocr-in-python.md)
- [Creating And Filling Pdf Forms Programmatically In Javascript](/blog/creating-and-filling-pdf-forms-programmatically-in-javascript.md)
- [The CTO’s AI playbook: Why accountability architecture beats orchestration](/blog/cto-ai-playbook-accountability-architecture.md)
- [Digital Signatures](/blog/digital-signatures.md)
- [Digital Workflow Automation](/blog/digital-workflow-automation.md)
- [Document Ai Vs Ocr](/blog/document-ai-vs-ocr.md)
- [Document Extraction Confidence Scores](/blog/document-extraction-confidence-scores.md)
- [Document Viewer](/blog/document-viewer.md)
- [Document Watermarking](/blog/document-watermarking.md)
- [Emerging threats: Your logging system may be an agentic threat vector](/blog/emerging-threats-your-logging-system.md)
- [Extract Patient Data On Premises](/blog/extract-patient-data-on-premises.md)
- [app.py](/blog/extract-text-from-pdf-using-python.md)
- [Fillable Pdf](/blog/fillable-pdf.md)
- [How To Add Digital Signature To Pdf Using React](/blog/how-to-add-digital-signature-to-pdf-using-react.md)
- [How To Build A Dotnet Maui Pdf Viewer](/blog/how-to-build-a-dotnet-maui-pdf-viewer.md)
- [How To Build A Flutter Pdf Viewer](/blog/how-to-build-a-flutter-pdf-viewer.md)
- [or](/blog/how-to-build-a-javascript-pdf-viewer-with-pdfjs.md)
- [How To Build A Javascript Pdf Viewer](/blog/how-to-build-a-javascript-pdf-viewer.md)
- [or](/blog/how-to-build-a-nextjs-pdf-viewer.md)
- [How To Build A Powerpoint Viewer Using Javascript](/blog/how-to-build-a-powerpoint-viewer-using-javascript.md)
- [Using Yarn](/blog/how-to-build-a-react-excel-viewer.md)
- [How To Build A React Native Pdf Viewer](/blog/how-to-build-a-react-native-pdf-viewer.md)
- [How To Build A React Powerpoint Viewer](/blog/how-to-build-a-react-powerpoint-viewer.md)
- [How To Build A Reactjs File Viewer](/blog/how-to-build-a-reactjs-file-viewer.md)
- [or](/blog/how-to-build-a-reactjs-pdf-viewer-with-react-pdf.md)
- [or](/blog/how-to-build-a-reactjs-pdf-viewer.md)
- [How To Build A Reactjs Viewer With Pdfjs](/blog/how-to-build-a-reactjs-viewer-with-pdfjs.md)
- [How To Build A Vuejs Pdf Viewer With Pdfjs](/blog/how-to-build-a-vuejs-pdf-viewer-with-pdfjs.md)
- [How To Build A Vuejs Pdf Viewer](/blog/how-to-build-a-vuejs-pdf-viewer.md)
- [How To Build An Android Pdf Viewer](/blog/how-to-build-an-android-pdf-viewer.md)
- [How To Build An Angular Pdf Viewer With Ng2 Pdf Viewer](/blog/how-to-build-an-angular-pdf-viewer-with-ng2-pdf-viewer.md)
- [How To Build An Angular Pdf Viewer With Pdfjs](/blog/how-to-build-an-angular-pdf-viewer-with-pdfjs.md)
- [How To Convert Docx To Pdf Using Javascript](/blog/how-to-convert-docx-to-pdf-using-javascript.md)
- [How To Convert Docx To Pdf Using Python](/blog/how-to-convert-docx-to-pdf-using-python.md)
- [How To Convert Html To Pdf Using Html2pdf](/blog/how-to-convert-html-to-pdf-using-html2pdf.md)
- [or](/blog/how-to-convert-html-to-pdf-using-react.md)
- [How To Convert Html To Pdf Using Wkhtmltopdf And Csharp](/blog/how-to-convert-html-to-pdf-using-wkhtmltopdf-and-csharp.md)
- [or](/blog/how-to-convert-html-to-pdf-using-wkhtmltopdf-and-python.md)
- [How To Convert Word To Pdf In Nodejs](/blog/how-to-convert-word-to-pdf-in-nodejs.md)
- [or](/blog/how-to-create-a-react-js-signature-pad.md)
- [How To Create Pdfs With React To Pdf](/blog/how-to-create-pdfs-with-react-to-pdf.md)
- [How To Edit Pdfs Using Ios Pdf Library](/blog/how-to-edit-pdfs-using-ios-pdf-library.md)
- [How To Embed A Pdf Viewer In Your Website](/blog/how-to-embed-a-pdf-viewer-in-your-website.md)
- [How To Extract Tables From Pdf And Images](/blog/how-to-extract-tables-from-pdf-and-images.md)
- [How To Generate Pdf From Html With Nodejs](/blog/how-to-generate-pdf-from-html-with-nodejs.md)
- [base_url tells WeasyPrint where to resolve relative asset paths](/blog/how-to-generate-pdf-reports-from-html-in-python.md)
- [How To Merge Pdfs Using Javascript](/blog/how-to-merge-pdfs-using-javascript.md)
- [How To Ocr Pdfs In Linux](/blog/how-to-ocr-pdfs-in-linux.md)
- [How To Print Pdf In Csharp](/blog/how-to-print-pdf-in-csharp.md)
- [Open an image.](/blog/how-to-use-tesseract-ocr-in-python.md)
- [From an HTML string.](/blog/html-in-pdf-format.md)
- [Html To Pdf In Javascript](/blog/html-to-pdf-in-javascript.md)
- [Javascript Pdf Editors](/blog/javascript-pdf-editors.md)
- [Javascript Pdf Libraries](/blog/javascript-pdf-libraries.md)
- [Linearized Pdf](/blog/linearized-pdf.md)
- [or](/blog/merge-pdfs.md)
- [Swift Package Manager](/blog/mobile-pdf-sdk.md)
- [`elements` come from your document parser — each has a type and content.](/blog/multimodal-rag.md)
- [Nutrient Flutter 6 Bindings Api](/blog/nutrient-flutter-6-bindings-api.md)
- [Nutrient Vs Conga Composer](/blog/nutrient-vs-conga-composer.md)
- [Online Document Viewer](/blog/online-document-viewer.md)
- [Open Pdf In Your Web App](/blog/open-pdf-in-your-web-app.md)
- [Building WCAG 2.2, Section 508, and PDF/UA-compliant PDFs with an SDK](/blog/pdf-accessibility.md)
- [Extract data from PDF files: A developer guide to structured data from PDFs and scans](/blog/pdf-data-extraction-developer-guide.md)
- [Pdf Extraction Benchmark Opendataloader Bench](/blog/pdf-extraction-benchmark-opendataloader-bench.md)
- [Pdf Extraction Document Case Studies](/blog/pdf-extraction-document-case-studies.md)
- [Pdf Page Labels](/blog/pdf-page-labels.md)
- [Pdf Sdk Compliance Security Checklist](/blog/pdf-sdk-compliance-security-checklist.md)
- [Pdf Sdk Performance Benchmark](/blog/pdf-sdk-performance-benchmark.md)
- [Pdf Ua Compliance Guide](/blog/pdf-ua-compliance-guide.md)
- [Pdfjs Accessibility Structtree Printing](/blog/pdfjs-accessibility-structtree-printing.md)
- [Pdfjs Advanced Loading Streaming Workers](/blog/pdfjs-advanced-loading-streaming-workers.md)
- [Pdfjs Annotation Editor Layer](/blog/pdfjs-annotation-editor-layer.md)
- [Pdfjs Area Annotations Canvas Capture](/blog/pdfjs-area-annotations-canvas-capture.md)
- [Pdfjs Coordinate Systems Pdf To Screen](/blog/pdfjs-coordinate-systems-pdf-to-screen.md)
- [Pdfjs Document Outline Bookmarks Metadata](/blog/pdfjs-document-outline-bookmarks-metadata.md)
- [Pdfjs Eventbus Guide](/blog/pdfjs-eventbus-guide.md)
- [macOS](/blog/pdfjs-file-format-conversion-to-pdf.md)
- [macOS](/blog/pdfjs-generating-pdf-thumbnails-pdf2pic.md)
- [Pdfjs Limitations Commercial Upgrade](/blog/pdfjs-limitations-commercial-upgrade.md)
- [Pdfjs Native Annotation Layer Forms](/blog/pdfjs-native-annotation-layer-forms.md)
- [Pdfjs Navigation Zoom Rotation](/blog/pdfjs-navigation-zoom-rotation.md)
- [Pdfjs Pdf Page Manipulation Pdf Lib](/blog/pdfjs-pdf-page-manipulation-pdf-lib.md)
- [Pdfjs React Viewer Setup](/blog/pdfjs-react-viewer-setup.md)
- [Pdfjs Rendering Overlays React Portals](/blog/pdfjs-rendering-overlays-react-portals.md)
- [Pdfjs Server Side Text Extraction](/blog/pdfjs-server-side-text-extraction.md)
- [Pdfjs Sticky Note Annotations](/blog/pdfjs-sticky-note-annotations.md)
- [Pdfjs Text Highlight Annotations](/blog/pdfjs-text-highlight-annotations.md)
- [Pdfjs Text Search Pdffindcontroller](/blog/pdfjs-text-search-pdffindcontroller.md)
- [Pdfjs Thumbnail Sidebar](/blog/pdfjs-thumbnail-sidebar.md)
- [Process Flows](/blog/process-flows.md)
- [React Native Pdf Annotation](/blog/react-native-pdf-annotation.md)
- [Using Yarn](/blog/react-pdf-editor.md)
- [React Pdf Loading States Errors Passwords](/blog/react-pdf-loading-states-errors-passwords.md)
- [React Pdf Setup Basic Rendering](/blog/react-pdf-setup-basic-rendering.md)
- [labels.py](/blog/route-documents-automatically-classify-api.md)
- [or](/blog/sample-blog-updated.md)
- [Sdk Product Updates Q2 2026](/blog/sdk-product-updates-q2-2026.md)
- [Add DWS MCP Server to your Claude Code project.](/blog/teaching-llms-to-read-pdfs.md)
- [Open an image file.](/blog/tesseract-python-guide.md)
- [Define the HTML part of the document.](/blog/top-10-ways-to-generate-pdfs-in-python.md)
- [Top 5 Javascript Pdf Viewers](/blog/top-5-javascript-pdf-viewers.md)
- [or](/blog/top-js-pdf-libraries.md)
- [Convert an HTML file to PDF.](/blog/top-ten-ways-to-convert-html-to-pdf.md)
- [Vector Pdf](/blog/vector-pdf.md)
- [Wcag2 Accessibility Requirements Documents](/blog/wcag2-accessibility-requirements-documents.md)
- [Web Sdk Is Now Headless](/blog/web-sdk-is-now-headless.md)
- [What Are Annotations](/blog/what-are-annotations.md)
- [What Is A Vpat](/blog/what-is-a-vpat.md)
- [What Is Document Processing](/blog/what-is-document-processing.md)
- [What Is Intelligent Document Processing](/blog/what-is-intelligent-document-processing.md)
- [What Is Pdf Ua](/blog/what-is-pdf-ua.md)
- [Why Pdfium Is A Trusted Platform For Pdf Rendering](/blog/why-pdfium-is-a-trusted-platform-for-pdf-rendering.md)
- [Why Your Ai Agent Hallucinates Pdf Table Data](/blog/why-your-ai-agent-hallucinates-pdf-table-data.md)