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

Pre-trained PaddleOCR models are centrally hosted in the Model Zoo at 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 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:

# 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:

#!/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:

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:

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 for English).

Mobile Deployment with Paddle-Lite

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

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 defines the lightweight mobile detection network architecture.
• Recognition: 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 for English models or 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 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 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, while recognition models reference files like configs/rec/PP-OCRv3/PP-OCRv3_mobile_rec.yml. These files define the exact network architecture and preprocessing used to generate the weights.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}