ML-For-Beginners
12 weeks, 26 lessons, 52 quizzes, classic Machine Learning for all
- 92k
- Jupyter Notebook
- MIT
- 11 d ago
PyMuPDF is a high performance Python library for data extraction, analysis, conversion & manipulation of PDF (and other) documents.
Repo pymupdf/PyMuPDF, read from GitHub 1 min ago. pymupdf has not joined Take My Repo.
pymupdf/PyMuPDF is a public repo on GitHub by pymupdf. PyMuPDF is a high performance Python library for data extraction, analysis, conversion & manipulation of PDF (and other) documents. It declares the AGPL-3.0 license on GitHub. It is written mainly in Python, has 11,153 stars and last changed on 2026-11-18. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-18.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
The PDF engine behind over 50 million monthly downloads, powering AI pipelines worldwide.
PyMuPDF is a high-performance Python library for data extraction, layout analysis, conversion, rendering and manipulation of PDF (and other) documents. Built on top of MuPDF — a lightweight, fast C engine — PyMuPDF gives you precise, low-level control over documents alongside high-level convenience APIs.
pip install --upgrade pymupdf
If you have a broken installation due to upgrading PyMuPDF from earlier versions, or from running separate installation commands for pymupdf-layout or pymupdf4llm, then please use:
pip install --force-reinstall --no-cache-dir pymupdf
This will ensure a clean installation of PyMuPDF.
Wheels are available for Windows, macOS, and Linux on Python 3.11–3.15. If no pre-built wheel exists for your platform, pip will compile from source (requires a C/C++ toolchain).
PyMuPDF uses the ONNX Runtime for certain layout analysis features - ensure your Python environment can support it. For more details see PyMuPDF Layout & ONNX Runtime
After installation, run the pymupdf-config command,
This will review what is installed and show information about what other packages
(Python and otherwise) may be available for your system and could improve accuracy and speed.
| Package | Purpose |
|---|---|
pymupdf-office |
Adds Office document support |
pymupdf-fonts |
Extended font collection for text output |
rapidocr |
OCR engine (recommended) |
tesseract-ocr |
OCR engine |
# Office support pip install pymupdf-office # More fonts pip install pymupdf-fonts # OCR pip install rapidocr # OCR (Tesseract must be installed separately) # macOS brew install tesseract # Ubuntu / Debian sudo apt install tesseract-ocr
We compared both OCR engines on the ExtractBench document corpus:
| Document length | PDFs | PyMuPDF + Tesseract | PyMuPDF + RapidOCR |
|---|---|---|---|
| Short, 1–10 pages | 252 | 80.39% | 88.94% |
| Medium, 11–50 pages | 98 | 82.72% | 87.00% |
| Long, over 50 pages | 20 | 30.49% | 29.22% |
| Overall | 370 | 78.31% | 85.20% |
Overall, for the best OCR accuracy, it is recommended to use RapidOCR.
| Category | Formats |
|---|---|
| PDF & derivatives | PDF, XPS, EPUB, CBZ, MOBI, FB2, SVG, TXT, MD |
| Images | PNG, JPEG, BMP, TIFF, GIF, and more |
| PyMuPDF Office | DOC, DOCX, XLS, XLSX, PPT, PPTX, HWP, HWPX |
| Format | Notes |
|---|---|
| Full fidelity conversion from Office formats | |
| SVG | Vector page rendering |
| Image (PNG, JPEG, …) | Page rasterisation at any DPI |
| Markdown | Structure-aware, LLM-ready |
| JSON | Bounding boxes, layout data, per-element detail |
| Plain text | Fast, lightweight extraction |
import pymupdf doc = pymupdf.open("document.pdf") for page in doc: print(page.get_text())
import pymupdf doc = pymupdf.open("document.pdf") page = doc[0] blocks = page.get_text("dict")["blocks"] for block in blocks: if block["type"] == 0: # text block for line in block["lines"]: for span in line["spans"]: print(f"{span['text']!r} font={span['font']} size={span['size']:.1f}")
import pymupdf doc = pymupdf.open("spreadsheet.pdf") page = doc[0] tables = page.find_tables() for table in tables: print(table.to_markdown()) # or get as Pandas DataFrame df = table.to_pandas()
import pymupdf doc = pymupdf.open("document.pdf") page = doc[0] pixmap = page.get_pixmap(dpi=150) pixmap.save("page_0.png")
import pymupdf doc = pymupdf.open("scanned.pdf") page = doc[0] # Requires Tesseract installed and on PATH text = page.get_textpage_ocr(language="eng").extractText() print(text)
import pymupdf md_doc = pymupdf.open("example.md") md_doc.save("example.pdf")
import pymupdf doc = pymupdf.open("report.pdf") md = doc.to_markdown() # Pass directly to your LLM or vector store print(md)
import pymupdf doc = pymupdf.open("contract.pdf") page = doc[0] # Add a highlight annotation rect = pymupdf.Rect(72, 100, 400, 120) page.add_highlight_annot(rect) # Add a redaction and apply it page.add_redact_annot(rect) page.apply_redactions() doc.save("contract_redacted.pdf")
import pymupdf merger = pymupdf.open() for path in ["part1.pdf", "part2.pdf", "part3.pdf"]: merger.insert_pdf(pymupdf.open(path)) merger.save("merged.pdf")
import pymupdf.office pymupdf.office.unlock("YOUR-LICENSE-KEY") doc = pymupdf.open("presentation.pptx") pdf_bytes = doc.convert_to_pdf() with open("output.pdf", "wb") as f: f.write(pdf_bytes)
import pymupdf.office pymupdf.office.unlock("YOUR-LICENSE-KEY") pymupdf.office.to_markdown("input.docx", "output.md")
| Feature | Description |
|---|---|
| Text extraction | Plain text, rich dict (font, size, color, bbox), HTML, XML, raw blocks |
| Table detection | find_tables() — locate, extract, and export tables as Markdown or structured data |
| Image extraction | Extract embedded images and render any page to a high-resolution Pixmap |
| Rendering | Render PDF pages to images or Pixmap data for use in UI or other workflows |
| OCR | Tesseract integration — full-page or partial OCR, configurable language |
| Annotations | Read and write highlights, underlines, squiggly lines, sticky notes, free text, ink, stamps |
| Redaction | Add and permanently apply redaction annotations |
| Forms | Read and fill PDF AcroForm fields |
| PDF creation | Create PDFs directly with the API or quickly convert from Markdown files |
| PDF editing | Insert, delete, and reorder pages; set metadata; merge and split documents |
| Drawing | Draw lines, curves, rectangles, and circles; insert HTML boxes |
| Encryption | Open password-protected PDFs; save with RC4 or AES encryption |
| Links | Extract hyperlinks, internal cross-references, and URI targets |
| Bookmarks | Read and write the outline / table of contents tree |
| Metadata | Title, author, creation date, producer, subject, and custom entries |
| Color spaces | RGB, CMYK, greyscale; color space conversion |
doc = pymupdf.open("document.pdf") , then:
| Output | API |
|---|---|
| Markdown | doc.to_markdown(path) |
| JSON | doc.to_json(path) |
| Plain text | doc.to_text(path) |
Supports multi-column layouts, natural reading order and page chunking.
Python 3.11 – 3.15 (as of v2.0). Wheels ship for:
manylinux x86_64 and aarch64musllinux x86_64PyMuPDF is built on MuPDF — one of the fastest PDF rendering engines available. Typical benchmarks against pure-Python PDF libraries show 10–50× speed improvements for text extraction and 100× or more for page rendering, with a minimal memory footprint.
PyMuPDF processes documents without a GPU, cutting infrastructure costs significantly compared to vision-based LLM approaches.
import pymupdf from pathlib import Path doc = pymupdf.open("document.pdf") out = Path("images") out.mkdir(exist_ok=True) for page_index, page in enumerate(doc): for img_index, img in enumerate(page.get_images()): xref = img[0] pix = pymupdf.Pixmap(doc, xref) if pix.n > 4: # convert CMYK pix = pymupdf.Pixmap(pymupdf.csRGB, pix) pix.save(out / f"page{page_index}_img{img_index}.png")
import pymupdf doc = pymupdf.open("document.pdf") needle = "confidential" for page in doc: hits = page.search_for(needle) if hits: print(f"Page {page.number}: {len(hits)} occurrence(s)") for rect in hits: page.add_highlight_annot(rect) doc.save("highlighted.pdf")
import pymupdf doc = pymupdf.open("document.pdf") for i, page in enumerate(doc): out = pymupdf.open() out.insert_pdf(doc, from_page=i, to_page=i) out.save(f"page_{i + 1}.pdf")
import pymupdf doc = pymupdf.open("document.pdf") for page in doc: page.insert_text( point=pymupdf.Point(72, page.rect.height / 2), text="DRAFT", fontsize=72, color=(0.8, 0.8, 0.8), rotate=45, ) doc.save("watermarked.pdf")
PyMuPDF can be extended with PyMuPDF Office. This adds a conversion layer that handles Microsoft and Korean Office formats natively — no Office installation, no COM interop, no LibreOffice subprocess.
Once unlocked, pymupdf.open() accepts Office files exactly like PDFs:
import pymupdf.office pymupdf.office.unlock("YOUR-LICENSE-KEY") # Works identically regardless of format for fmt in ["contract.docx", "data.xlsx", "deck.pptx", "report.hwpx"]: doc = pymupdf.open(fmt) for page in doc: print(page.get_text())
Get a trial license key for PyMuPDF Office
What you can do with Office documents:
doc.convert_to_pdf()When pymupdf.office.unlock() is called without a key, the following restrictions apply:
| Restriction | Detail |
|---|---|
| Page limit | Only the first 3 pages of any document are accessible |
| Time limit | Evaluation period — functionality expires after a set duration |
All other features work normally within these constraints, making it straightforward to prototype before purchasing a license.
Yes, absolutely — and this is one of PyMuPDF's most significant advantages.
PyMuPDF runs entirely locally. It is a native Python library built on top of the MuPDF C engine. When you call pymupdf.open(), page.get_text(), page.find_tables(), or any other method, everything executes in-process on your own machine. No data is transmitted anywhere.
There are no telemetry calls, no licence validation callbacks, no cloud dependencies of any kind in the open-source AGPL build or the commercial build. Once the package is installed, it works fully air-gapped.
This makes PyMuPDF well-suited for:
The only thing you need an internet connection for is the initial pip install. After that, the package and all its capabilities are entirely self-contained.
import pymupdf or import fitz?Use import pymupdf. The fitz name is a legacy alias that still works as of v1.24.0+, but import pymupdf is the recommended and future-proof approach. The two are interchangeable in existing code:
import pymupdf # recommended # import fitz # legacy alias — still works but avoid for new code
Yes — PyMuPDF has solid CJK support
This is the best starting point for feeding an LLM or building a RAG pipeline.
import pymupdf doc = pymupdf.open("report.pdf") md = doc.to_markdown() print(md) # Tables appear as Markdown | col1 | col2 | ... inline with the text
This usually means the PDF uses custom font encodings without a proper character map (CMAP). The font's glyphs are present but cannot be mapped back to Unicode. In these cases:
page.get_textpage_ocr())Pass a clip rectangle to get_text():
import pymupdf doc = pymupdf.open("input.pdf") page = doc[0] # Define the area you want (x0, y0, x1, y1) in points clip = pymupdf.Rect(50, 100, 400, 300) text = page.get_text("text", clip=clip)
import pymupdf doc = pymupdf.open("input.pdf") page = doc[0] # Returns a list of Rect objects surrounding each match locations = page.search_for("invoice number") for rect in locations: print(rect) # e.g. Rect(72.0, 120.5, 210.0, 134.0)
get_images shows no images but I can clearly see charts in the PDF. Why?Charts and diagrams created by tools like matplotlib, Excel, or R are typically rendered as vector graphics (PDF drawing commands), not raster images. get_images only lists embedded raster image objects and will not detect vector graphics. To capture these, rasterise the entire page with page.get_pixmap().
PyMuPDF uses MuPDF's built-in Tesseract-based OCR support, so there is no Python-level pytesseract dependency. However, PyMuPDF still needs access to the Tesseract language data files (tessdata), and automatic tessdata discovery may invoke the tesseract executable (for example, to list available languages) if you do not explicitly provide a tessdata path. In practice, the recommended setup is to either install Tesseract so discovery works automatically, or configure the tessdata location yourself via the tessdata parameter or the TESSDATA_PREFIX environment variable. Over 100 languages are supported.
PyMuPDF also supports RapidOCR - which is the recommended OCR engine - RapidOCR is a pip-installable Python package that runs ONNX models, so it doesn't need a separate Tesseract install or TESSDATA_PREFIX.
import pymupdf doc = pymupdf.open("scanned.pdf") page = doc[0] # Get a text page using OCR tp = page.get_textpage_ocr(language="eng") text = page.get_text(textpage=tp) print(text)
import pymupdf pix = pymupdf.Pixmap("image.png") if pix.alpha: pix = pymupdf.Pixmap(pix, 0) # remove alpha channel — required for OCR # Wrap in a 1-page PDF and OCR it doc = pymupdf.open() page = doc.new_page(width=pix.width, height=pix.height) page.insert_image(page.rect, pixmap=pix) tp = page.get_textpage_ocr() text = page.get_text(textpage=tp)
import pymupdf doc = pymupdf.open("input.pdf") page = doc[0] # Use quads=True for accurate highlights on non-horizontal text quads = page.search_for("important term", quads=True) page.add_highlight_annot(quads) doc.save("highlighted.pdf")
PyMuPDF supports all standard PDF text markers: highlight, underline, strikeout, and squiggly.
Redaction is a deliberate two-step process so you can review before committing:
import pymupdf doc = pymupdf.open("input.pdf") page = doc[0] # Step 1: Mark the area(s) to redact rect = page.search_for("confidential")[0] page.add_redact_annot(rect, fill=(1, 1, 1)) # white fill # Step 2: Apply — permanently removes the underlying content page.apply_redactions() doc.save("redacted.pdf")
After apply_redactions(), the original content is gone. It cannot be recovered from the saved file.
import pymupdf doc = pymupdf.open("form.pdf") page = doc[0] for field in page.widgets(): print(f"{field.field_name}: {field.field_value}")
import pymupdf doc = pymupdf.open("form.pdf") page = doc[0] for field in page.widgets(): if field.field_name == "First Name": field.field_value = "Ada" field.update() doc.save("filled_form.pdf")
No. PyMuPDF does not support multithreaded use, even with Python's newer free-threading mode. The underlying MuPDF library only provides partial thread safety, and a fully thread-safe PyMuPDF implementation would still impose a single-threaded overhead — negating the benefit.
Use multiprocessing instead. Each process opens the file independently and works on its own page range:
from multiprocessing import Pool import pymupdf def process_pages(args): path, start, end = args doc = pymupdf.open(path) # each process opens its own handle results = [] for i in range(start, end): results.append(doc[i].get_text()) return results with Pool(4) as pool: chunks = [("input.pdf", 0, 25), ("input.pdf", 25, 50), ...] all_results = pool.map(process_pages, chunks)
Reuse a TextPage object. Creating a TextPage is the expensive part — once created, switching between extraction formats is cheap:
import pymupdf page = doc[0] tp = page.get_textpage() # create once text = page.get_text("text", textpage=tp) words = page.get_text("words", textpage=tp) data = page.get_text("dict", textpage=tp)
This can reduce execution time by 50–95% for repeated extractions on the same page.
import pymupdf doc = pymupdf.open("input.pdf") # Read print(doc.metadata) # {'title': '...', 'author': '...', 'subject': '...', 'keywords': '...', ...} # Write doc.set_metadata({ "title": "Annual Report 2025", "author": "Finance Team", "keywords": "annual, finance, 2025" }) doc.save("output.pdf")
import pymupdf doc = pymupdf.open("input.pdf") # Read — returns a list of [level, title, page_number] entries toc = doc.get_toc() for level, title, page in toc: print(" " * level, title, "→ page", page) # Write new_toc = [ [1, "Introduction", 1], [1, "Methods", 5], [2, "Data sources", 6], ] doc.set_toc(new_toc) doc.save("output.pdf")
Full installation guide, API reference, cookbook, and tutorial at pymupdf.readthedocs.io.
PyMuPDF and MuPDF are maintained by Artifex Software, Inc.
Contributions are welcome. Please open an issue before submitting large pull requests.
If you find this useful, please consider giving it a star — it helps others discover it!
pymupdf/PyMuPDF is a public repo on GitHub by pymupdf. PyMuPDF is a high performance Python library for data extraction, analysis, conversion & manipulation of PDF (and other) documents.
It declares the AGPL-3.0 license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-11-18. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
12 weeks, 26 lessons, 52 quizzes, classic Machine Learning for all
Convert PDF to markdown + JSON quickly with high accuracy
Bring data to life with SVG, Canvas and HTML. :bar_chart::chart_with_upwards_trend::tada:
The 30 Days of Python programming challenge is a step-by-step guide to learn the Python programming language in 30 days. This challenge may take more than 100 days. Follow your own pace. These videos may help too: https://www.youtube.com/channel/UC7PNRuno1rzYPb1xLa4yktw
Kavita is a fast, feature rich, cross platform reading server. Built with the goal of being a full solution for all your reading needs. Setup your own server and share your reading collection with your friends and family.
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/pymupdf/PyMuPDFTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.