How to run PaddleOCR on a cloud GPU

Rent a GPU on Deploy, then open a terminal in JupyterLab or over SSH. Install PaddlePaddle and PaddleOCR the way the official PaddlePaddle/PaddleOCR docs print, run the documented OCR or PP-StructureV3 command, and copy the output directory off the instance before you destroy it. Destroying the instance deletes its disk.

A PDF pipeline whose README says at least 12 GB of GPU RAM is How to convert PDFs to text with olmOCR on a cloud GPU. A converter whose README states 8 GB+ VRAM on two standard rows is How to convert PDFs to Markdown with MinerU on a cloud GPU. A converter whose README prints no GPU GB figure is How to convert PDFs to Markdown with Marker on a cloud GPU. Docling’s README also prints no minimum GPU GB figure: How to convert PDFs and documents with Docling on a cloud GPU. The install below is pip. A conda environment, if you want one around those pip lines, is How to set up a conda environment on a cloud GPU. If the process runs out of memory: How to fix CUDA out of memory on a cloud GPU. The serving example binds port 8080: How to use SSH port forwarding on a cloud GPU.

LICENSE is the Apache License, Version 2.0, January 2004. The appendix copyright line is Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved. The README says this project is released under the Apache 2.0 license. pyproject.toml sets license text to Apache License 2.0 and name to paddleocr. The version field is dynamic. This page does not invent a PyPI version. The GitHub license field on 2026-11-13 was Apache-2.0. Read the file before you redistribute the program.

The commands below are copied from the upstream files named in each step. They were not run on a CloudGPU instance for this page. Anything this page adds around them is marked.

What the docs say about memory

The README, docs/quick_start.en.md, docs/version3.x/installation.en.md, docs/version3.x/paddlepaddle_installation.en.md, and docs/version3.x/pipeline_usage/PP-StructureV3.en.md print no GPU GB figure. The PP-StructureV3 quick start says that if the program runs out of memory resources, try disabling unnecessary features or using lighter-weight models. That sentence has no GB number. The same file’s performance test environment names NVIDIA Tesla T4 and does not print a GB figure for that card. Tesla T4 is not a catalog row. This page does not copy the inference-time columns in that file.

GET /v1/public/compute-capabilities does not list GPUs. It returns feature flags. The memory column is vram_gb from gpu-prices.json, updated_at 2026-11-13T15:11:42.412Z. GET /v1/public/gpu-catalog the same day (generated_at 2026-11-13T15:11:42.831Z) listed the same names and the same vram_gb values, plus Ascend 910B at 64, which is not in gpu-prices.json and is not listed here. The catalog response also includes an availability field. This page does not copy it. Every prices row has gpu_count 1. Every catalog row has min_gpu_count 1. The catalog template list had no PaddleOCR template. This page did not run PaddleOCR and does not mark a row as enough. Which listing you can start is on Deploy.

Catalog name vram_gb
RTX 2080 8
RTX 3080 10
RTX 2080 Ti 11
RTX 3080 Ti 12
V100 16G 16
A30 24
RTX 3090 24
RTX 4090 24
RTX 4090D 24
RTX 4080 SUPER 32G 32
RTX 5090 32
RTX 5090D 32
V100 32G 32
A100 40G 40
A800 40G 40
A40 48
RTX 4090 48G 48
RTX 4090D 48G 48
RTX A6000 48
NVIDIA RTX PRO 5000 72G 72
RTX PRO 5000 72G 72
A100 80G 80
A800 80G 80
H800 80
RTX 6000D 83
H20 96G 96
RTX PRO 6000 96G 96
RTX PRO 6000 Max-Q 96
H20-3e 141G 141

Install

On Deploy, choose Raw GPU. The inference install is pip. The training section of installation.en.md is the part that prints git clone. This page follows the inference path.

The GPU pip lines in docs/version3.x/paddlepaddle_installation.en.md, copied. That file also prints Docker docker run lines. The image host in those lines includes a region code, so this page does not print them. Copy them from that file if you use Docker. The same file’s note says you do not need to pay attention to the physical machine’s CUDA version and only need to care about the GPU driver version.

