Run open OCR models on a cloud GPU

The open source OCR tools for a GPU come in two kinds, and the kind decides how you run them. Pipelines such as MinerU, Docling, marker and olmOCR take a folder of PDFs and write Markdown. OCR models such as GLM-OCR, DeepSeek-OCR, PaddleOCR-VL, dots.ocr and Unlimited-OCR are vision-language models that you serve with vLLM and call once per page image. Every checkpoint below is between 1.9 and 10.1 GB, so by the calculation further down all of them fit a 48 GB GPU with room for batches, and I would start on the cheapest 48 GB offer. The repository, Hugging Face, PyPI and vLLM recipe facts were checked on 12 November 2026.

Pipelines and OCR models are different tools

A pipeline is a program with several parts: a layout detector, text recognition, table and formula models, and code that puts the pieces back in reading order. You give it PDFs and it gives back Markdown or JSON per document. Some pipelines run a vision-language model inside. MinerU's standard tier adds a VLM to its small models, and marker's README says it runs layout, OCR and table recognition through one served VLM.

An OCR model is only the recognition part, a vision-language model that reads an image and writes text. You serve it and send it one page image per request, so you convert PDF pages to images first. Several vendors close the gap with their own pipeline: the GLM-OCR SDK adds the PP-DocLayoutV3 layout model, and the PaddleOCR-VL recipe pairs its 0.9B model with a PP-DocLayout model, V2 for the first version and V3 for 1.6. That is why a search for PDF to Markdown ends at both kinds of tool.

Open source OCR tools and models side by side

The pipelines first. Versions are the latest on PyPI today:

MinerU's license allows commercial use, requires a separate license above 100 million monthly active users or USD 20 million in monthly revenue, and requires attribution if you offer an online service built on it. marker's README says the weights are free for research, personal use and startups under $5M in funding or revenue. Now the models, with parameters from the Hub's safetensors metadata and checkpoint sizes summed from the *.safetensors files, in GB of 10^9 bytes:

The cards name some sizes differently: GLM-OCR says 0.9B, and dots.ocr says a 1.7B language model, while the metadata counts the whole model. Unlimited-OCR lists the same 6.67 GB file under two names, and the Hub repository rednote-hilab/dots.ocr now redirects to dots-studio/dots.ocr. The dots.ocr agreement adds a prohibited-uses clause that covers unauthorized digitization of publications and bulk scraping, and data-privacy rules, so read it before a large run. Unlimited-OCR-2 reached the Hub on 26 October 2026. Its card describes sparse reference sliding window attention, which it says keeps decoding memory nearly constant as a document grows, and it recommends SGLang with a wheel from its own repository. Every GPU DeployGPU rents as a VM has at least 48 GB. By the site's calculated rule, 92 percent of 48 GB is 44.2 GB, and the largest checkpoint above leaves about 34 GB for activations and batches.

Convert a folder of PDFs to Markdown with a pipeline

Docling's CLI reference documents docling convert with a directory as the source, Markdown as the default output and a --device option. MinerU's quick start documents the batch form with a directory and -o. Install each tool in its own virtual environment, as the PyTorch install guide shows for uv:

pip install docling
docling convert ./pdfs --from pdf --to md --output ./markdown --device cuda

uv venv --python 3.12 .mineru
source .mineru/bin/activate
uv pip install -U "mineru>=4.0,<5"
mineru-kit parse ./pdfs -o ./markdown --format zip

MinerU's README says mineru[full] suits high-throughput NVIDIA deployments, and its documentation says the first model-backed parse may download weights. Its output reference says --format zip saves markdown.md, middle_json.json, structured_content.json and an images folder, so expect zip files in the output folder. marker and olmOCR take a folder or a glob in the same way:

