By ByteBot
Chandra OCR 2, released March 18, 2026 by Datalab, beats Google Gemini 2.5 Flash by 10 percentage points and OpenAI GPT-5 Mini by 17 percentage points on multilingual document tests. The open-source model achieves 85.9% accuracy on the standard olmOCR benchmark—state-of-the-art performance—while remaining completely free and capable of local deployment. Unlike traditional OCR that merely extracts text, Chandra preserves complete document structure: tables, forms, handwriting, and multi-column layouts.
This isn’t incremental improvement. A 4-billion parameter specialized model is decisively beating general-purpose vision models from tech giants. For developers, this means access to better document extraction capabilities than paid enterprise APIs.
Chandra Dominates Standard Benchmarks
On the authoritative olmOCR benchmark, Chandra 2 scored 85.9%—the highest score among all tested models. DeepSeek OCR managed 75.4%. GPT-4o hit 69.9%. Google Gemini and OpenAI’s GPT-5 Mini performed even worse on multilingual tests: 67.6% and 60.5% respectively, compared to Chandra’s 77.8%.
The performance gap is consistent across specific capabilities. Chandra achieves 88.0% on table recognition, 80.3% on mathematical notation, and 92.3% on tiny text parsing. These aren’t marketing numbers—they’re from independent benchmarks run by AllenAI and multiple research teams.
Moreover, Chandra 2 is smaller and faster than its predecessor. At 4 billion parameters (down from Chandra 1’s 9 billion), it delivers better accuracy while requiring less compute. This efficiency matters for production deployments where GPU costs directly impact ROI.
Layout Preservation Sets Chandra Apart
Traditional OCR tools like Tesseract treat documents as flat text streams. They recognize characters but destroy structure. Need to extract a table from a PDF? Good luck parsing the jumbled text output.
Chandra understands document structure. Multi-column layouts, nested tables, form fields, headers, footers—all preserved in the output. The model exports to HTML (with semantic tags), Markdown (for documents), or JSON (for data pipelines). You get structured data, not garbage you have to manually parse.
Form processing demonstrates this advantage. Chandra recognizes checkbox states (checked/unchecked), maintains field relationships, and preserves form logic. Invoice extraction becomes trivial: line items, totals, dates, and vendor information come out as structured JSON ready for validation and processing.
This capability extends to academic papers with mathematical notation, medical records with handwritten notes, and historical documents with complex layouts. One developer successfully extracted content from Ramanujan’s 1913 handwritten mathematical letter—both the handwriting and mathematical symbols recognized accurately.
Installation and Basic Usage
Chandra runs locally via Python with straightforward setup. Three installation options exist: pip install for vLLM (fast, default), HuggingFace backend (includes torch/transformers), or hosted API (free tier available). Basic requirements: Python 3.8+, approximately 2GB RAM minimum, GPU recommended for production workloads.
Installation takes one command:
pip install chandra-ocrBasic usage requires three lines of Python:
from chandra_ocr import InferenceManager
ocr = InferenceManager(method='hf')
result = ocr.process_image('invoice.pdf', output_format='json')
print(result)CLI usage is even simpler. Start the vLLM server with chandra_vllm, then process documents: chandra input.pdf ./output --format markdown. The model downloads automatically on first run (approximately 8GB).
For production deployments, batch processing supports multi-page PDFs and document collections. GPU acceleration provides 3-5x speedup over CPU-only inference. Self-hosted deployment eliminates API costs while maintaining data privacy—critical for healthcare, legal, and financial documents.
Real-World Applications
Invoice and receipt processing represents the obvious use case. Extract line items, totals, dates, and vendor information from scanned documents. The table recognition accuracy (88.0%) handles complex invoice layouts that break traditional OCR tools.
Medical records extraction tackles notoriously difficult doctor’s handwriting. Chandra’s handwriting recognition across 90 languages handles cursive notes, prescription forms, and patient charts. One medical organization reported significant reduction in manual data entry after deploying Chandra for record digitization.
Legal document digitization benefits from layout preservation. Contracts, court filings, and agreements maintain formatting in structured text output. This matters for e-discovery workflows where document structure carries legal significance.
Academic paper extraction handles mathematical equations, tables, figures, and multi-column layouts. Research databases and literature review tools can now digitize papers while preserving semantic relationships. The Ramanujan letter test proves the model handles even historical documents with complex notation.
When to Choose Chandra Over Alternatives
Use Chandra for complex document structures. If your documents contain tables, forms, or multi-column layouts, Chandra’s structure preservation justifies the setup complexity. Invoice processing, form automation, and academic paper extraction all benefit significantly.
Handwriting recognition requirements point toward Chandra. The 90-language support and cursive recognition outperform alternatives. Medical records, historical documents, and handwritten forms become tractable.
However, simple text extraction from clean PDFs doesn’t need Chandra. Use PyPDF2 or pdfplumber for documents with embedded text—no OCR needed. For real-time camera OCR applications, lighter models like EasyOCR provide better latency despite lower accuracy.
Cost considerations matter. Self-hosted Chandra costs GPU compute time ($0.50-$2.00/hour on cloud GPUs) but zero per-page fees. Google Vision API charges $1.50 per 1000 pages. At 100,000 pages monthly, that’s $150 versus GPU costs around $75-150. The accuracy gap (85.9% vs 67.6%) makes Chandra the obvious choice for high-volume processing.
Low-volume users (<10,000 pages/month) might prefer hosted APIs for convenience. Setup complexity and GPU management overhead aren’t worth it for occasional document processing. Use Datalab’s hosted Chandra API or Google Vision for simplicity.
Limitations to Consider
Memory requirements bite harder than expected. The 4-billion parameter model needs 8-12GB VRAM for smooth inference. CUDA out-of-memory errors occur frequently on smaller GPUs. Solution: reduce batch size, use CPU inference (much slower), or switch to API.
Language-specific issues exist. GitHub issues document hallucination problems with Russian and Kazakh texts—repetitive token loops or empty responses. Test thoroughly if these languages matter for your use case. The multilingual benchmark (72.7% on 90 languages) shows performance varies significantly by language.
Processing speed lags lighter tools. At 1.29 pages per second, Chandra is slower than Tesseract (5-10 pages/sec) or PaddleOCR. For real-time applications or massive batch processing, the accuracy-speed trade-off requires careful evaluation.
Setup complexity exceeds simpler alternatives. Tesseract installs with apt-get and works immediately. Chandra requires Python environment setup, model downloads (8GB), CUDA configuration, and inference backend selection. Budget 30-60 minutes for first deployment. However, 85.9% accuracy is worth the investment.
Key Takeaways
- Chandra 2 achieves 85.9% olmOCR accuracy, beating Google Gemini (67.6%) and OpenAI GPT-5 Mini (60.5%) by 10-17 percentage points on document intelligence tasks
- Structure preservation differentiates Chandra from traditional OCR: tables, forms, handwriting, and multi-column layouts maintained in HTML/Markdown/JSON output
- Choose Chandra for complex documents (invoices, forms, medical records, academic papers) where layout and structure matter; skip it for simple text extraction
- Self-hosted deployment requires GPU (8-12GB VRAM recommended) but eliminates per-page API costs; 100K pages/month costs $75-150 in compute versus $150 for Google Vision with lower accuracy
- Installation:
pip install chandra-ocrfollowed by 3 lines of Python code; model downloads automatically (8GB); GitHub repo at datalab-to/chandra
Open-source specialized models like Chandra demonstrate that domain-specific tools can outperform general-purpose vision models from tech giants. For document extraction, structure preservation, and multilingual support, Chandra sets a new benchmark. The accuracy gap isn’t marginal—it’s decisive.