# GPU version, requires driver version >= 450.80.02 (Linux) or >= 452.39 (Windows)
python -m pip install paddlepaddle-gpu==3.2.0 -i https://www.paddlepaddle.org.cn/packages/stable/cu118/

# GPU version, requires driver version >= 550.54.14 (Linux) or >= 550.54.14 (Windows)
python -m pip install paddlepaddle-gpu==3.2.0 -i https://www.paddlepaddle.org.cn/packages/stable/cu126/

The verify command from that file, copied:

python -c "import paddle; print(paddle.__version__)"

The file says a successful install outputs a version number like 3.2.0. This page did not run it.

docs/quick_start.en.md says that when using PaddlePaddle for inference, PaddleOCR 3.x depends on PaddlePaddle version 3.0 or above. docs/version3.x/paddleocr_and_paddlex.en.md prints a correspondence table from PaddleOCR 3.0.0 through 3.7.x. Every row in that table sets the PaddlePaddle column to >= 3.0.0.

installation.en.md says paddleocr itself and the doc2md group support Python 3.8 and later. The other optional groups (doc-parser, ie, trans, all, and so on) require Python 3.9 or later. The PyPI install, copied:

# Default capabilities only: general OCR and document image preprocessing
python -m pip install paddleocr
# All optional capabilities: document parsing, document understanding,
# document translation, key information extraction, etc.
# python -m pip install "paddleocr[all]"

The same file’s source install, copied:

# Default capabilities only: general OCR and document image preprocessing
python -m pip install "paddleocr@git+https://github.com/PaddlePaddle/PaddleOCR.git"
# All optional capabilities: document parsing, document understanding,
# document translation, key information extraction, etc.
# python -m pip install "paddleocr[all]@git+https://github.com/PaddlePaddle/PaddleOCR.git"

The dependency-group table says doc-parser is document parsing and includes model solutions such as PP-StructureV3. The PP-StructureV3 tutorial says the corresponding dependency group for that pipeline is doc-parser. The quick start installs the full set with this line, copied:

python -m pip install "paddleocr[all]"

The same install file’s section 3 is Windows wheels for NVIDIA 50-series GPUs. It says the methods above do not properly support NVIDIA 50-series GPUs on Windows. This page does not copy those wheel URLs. The quick start’s Transformers tab prints python -m pip install "transformers>=5.8.0". The commands on this page use the Paddle engine.

OCR

The quick start’s Paddle command for general OCR, copied. It does not pass --device. The image name is the one that file prints.

# Use PaddlePaddle for inference
paddleocr ocr -i ./general_ocr_002.png \
    --use_doc_orientation_classify False \
    --use_doc_unwarping False \
    --use_textline_orientation False \
    --engine paddle

The Python example from the same section, copied:

# Use PaddlePaddle for inference
from paddleocr import PaddleOCR

ocr = PaddleOCR(
    use_doc_orientation_classify=False,
    use_doc_unwarping=False,
    use_textline_orientation=False,
    engine="paddle",
)
result = ocr.predict("./general_ocr_002.png")
for res in result:
    res.print()
    res.save_to_img("output")
    res.save_to_json("output")

This page did not run the command, so it does not state a filename inside output for that OCR result class. The quick start passes the directory name output.

PP-StructureV3

The tutorial’s GPU command uses a local image. The first command on that page uses a URL whose host includes a region code. This page does not print that URL. Copy it from the tutorial if you want the remote demo image. The local GPU line, copied:

# Use --device to specify GPU for inference
paddleocr pp_structurev3 -i ./pp_structure_v3_demo.png --device gpu

The tutorial says those examples use local Paddle inference engines by default, and that you install PaddlePaddle first. The quick start’s Paddle command for the same pipeline, copied:

# Use PaddlePaddle for inference
paddleocr pp_structurev3 -i ./pp_structure_v3_demo.png \
    --use_doc_orientation_classify False \
    --use_doc_unwarping False \
    --engine paddle

The Python example from the quick start, copied:

# Use PaddlePaddle for inference
from paddleocr import PPStructureV3

