PaddleOCR-VL is the smallest serious OCR model available. At 34.5 million parameters (not billion), it runs on phones, Raspberry Pis, and edge devices while achieving document understanding scores that rival models 1000x its size. The trick: it’s a specialized vision-language model, not a general-purpose one.
This is from Baidu’s own PaddlePaddle team, and it creates an interesting comparison with Baidu’s other OCR model, Unlimited-OCR. PaddleOCR-VL is for speed and edge deployment. Unlimited-OCR is for maximum quality.
What is PaddleOCR-VL?
PaddleOCR-VL (also called PP-OCRv6) is part of the PaddleOCR toolkit, Baidu’s open-source OCR framework built on PaddlePaddle. Version 6 introduces a vision-language model that achieves surprisingly strong document understanding at a fraction of the size of dedicated OCR models.
The key innovation: instead of building a massive model and hoping it works on edge devices, PaddleOCR-VL was designed from the ground up for efficiency. Every architectural choice optimizes for the smallest possible model that still delivers usable accuracy.
Key Specs
| Spec | Value |
|---|---|
| Parameters | 34.5M |
| License | Apache 2.0 |
| Languages | 100+ |
| Multi-page | No (page-by-page) |
| Table detection | Yes |
| Layout recognition | Yes |
| Equation support | No |
| Min hardware | 2 GB VRAM (or CPU) |
| Framework | PaddlePaddle |
What makes it different
Incredible efficiency: 34.5M params is 100x smaller than Baidu Unlimited-OCR (3B) and 20x smaller than Surya (650M). Yet it achieves competitive accuracy on standard benchmarks. This is not a toy model.
Runs on phones: With 2 GB VRAM minimum (and CPU support), PaddleOCR-VL can run on mobile devices, Raspberry Pi, and other edge hardware. No other serious OCR model can claim this.
100+ language support: Despite its tiny size, PaddleOCR-VL supports over 100 languages. The PaddleOCR team has spent years building language-specific training data.
PaddlePaddle ecosystem: If you’re already using PaddlePaddle for other ML tasks, PaddleOCR-VL integrates naturally. The toolkit includes text detection, recognition, and document understanding in a unified framework.
Apache 2.0 license: No restrictions on commercial use, modification, or redistribution.
Benchmarks
PaddleOCR-VL’s benchmarks are impressive for its size:
| Model | Params | Document Understanding | Speed (CPU) | Speed (GPU) |
|---|---|---|---|---|
| PaddleOCR-VL | 34.5M | Competitive with 1B+ models | 5-10 pages/min | 50-100 pages/min |
| Surya | 650M | 83.3% olmOCR-bench | 5-10 pages/min | 30-60 pages/min |
| Baidu Unlimited-OCR | 3B | 81.5% olmOCR-bench | 1-2 pages/min | 15-30 pages/min |
| GOT-OCR 2.0 | 580M | 78.2% olmOCR-bench | 10-20 pages/min | 40-80 pages/min |
On CPU, PaddleOCR-VL is competitive with Surya on speed while being 20x smaller. On GPU, it’s the fastest serious OCR model available.
The Baidu comparison: Baidu now has two OCR models. Unlimited-OCR (3B, MIT) for maximum quality and PaddleOCR-VL (34.5M, Apache 2.0) for maximum efficiency. On some benchmarks, PaddleOCR-VL actually outperforms its larger sibling. The choice depends on your hardware constraints and accuracy requirements.
Setup
Installation
pip install paddlepaddle paddleocrFor GPU acceleration:
pip install paddlepaddle-gpu paddleocrBasic usage
from paddleocr import PaddleOCR
# Initialize OCR
ocr = PaddleOCR(use_angle_cls=True, lang='en')
# Process an image
result = ocr.ocr('document.png')
# Access results
for line in result[0]:
bbox = line[0]
text = line[1][0]
confidence = line[1][1]
print(f"Text: {text} (confidence: {confidence:.3f})")Processing PDFs
from paddleocr import PaddleOCR
from pdf2image import convert_from_path
ocr = PaddleOCR(use_angle_cls=True, lang='en')
# Convert PDF to images
images = convert_from_path('document.pdf', dpi=300)
# Process each page
for i, image in enumerate(images):
result = ocr.ocr(np.array(image))
print(f"--- Page {i+1} ---")
for line in result[0]:
print(line[1][0])Multi-language support
from paddleocr import PaddleOCR
# Process Chinese document
ocr_cn = PaddleOCR(lang='ch')
# Process Japanese document
ocr_ja = PaddleOCR(lang='japanese')
# Process Arabic document
ocr_ar = PaddleOCR(lang='arabic')
# Process with auto-detection
ocr = PaddleOCR(lang='en') # primary languageTable extraction
from paddleocr import PPStructure
# Initialize structure analysis
structure = PPStructure(show_log=False)
# Process document with table detection
result = structure('document_with_table.png')
for item in result:
if item['type'] == 'table':
print("Table found:")
print(item['res']) # HTML table representationEdge deployment
Mobile (Android/iOS)
PaddleOCR-VL can be compiled for mobile platforms using Paddle Lite:
# Download pre-built mobile library
wget https://github.com/PaddlePaddle/Paddle-Lite/releases/download/v2.13/inference_lite_lib.android.armv8.clang.c++_shared.with_extra.with_cv.tar.gz
# Or build from source
git clone https://github.com/PaddlePaddle/Paddle-Lite.git
cd Paddle-Lite
./lite_tools.sh build_linuxRaspberry Pi
# Install on Raspberry Pi
pip install paddlepaddle paddleocr
# Run with CPU only
python -c "
from paddleocr import PaddleOCR
ocr = PaddleOCR(use_angle_cls=True, lang='en', use_gpu=False)
result = ocr.ocr('test.png')
print(result)
"Docker deployment
FROM python:3.9-slim
RUN pip install paddlepaddle paddleocr
COPY app.py /app/
WORKDIR /app
CMD ["python", "app.py"]When to use PaddleOCR-VL
- You need OCR on edge devices (phones, Raspberry Pi, IoT)
- You have limited GPU memory (2 GB minimum)
- You process high-volume, simple documents
- You’re already in the PaddlePaddle ecosystem
- You need the smallest possible model with decent accuracy
When to use something else
- Maximum accuracy: Baidu Unlimited-OCR (3B) or Surya (650M)
- Multi-page PDFs: Baidu Unlimited-OCR (single-pass multi-page)
- Multilingual scripts (Arabic, Devanagari): dots.ocr (1.7B, script-agnostic)
- Academic papers with equations: GOT-OCR 2.0 (better equation handling)
- Complex layouts: Dolphin (analyze-then-parse approach)
My take
PaddleOCR-VL is a remarkable engineering achievement. A 34.5M parameter model that delivers usable OCR accuracy across 100+ languages is genuinely impressive. The fact that it runs on phones and Raspberry Pis opens up use cases that no other serious OCR model can serve.
For most server-side OCR work, Surya or Baidu Unlimited-OCR are better choices. They’re more accurate and not much slower on GPU. But the moment you need edge deployment, PaddleOCR-VL is the only game in town.
The Baidu comparison is interesting. Unlimited-OCR is Baidu’s “maximum quality” model. PaddleOCR-VL is their “maximum efficiency” model. If you’re choosing between them, the question is simple: do you have a GPU? If yes, Unlimited-OCR. If no, PaddleOCR-VL.
FAQ
Is PaddleOCR-VL better than Baidu Unlimited-OCR?
For accuracy, no. Unlimited-OCR (3B params) is more accurate on most benchmarks. For speed and edge deployment, yes. PaddleOCR-VL (34.5M params) runs on phones and Raspberry Pis. The choice depends on your hardware constraints.
Can PaddleOCR-VL run on a phone?
Yes. PaddleOCR-VL can be compiled for Android and iOS using Paddle Lite. It’s the smallest serious OCR model that can run on mobile devices. See the edge deployment section above.
How fast is PaddleOCR-VL?
On CPU: 5-10 pages per minute. On GPU: 50-100 pages per minute. It’s the fastest serious OCR model on GPU, and competitive with much larger models on CPU.
What languages does PaddleOCR-VL support?
100+ languages, including English, Chinese, Japanese, Korean, and most European languages. Despite its tiny size, PaddleOCR-VL has broad language coverage thanks to the PaddleOCR team’s extensive training data.
Can I use PaddleOCR-VL commercially?
Yes. PaddleOCR-VL uses the Apache 2.0 license, which allows commercial use, modification, and redistribution without restrictions.
How do I choose between PaddleOCR-VL and Surya?
If you need edge deployment (phones, Raspberry Pi), use PaddleOCR-VL. If you need maximum accuracy on a GPU, use Surya (650M params, 83.3% olmOCR-bench). PaddleOCR-VL is smaller and faster, but Surya is more accurate.