Python OCR libraries: choose by output and deployment

PaddleOCR: use the documented predict interface

The current documentation uses PaddleOCR().predict(), with result objects that can print or save JSON. The old use_angle_cls constructor example belongs to a different API generation. Choose a supported runtime from the installation guide before running this example; record the resolved package and model versions.

Documentation-based example; no runtime measurement is claimed.

from paddleocr import PaddleOCR

ocr = PaddleOCR(
    lang="en",
    use_doc_orientation_classify=False,
    use_doc_unwarping=False,
    use_textline_orientation=False,
)
for result in ocr.predict("invoice.png"):
    result.print()
    result.save_to_json("output")

Tesseract and EasyOCR: simple text baselines

pytesseract wraps the separately installed native engine. EasyOCR loads its detector and recognizer through Reader. Neither short example reconstructs invoice line items or proves field extraction accuracy.

Documentation-based example; no runtime measurement is claimed.

# pip install pytesseract pillow easyocr
# Install native Tesseract and English language data separately.
import pytesseract
from PIL import Image
import easyocr

print(pytesseract.image_to_string(Image.open("invoice.png"), lang="eng"))
reader = easyocr.Reader(["en"], gpu=False)
for box, text, confidence in reader.readtext("invoice.png"):
    print(text, confidence)

RapidOCR: replace the legacy package example

The current quickstart installs rapidocr with onnxruntime and returns a result object. Its models and language coverage depend on the configuration; the default Chinese/English model is not a universal language choice.

Documentation-based example; no runtime measurement is claimed.

# pip install rapidocr onnxruntime
from rapidocr import RapidOCR

engine = RapidOCR()
result = engine("invoice.png")
print(result)
result.vis("invoice-ocr.jpg")

Surya: current v2 API and separate weight license

The checked upstream v2 API uses SuryaInferenceManager and returns page results with blocks, including HTML. It requires a supported inference backend: vLLM on NVIDIA or llama-server for CPU/Apple Silicon. The code uses Apache-2.0; the modified AI Pubs Open Rail-M weight license has eligibility limits, including a $5M funding/revenue threshold. Review the model license for broader commercial use.

Documentation-based example; no runtime measurement is claimed.

# pip install surya-ocr pillow
# Configure the backend described in the upstream installation guide.
from PIL import Image
from surya.inference import SuryaInferenceManager
from surya.recognition import RecognitionPredictor

manager = SuryaInferenceManager()
recognizer = RecognitionPredictor(manager)
pages = recognizer([Image.open("invoice.png")])
for page in pages:
    for block in page.blocks:
        print(block.html)

docTR: document-level OCR output

docTR exposes a pretrained OCR predictor and document loaders. Keep the model architecture and checkpoint in your evaluation manifest rather than treating every ocr_predictor configuration as the same system.

Documentation-based example; no runtime measurement is claimed.

# pip install python-doctr
from doctr.io import DocumentFile
from doctr.models import ocr_predictor

predictor = ocr_predictor(pretrained=True)
result = predictor(DocumentFile.from_images("invoice.png"))
print(result.render())

Run a comparison that can support a recommendation

Use the same held-out pages and ground truth for every candidate. Include clean scans, phone photos, rotation, small text and the languages you serve. Keep invoice templates out of both tuning and test sets to expose generalization failures.

Report CER/WER for text, reading-order errors for pages, cell structure for tables, and exact match or field F1 for invoice extraction. Time model loading, warm inference and full pipeline latency separately; record CPU/GPU, batch size, peak memory, retries and failures. Publish inputs or hashes, outputs, package locks, checkpoint IDs and normalization rules before calling a result reproducible.