🤖 AI Tools
· 6 min read

Surya OCR: The 650M Model That Outperforms Giants (2026)

Surya is the OCR model that shouldn’t work as well as it does. At 650M parameters, it’s a fraction of the size of models like Baidu Unlimited-OCR (3B), yet it scores 83.3% on olmOCR-bench, making it the top-scoring model under 3B parameters. It handles 90+ languages, recognizes tables and layouts, and runs fast enough for production use.

If you need OCR that’s accurate, fast, and doesn’t require a massive GPU, Surya is worth serious consideration.

What is Surya?

Surya comes from VikParuchuri, the same developer who contributed to Tesseract and later built the Marker document conversion tool. It’s designed from the ground up to be practical: fast inference, broad language support, and good accuracy without massive hardware requirements.

The model architecture is optimized for single-page document processing. Unlike Baidu Unlimited-OCR, it doesn’t do multi-page in a single pass. But for single-page work, it’s faster and often more accurate than larger models.

Key Specs

SpecValue
Parameters650M
LicenseApache 2.0
Languages90+
Multi-pageNo (page-by-page)
Table detectionYes
Layout recognitionYes
Equation supportLimited
Min hardware4 GB VRAM
olmOCR-bench83.3% (top under 3B)

Benchmarks

Surya scores 83.3% on olmOCR-bench, which tests OCR accuracy across diverse document types. Here’s how it compares:

ModelParamsolmOCR-benchSpeed (pages/min)
Surya650M83.3%30-60 (GPU)
Baidu Unlimited-OCR3B81.5%15-30 (GPU)
GOT-OCR 2.0580M78.2%40-80 (GPU)
DeepSeek-OCR 21.3B79.8%20-40 (GPU)
Florence-2770M72.1%50-100 (GPU)
Tesseract 5N/A65.4%200+ (CPU)

Surya outperforms models 4-5x its size while running faster. The only model that beats it on raw accuracy is Baidu Unlimited-OCR on certain document types, but Surya is 2x faster.

Strengths

Speed: At 650M params, Surya is one of the fastest neural OCR models. On an RTX 3060, expect 30-60 pages per minute. On CPU, it’s slower (5-10 pages/minute) but still usable for batch processing.

Language breadth: 90+ languages is the broadest among neural OCR models. Most competitors support 20-40 languages. If you process documents in less-common languages (Vietnamese, Thai, Polish, etc.), Surya is more likely to handle them well.

Table and layout detection: Built-in. No need for a separate layout analysis model. Surya identifies tables, figures, text blocks, and headers in a single pass.

Active development: VikParuchuri releases updates frequently. The model has been refined multiple times since launch, with each version improving accuracy and speed.

Apache 2.0 license: No restrictions on commercial use, modification, or redistribution.

Weaknesses

No multi-page support: Unlike Baidu Unlimited-OCR, Surya processes one page at a time. For multi-page PDFs, you need to split them first and reassemble the results.

Limited equation support: LaTeX equation extraction is limited compared to GOT-OCR 2.0 or Nougat. If you process academic papers with heavy math, Surya isn’t the best choice.

Single-pass output: Output is plain text with bounding boxes. No structured HTML tables or formatted output like Baidu Unlimited-OCR provides.

Newer community: While growing fast, Surya’s community is smaller than Tesseract’s or PaddleOCR’s. Fewer tutorials, fewer pre-trained variants, fewer integration examples.

Setup

Installation

pip install surya-ocr

For GPU acceleration:

pip install surya-ocr[gpu]

Basic usage

from surya.ocr import run_ocr
from surya.model.detection.model import load_model as load_det_model
from surya.model.recognition.model import load_model as load_rec_model
from surya.model.recognition.processor import load_processor
from PIL import Image

# Load models
det_model = load_det_model()
det_processor = load_processor()
rec_model = load_rec_model()
rec_processor = load_processor()

# Load image
image = Image.open("document.png")

# Run OCR
result = run_ocr(
    [image],
    [["en", "fr"]],  # languages per image
    det_model,
    det_processor,
    rec_model,
    rec_processor
)

# Access results
for line in result[0]:
    print(f"Text: {line.text}")
    print(f"Confidence: {line.confidence}")
    print(f"Bounding box: {line.bbox}")

Processing PDFs

from surya.ocr import run_ocr
from pdf2image import convert_from_path

# Convert PDF to images
images = convert_from_path("document.pdf", dpi=300)

