Ten Years, One Billion Downloads: A Technical History of PyMuPDF

Introduction

When PyMuPDF first appeared on PyPI on 19 August 2016, it was not intended to become a major component in the Python document-processing ecosystem. It began as a pragmatic bridge: a Pythonic interface to the mature and efficient MuPDF library, designed to give Python developers access to fast rendering, reliable text extraction, and a clean API. At the time, the landscape of PDF tools in Python was fragmented. Some libraries focused on simple metadata manipulation, others on partial parsing, and very few offered high-performance rendering or full document introspection. PyMuPDF emerged to fill that gap.

Milestone downloads

4 days after its 10th birthday PyMuPDF passed one billion cumulative downloads on PyPI. Of those billion downloads, 83% happened in the last twelve months alone, carried by the surge in AI systems that need to read documents before they can reason about them.

Crossing one billion downloads puts PyMuPDF in unusual company. The packages at this scale are almost entirely infrastructure: AWS clients, HTTP stacks, packaging tools, type stubs. A library that does one specific thing, and does it to documents, does not normally end up there. That says something about how much of modern Python software has document processing somewhere inside it.

A Personal Beginning

The project’s origins were surprisingly modest. For many years, I subscribed to a scientific magazine that distributed its issues as monthly PDF downloads. Around 2013–2015, many of these PDFs lacked a usable table of contents. Navigating long articles became tedious, and I began searching for software that could insert and maintain a proper TOC.

At that time, I had no background in PDF internals, no knowledge of Python, and no experience with C. What I did have was a practical problem and the curiosity to explore solutions. My search eventually led me to MuPDF and to a small Python library called fitz-python that used SWIG to generate bindings from MuPDF’s header files (version 1.2 at that time). The technical clarity and performance of MuPDF immediately convinced me. That discovery became the spark: if MuPDF was this capable, perhaps a more complete and Pythonic interface could be built on top of it.

PyMuPDF grew out of that simple need - to make PDFs more usable - and out of the fascination with MuPDF’s design.

Early Development (2016–2021)

The initial release in August 2016 provided a compact but powerful feature set: page rendering, text extraction, and basic document manipulation: metadata and Table of Contents. The API was intentionally straightforward, reflecting the underlying MuPDF philosophy of clarity and speed but centered around a typical application programmer’s view. Early adopters appreciated the combination of performance and intuitive simplicity, and the first GitHub issues already showed a pattern that would continue for years: users wanted more high-level convenience functions, but without sacrificing the speed that MuPDF offered.

Download numbers were modest at first, but they grew consistently. The project attracted developers who needed reliable PDF rendering in Python - something that had been difficult to achieve without resorting to external command-line tools.

The first years established PyMuPDF as a practical solution for real-world tasks, and the fast reaction to user questions and requests for help quickly became a defining characteristic of the project.

Over the next years, PyMuPDF evolved at modest speed, continuously adding new functions and supporting new object types

• Support for merging, splitting, and reorganizing documents
• Annotations
• Form fields
• Improvements in text extraction accuracy and structure

In January 2021, our accumulated downloads from PyPI exceeded two million.

In autumn 2021, PyMuPDF adopted MuPDF’s integrated OCR support. It became the first document management tool that offered this feature as a seamless part of its functionality.

The effect on the users was rewarding: the sharp increase in the download numbers during the following months showed that PyMuPDF was under close observation among users.

A notable milestone occurred when Artifex Software - the company behind MuPDF - expressed interest in PyMuPDF. This resulted in a formal Sales Representation Agreement in February 2021.

The partnership provided access to deeper technical insights, improved coordination with MuPDF’s development, and a clearer path for long-term maintenance. It also demonstrated that PyMuPDF had become an important part of the MuPDF ecosystem, not just a Python wrapper.

For me personally, it meant the privilege of exchanging ideas almost daily with the technical experts of the MuPDF team and reflecting on the future development of PyMuPDF.

A little more than a year after this, in May 2022, Artifex acquired PyMuPDF. This marked a turning point in the project’s history. The acquisition formalized the relationship between PyMuPDF and MuPDF, ensuring that the Python bindings would be maintained, supported, and extended as part of Artifex’s product strategy.

PyMuPDF was no longer a community-driven wrapper; it became an officially supported component of a commercial PDF engine.

Not long after Artifex acquired PyMuPDF, they invited me to help shape its future. I accepted the invitation with genuine joy – it felt like a rare chance to contribute to a project that had already become part of my daily life. Suddenly, I found myself exchanging ideas almost every day with the MuPDF technical experts, discussing design choices, exploring new directions, and learning from people whose deep understanding of PDF internals had once seemed almost unreachable to me.

Becoming part of the maintainer team changed my relationship with PyMuPDF. I began developing new features, contributing to forward‑looking decisions, writing blog posts, and helping guide the project’s evolution. What had started as a personal fascination grew into a shared responsibility – and a privilege I still feel every day.

