Run Tesseract as an API
or self-hosted service.

pip install fastapi uvicorn python-multipart pytesseract pillow
# install the engine + language packs first (see the install guide)
uvicorn app:app --host 0.0.0.0 --port 8000

Then call it: curl -F "file=@invoice.png" "http://localhost:8000/ocr?lang=eng". Tesseract itself is installed per the installation guide.

One primary intent per endpoint. Keep /ocr returning text, and add separate endpoints for PDFs and layout data rather than overloading one response.

import asyncio, io
from concurrent.futures import ProcessPoolExecutor
from fastapi import FastAPI, File, UploadFile, HTTPException, Query
from PIL import Image
import pytesseract

app = FastAPI(title="Tesseract OCR API")
pool = ProcessPoolExecutor(max_workers=4)
MAX_BYTES = 10 * 1024 * 1024  # 10 MB
LANGS = {"eng", "deu", "fra", "spa"}

def _ocr(data: bytes, lang: str) -> str:
    image = Image.open(io.BytesIO(data))
    return pytesseract.image_to_string(image, lang=lang)

@app.get("/health")
def health():
    return {"status": "ok"}

@app.post("/ocr")
async def ocr(file: UploadFile = File(...), lang: str = Query("eng")):
    if lang not in LANGS:
        raise HTTPException(400, "Unsupported language")
    data = await file.read()
    if len(data) > MAX_BYTES:
        raise HTTPException(413, "File too large")
    loop = asyncio.get_running_loop()
    try:
        text = await asyncio.wait_for(loop.run_in_executor(pool, _ocr, data, lang), timeout=30)
    except asyncio.TimeoutError:
        raise HTTPException(504, "OCR timed out")
    return {"text": text, "lang": lang}

Key details: allow-list languages, enforce a byte limit before decoding, run OCR in a process pool, and cap the wall-clock time. See the Python guide for the full pytesseract API.

FROM python:3.12-slim
RUN apt-get update && apt-get install -y --no-install-recommends \
      tesseract-ocr tesseract-ocr-eng tesseract-ocr-deu \
      libgl1 libglib2.0-0 && rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
EXPOSE 8000
HEALTHCHECK CMD python -c "import urllib.request;urllib.request.urlopen('http://localhost:8000/health')"
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "2"]

Add only the language packs you need to keep the image small. The install guide covers Docker and tessdata placement in more depth.

• Process pool or CLI subprocesses: Python's GIL means a thread pool will not speed up OCR. Use ProcessPoolExecutor or a pool of tesseract subprocesses.
• Workers vs replicas: run a few uvicorn workers per container and scale replicas horizontally behind a load balancer.
• Queueing: for bursts or long documents, accept the upload, return a job ID, and process from a queue (Celery, RQ, or a broker).
• Backpressure: cap the queue and reject with 429 when saturated rather than letting latency spiral.
• Resource limits: pin CPU/memory per worker and set an OCR timeout so one bad image cannot stall a replica.

• No data egress: images stay inside your network — important for legal, medical and financial documents.
• Validate input: check MIME type and magic bytes, not just the extension; decode in a try/except.
• Limit resources: max upload size, per-request timeout, and a memory ceiling to resist decompression bombs.
• Authenticate: put an API key or gateway in front; OCR endpoints are expensive to abuse.
• Strip metadata: if you persist files, remove EXIF and delete originals on a schedule.

• Container runtimes: Cloud Run, AWS Lambda container images and Fly.io all run a Tesseract image without managing servers.
• Cold starts: a Tesseract image plus language packs is large, so cold starts are slow — keep one instance warm for latency-sensitive traffic.
• Limits: raise memory and timeout; a small default timeout will kill large documents.
• Ephemeral disk: write scratch files to /tmp only; treat the filesystem as disposable.

Many teams self-host Tesseract for high-volume, privacy-sensitive work and fall back to a managed API only for the hard minority of documents.