pipeline = PPStructureV3(
    use_doc_orientation_classify=False,
    use_doc_unwarping=False,
    engine="paddle",
)
output = pipeline.predict(
    input="./pp_structure_v3_demo.png")
for res in output:
    res.print()
    res.save_to_json(save_path="output")
    res.save_to_markdown(save_path="output")

The tutorial also shows PPStructureV3(device="gpu") as a commented constructor. The CLI parameter table says --save_path, if not set, means results will not be saved locally. The result-method notes say save_to_json() on a directory writes save_path/{your_img_basename}_res.json, and save_to_markdown() writes save_path/{your_img_basename}.md. This page did not run the example.

Serving

docs/version3.x/inference_deployment/serving/serving.en.md says PaddleOCR recommends PaddleX for serving, and that basic serving is the one to try first. The install and the general-OCR example, copied:

paddlex --install serving

paddlex --serve --pipeline OCR

The sample log in that file includes this line: INFO: Uvicorn running on http://0.0.0.0:8080 (Press CTRL+C to quit). The option table says --host defaults to 0.0.0.0 and --port defaults to 8080. --device says a GPU will be used if available, otherwise a CPU. The mapping table in paddleocr_and_paddlex.en.md lists General OCR as OCR and PP-StructureV3 as PP-StructureV3. The serving doc’s example uses OCR. This page adds the other registration name. It was not the example command.

# Added on this page. The serving doc's example uses OCR.
# The mapping table lists PP-StructureV3 as PP-StructureV3.
paddlex --serve --pipeline PP-StructureV3

The PP-StructureV3 tutorial says the layout-parsing operation is POST /layout-parsing. It also says that, by default, a PDF or multi-page TIFF exceeding 10 pages has only the first 10 pages processed. This page did not start the server. From your own computer, the documented port is 8080. How to use SSH port forwarding on a cloud GPU is the tunnel. The same serving file has a URL-return example whose endpoint host includes a region code. This page does not print that host.

ComfyUI

The README does not document ComfyUI. The ComfyUI examples top-level directory list on 2026-11-13 had no directory named for this project. Examples HEAD was f9431bb000ce792094ff345446e22cac1ea6cef3. This page does not add a ComfyUI route. How to install ComfyUI and ComfyUI-Manager on a cloud GPU is a separate install.

When it fails

CUDA out of memory. The PP-StructureV3 tutorial’s only memory sentence is the one that says to disable unnecessary features or use lighter-weight models. It prints no flag that names a GB figure. If the process raises that error, use how to fix CUDA out of memory on a cloud GPU.

“CUDA error: no kernel image is available for execution on the device” on an RTX 5090. The Linux GPU lines above are paddlepaddle-gpu==3.2.0 from the cu118 and cu126 indexes. The install doc’s 50-series wheels are the Windows section. The RTX 5090 guide is about PyTorch wheels and compute capability 12.0 (sm_120). This page did not install paddlepaddle-gpu and did not re-test this package on an RTX 5090. Catalog RTX 5090 and RTX 5090D are 32. That is the catalog number only.

Save the files, then destroy

Copy the output directory from the Python examples, and anything you passed as --save_path, before you destroy the instance. The CLI table says an unset --save_path does not save results locally. Save your work before you destroy a cloud GPU is the checklist. The terms say data on local instance storage is permanently deleted when the instance is destroyed.

The pricing page FAQ states the billing rule in these words:

Per-minute options have a 1-minute minimum; unused prepaid minutes are refunded when you destroy the instance. Some configurations use whole-hour billing with a 1-hour minimum; unused time within a charged hour is not refunded on voluntary stop. The billing period, minimum charge and initial prepayment are shown before confirmation. No subscription.

Prices are not copied here.

Frequently asked questions

How much VRAM do the PaddleOCR docs print?

The README, the quick start, the install docs, and the PP-StructureV3 tutorial print no GPU GB figure. The tutorial says to disable features or use a lighter model if the process runs out of memory, and that sentence has no GB number. The performance test environment names NVIDIA Tesla T4 and does not print a GB figure. Tesla T4 is not a catalog row. This page does not mark a catalog row as enough. Which listing you can start is on https://cloudgpu.app/deploy.

