PaddleOCR vs Tesseract vs DocsAPI: 2026 Benchmark

Short answer: for clean printed English on an ordinary CPU, Tesseract is enough and much lighter. For phone photos, faded receipts, tables or Chinese, PaddleOCR is more accurate, and its new PP-OCRv6 small model is quick enough on a laptop. Below: our side-by-side test with the code and raw outputs, our larger benchmark, speed, setup, languages, and where EasyOCR, docTR and hosted APIs fit.

Is PaddleOCR better than Tesseract?

Yes, on hard images. PaddleOCR made fewer errors than Tesseract on a skewed phone-style photo, a faded receipt and Chinese text in our test, and scored 15 to 24 points higher on tables, phone photos and mixed-language pages in our larger benchmark. On clean printed English the two tie, and Tesseract runs far faster on a CPU.

The useful question is which errors you can live with. Tesseract's mistakes in our test were the kind that slip into a database unnoticed: a ZIP code read as "$0205" and a receipt total read as "Ti ay". PaddleOCR's default model got every number right and only changed some punctuation. If your pipeline pulls amounts, dates or IDs, that difference matters more than speed.

PaddleOCR vs Tesseract: our side-by-side test (September 2026)

On September 28, 2026 we ran both engines, with default settings, on the same six images and compared the output with the exact text we put in. This small test shows the kinds of errors each engine makes. It is not an error rate to expect on your documents; for that, see the benchmark section further down.

• Machine: an Apple M5 laptop with 16 GB of memory, CPU only, no GPU.
• Tesseract: version 5.5.2 from Homebrew with the standard English model (eng) and, for the Chinese image, the official chi_sim model from the tessdata repository.
• PaddleOCR: version 3.7.0 on PaddlePaddle 3.3.1 and Python 3.9. Its default models are PP-OCRv6 medium. We also ran the smaller "small" and "tiny" tiers.
• Images: made with Python's Pillow library, so the correct text is known exactly. (1) A clean printed invoice paragraph. (2) The same paragraph made to look like a phone photo: 4 degree tilt, blur, gray background, noise and heavy JPEG compression. (3) The paragraph in small 12 pixel print. (4) A ruled bank statement table with 7 rows. (5) Three lines from a Chinese invoice. (6) A faded, slightly tilted thermal receipt.
• Scoring: character error rate (CER), the share of characters you would have to insert, delete or change to turn the output into the correct text. Lower is better. We also counted how many money amounts came out exactly right. Times are the median of 3 runs per image, after the models were loaded.

Image	Tesseract 5.5.2	PP-OCRv6 medium (default)	PP-OCRv6 small	PP-OCRv6 tiny
1. Clean paragraph	0.0% CER, 1/1 amounts, 0.11 s	0.0%, 1/1, 2.18 s	0.0%, 1/1, 0.66 s	0.5%, 1/1, 0.24 s
2. Phone-style photo	1.0%, 1/1, 0.12 s	0.0%, 1/1, 2.17 s	0.0%, 1/1, 0.69 s	0.0%, 1/1, 0.24 s
3. Small print	1.0%, 1/1, 0.07 s	1.4%, 1/1, 1.36 s	0.0%, 1/1, 0.49 s	1.4%, 0/1, 0.16 s
4. Ruled bank table	0.0%, 11/11, 0.16 s	0.0%, 11/11, 3.64 s	0.0%, 11/11, 1.38 s	0.0%, 11/11, 0.45 s
5. Chinese invoice lines	3.4%, 1/1, 0.26 s	0.0%, 1/1, 1.39 s	0.0%, 1/1, 0.47 s	1.7%, 1/1, 0.17 s
6. Faded receipt	3.9%, 5/6, 0.10 s	0.0%, 6/6, 1.80 s	0.0%, 6/6, 0.60 s	0.8%, 6/6, 0.21 s

What each engine actually got wrong