# Process each page
for i, image in enumerate(images):
    result = run_ocr(
        [image],
        [["en"]],
        det_model, det_processor,
        rec_model, rec_processor
    )
    print(f"--- Page {i+1} ---")
    for line in result[0]:
        print(line.text)

Batch processing

import os
from surya.ocr import run_ocr

# Process all images in a directory
image_dir = "./documents"
images = []
languages = []

for filename in os.listdir(image_dir):
    if filename.endswith(('.png', '.jpg', '.jpeg')):
        img = Image.open(os.path.join(image_dir, filename))
        images.append(img)
        languages.append(["en"])  # adjust per document

results = run_ocr(
    images,
    languages,
    det_model, det_processor,
    rec_model, rec_processor
)

for i, result in enumerate(results):
    print(f"--- {os.listdir(image_dir)[i]} ---")
    for line in result:
        print(line.text)

Performance tips

GPU memory optimization:

  • Process images at 300 DPI (higher doesn’t improve accuracy much)
  • Batch process multiple images together when possible
  • Clear GPU memory between large batches

Speed optimization:

  • Use GPU (10-30x faster than CPU)
  • Process pages in parallel for multi-page PDFs
  • Resize very large images before processing

Accuracy optimization:

  • Use language-specific models when available
  • Set appropriate DPI for PDF conversion (300 is usually optimal)
  • Pre-process images (deskew, denoise) for poor quality scans

When to use Surya

  • You need fast, accurate OCR across many languages
  • You process single-page documents (or can split multi-page)
  • You have modest GPU hardware (4 GB VRAM minimum)
  • You need table and layout detection built-in
  • You want active development and frequent updates

When to use something else

  • Multi-page PDFs in one shot: Baidu Unlimited-OCR
  • Academic papers with heavy math: GOT-OCR 2.0 or Nougat
  • Ultra-lightweight (phone/edge): PaddleOCR-VL (34.5M params)
  • Complex layouts: Dolphin (analyze-then-parse approach)
  • No GPU at all: Tesseract 5

My take

Surya is the best open-source OCR model for most developers. It’s fast, accurate, handles 90+ languages, and runs on modest hardware. The 83.3% olmOCR-bench score at only 650M params is genuinely impressive.

The main limitation is no multi-page support. If you process lots of multi-page PDFs, Baidu Unlimited-OCR is still the better choice. But for single-page documents, receipts, forms, and general text extraction, Surya is hard to beat.

If you’re starting a new OCR project today, start with Surya. It’s the safest bet for quality, speed, and future development.

FAQ

Is Surya better than Baidu Unlimited-OCR?

For single-page accuracy, yes (83.3% vs 81.5% on olmOCR-bench). For multi-page PDFs, no. Baidu Unlimited-OCR handles multi-page in a single pass. Surya requires page-by-page processing.

How fast is Surya?

On a GPU (RTX 3060), expect 30-60 pages per minute. On CPU, 5-10 pages per minute. Speed depends on document complexity and image resolution.

What languages does Surya support?

90+ languages, the broadest among neural OCR models. Includes English, Chinese, Japanese, Korean, and most European languages. For less-common languages, Surya is more likely to have coverage than alternatives.

Can I use Surya commercially?

Yes. Surya uses the Apache 2.0 license, which allows commercial use, modification, and redistribution without restrictions.

Does Surya handle handwriting?

Limited. Like most open-source OCR models, Surya struggles with handwriting. For handwritten documents, cloud services (Google, Mistral) still significantly outperform.

How do I run Surya on a server?

Use the Python API with a web framework like FastAPI. Process images in batches for efficiency. See the setup section above for code examples. For production, add rate limiting and error handling.

You might also like

dots.ocr: The 1.7B Model That Reads Any Script (2026)

dots.ocr is a 1.7B parameter OCR model that handles virtually any writing system. Setup, benchmarks, and how it compares to Surya and Baidu OCR.

GLM-OCR: Zhipu AI's Document Understanding Model (2026)

GLM-OCR is a 500M parameter OCR model from Zhipu AI with strong Chinese document support and Multi-Token Prediction loss. Setup, benchmarks, and comparisons.

Dolphin OCR: ByteDance's Layout-Aware Document Parser (2026)

Dolphin is a 400M parameter OCR model from ByteDance that uses analyze-then-parse for complex document layouts. Setup, benchmarks, and comparisons.

Best Open-Source OCR Models 2026 (Compared)

Every open-source OCR model worth using in 2026: Baidu Unlimited-OCR, Surya, dots.ocr, PaddleOCR-VL, Dolphin, and more. Benchmarks, pricing, and recommendations.