The major contribution in this new role was the integration of a table recognition module in August 2023. This was obviously a long-awaited feature: once again download numbers increased dramatically to three, then seven millions in the following two months.

The LLM Era: PyMuPDF4LLM (2024–2026)

The introduction of PyMuPDF4LLM in April 2024 opened yet another chapter for me. It brought together my long‑standing interest in document understanding, and practical AI workflows. Suddenly, PyMuPDF was not only a tool for developers working with PDFs – it became a bridge between classical document processing and modern language models.

Watching PyMuPDF4LLM evolve has been remarkable. In a field where accuracy is usually bought with time and hardware, it holds its own on real documents while remaining, by a wide margin, the fastest and most resource-efficient option available.

What began as an experimental extension quickly proved its strength in real‑world document‑understanding workflows, combining precision, speed, and simplicity in a way that few others can match.

Once again, the market success is reflected by the download numbers: PyMuPDF4LLM has been downloaded 160 million times so far.

Working on 4LLM has been both challenging and deeply rewarding. Designing the API, refining the extraction logic, integrating AI technologies like a Graph Neural Network for page layout detection – all of this has given me a sense of creative momentum I hadn’t felt in years. And it made me realize how much potential still lies ahead.

Today, when I think about the future of PyMuPDF, I feel a mixture of excitement and gratitude. Excitement, because the combination of MuPDF’s technical foundation and the new AI‑driven capabilities opens doors we could barely imagine a few years ago. Gratitude, because I get to be part of this journey – contributing ideas, building features, and helping shape a project that has accompanied me for more than a decade.

Ten Years in Numbers

113 Releases in total

Across its first decade, PyMuPDF achieved measurable impact:

• A long and consistent release history
• A billion downloads across PyPI channels
• Adoption in research, enterprise automation, and AI workflows
• A stable API used in thousands of projects
• A growing ecosystem of tools built on top of PyMuPDF
• Continuous integration with the evolving MuPDF engine

These numbers reflect not only technical success but also the trust developers place in the library.

What Makes PyMuPDF Distinct

Several characteristics define PyMuPDF’s identity:

• Performance: MuPDF’s speed, exposed cleanly through Python.
• Precision: Accurate rendering and extraction, even for complex PDFs.
• Breadth: Support for multiple document formats.
• Stability: A consistent API that respects backward compatibility.
• Practicality: A focus on real-world use cases rather than theoretical completeness.
• Community: A user base that provides valuable feedback and diverse documents.
• Professional backing: Artifex’s stewardship ensures long-term viability.

These qualities have made PyMuPDF a dependable tool for developers who need both flexibility and reliability.

Looking Ahead

Here are three key areas for our future consideration:

1. Document Perception

We’re appreciating more and more that documents need to be able to be understood and verified on an ongoing basis and not just parsed once, the result stored and the original source document forgotten. Given this situation we believe that PyMuPDF must be able to move from supporting document parsing to being able to support document perception. So being able to revisit a document and derive different information from it with different queries is of key interest. For example, perhaps initially you may be interested in extracting tables from a document for a downstream pipeline, but then on another day you may be more interested in how one region of a document relates to another. In this case the document hasn’t changed, but the question has. PyMuPDF should be able to provide for this kind of scenario where different ways of perceiving a document and the interrelations between page elements can be explained and provided for.

2. Verifiable Evidence Objects

Another aspect is being able to provide the best evidence for source data so for when LLMs query a document the answers can also be shown. In this way we are increasingly seeing documents as “evidence objects” capable of supporting questions with actual evidence and confidence scores. Being able to validate areas in documents so we can show grounded results reliably and quickly will become increasingly important.

3. Supporting Document Agents

As agents get increasingly sophisticated they will rarely rely on a single retrieval step. Instead, they may continuously inspect documents throughout the reasoning process and examine different areas of a document as required. They may also be expected to edit and update documents, apply comments or make redactions. And so as these systems mature, we may also see document agents performing long-running workflows beyond simple parsing. For example, an organization may deploy agents that continuously monitor incoming documents. In this example scenario when a new contract arrives, the agent(s) may automatically classify it, extract key terms, redact confidential information where necessary and route the document for approval depending on the document type. At each stage of this process PyMuPDF should be able to provide a deterministic suite of functionality to support the required processes.

With deterministic document operations being a core operational principle which PyMuPDF is founded on, then AI systems can empower their agents with the trust that their probabilistic planning can be combined with deterministic execution.

_____________________________________________________________________

Whatever the future holds, PyMuPDF’s foundation - clarity, performance, and practicality - will remain central. Its evolution must reflect both the needs of developers and the broader shifts in how documents are analyzed and understood, especially in the era of AI.