• Tesseract, phone-style photo: read the ZIP code 80205 as "$0205" and one comma as a period.
• Tesseract, faded receipt: read every line except the last, where "TOTAL 11.55" came out as "TOTAL Ti ay". The one number that matters most on a receipt was lost.
• Tesseract, Chinese: dropped the character for "day" from the date and read the yuan sign (¥) as "#". The digits were right.
• Tesseract, small print: added a comma and dropped a final period. No digit errors.
• PaddleOCR medium, small print: turned two commas into periods and dropped a period. No digit errors.
• PaddleOCR tiny: read $4,812.50 as "$4.812.50" and 8.25% as "8.258". These are the silent amount errors that break financial data, so test the tiny tier carefully before trusting it with numbers.
• PaddleOCR small: no errors on any of the six images.

One more finding. When we forced Tesseract into page segmentation mode 6 (the --psm 6 flag, "treat the image as one block of text"), a common tip for tables, it turned the ruled bank table into nonsense and got 0 of 11 amounts right. The default mode (3) read the same table perfectly. If you tune Tesseract, test every setting on your own documents before you rely on it.

The code we ran

Both engines take a few lines. Tesseract runs from the command line (Python users usually call it through the pytesseract wrapper):

tesseract receipt.jpg stdout -l eng
tesseract invoice-zh.png stdout -l chi_sim --tessdata-dir ./tessdata

PaddleOCR 3.x runs from Python. The three flags switch off optional steps that straighten rotated or curled pages; we did not need them for flat images, but turn them on if your photos may be rotated or bent:

from paddleocr import PaddleOCR

ocr = PaddleOCR(
    use_doc_orientation_classify=False,
    use_doc_unwarping=False,
    use_textline_orientation=False,
)
result = ocr.predict("receipt.jpg")
print(" ".join(result[0]["rec_texts"]))

For a faster tier, add text_detection_model_name="PP-OCRv6_small_det" and text_recognition_model_name="PP-OCRv6_small_rec" (or the tiny names) when you create the PaddleOCR object.

Tesseract OCR vs PaddleOCR at a glance

Versions and language counts come from each project's GitHub page, checked on September 28, 2026. Speeds come from our test above.

Dimension	Tesseract	PaddleOCR
What it is	Classic OCR engine with an LSTM neural network, written in C++	Deep-learning OCR toolkit built on Baidu's PaddlePaddle framework, used from Python
License	Apache 2.0, free for commercial use	Apache 2.0, free for commercial use
Latest release	5.5.3, July 24, 2026	3.7.0 with PP-OCRv6, June 11, 2026
Languages	More than 100 out of the box, one model file per language	100+ across its models; one PP-OCRv6 model reads 50 (Chinese, English, Japanese and 46 Latin-script languages)
Model download	English model: 4.1 MB	PP-OCRv6 tiny about 6 MB, small about 30 MB, medium about 132 MB
Tables and layout	Text only, no table structure	PP-StructureV3 pipeline returns tables and layout as Markdown or JSON
GPU	Not needed and not used	Optional, much faster with one
CPU time per image, our test	0.07 to 0.26 s	0.16 to 0.45 s (tiny), 0.47 to 1.38 s (small), 1.36 to 3.64 s (medium)
Hard images, our test	Missed a receipt total and a ZIP code	Small and medium read every amount right
Best for	Clean printed text, CPU-only servers, minimal setup	Photos, receipts, tables, Chinese and Japanese text

What our larger benchmark found

Six images show the type of errors; they cannot give you a rate. For rates on real documents, our 2026 OCR accuracy benchmark compared Tesseract 5.x, PaddleOCR (the PP-OCRv4 generation at the time) and DocsAPI on 500 anonymized production documents, 100 per category. Scores are character accuracy against hand-labeled text, except bank statements, which were scored per table row.

Document category	Tesseract 5.x	PaddleOCR (PP-OCRv4)	DocsAPI
Typed English, clean	97-99%	97-99%	97-99%
Scanned bank statements (multi-page tables)	64%	79%	91%
Phone-photographed receipts	58%	82%	76%
Multilingual (English plus Mandarin or Spanish)	71%	89%	81%
Handwritten forms	61%	73%	78%

The pattern matches our small test: a tie on clean English, and a PaddleOCR lead of 15 to 24 points on tables, phone photos and mixed-language pages. Two caveats. PaddleOCR has shipped two model generations since then, and its maintainers report that PP-OCRv6 medium improves recognition accuracy by 5.1% over PP-OCRv5, so current PaddleOCR is likely stronger than these numbers; we have not rerun the 500 documents on it yet. And on handwriting no engine reached 80%, so for handwritten forms read our VLM vs OCR guide before choosing. If you are unsure how these scores are computed, our guide to OCR accuracy metrics explains CER, word accuracy and field accuracy.

