Skip to content
/ doctr Public

docTR (Document Text Recognition) - a seamless, high-performing & accessible library for OCR-related tasks powered by Deep Learning.


Notifications You must be signed in to change notification settings


Repository files navigation

Slack Icon License Build Status Docker Images codecov CodeFactor Codacy Badge Doc Status Pypi Hugging Face Spaces Open In Colab

Optical Character Recognition made seamless & accessible to anyone, powered by TensorFlow 2 & PyTorch

What you can expect from this repository:

  • efficient ways to parse textual information (localize and identify each word) from your documents
  • guidance on how to integrate this in your current architecture


Quick Tour

Getting your pretrained model

End-to-End OCR is achieved in docTR using a two-stage approach: text detection (localizing words), then text recognition (identify all characters in the word). As such, you can select the architecture used for text detection, and the one for text recognition from the list of available implementations.

from doctr.models import ocr_predictor

model = ocr_predictor(det_arch='db_resnet50', reco_arch='crnn_vgg16_bn', pretrained=True)

Reading files

Documents can be interpreted from PDF or images:

from import DocumentFile
pdf_doc = DocumentFile.from_pdf("path/to/your/doc.pdf")
# Image
single_img_doc = DocumentFile.from_images("path/to/your/img.jpg")
# Webpage (requires `weasyprint` to be installed)
webpage_doc = DocumentFile.from_url("")
# Multiple page images
multi_img_doc = DocumentFile.from_images(["path/to/page1.jpg", "path/to/page2.jpg"])

Putting it together

Let's use the default pretrained model for an example:

from import DocumentFile
from doctr.models import ocr_predictor

model = ocr_predictor(pretrained=True)
doc = DocumentFile.from_pdf("path/to/your/doc.pdf")
# Analyze
result = model(doc)

Dealing with rotated documents

Should you use docTR on documents that include rotated pages, or pages with multiple box orientations, you have multiple options to handle it:

  • If you only use straight document pages with straight words (horizontal, same reading direction), consider passing assume_straight_boxes=True to the ocr_predictor. It will directly fit straight boxes on your page and return straight boxes, which makes it the fastest option.

  • If you want the predictor to output straight boxes (no matter the orientation of your pages, the final localizations will be converted to straight boxes), you need to pass export_as_straight_boxes=True in the predictor. Otherwise, if assume_straight_pages=False, it will return rotated bounding boxes (potentially with an angle of 0°).

If both options are set to False, the predictor will always fit and return rotated boxes.

To interpret your model's predictions, you can visualize them interactively as follows:

# Display the result (requires matplotlib & mplcursors to be installed)

Visualization sample

Or even rebuild the original document from its predictions:

import matplotlib.pyplot as plt

synthetic_pages = result.synthesize()
plt.imshow(synthetic_pages[0]); plt.axis('off');

Synthesis sample

The ocr_predictor returns a Document object with a nested structure (with Page, Block, Line, Word, Artefact). To get a better understanding of our document model, check our documentation:

You can also export them as a nested dict, more appropriate for JSON format:

json_output = result.export()

Use the KIE predictor

The KIE predictor is a more flexible predictor compared to OCR as your detection model can detect multiple classes in a document. For example, you can have a detection model to detect just dates and addresses in a document.

The KIE predictor makes it possible to use detector with multiple classes with a recognition model and to have the whole pipeline already setup for you.

from import DocumentFile
from doctr.models import kie_predictor

# Model
model = kie_predictor(det_arch='db_resnet50', reco_arch='crnn_vgg16_bn', pretrained=True)
doc = DocumentFile.from_pdf("path/to/your/doc.pdf")
# Analyze
result = model(doc)

predictions = result.pages[0].predictions
for class_name in predictions.keys():
    list_predictions = predictions[class_name]
    for prediction in list_predictions:
        print(f"Prediction for {class_name}: {prediction}")

The KIE predictor results per page are in a dictionary format with each key representing a class name and it's value are the predictions for that class.

If you are looking for support from the Mindee team

Bad OCR test detection image asking the developer if they need help



Python 3.9 (or higher) and pip are required to install docTR.

Latest release

You can then install the latest release of the package using pypi as follows:

pip install python-doctr

⚠️ Please note that the basic installation is not standalone, as it does not provide a deep learning framework, which is required for the package to run.

We try to keep framework-specific dependencies to a minimum. You can install framework-specific builds as follows:

# for TensorFlow
pip install "python-doctr[tf]"
# for PyTorch
pip install "python-doctr[torch]"

For MacBooks with M1 chip, you will need some additional packages or specific versions:

Developer mode

Alternatively, you can install it from source, which will require you to install Git. First clone the project repository:

git clone
pip install -e doctr/.

Again, if you prefer to avoid the risk of missing dependencies, you can install the TensorFlow or the PyTorch build:

