PaddleOCR license: free for commercial use, with a few rules

What Apache-2.0 lets you do#

Apache-2.0 is a permissive license. Unlike the GPL or AGPL, it doesn't require you to publish your own source code, and it doesn't care whether your product is free or paid. Section by section, in plain English:

Quotes are from PaddleOCR's own LICENSE file, which is the standard Apache License 2.0 text with the copyright line "Copyright (c) 2016 PaddlePaddle Authors".¹

What you must do when you redistribute#

Section 4 sets four conditions on redistribution, meaning when you hand copies of PaddleOCR or a modified version to someone else. That includes a desktop app, an SDK, a Docker image you give to customers, or an appliance.¹

1. Give recipients a copy of the license — §4(a)#

   Ship the Apache-2.0 text with your product, for example in a LICENSES/ folder or an "Open-source notices" screen.

2. Mark files you changed — §4(b)#

   Modified files must carry "prominent notices stating that You changed the files". A comment at the top of each changed file is the usual way.

3. Keep existing notices — §4(c)#

   Retain "all copyright, patent, trademark, and attribution notices" from the source, such as the license headers at the top of PaddleOCR's Python files.

4. Pass on NOTICE contents, if there is a NOTICE file — §4(d)#

   The PaddleOCR repo has no top-level NOTICE file, so for the main library there is nothing extra to copy. The iOS demo folder does have one (deploy/ios_demo/NOTICE). If you ship that code, include it.⁴

If you only run PaddleOCR on your own servers, for example behind an API your customers call, you aren't handing them copies, and these §4 conditions are written for redistribution. Many teams still keep the notices in their internal records and their "third-party software" page. That costs nothing and avoids questions during due diligence.

Model weights: also Apache-2.0#

Code licenses don't automatically cover trained models, so we checked the license field of PaddlePaddle's model cards on Hugging Face. All 16 return apache-2.0:³

Two limits to what we verified. First, we didn't check every model PaddleOCR can download, nor the copies served from ModelScope or Baidu's own download servers. Second, PaddleOCR-VL is built on ERNIE-4.5-0.3B, and its card also credits other projects. PaddlePaddle declares Apache-2.0 for the released model, and the 1.6 repo includes the full Apache text, but we did not audit the upstream licenses separately.³ If a model matters to your product, open its card and record the license you saw, with the date.

Parts of the repo under other licenses#

A few files in the PaddleOCR repository come from other projects and keep their own permissive licenses:⁴

About 91 files under ppocr/ say "This code is refer from: …", pointing to projects such as mmocr. We haven't audited each one. If you vendor the training code, check those headers.

Other official packages: the browser SDK @paddleocr/paddleocr-js and the @paddleocr/api-sdk TypeScript client are Apache-2.0. The browser SDK depends on onnxruntime-web (MIT), js-yaml (MIT), @techstark/opencv-js (Apache-2.0) and clipper-lib (listed as "BSL" on npm). The paddleocr-mcp package has no license field in its PyPI metadata, although its source files carry Apache-2.0 headers.⁵

Your dependency tree: what pip actually installs#

PaddleOCR's license doesn't cover the libraries it pulls in, so we checked those too. We followed the declared requirements of a base pip install paddleocr==3.7.0 in our Python 3.13 test environment on October 27, 2026. That comes to 64 distributions including PaddleOCR itself, or 71 with paddlepaddle. Then we read each one's declared license.⁶

• The core is permissive: paddleocr and paddlex (Apache-2.0), paddlepaddle (Apache), onnxruntime (MIT), opencv-contrib-python (Apache 2.0), and most of the rest MIT, BSD or Apache.
• Two are LGPL: python-bidi (required by paddlex) and crc32c (via bce-python-sdk ← aistudio-sdk).
• Two involve MPL-2.0: certifi (via requests) and tqdm (MPL-2.0 AND MIT).
• pypdfium2 declares "BSD-3-Clause, Apache-2.0, dependency licenses" because it bundles the PDFium binary.

LGPL and MPL are weak-copyleft licenses. Their extra obligations mostly concern modifying or redistributing those libraries, for example inside a frozen executable or a Docker image you give to customers. To list licenses in your own environment:

import importlib.metadata as md

def license_of(m):
    if m.get("License-Expression"):
        return m["License-Expression"]
    text = (m.get("License") or "").split("\n")[0]
    if text:
        return text
    return ", ".join(c.split("::")[-1].strip()
                     for c in (m.get_all("Classifier") or [])
                     if c.startswith("License ::"))

for d in sorted(md.distributions(), key=lambda d: d.metadata["Name"].lower()):
    print(f'{d.metadata["Name"]:28} {d.version:12} {license_of(d.metadata)[:60]}')

Run it inside a fresh virtual environment where you installed only what you ship. Extras such as paddleocr[doc-parser] add more packages.

What PaddleOCR costs#

Running it yourself. Your costs are compute and the time to operate it. For scale, in our benchmark on a 4-vCPU Xeon with no GPU, PP-OCRv6 small averaged 0.9 s per page and medium 2.9 s, using the ONNX Runtime engine. PaddleOCR's own docs say "CPU inference is not recommended" for PaddleOCR-VL, so budget for a GPU if you need it.⁸

The official hosted API. paddleocr.com redirects to Baidu AI Studio, which runs PaddleOCR models as a service. According to its quota rules (updated February 10, 2026), each user can parse up to 3,000 pages per model per day, after which the API returns HTTP 429. For files over 100 pages "the API will only parse the first 100 pages", although the async guide says it "supports up to 1000 PDF pages per request". The two documents disagree. Higher volumes go through a questionnaire "to apply for a free quota increase". We could not find any published price.⁷ The Apache license covers the open-source code, not this service: the service has its own terms, and your files are processed on Baidu's servers. Details in our API guide.

How this compares with other OCR tools#

Licensing is where OCR tools differ most, and the catch is often in the weights rather than the code.⁹

The full side-by-side, with benchmarks and languages, is on our OCR comparison page.

Checklist: shipping PaddleOCR in a commercial product#

1. Pin what you ship. Record the paddleocr version and every model name you load, for example PP-OCRv6_medium_det and PP-OCRv6_medium_rec.
2. Record each model's license. Save the Hugging Face card URL and the license it showed (apache-2.0 for the 16 we checked), with the date. If you fetch models from somewhere else, check that source.
3. Include the Apache-2.0 text in your distribution, §4(a).
4. Keep PaddleOCR's copyright and license headers in any source you ship, §4(c).
5. Mark modified files if you patched PaddleOCR, §4(b). Keep the patches in version control.
6. Add the third-party notices for what you actually ship: MIT for the two _doc2md/math files, and MIT or Boost if you reuse the C++ or iOS deployment code.
7. Inventory your Python dependencies with the script above and review the LGPL and MPL packages, especially if you freeze or containerize them for customers.
8. Don't use the names as branding. "Powered by PaddleOCR" as a factual credit is fine under §6. A product called "PaddleOCR Pro" or a Baidu logo on your site is not.
9. Decide on the hosted API separately. If you call Baidu's API instead of running locally, read its terms and check where your users' documents go.
10. Re-check on upgrades. Licenses change: MinerU moved from AGPL-3.0 to a custom license between releases. Re-run your inventory when you bump versions.

Questions#