Which is faster, PaddleOCR or Tesseract?

On a plain CPU, Tesseract. In our test it took 0.07 to 0.26 seconds per image, 5 to 23 times faster than PaddleOCR's default medium model. PaddleOCR's tiny tier closes most of that gap (0.16 to 0.45 seconds). With a GPU, PaddleOCR is the fastest: 0.4 seconds per full page in our benchmark, against 1.8 seconds for Tesseract.

Three things change speed more than the engine you pick:

• Model tier. PP-OCRv6 small ran about 3 times faster than medium in our test (0.47 to 1.38 seconds against 1.36 to 3.64) and made no errors, so on a CPU it is the tier we would start with.
• Loading the model once. PaddleOCR took 1.5 seconds to load its models on a warm start and 35 seconds on the very first run, which includes downloading them. In a server, create one PaddleOCR object and keep it alive instead of starting a new process for every file. Tesseract has almost no start-up cost.
• How much text is on the image. Our images hold a few lines each. A dense full page takes longer on both engines: our benchmark measured 1.8 seconds per page for Tesseract and 2.3 seconds for PaddleOCR (PP-OCRv4) on a mid-tier laptop CPU, so time your own pages before you size servers.

Should you use PaddleOCR or Tesseract?

Use Tesseract when your documents are clean, printed and mostly in Latin-script languages, and you want the simplest install on a CPU server. Use PaddleOCR when you read photos, receipts, tables, Chinese or Japanese, or when a wrong number is costly. If you are unsure, run both on 20 of your own worst documents and count the wrong amounts.

Your situation	Pick	Why
Clean scanned or digital pages in English, Spanish, French or German	Tesseract	Ties PaddleOCR on accuracy and ran 5 to 23 times faster on a CPU in our test
Phone photos, faded receipts, tilted scans	PaddleOCR, small or medium tier	Read every amount right in our test, while Tesseract lost a receipt total
Tables you need as rows and columns	PaddleOCR with PP-StructureV3, or a document API	Tesseract returns text, not table structure
Chinese or Japanese text	PaddleOCR	One model covers them; Tesseract dropped a character and misread the yuan sign
Small CPU-only server or edge device	Tesseract, or PaddleOCR tiny if accuracy matters more	The tiny model is about 6 MB and fast, but check it for number errors
High volume with a GPU	PaddleOCR	0.4 seconds per page on a GPU in our benchmark
Must run offline or air-gapped	Either	Both run entirely on your own machines
Handwriting	Neither on its own	Both stayed below 75% in our benchmark; test a vision-language model
No time to run and maintain an OCR pipeline	A hosted API	You pay per page instead of paying in engineering hours

How hard is each one to install and keep running?

Tesseract is a one-line install and rarely changes. PaddleOCR is a Python install of a whole deep-learning framework that downloads its models on first run and ships new model generations every few months, so pin your version and retest before upgrading.

• Tesseract: brew install tesseract on a Mac, or apt install tesseract-ocr on Debian and Ubuntu. Add languages with packages such as tesseract-ocr-chi-sim, or download a .traineddata file from the tessdata repository. Releases are mostly fixes: 5.5.0 came out in November 2024 and 5.5.3 in July 2026.
• PaddleOCR: pip install paddlepaddle paddleocr for CPU (GPU needs the paddlepaddle-gpu build matched to your CUDA version). On our Mac the install took a few minutes and the first run downloaded the models. PaddleOCR shipped four releases between April and June 2026 (3.4.1 to 3.7.0), including a new model generation.
• The hidden cost: PaddleOCR runs on PaddlePaddle rather than PyTorch, which most machine learning teams know better, so debugging deep inside it takes longer. Tesseract's problems are usually about image quality, not the software.

For Tesseract, its own documentation gives the three fixes that matter most: images of at least 300 DPI, straight (deskewed) text lines, and clean backgrounds, because its built-in binarization can struggle when the page background is uneven.

Which reads more languages?

Both claim more than 100. The difference is how you use them. Tesseract needs one model file per language and you name the languages with -l, for example -l eng+chi_sim. PaddleOCR's PP-OCRv6 reads Chinese, English, Japanese and 46 Latin-script languages with a single model, so mixed English and Chinese pages need no switching.

