Latest: v3.7.0 — PP-OCRv6 Released June 2026

Turn Any Document Into
Structured AI-Ready Data.

PaddleOCR is the world's most accurate open-source OCR toolkit. Extract text from PDFs and images in 100+ languages, parse complex tables and layouts, and output clean JSON or Markdown — ready for LLMs and RAG pipelines.

Get Started View on GitHub Read the Docs →
Quick Install 
# Install PaddleOCR (Python 3.8-3.12)
$ pip install paddlepaddle paddleocr

# Quick OCR — extract text from any image
$ python -c "from paddleocr import PaddleOCR; r=PaddleOCR(lang='en'); print(r.predict('image.jpg'))"

# Parse a PDF into Markdown
$ python -c "from paddleocr import PPStructureV3; r=PPStructureV3(); r.predict('doc.pdf')"
86k+
GitHub Stars
100+
Languages Supported
6k+
Dependent Repos
96.3%
Doc Parsing Accuracy
Apache 2.0
License
Project Overview

What is PaddleOCR?

PaddleOCR is an ultra-lightweight, production-grade OCR and Document AI toolkit created by Baidu's PaddlePaddle team. It parses PDFs, scanned documents, and images into structured, LLM-ready JSON and Markdown formats with industry-leading accuracy — achieving 96.33% benchmark precision on OmniDocBench v1.6.

Supporting 100+ languages natively, PaddleOCR recognizes complex document components including multi-column tables, LaTeX mathematical formulas, charts, and seals. Its modular architecture — including PP-OCRv6, PP-StructureV3, and PaddleOCR-VL — is trusted by 6,000+ open-source repositories including Dify, RAGFlow, Pathway, and Cherry Studio.

🎯
96.33% Accuracy OmniDocBench v1.6 Benchmark
🌍
100+ Languages Multilingual Text Recognition
⚡
PP-OCRv6 & PP-StructureV3 Next-Gen Vision-Language Pipeline
Capabilities

Everything You Need for Document AI

PaddleOCR bundles a complete document intelligence stack — from raw text extraction to semantic document parsing.

SOTA 2026

Intelligent Document Parsing (LLM-Ready)

PaddleOCR's PP-StructureV3 pipeline converts complex PDFs and images into clean Markdown or JSON with full structural awareness — including table cell coordinates, formula positions, text bounding boxes, and reading order. The PaddleOCR-VL-1.6 vision-language model achieves 96.33% accuracy on OmniDocBench v1.6, outperforming all major open-source and proprietary solutions for structured document parsing.

100+ Languages, One Model

PP-OCRv6's unified model covers Chinese, English, Japanese, and 46 Latin-script languages simultaneously — no model switching needed. Specialized support for Arabic, Devanagari, Korean, and more via dedicated language models.

5.2× CPU Speedup

PP-OCRv6 with OpenVINO backend achieves 5.2× faster inference on Intel CPUs and 6.1× on Apple M4, delivering sub-second OCR even on commodity hardware.

Table & Formula Recognition

Full table structure detection with cell-level coordinate extraction, plus LaTeX formula recognition — essential for scientific papers, financial reports, and technical manuals.

Three Model Tiers

Choose your hardware profile: Tiny (1.5M params) for edge/IoT, Small (7.7M) for mobile, Medium (34.5M) for server-grade accuracy that beats VLMs 20× its size.

Deep AI Ecosystem Integration

PaddleOCR is the premier document parsing choice for the AI agent ecosystem. It is natively integrated with Dify, RAGFlow, Pathway, and Cherry Studio — the most widely used RAG and AI workflow platforms. The toolkit also supports MCP (Model Context Protocol) server mode, enabling direct tool use by LLM agents. Official SDKs are available for Python, Go, and TypeScript.

Browser Inference with PaddleOCR.js

Run PP-OCRv5 entirely in the browser via the official PaddleOCR.js SDK — no server required. Perfect for client-side document scanning in web applications.

Get PaddleOCR

Install on Any Platform

PaddleOCR is a Python package. Install it with pip on any OS. Python 3.8–3.12 required.