# for TensorFlow
pip install -e doctr/.[tf]
# for PyTorch
pip install -e doctr/.[torch]

Models architectures

Credits where it's due: this repository is implementing, among others, architectures from published research papers.

Text Detection

Text Recognition

More goodies


The full package documentation is available here for detailed specifications.

Demo app

A minimal demo app is provided for you to play with our end-to-end OCR models!

Demo app

Live demo

Courtesy of 🤗 Hugging Face 🤗, docTR has now a fully deployed version available on Spaces! Check it out Hugging Face Spaces

Running it locally

If you prefer to use it locally, there is an extra dependency (Streamlit) that is required.

Tensorflow version
pip install -r demo/tf-requirements.txt

Then run your app in your default browser with:

USE_TF=1 streamlit run demo/
PyTorch version
pip install -r demo/pt-requirements.txt

Then run your app in your default browser with:

USE_TORCH=1 streamlit run demo/


Instead of having your demo actually running Python, you would prefer to run everything in your web browser? Check out our TensorFlow.js demo to get started!

TFJS demo

Docker container

We offer Docker container support for easy testing and deployment.

Using GPU with docTR Docker Images

The docTR Docker images are GPU-ready and based on CUDA 11.8. However, to use GPU support with these Docker images, please ensure that Docker is configured to use your GPU.

To verify and configure GPU support for Docker, please follow the instructions provided in the NVIDIA Container Toolkit Installation Guide.

Once Docker is configured to use GPUs, you can run docTR Docker containers with GPU support:

docker run -it --gpus all bash

Available Tags

The Docker images for docTR follow a specific tag nomenclature: <framework>-py<python_version>-<system>-<doctr_version|YYYY-MM>. Here's a breakdown of the tag structure:

  • <framework>: tf (TensorFlow) or torch (PyTorch).
  • <python_version>: 3.8.18, 3.9.18, or 3.10.13.
  • <system>: cpu or gpu
  • <doctr_version>: a tag >= v0.7.1
  • <YYYY-MM>: e.g. 2023-09

Here are examples of different image tags:

Tag Description
tf-py3.8.18-cpu-v0.7.1 TensorFlow version 3.8.18 with docTR v0.7.1.
torch-py3.9.18-gpu-2023-09 PyTorch version 3.9.18 with GPU support and a monthly build from 2023-09.

Building Docker Images Locally

You can also build docTR Docker images locally on your computer.

docker build -t doctr .

You can specify custom Python versions and docTR versions using build arguments. For example, to build a docTR image with TensorFlow, Python version 3.9.10, and docTR version v0.7.0, run the following command:

docker build -t doctr --build-arg FRAMEWORK=tf --build-arg PYTHON_VERSION=3.9.10 --build-arg DOCTR_VERSION=v0.7.0 .

Example script

An example script is provided for a simple documentation analysis of a PDF or image file:

python scripts/ path/to/your/doc.pdf

All script arguments can be checked using python scripts/ --help

Minimal API integration

Looking to integrate docTR into your API? Here is a template to get you started with a fully working API using the wonderful FastAPI framework.

Deploy your API locally

Specific dependencies are required to run the API template, which you can install as follows:

cd api/
pip install poetry
make lock
pip install -r requirements.txt

You can now run your API locally:

uvicorn --reload --workers 1 --host --port=8002 --app-dir api/ app.main:app

Alternatively, you can run the same server on a docker container if you prefer using:

PORT=8002 docker-compose up -d --build

What you have deployed

Your API should now be running locally on your port 8002. Access your automatically-built documentation at http://localhost:8002/redoc and enjoy your three functional routes ("/detection", "/recognition", "/ocr", "/kie"). Here is an example with Python to send a request to the OCR route:

import requests

headers = {"accept": "application/json"}
params = {"det_arch": "db_resnet50", "reco_arch": "crnn_vgg16_bn"}

with open('/path/to/your/doc.jpg', 'rb') as f:
    files = [  # application/pdf, image/jpeg, image/png supported
        ("files", ("doc.jpg",, "image/jpeg")),
print("http://localhost:8080/ocr", headers=headers, params=params, files=files).json())

Example notebooks

Looking for more illustrations of docTR features? You might want to check the Jupyter notebooks designed to give you a broader overview.


If you wish to cite this project, feel free to use this BibTeX reference:

    title={docTR: Document Text Recognition},
    publisher = {GitHub},
    howpublished = {\url{}}


If you scrolled down to this section, you most likely appreciate open source. Do you feel like extending the range of our supported characters? Or perhaps submitting a paper implementation? Or contributing in any other way?

You're in luck, we compiled a short guide (cf. CONTRIBUTING) for you to easily do so!


Distributed under the Apache 2.0 License. See LICENSE for more information.