PaddleOCR read the Chinese invoice lines with no errors, while Tesseract with its official Chinese model lost one character and the currency sign. Our benchmark found the same direction on mixed English and Mandarin or Spanish pages (89% against 71%). If your documents are Latin-script only, language is not the deciding factor; tables, photos and speed are.

Tesseract vs PaddleOCR vs EasyOCR, and where docTR fits

If you are weighing EasyOCR vs Tesseract vs PaddleOCR: EasyOCR is the quickest deep-learning option for teams that already use PyTorch, but it has not shipped a release since version 1.7.2 in September 2024. docTR, from Mindee, is an actively released PyTorch library for documents (1.1.0 in August 2026). We did not test either in this round, so the notes below come from their GitHub pages.

Engine	Built on	Languages (per the project)	Latest release	Consider it when
Tesseract	C++ with an LSTM network	More than 100	5.5.3, July 2026	Clean printed text on CPU
PaddleOCR	PaddlePaddle	100+, 50 in one PP-OCRv6 model	3.7.0, June 2026	Hard images, Chinese and Japanese, tables
EasyOCR	PyTorch	80+	1.7.2, September 2024	You live in PyTorch and want quick multilingual OCR
docTR	PyTorch	See the project's model list	1.1.0, August 2026	You want a document OCR library you can fine-tune in PyTorch

For docTR vs Tesseract specifically: docTR works like PaddleOCR, with one neural network that finds text and a second that reads it, so expect it to behave more like PaddleOCR than Tesseract on hard images, and to need more setup. Test it on your own documents before you decide.

Where a hosted API like DocsAPI fits

Disclosure: DocsAPI is our product. Both open-source engines give you text. Many business teams need more than text: named fields such as vendor, amount and date, tables stitched across pages, checks that the numbers add up, and someone else running the servers.

In our benchmark DocsAPI led on multi-page bank statement tables (91%, against 79% for PaddleOCR and 64% for Tesseract) because it joins transaction tables across pages. It did not win everything: PaddleOCR scored higher on phone photos (82% against 76%) and mixed-language pages (89% against 81%). DocsAPI prices per page, starting at $0.02, with volume discounts above 100,000 pages a month and a free 30-day trial for qualified lenders after a demo. At 100,000 pages that is $2,000 a month before discounts. The open-source engines cost nothing to license but not nothing to run: as an example, 4 hours a month of engineering at $100 an hour is $400 a month before compute. A hosted API cannot run air-gapped, so for data that must never leave your network, the open-source engines are the only option here.

For other comparisons, see Docling vs LlamaParse, AWS Textract vs DocsAPI, ABBYY FineReader alternatives and our best OCR software guide.

What to do next

• You just need text from a clean image or PDF right now: our free OCR tool runs Tesseract in your browser with no upload and no signup.
• You are not sure which engine fits: the Which OCR should I use tool asks six questions and is honest about when open source is the right call.
• You are building on open source: copy the code above, run PaddleOCR, Tesseract and any API you are considering on 20 of your hardest documents, and count wrong amounts, not just character errors. Our PDF text recognition guide covers when Tesseract alone is enough, and our OCR for PDFs guide covers scanned PDFs.
• You need fields from bank statements or invoices: compare the output on your own files in a DocsAPI trial.

Sources and how we checked this

• Tesseract: history, language count and license from the Tesseract GitHub repository (developed at HP from 1985 to 1994, open-sourced in 2005, developed by Google from 2006 to 2017); release dates from its releases page; image-quality advice from Improving the quality of the output.
• PaddleOCR: PP-OCRv6 tiers, the 50-language model and the 5.1% recognition gain from the v3.7.0 release notes; language count and PP-StructureV3 from the PaddleOCR repository.
• EasyOCR and docTR: framework, language count and latest release from the EasyOCR and docTR repositories.
• Release dates were read from GitHub's releases API on September 28, 2026. Model download sizes are the files PaddleOCR saved on our machine.
• Our side-by-side test: run on September 28, 2026 with the setup described above. The images are synthetic, so the test shows error types, not rates. Our larger numbers come from our OCR accuracy benchmark.