# Where to Find Pre-Trained PaddleOCR Models: The Complete Model Zoo Guide

> Discover pre-trained PaddleOCR models easily. Find download links for detection, recognition, and classification weights in the official Model Zoo.

- Repository: [PaddlePaddle/PaddleOCR](https://github.com/PaddlePaddle/PaddleOCR)
- Tags: getting-started
- Published: 2026-03-03

---

**Pre-trained PaddleOCR models are centrally hosted in the Model Zoo at [`docs/version2.x/ppocr/model_list.en.md`](https://github.com/PaddlePaddle/PaddleOCR/blob/main/docs/version2.x/ppocr/model_list.en.md), providing direct download URLs for detection, recognition, and classification weights in inference, trained, and Paddle-Lite NB formats.**

PaddleOCR maintains an extensive collection of production-ready OCR models through its official Model Zoo within the PaddlePaddle/PaddleOCR repository. These pre-trained PaddleOCR models cover the complete OCR pipeline—including text detection, recognition, and angle classification—with specific variants optimized for Chinese, English, and multilingual scenarios.

## The Central Model Zoo Location

All pre-trained model download links are cataloged in the **Model List** document located at [`docs/version2.x/ppocr/model_list.en.md`](https://github.com/PaddlePaddle/PaddleOCR/blob/main/docs/version2.x/ppocr/model_list.en.md) in the repository root. This file contains structured tables organizing models by component type, each listing model size, description, configuration references, and direct download URLs for three distinct formats.

### Available Model Categories

The Model Zoo organizes pre-trained weights into four primary component categories:

- **Text Detection**: Includes `PP-OCRv4_mobile_det`, `PP-OCRv3_server_det`, and slimmed variants like `en_PP-OCRv3_det_slim` for Chinese, English, and multilingual detection.
- **Text Recognition**: Offers `PP-OCRv3_mobile_rec`, `en_PP-OCRv3_mobile_rec_slim`, and language-specific variants such as `korean_PP-OCRv3_mobile_rec`.
- **Text Angle Classification**: Provides `ch_ppocr_mobile_v2.0_cls` and slim variants for orientation detection.
- **Paddle-Lite NB Models**: Optimized edge deployment versions including `PP-OCRv2` and `PP-OCRv2(slim)` for mobile and embedded devices.

## Understanding Model Formats

The Model Zoo distributes pre-trained PaddleOCR models in three distinct formats, each serving different deployment and development needs.

### Inference Model Format

The **inference model** format consists of `inference.pdmodel` and `inference.pdiparams` files. These are serialized for immediate deployment with the Paddle Inference engine, enabling fast CPU and GPU inference without training dependencies.

### Trained Model Format

**Trained models** (or checkpoints) contain `*.pdparams`, `*.pdopt`, and `*.states` files. These preserve the complete training state including optimizer information, making them essential for fine-tuning existing weights on custom datasets.

### Paddle-Lite NB Format

**NB models** use the `*.nb` extension and are specifically optimized through Paddle-Lite for ARM-based mobile and embedded devices. These models undergo quantization and graph optimization for edge deployment.

## How to Download Pre-Trained Models

Downloading pre-trained weights requires copying the direct URL from the Model List tables and extracting the tarball to your local environment.

### Command-Line Download

Use standard HTTP clients to fetch inference models directly from the Baidu object storage endpoints listed in the documentation:

```bash

# Download the lightweight Chinese detection model

wget -O PP-OCRv4_mobile_det_infer.tar \
    https://paddle-model-ecology.bj.bcebos.com/paddlex/official_inference_model/paddle3.0.0/PP-OCRv4_mobile_det_infer.tar

# Extract the archive

tar -xf PP-OCRv4_mobile_det_infer.tar

```

For complete pipeline setup, download both detection and recognition models:

```bash
#!/usr/bin/env bash

# Download detection and recognition pair

DETECT_URL="https://paddle-model-ecology.bj.bcebos.com/paddlex/official_inference_model/paddle3.0.0/PP-OCRv4_mobile_det_infer.tar"
RECOG_URL="https://paddle-model-ecology.bj.bcebos.com/paddlex/official_inference_model/paddle3.0.0/PP-OCRv3_mobile_rec_infer.tar"

wget -O det.tar $DETECT_URL && tar -xf det.tar
wget -O rec.tar $RECOG_URL && tar -xf rec.tar

```

## Loading Pre-Trained Models in Python

The `PaddleOCR` class loads downloaded inference models through directory path parameters that point to the extracted model folders.

### Basic Inference Setup

Initialize the OCR pipeline by specifying the local directories containing your downloaded inference files:

```python
from paddleocr import PaddleOCR

# Point to downloaded inference model folders

ocr = PaddleOCR(
    det_model_dir="PP-OCRv4_mobile_det_infer",
    rec_model_dir="PP-OCRv3_mobile_rec_infer",
    use_angle_cls=True,  # Enable angle classification

    lang="ch"            # Match dictionary to model language

)

# Run inference

result = ocr.ocr("example.jpg", cls=True)
print(result)

```

### Complete Visualization Example

For full pipeline execution with result visualization:

```python
from paddleocr import PaddleOCR, draw_ocr
import cv2

# Initialize with explicit model paths

det_dir = "PP-OCRv4_mobile_det_infer"
rec_dir = "PP-OCRv3_mobile_rec_infer"

ocr = PaddleOCR(
    det_model_dir=det_dir,
    rec_model_dir=rec_dir,
    use_angle_cls=True,
    lang="ch"
)

# Process image

img_path = "sample_image.jpg"
result = ocr.ocr(img_path, cls=True)

# Visualize results

image = cv2.imread(img_path)
boxes = [line[0] for line in result[0]]
txts = [line[1][0] for line in result[0]]
scores = [line[1][1] for line in result[0]]

im_show = draw_ocr(image, boxes, txts, scores, font_path='path/to/font.ttf')
cv2.imwrite("result.jpg", im_show)

```

The `det_model_dir` and `rec_model_dir` parameters accept any folder containing valid `inference.pdmodel` and `inference.pdiparams` files. The `lang` parameter automatically selects the appropriate character dictionary from `ppocr/utils/` (e.g., [`en_dict.txt`](https://github.com/PaddlePaddle/PaddleOCR/blob/main/en_dict.txt) for English).

### Mobile Deployment with Paddle-Lite

For edge devices, load the optimized NB models using the Paddle-Lite runtime:

```python
import paddlelite as lite

predictor = lite.Engine()
model_path = "PP-OCRv2/lite/ch_PP-OCRv2_det_opt.nb"
predictor.set_model_from_file(model_path)

# Feed image tensor, invoke inference, and retrieve output

```

## Configuration Files and Architecture Definitions

Each pre-trained model references a **configuration YAML file** that defines the network architecture, preprocessing pipelines, and post-processing parameters.

### Configuration File Locations

Model architectures are defined in files within the `configs/` directory:

- **Detection**: [`configs/det/PP-OCRv4/PP-OCRv4_mobile_det.yml`](https://github.com/PaddlePaddle/PaddleOCR/blob/main/configs/det/PP-OCRv4/PP-OCRv4_mobile_det.yml) defines the lightweight mobile detection network architecture.
- **Recognition**: [`configs/rec/PP-OCRv3/PP-OCRv3_mobile_rec.yml`](https://github.com/PaddlePaddle/PaddleOCR/blob/main/configs/rec/PP-OCRv3/PP-OCRv3_mobile_rec.yml) specifies the recognition backbone and head configuration.

These YAML files are referenced directly in the Model List tables, ensuring you can replicate the exact training setup used to generate the pre-trained weights.

### Core Model Definitions

The underlying neural network implementations reside in `ppocr/modeling/`, containing backbone architectures, detection heads, and post-processing logic. For mobile deployment conversion, the `deploy/slim/` directory provides scripts for quantization and NB model generation.

### Character Dictionaries

Recognition models require specific character dictionaries located in `ppocr/utils/`, such as [`en_dict.txt`](https://github.com/PaddlePaddle/PaddleOCR/blob/main/en_dict.txt) for English models or [`ch_dict.txt`](https://github.com/PaddlePaddle/PaddleOCR/blob/main/ch_dict.txt) for Chinese models. The `lang` parameter in the Python API automatically maps to these dictionary files.

## Summary

- **Primary Location**: All pre-trained PaddleOCR model download links are centralized in [`docs/version2.x/ppocr/model_list.en.md`](https://github.com/PaddlePaddle/PaddleOCR/blob/main/docs/version2.x/ppocr/model_list.en.md) within the PaddlePaddle/PaddleOCR repository.
- **Three Formats**: Models are available as **inference models** (deployment-ready), **trained models** (fine-tuning checkpoints), and **NB models** (mobile-optimized).
- **Download Method**: Use `wget` or `curl` with URLs from the Model Zoo tables, then extract tarballs to access `inference.pdmodel` and `inference.pdiparams` files.
- **Python Integration**: Load models via the `PaddleOCR` class using `det_model_dir` and `rec_model_dir` parameters pointing to extracted inference folders.
- **Configuration**: Architecture definitions in `configs/` and character dictionaries in `ppocr/utils/` ensure reproducible model behavior.

## Frequently Asked Questions

### Where are the official pre-trained PaddleOCR model download links located?

The official download links are maintained in the **Model List** document at [`docs/version2.x/ppocr/model_list.en.md`](https://github.com/PaddlePaddle/PaddleOCR/blob/main/docs/version2.x/ppocr/model_list.en.md) in the PaddleOCR repository. This file contains organized tables with direct URLs to Baidu object storage endpoints for detection, recognition, classification, and Paddle-Lite models, complete with checksums and configuration file references.

### What is the difference between inference models and trained models in PaddleOCR?

**Inference models** consist of `inference.pdmodel` and `inference.pdiparams` files serialized for the Paddle Inference engine, optimized for immediate prediction without training code. **Trained models** contain `*.pdparams`, `*.pdopt`, and `*.states` files representing complete training checkpoints including optimizer states, enabling fine-tuning and resuming training sessions.

### How do I use pre-trained PaddleOCR models on mobile devices?

For mobile deployment, download the **NB models** (`.nb` extension) from the Paddle-Lite section of the Model Zoo. These optimized models run through the Paddle-Lite runtime using the `lite.Engine()` class, requiring minimal memory and providing accelerated inference on ARM-based mobile and embedded hardware.

### Which configuration files correspond to specific pre-trained models?

Each pre-trained model entry in the Model Zoo references a specific YAML configuration file in the `configs/` directory. For example, `PP-OCRv4_mobile_det` uses [`configs/det/PP-OCRv4/PP-OCRv4_mobile_det.yml`](https://github.com/PaddlePaddle/PaddleOCR/blob/main/configs/det/PP-OCRv4/PP-OCRv4_mobile_det.yml), while recognition models reference files like [`configs/rec/PP-OCRv3/PP-OCRv3_mobile_rec.yml`](https://github.com/PaddlePaddle/PaddleOCR/blob/main/configs/rec/PP-OCRv3/PP-OCRv3_mobile_rec.yml). These files define the exact network architecture and preprocessing used to generate the weights.