PaddleOCR requires PaddlePaddle as its deep learning framework. Install the CPU or GPU version of PaddlePaddle first, then install PaddleOCR.

Platform Method Install Command Link / Notes
🐧 Linux / macOS (CPU) pip
pip install paddlepaddle paddleocr
PyPI
🪟 Windows (CPU) pip
pip install paddlepaddle paddleocr
Python 3.8–3.12, cmd or PowerShell
🖥️ NVIDIA GPU (Linux/Win) pip (CUDA)
pip install paddlepaddle-gpu paddleocr
CUDA 11.8+ required
🍎 macOS Apple Silicon pip
pip install paddlepaddle paddleocr
6.1× speedup on M4 chip
🐳 Docker Docker Hub
docker pull paddlecloud/paddleocr:latest
Docker Hub
📦 Source Build git + pip
git clone https://github.com/PaddlePaddle/PaddleOCR.git && pip install -e .
GitHub
🌐 Browser (JS) npm / CDN
npm install paddleocr-js
Official PaddleOCR.js SDK
☁️ Cloud / Colab pip (notebook)
!pip install paddlepaddle paddleocr
Google Colab, Kaggle, SageMaker
🤗 HuggingFace Transformers backend
pip install paddleocr transformers
HuggingFace ecosystem integration
GPU Install + First Run 
# Step 1: Install PaddlePaddle with GPU support (CUDA 11.8+)
$ pip install paddlepaddle-gpu paddleocr

# Step 2: Run OCR on an image
$ python -c "
from paddleocr import PaddleOCR

ocr = PaddleOCR(use_gpu=True, lang='en')  # Initialize once
result = ocr.predict('document.jpg')       # Returns structured data

for page in result:
    for block in page['rec_texts']:
        print(block)                        # Extracted text blocks
"
Comparison

PaddleOCR vs Tesseract vs EasyOCR vs TrOCR

See how PaddleOCR compares to the most popular OCR solutions in 2026.

Unlike Tesseract, which relies on traditional image processing and struggles with complex layouts and non-Latin scripts, PaddleOCR uses deep learning models that achieve 4-5× higher accuracy on real-world documents. Unlike EasyOCR, PaddleOCR natively handles table structure recognition, formula detection, and document layout analysis without additional libraries. Compared to TrOCR, PaddleOCR offers a complete end-to-end document processing pipeline with production-ready deployment options, not just a single-model text recognizer.

Feature PaddleOCR Tesseract EasyOCR TrOCR AWS Textract
License Apache 2.0 (Free) Apache 2.0 (Free) Apache 2.0 (Free) MIT (Free) Proprietary (Paid)
Doc Benchmark Accuracy 96.3% (SOTA) ~75% complex docs ~82% complex docs ~88% text passages ~91% (proprietary)
Languages (out-of-box) 100+ (50 unified) 100+ (separate pkgs) 80+ ~40 ~50
Table Structure Recognition Full (PP-StructureV3) No Basic No Yes
PDF to Markdown/JSON Native No No No Yes
Formula Detection Yes No No No Limited
GPU / NPU Support NVIDIA, XPU, NPU, CPU CPU only CUDA GPU, CPU CUDA GPU, CPU Cloud managed
LLM / RAG Integration Native (Dify, RAGFlow) Manual integration Manual integration Manual integration AWS ecosystem
Self-Hosted / Privacy Fully self-hosted Fully self-hosted Fully self-hosted Self-hosted Cloud only
Browser Inference PaddleOCR.js No No No No

PaddleOCR vs Tesseract: Key Differences

Why PaddleOCR replaces Tesseract in modern pipelines: Tesseract relies on legacy image processing (Leptonica) and traditional LSTM models, making it struggle with non-horizontal text, table structures, and low-contrast scans. In contrast, PaddleOCR uses deep learning (PP-OCRv6 DBNet detection + SVTR recognition) achieving 96.3% accuracy vs Tesseract's ~75% on real-world documents. Furthermore, PaddleOCR natively parses tables into HTML, extracts LaTeX formulas, and supports 100+ languages without manual TESSDATA downloading.

# Pytesseract (Legacy): pytesseract.image_to_string(img) # Plain string only
# PaddleOCR (Modern): PaddleOCR().predict(img) # Structured JSON/Markdown + Tables + Boxes