pip install marker-pdf
marker ./pdfs --output_dir ./markdown
olmocr ./localworkspace --markdown --pdfs ./pdfs/*.pdf

olmOCR's README asks for a clean conda environment with Python 3.11, the poppler-utils package plus fonts, and pip install olmocr[gpu] from the PyTorch cu128 index, and it writes Markdown to ./localworkspace/markdown/. marker starts a vLLM server in Docker on NVIDIA GPUs by itself, so the VM needs the Container Toolkit, which the toolkit guide covers.

Serve an OCR model with vLLM and send it an image

The vLLM recipe for GLM-OCR, updated on 17 April 2026, asks for vLLM 0.16.0 or newer, and its install notes ask for the nightly wheel and Transformers from source, so check the recipe again before you rely on those lines. This is its Docker command with three changes: it runs detached under a name, the port is bound to the VM's loopback address as in the vLLM guide, and the recipe's --privileged flag is gone. Check the CUDA Version first, as the CUDA guide explains.

sudo docker run -d --name glm-ocr --gpus all --ipc=host \
  -p 127.0.0.1:8000:8000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  vllm/vllm-openai:latest zai-org/GLM-OCR \
  --tensor-parallel-size 1 \
  --speculative-config.method mtp \
  --speculative-config.num_speculative_tokens 1

A model server takes images, so turn the PDF pages into PNG files first. The pdftoppm manual says -png writes PNG files and -r sets the resolution, 150 DPI by default:

pdftoppm -png scan.pdf page

The recipe's client is the OpenAI SDK with the prompt Text Recognition:, and it says greedy sampling with temperature=0.0 gives the best OCR accuracy. vLLM's multimodal documentation shows base64 data URLs in image_url fields, so this is the recipe's call with a local page in place of its remote URL:

import base64
from openai import OpenAI

client = OpenAI(api_key="EMPTY", base_url="http://localhost:8000/v1", timeout=3600)
with open("page-1.png", "rb") as f:
    data_url = "data:image/png;base64," + base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="zai-org/GLM-OCR",
    messages=[{
        "role": "user",
        "content": [
            {"type": "image_url", "image_url": {"url": data_url}},
            {"type": "text", "text": "Text Recognition:"},
        ],
    }],
    max_tokens=2048,
    temperature=0.0,
)
print(response.choices[0].message.content)

The other models need their own settings, so use their recipes and cards and not a plain serve command. DeepSeek-OCR, DeepSeek-OCR-2 and Unlimited-OCR need an n-gram logits processor and per-request arguments, and the Unlimited-OCR recipe says empty output almost always means the prompt lacks the literal <image> prefix or skip_special_tokens was left True. PaddleOCR-VL-1.6 adds --max-num-batched-tokens 16384 and uses PaddleOCR as the client for layout. The SSH port forwarding guide shows how to reach the server from your own machine.

Reported accuracy, with the benchmark named

These are the numbers the projects themselves publish in text. They come from different benchmarks and versions, so they do not rank the tools against each other:

I found no headline score in the text of the MinerU, Docling, DeepSeek-OCR or Unlimited-OCR pages I read, so I list none. To find the best OCR model for your documents, run two or three on a sample of your own pages and compare the output by eye, then compare the cost per page, as the Whisper guide does for audio.

Move PDFs in and Markdown out

The Hugging Face cache and the Python environment share the VM's disk, so check df -h first, and note that the disk is fixed by the offer on QuantaCloud, Massed Compute and Hyperstack. Push the PDFs from your machine, run the job in tmux, and pull the Markdown back before you stop the instance, because stopping deletes the disk:

# from your machine
rsync -avP -e "ssh -p 22" ./pdfs/ ubuntu@YOUR_VM_IP:~/pdfs/
# on the VM: open tmux and run the pipeline command inside it
tmux new -s ocr
# from your machine again, before you stop the instance
rsync -avP -e "ssh -p 22" ubuntu@YOUR_VM_IP:~/markdown/ ./markdown/

Use the user from your deployment's SSH command, which is ubuntu on QuantaCloud and Hyperstack, Ubuntu on Massed Compute and root on Verda. The data transfer guide compares the tools, keeping jobs running covers tmux, and the batch jobs guide shows how to launch, run, copy off and stop from a script. DeployGPU has no idle timer, so the meter runs until you stop the instance.