Compress PDFs in Python: 5 Libraries Benchmarked (2026)

Why You'd Compress PDFs in Python

If you have a pipeline that generates or receives PDFs — invoices, reports, scanned documents — you need programmatic compression. The five most commonly used Python approaches differ significantly in compression ratio, speed, quality, and dependencies.

Test Setup

We ran each library on 10 PDFs across three categories:

• 3 image-heavy PDFs (scanned documents, 150–300 DPI, 5–40 MB each)
• 4 mixed PDFs (text + images, financial reports, 1–10 MB each)
• 3 text-only PDFs (contracts, reports, 100 KB–1 MB each)

Environment: Python 3.12, Ubuntu 24.04, 8-core machine.

1. Ghostscript (via subprocess)

Ghostscript is the gold standard for PDF compression. It re-renders the PDF through a PostScript interpreter and applies optimised image downsampling.

import subprocess

def compress_pdf_ghostscript(input_path: str, output_path: str, quality: str = "ebook") -> None:
    """
    quality options: screen (72 DPI), ebook (150 DPI), printer (300 DPI), prepress (300 DPI, colour-managed)
    """
    subprocess.run([
        "gs",
        "-sDEVICE=pdfwrite",
        "-dCompatibilityLevel=1.5",
        f"-dPDFSETTINGS=/{quality}",
        "-dNOPAUSE",
        "-dQUIET",
        "-dBATCH",
        f"-sOutputFile={output_path}",
        input_path,
    ], check=True)

Results:

• Image-heavy: 67% compression (best in test)
• Mixed: 52% compression
• Text-only: 22% compression
• Speed: 3.2s average per file
• Quality: Excellent (ebook setting)
• Dependency: Requires Ghostscript installed (apt install ghostscript)

Verdict: Best compression ratios. Requires system dependency. Ideal for server pipelines.

2. PyMuPDF (fitz)

PyMuPDF wraps MuPDF, a high-quality PDF rendering library. Fast and no system dependencies.

import fitz  # PyMuPDF

def compress_pdf_pymupdf(input_path: str, output_path: str, image_quality: int = 50) -> None:
    doc = fitz.open(input_path)
    for page in doc:
        for img in page.get_images(full=True):
            xref = img[0]
            image = doc.extract_image(xref)
            # Re-insert with lower quality
            # Note: PyMuPDF doesn't directly recompress in-place;
            # use deflate=True on save for structure compression
    doc.save(output_path, deflate=True, garbage=4, clean=True)
    doc.close()

For image recompression with PyMuPDF, the recommended approach is to re-render pages:

def compress_pdf_pymupdf_render(input_path: str, output_path: str, dpi: int = 150) -> None:
    src = fitz.open(input_path)
    doc = fitz.open()
    for page in src:
        pix = page.get_pixmap(dpi=dpi)
        img_pdf = fitz.open("pdf", pix.pdfocr_tobytes())
        doc.insert_pdf(img_pdf)
    doc.save(output_path, deflate=True)
    src.close()
    doc.close()

Results:

• Image-heavy: 58% compression
• Mixed: 41% compression
• Text-only: 15% compression (text rendered to image — not ideal for text PDFs)
• Speed: 1.8s average (fastest in test)
• Dependency: pip install pymupdf (no system deps)

Verdict: Best for image-heavy PDFs without Ghostscript. Note: rendering text PDFs to images loses text selectability.

3. pikepdf

pikepdf is a Pythonic wrapper around libqpdf. Excellent for structural optimisation but limited image recompression.

import pikepdf

def compress_pdf_pikepdf(input_path: str, output_path: str) -> None:
    with pikepdf.open(input_path) as pdf:
        pdf.save(
            output_path,
            compress_streams=True,
            stream_decode_level=pikepdf.StreamDecodeLevel.generalized,
            object_stream_mode=pikepdf.ObjectStreamMode.generate,
        )

Results:

• Image-heavy: 12% compression (structural only — no image resampling)
• Mixed: 18% compression
• Text-only: 25% compression (best for pure text)
• Speed: 0.4s average (fastest)
• Dependency: pip install pikepdf

Verdict: Best for text-heavy PDFs where you want structural compression without image quality loss. Poor for image-heavy files.

4. pypdf (formerly PyPDF2)

pypdf is pure Python, no C dependencies. Good for reading/writing but limited compression capability.

from pypdf import PdfWriter, PdfReader

def compress_pdf_pypdf(input_path: str, output_path: str) -> None:
    reader = PdfReader(input_path)
    writer = PdfWriter()
    for page in reader.pages:
        page.compress_content_streams()
        writer.add_page(page)
    with open(output_path, "wb") as f:
        writer.write(f)

Results:

• Image-heavy: 8% compression
• Mixed: 11% compression
• Text-only: 14% compression
• Speed: 1.2s average
• Dependency: pip install pypdf (pure Python)

Verdict: Easy to install but weakest compression. Use for simple workflows where dependencies matter more than ratio.

5. img2pdf + Pillow (for scanned PDFs)

For purely scanned (image-only) PDFs, converting images to JPEG before re-embedding gives strong compression.

import img2pdf
from PIL import Image
import fitz
import io

def compress_scanned_pdf(input_path: str, output_path: str, quality: int = 60) -> None:
    doc = fitz.open(input_path)
    images = []
    for page in doc:
        pix = page.get_pixmap(dpi=150)
        img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
        buf = io.BytesIO()
        img.save(buf, format="JPEG", quality=quality)
        images.append(buf.getvalue())
    with open(output_path, "wb") as f:
        f.write(img2pdf.convert(images))

Results (scanned PDFs only):

• Compression: 71% (best for scanned content)
• Speed: 2.1s average
• Caveat: Text becomes image — not searchable

Verdict: Best for archiving scanned documents where text searchability is not required.

Benchmark Summary

Library	Image PDF	Mixed PDF	Text PDF	Speed	Install
Ghostscript	67%	52%	22%	3.2s	System dep
PyMuPDF	58%	41%	15%*	1.8s	pip only
pikepdf	12%	18%	25%	0.4s	pip only
pypdf	8%	11%	14%	1.2s	pip only
img2pdf+Pillow	71%*	N/A	N/A	2.1s	pip only

*Caveat: text rendered as image

Recommendation

For production pipelines: Ghostscript for maximum compression; PyMuPDF when you can't install system dependencies.

For text documents: pikepdf for structural compression without quality loss.

For scanned archives: img2pdf + Pillow for maximum image compression.

For quick scripting: pypdf for simplest installation, accepting lower compression.

For occasional or one-off compression without code, our online PDF compressor uses a Ghostscript backend and achieves the same ratios without setup.