Which commands does the quick start print for OCR and PP-StructureV3?

The Paddle OCR command is paddleocr ocr with the image ./general_ocr_002.png and --engine paddle. The Paddle PP-StructureV3 command is paddleocr pp_structurev3 with ./pp_structure_v3_demo.png and --engine paddle. The tutorial also prints paddleocr pp_structurev3 with --device gpu. The Python examples call predict and then save_to_img or save_to_json, and the structure example also calls save_to_markdown, with the directory name output. This page did not run the commands.

Where does serving listen?

The serving doc’s example is paddlex --serve --pipeline OCR. The sample log prints Uvicorn on http://0.0.0.0:8080. The option table defaults --host to 0.0.0.0 and --port to 8080. The mapping table lists PP-StructureV3 as the registration name PP-StructureV3. The PP-StructureV3 tutorial names POST /layout-parsing. This page did not start the server.

What usage terms does the repository print?

LICENSE is the Apache License, Version 2.0, January 2004. The appendix copyright line is Copyright © 2016 PaddlePaddle Authors. All Rights Reserved. The grant uses the words no-charge, royalty-free. That pair is license text, not a CloudGPU price and not a storage allowance. The file prints no dollar amount.

Sources (read 2026-11-13, Asia/Shanghai)

  • PaddleOCR README (Apache 2.0 pointer, PP-StructureV3 named, no GPU GB figure): https://github.com/PaddlePaddle/PaddleOCR/blob/main/README.md commit 811e0c59e33c27ab0ad8c978f290b6bf534d378d. Repository HEAD dab3fe35379033fdcb2d0e9572fac0b36c9a9ebf, committed 2026-09-16T03:30:53Z
  • docs/version3.x/installation.en.md (pip install, doc-parser, Python 3.8 and 3.9): commit dab3fe35379033fdcb2d0e9572fac0b36c9a9ebf
  • docs/version3.x/paddlepaddle_installation.en.md (paddlepaddle-gpu==3.2.0, cu118 and cu126, driver lines, Windows 50-series note): commit eeb12cd4de185ba444a2aff6b56ab31995558e1c
  • docs/quick_start.en.md (OCR and PP-StructureV3 CLI and Python, paddleocr[all], PaddlePaddle 3.0 or above): commit b03f46425e8ff4442b268ce449e3eef758146cd4
  • docs/version3.x/pipeline_usage/PP-StructureV3.en.md (--device gpu, save paths, POST /layout-parsing, 10-page default, Tesla T4 test environment, no GPU GB figure): commit 71c7fefbf5e8478bc7f14b2d9b095bb80580178b
  • docs/version3.x/inference_deployment/serving/serving.en.md (paddlex --install serving, paddlex --serve --pipeline OCR, host 0.0.0.0, port 8080): commit d4b5b09865aa3bce62b57ef7358d192e7bfe05cf
  • docs/version3.x/paddleocr_and_paddlex.en.md (registration names OCR and PP-StructureV3, version table): commit b03f46425e8ff4442b268ce449e3eef758146cd4
  • pyproject.toml (paddleocr, Apache License 2.0, dynamic version): commit b03f46425e8ff4442b268ce449e3eef758146cd4
  • LICENSE (Apache 2.0, January 2004, Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.): commit b9da97bea9db53ea5cbb1c32bf5c53b9d09be7b1. GitHub license field Apache-2.0
  • ComfyUI examples top-level directories (no PaddleOCR directory): https://github.com/comfyanonymous/ComfyUI_examples commit f9431bb000ce792094ff345446e22cac1ea6cef3
  • Public GPU memory: https://cloudgpu.app/gpu-prices.json (updated_at 2026-11-13T15:11:42.412Z) and https://cloudgpu.app/v1/public/gpu-catalog (generated_at 2026-11-13T15:11:42.831Z). GET /v1/public/compute-capabilities returned feature flags and no GPU list. The catalog had no PaddleOCR template

Cards you can start are on the Deploy page. Prices are on https://cloudgpu.app/pricing and are not repeated here.

Last updated: 2026-11-13 (Asia/Shanghai).