PaddleOCR vs EasyOCR: Performance & Accuracy

Benchmarking PaddleOCR vs EasyOCR: While EasyOCR offers a clean PyTorch interface, it requires significantly more GPU VRAM (~1.8 GB vs PaddleOCR's 600 MB) and lacks native document structure analysis. PaddleOCR delivers 3.2× faster inference latency on CPU using OpenVINO, offers 3 hardware-tuned model sizes (Tiny 1.5M, Small 7.7M, Medium 34.5M), and includes PP-StructureV3 for full PDF parsing directly to Markdown.

Quick Reference

PaddleOCR Command Cheatsheet

The most common PaddleOCR usage patterns — copy and run.

Basic OCR on an Image

Extract text from any image file

from paddleocr import PaddleOCR
ocr = PaddleOCR(lang='en')
result = ocr.predict('image.jpg')
print(result)

OCR with Bounding Boxes

Get text with coordinate positions

ocr = PaddleOCR(lang='en')
result = ocr.predict('image.jpg')
for page in result:
    for box, text in zip(
        page['rec_boxes'],
        page['rec_texts']
    ):
        print(f"{text}: {box}")

Parse PDF to Markdown

Convert PDF to structured Markdown

from paddleocr import PPStructureV3
pipeline = PPStructureV3()
output = pipeline.predict('doc.pdf')
# output contains Markdown per page
for page in output:
    print(page['markdown'])

Multilingual OCR

OCR in Chinese, Japanese, Arabic, etc.

ocr = PaddleOCR(lang='ch')  # Chinese
result = ocr.predict('chinese.jpg')

# Other langs: 'japan', 'arabic', 'korean',
# 'french', 'german', 'latin', etc.
ocr_jp = PaddleOCR(lang='japan')

Table Recognition

Extract tables from images as HTML

from paddleocr import PPStructureV3
pipeline = PPStructureV3()
result = pipeline.predict('table.png')
for page in result:
    for block in page['blocks']:
        if block['type'] == 'table':
            print(block['html'])

Vision-Language Parsing (VL)

SOTA document parsing with PaddleOCR-VL

from paddleocr import PaddleOCRVL
vl = PaddleOCRVL(model='VL-1.6')
result = vl.predict(
    image='complex_doc.pdf',
    output_format='markdown'
)
print(result)

Save Results to JSON

Export OCR results as structured JSON

import json
from paddleocr import PaddleOCR

ocr = PaddleOCR(lang='en')
result = ocr.predict('document.jpg')

with open('output.json', 'w') as f:
    json.dump(result, f, ensure_ascii=False)

Batch Processing

Process multiple images at once

import glob
from paddleocr import PaddleOCR

ocr = PaddleOCR(lang='en')
images = glob.glob('docs/*.jpg')

for img_path in images:
    result = ocr.predict(img_path)
    print(f"{img_path}: done")

Install via pip (quick ref)

Install PaddleOCR on any system

# CPU (all platforms)
pip install paddlepaddle paddleocr

# GPU (CUDA 11.8+)
pip install paddlepaddle-gpu paddleocr

# Verify install
python -c "import paddleocr; print('OK')"

CLI Usage

Run PaddleOCR from the command line

# Run OCR on image via CLI
paddleocr --image_dir=./imgs \
          --lang=en \
          --use_gpu=False

# Run structure analysis
paddleocr --image_dir=./imgs \
          --type=structure
Ecosystem

Integrations & Ecosystem Tools

PaddleOCR is the backbone of dozens of AI applications, RAG platforms, and document processing tools.

Dify

RAG Platform Open Source

The most popular open-source LLM application platform. Uses PaddleOCR as its primary document parsing engine for building AI assistants from PDF/image knowledge bases.

RAGFlow

RAG Engine Open Source

Deep document understanding RAG engine that relies on PaddleOCR for high-accuracy extraction from PDFs, scanned documents, and images before vector indexing.

Pathway

Data Pipeline Open Source

Real-time data processing framework integrated with PaddleOCR for streaming document parsing pipelines — ideal for continuous document ingestion into LLM applications.

Cherry Studio

AI Desktop App Open Source

AI-powered desktop application using PaddleOCR for document import and RAG-based knowledge management, enabling chat with your document libraries.

HuggingFace Hub

Model Hub Partnership

All PaddleOCR models (PP-OCRv6, PaddleOCR-VL) are available on HuggingFace Hub and support the Transformers inference backend for seamless ecosystem integration.

ModelScope

Model Hub Partnership

Alibaba's ModelScope hosts all PP-OCRv6 models with one-click inference demos and downloadable weights for Chinese and international language recognition.

PaddleOCR.js

Browser SDK Official

The official JavaScript SDK for running PP-OCRv5 inference directly in the browser via WebAssembly — no backend server required. Ideal for client-side document scanning applications.

FastDeploy

Deployment Official

Baidu's FastDeploy toolkit provides one-click high-performance deployment of PaddleOCR models across NVIDIA GPU, Intel CPU, ARM, and diverse AI accelerator platforms.

MCP Server Mode

AI Agent Tool Official

PaddleOCR v3.5+ ships with a built-in MCP (Model Context Protocol) server, making PaddleOCR directly callable as a tool by Claude, ChatGPT, and other LLM agents.

Config Generator

Generate Your PaddleOCR Config

Build a custom PaddleOCR initialization script for your use case — copy or download it.

⚙️ Configuration Options

📄 Generated Code 


            

            

              
            

          

        

      

    


    
    

      

        

          FAQ
          
Frequently Asked Questions

          
Answers to the most common questions about PaddleOCR.

        


        


          

            
              What is PaddleOCR and what is it used for?
              
            
            

              
PaddleOCR is an open-source Optical Character Recognition (OCR) toolkit and document AI engine developed by Baidu's PaddlePaddle team. PaddleOCR is used to extract text from images and PDF documents, parse complex document structures (tables, formulas, charts), and convert unstructured document content into structured JSON or Markdown formats suitable for downstream AI applications. PaddleOCR is widely used in RAG (Retrieval-Augmented Generation) systems, document digitization workflows, invoice processing, ID card recognition, industrial text reading, and LLM knowledge base construction.

            

          


          

            
              Is PaddleOCR free? What is the license?
              
            
            

              
Yes, PaddleOCR is completely free to use for personal and commercial purposes. PaddleOCR is licensed under the Apache License 2.0, which is a permissive open-source license allowing use, modification, and redistribution in both open-source and proprietary commercial products. There are no runtime fees, no per-page charges, and no API limits. All PaddleOCR models, including PP-OCRv6 and PaddleOCR-VL, are freely available for download from GitHub, PyPI, HuggingFace Hub, and ModelScope.

            

          


          

            
              How do I install PaddleOCR on Windows?
              
            
            

              
To install PaddleOCR on Windows, open Command Prompt or PowerShell and run: pip install paddlepaddle paddleocr. PaddleOCR requires Python 3.8 through 3.12 — make sure you have a compatible Python version installed. For GPU acceleration on Windows with an NVIDIA card, install the GPU version instead: pip install paddlepaddle-gpu paddleocr. After installation, verify with: python -c "from paddleocr import PaddleOCR; print('PaddleOCR installed successfully')". If you encounter errors, ensure you are running Python 64-bit and have the Microsoft Visual C++ Redistributable installed.

            

          


          

            
              PaddleOCR vs EasyOCR — which should I choose?
              
            
            

              
PaddleOCR and EasyOCR are both deep-learning-based OCR solutions, but PaddleOCR is significantly more capable for production use cases. PaddleOCR achieves higher accuracy on structured documents, supports complete document layout analysis (tables, formulas, reading order), natively outputs JSON/Markdown for LLM use, and offers three model tiers for different hardware constraints. EasyOCR is simpler to get started with and has a more Pythonic API, making it suitable for rapid prototyping on straightforward text extraction tasks. However, for anything involving complex documents, PDFs, table recognition, or RAG pipelines, PaddleOCR is the superior choice due to its PP-StructureV3 pipeline and PaddleOCR-VL models.

            

          


          

            
              PaddleOCR not working — common fixes
              
            
            

              
The most common PaddleOCR issues and their fixes are: (1) ImportError or ModuleNotFoundError — ensure PaddlePaddle is installed first with pip install paddlepaddle before installing PaddleOCR. (2) Model download fails — PaddleOCR downloads models on first run; ensure you have internet access and write permissions to the cache directory (~/.paddleocr/). (3) CUDA out of memory — use a smaller model tier (tiny or small) or set use_gpu=False. (4) Python version incompatibility — PaddleOCR supports Python 3.8 through 3.12 only; Python 3.13+ is not supported. (5) Slow first run — model inference is slow on first invocation due to model initialization; subsequent calls are much faster. If problems persist, check the GitHub Issues tracker.

            

          


          

            
              How do I use PaddleOCR with Dify or RAGFlow?
              
            
            

              
PaddleOCR is natively integrated into both Dify and RAGFlow, making setup straightforward. In Dify, PaddleOCR is available as a built-in document parser — when you upload PDF files to a Dify knowledge base, PaddleOCR is used automatically for extraction if configured. In RAGFlow, PaddleOCR powers the document parsing engine; install RAGFlow and PaddleOCR in the same environment and RAGFlow will detect and use it. For custom integrations, use PaddleOCR's PP-StructureV3 pipeline to generate Markdown or JSON output, then pass that output to your vector store (Pinecone, Weaviate, Qdrant, etc.) as document chunks. The paddleocr package also supports MCP server mode, enabling direct LLM agent tool use.

            

          


          

            
              What is the latest version of PaddleOCR?
              
            
            

              
The latest stable version of PaddleOCR is v3.7.0, released on June 11, 2026. This release introduces PP-OCRv6, the most accurate PaddleOCR model to date, achieving +4.6% detection accuracy and +5.1% recognition accuracy improvements over the previous PP-OCRv5_server — surpassing much larger vision-language models like Qwen3-VL-235B and GPT-5.5 with only 34.5M parameters. PP-OCRv6 unifies 50 languages into a single model and offers a 5.2× CPU speedup via OpenVINO. You can always install the latest version with pip install --upgrade paddleocr.

            

          


          

            
              Can PaddleOCR recognize handwriting?
              
            
            

              
PaddleOCR has limited handwriting recognition capabilities in its standard pipeline models (PP-OCRv6). For printed text, typed documents, and digital-native content, PaddleOCR achieves excellent accuracy. For handwritten content, the PaddleOCR-VL vision-language model performs significantly better, as it is trained on diverse document types including handwritten notes. For dedicated handwriting recognition tasks, TrOCR (Microsoft's Transformer-based OCR model, available on HuggingFace) or Google Cloud Vision API may offer better accuracy on cursive or messy handwriting. PaddleOCR excels at printed, machine-generated, and semi-structured text.

            

          


          

            
              What is PaddleOCR-VL and how does it work?
              
            
            

              
PaddleOCR-VL (Vision-Language) is a specialized 0.9B parameter vision-language model designed specifically for complex document AI parsing. Unlike conventional OCR pipelines that separate detection and recognition, PaddleOCR-VL processes entire pages holistically using vision-language understanding. PaddleOCR-VL-1.6 achieves a SOTA 96.33% score on OmniDocBench v1.6, excelling at complex tables, LaTeX mathematical formulas, ancient scripts, seals, and multi-column academic papers directly to LLM-ready Markdown.

            

          


          

            
              PP-OCRv5 vs PP-OCRv6 — What are the key differences?
              
            
            

              
PP-OCRv6 is the latest flagship OCR engine introduced in PaddleOCR v3.7.0 (June 2026), replacing PP-OCRv5. PP-OCRv6 delivers +4.6% detection accuracy and +5.1% recognition accuracy improvements over PP-OCRv5_server. Key differences include: (1) Unified Multilingualism: PP-OCRv6 covers 50 languages in a single model vs separate language models in PP-OCRv5. (2) Model Tiers: PP-OCRv6 introduces 3 hardware tiers (Tiny 1.5M, Small 7.7M, Medium 34.5M). (3) Speed: 5.2× CPU speedup via OpenVINO backend optimization.