Top 10 Python PDF generation libraries (2025 edition)

1. Generating PDFs with FPDF

FPDF(opens in a new tab) is a lightweight, dependency-free library for building PDFs from scratch.

Key features

• Quick text and image insertion — Add paragraphs, pictures, and simple lines.
• Multipage support — Loop through pages with just a few commands.
• Basic formatting — Set fonts, colors, and alignments easily.
• Fast and tiny footprint — Ideal for small scripts or environments with minimal packages.

Best for: Simple multipage docs, or image-rich flyers that only need basic text, images, and custom formatting.

Installation

Install FPDF using pip:

pip install fpdf

Usage example

Here’s a simple example of how to create a PDF with FPDF:

from fpdf import FPDF

# Create an instance of an FPDF class.
pdf = FPDF()

# Add a page.
pdf.add_page()

# Set the font.
pdf.set_font("Arial", size=12)

# Add a cell.
pdf.cell(200, 10, txt="Hello, this is a PDF generated using FPDF!", ln=True, align='C')

# Save the PDF with the name `.pdf`.
pdf.output("output.pdf")

print("PDF generated successfully!")

In this example, you created a PDF document, added a single page, and inserted a line of centered text. The PDF was then saved to a file named output.pdf. FPDF provides a simple and effective way to generate PDFs with basic content and formatting.

Advanced example: Generating a multipage PDF with images and custom formatting

In this example, you’ll create a Python script to generate a multipage PDF that includes both text and images. You’ll use the fpdf library to:

• Add multiple pages to the PDF.
• Insert custom text on each page.
• Include an image (e.g. example.jpg) on each page.

Ensure you have an image file (e.g. example.jpg) you want to include in the PDF. Place this image in the same directory as your script.

Save the following Python code in a .py file (e.g. generate_pdf.py):

from fpdf import FPDF

# Create an instance of an FPDF class.
pdf = FPDF()

# Add multiple pages.
for i in range(3):
 pdf.add_page()  # Add a new page.
 pdf.set_font("Arial", size=16)  # Set the font for text.
 pdf.cell(200, 10, txt=f"Page {i+1}", ln=True, align='C')  # Add text to the page.
 pdf.image("example.jpg", x=10, y=30, w=100)  # Add an image to the page.

# Output the PDF to a file.
pdf.output("multi_page.pdf")

print("Multipage PDF with images generated successfully!")

Open your terminal, navigate to the folder where the script and image are stored, and run:

python generate_pdf.py

This will generate a multi_page.pdf file in the same directory. Each page will have custom text and the example.jpg image placed at specified coordinates.

2. Generating PDFs with ReportLab

ReportLab(opens in a new tab) is an open source Python library designed for creating and manipulating PDF documents.

Key features

• PDF generation — Easily create PDFs with text, images, charts, and custom graphics. ReportLab provides all the tools necessary to construct a wide variety of document types.
• Advanced graphics — With ReportLab, you can add complex graphical elements to your documents, such as lines, shapes, curves, and even custom-designed illustrations.
• Document templates — It supports the use of templates, making it easier to create documents with a consistent layout and formatting.
• Custom fonts and styles — ReportLab provides fine-tuned control over the appearance of your PDF documents, including support for custom fonts, colors, and styles.

Best for: Complex, template-driven layouts — charts, custom graphics, high-quality typography — when you need professionally printable PDFs like detailed reports, brochures, or invoices.

Licensing

ReportLab offers a community edition under the ReportLab Open Source License, which is free and suitable for most non-commercial uses. For commercial applications and additional features, ReportLab also provides a commercial edition with extended capabilities and support.

Installation

To install ReportLab, use pip:

pip install reportlab

Alternatively, if you’re using a system like Anaconda, you can install it via conda:

conda install -c conda-forge reportlab

Usage example

Here’s a basic example of how to generate a PDF using ReportLab:

from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas

# Create a PDF file.
c = canvas.Canvas("example.pdf", pagesize=letter)

# Draw some text.
c.drawString(100, 750, "Hello, this is a PDF generated with ReportLab!")

# Save the PDF.
c.save()

In this example, a PDF file named example.pdf is created with a simple line of text. ReportLab’s capabilities extend far beyond this example, allowing for the creation of complex and professional documents.

More advanced features

ReportLab offers more advanced features, outlined below.

Adding graphics

You can draw more than just text — for example, lines, shapes, and even custom images:

from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas

c = canvas.Canvas("example_graphics.pdf", pagesize=letter)

# Draw a line.
c.line(50, 700, 550, 700)

# Draw a rectangle.
c.rect(50, 600, 200, 100)

# Draw an image.
c.drawImage("example_image.jpg", 300, 500, width=100, height=100)

c.save()

Creating charts

You can also generate various types of charts using ReportLab’s rlbcharts module. It allows you to create bar charts, line charts, and pie charts with extensive customization.

If you’re looking to generate detailed reports with charts, graphs, and complex page layouts, ReportLab is a fantastic choice. However, for simpler PDFs or documents that don’t require advanced graphical elements, other libraries like FPDF or Pillow might be more lightweight and suitable alternatives.

3. Generating PDFs with PDFKit

PDFKit(opens in a new tab) is a thin Python wrapper around wkhtmltopdf, letting you generate pixel-perfect PDFs directly from HTML/CSS.

Key features

• Full HTML/CSS ↔︎ PDF conversion — Supports media queries, page breaks, and inline JavaScript execution.
• Complex layout handling — Preserves grids, tables, and layered elements without extra tweaking.
• Drop-in integration — Call one function (pdfkit.from_file/string/url) and deploy on any system that has wkhtmltopdf installed.

Best for: Converting webpages or HTML templates into styled PDFs — perfect for reports, ebooks, and other web-native documents.

Installation

To use PDFKit, install both the pdfkit library and the wkhtmltopdf tool. Follow the steps below to set it up.

1. Install the PDFKit library:

pip install pdfkit

2. Download and install wkhtmltopdf from its official website(opens in a new tab), or use a package manager.

• For macOS (Homebrew):

brew install wkhtmltopdf

• For Ubuntu/Debian:

sudo apt-get install wkhtmltopdf

• For Windows:

Download the installer from the official website(opens in a new tab) and follow the installation instructions.

Converting HTML to PDF

Here’s a simple guide for converting an HTML file into a PDF:

import pdfkit

# Specify the path to your HTML file.

html_file = 'example.html'

# Define the output PDF file name.

output_pdf = 'output.pdf'

# Convert HTML to PDF.

pdfkit.from_file(html_file, output_pdf)

To learn more about converting HTML to PDF using Python, check out our blog post:

• Python HTML to PDF: Convert HTML to PDF using wkhtmltopdf

4. Generating PDFs with WeasyPrint

WeasyPrint(opens in a new tab) is a Python library that turns modern HTML + CSS into print-ready PDFs while faithfully preserving the source layout and styles.

Key features

• Accurate HTML/CSS rendering — Handles flexbox, grid, media queries, and other modern web layouts.
• Rich styling support — Full CSS3, responsive design, and custom fonts.
• Unicode and multilingual — Reliable output for RTL and non-Latin scripts.
• SVG embedding — Renders inline or linked SVG graphics without rasterization.

Best for: Web content conversion, styled reports, invoices and receipts, and publication-ready ebooks or documentation — any time you need pixel-perfect fidelity to modern HTML + CSS layouts.

Installation

To use WeasyPrint, install the weasyprint library, along with its dependencies.

Here’s how to install it:

pip install weasyprint

WeasyPrint also requires some additional system dependencies for full functionality. On macOS, Ubuntu/Debian, or Windows, ensure you have the necessary packages installed. For Ubuntu/Debian, you might need:

sudo apt-get install libffi-dev libpq-dev

Usage example

To illustrate the capabilities of WeasyPrint, consider the following example that generates a styled PDF document:

from weasyprint import HTML

# Define HTML content.
html_content = '''
<!DOCTYPE html>
<html>
<head>
    <title>Sample PDF</title>
    <style>
        body { font-family: Arial, sans-serif; }
        h1 { color: #333; }
    </style>
</head>
<body>
    <h1>Hello, this is a PDF generated using WeasyPrint!</h1>
    <p>This PDF is created from HTML content with CSS styling.</p>
</body>
</html>
'''

# Convert HTML to PDF.
HTML(string=html_content).write_pdf("output.pdf")

print("PDF generated successfully!")

In this example, HTML(string=html_content).write_pdf("output.pdf") converts the provided HTML content into a PDF file named output.pdf.

To learn more about WeasyPrint, visit our blog post on how to generate PDF from HTML using Python.

5. Generating PDFs with borb

borb(opens in a new tab) is a modern, pure-Python library for both creating and manipulating PDFs.

It offers high-level layout primitives (Paragraph, Table, Chart) so you can build complex, print-ready documents entirely in code, yet still drop down to low-level drawing commands when you need pixel-perfect control.

Key features

• Rich layout engine — Paragraphs, images, tables, barcodes, SVG, pie and bar charts.
• Interactive elements — Forms, annotations, document outlines.
• Post-processing — Merge, split, redact, encrypt existing PDFs.

Why choose borb? It’s pure-Python toolkit that does it all — lay out complex pages (tables, charts, barcodes) and merge, split, or secure finished PDFs with no external binaries needed.

Installing borb

borb can be installed via pip:

pip install borb

Usage example

from borb.pdf import Document, Page, PDF, SingleColumnLayout, Paragraph

# 1. Create the document and a page.
doc  = Document()
page = Page()
doc.add_page(page)

# 2. Choose a layout manager for that page.
layout = SingleColumnLayout(page)

# 3. Add content via the layout.
layout.add(Paragraph("Hello, borb!"))

# 4. Serialize to a PDF file.
with open("borb_hello.pdf", "wb") as fh:
    PDF.dumps(fh, doc)

6. Generating PDFs with img2pdf

img2pdf(opens in a new tab) is a tiny utility for stitching images into a single, lossless PDF.

Key features

• Any-image ↔︎ PDF — Handles JPEG, PNG, TIFF, and more.
• Batch combine — Merge dozens of images into one document in file order.
• Lossless output — Keeps original pixels; no reencoding artefacts.
• Blazing fast and minimal — Pure Python, zero heavyweight deps.

Best for: Bundling images — such as scans, photos, and graphics — into a single, lossless PDF when you don’t need additional text or formatting.

Installation

You can install img2pdf with pip by running the following command:

pip install img2pdf

This command will install the latest version of the library from the Python Package Index (PyPI).

Usage example

Here’s a basic example of how to use img2pdf to convert images to a PDF:

import img2pdf

# List of image file paths.
image_files = ['image1.jpg', 'image2.png', 'image3.tiff']

# Convert images to PDF.
with open('output.pdf', 'wb') as f:
    f.write(img2pdf.convert(image_files))

print("PDF generated successfully!")

In this example, img2pdf.convert() takes a list of image file paths and writes them into a PDF file named output.pdf.

7. Using Pillow with img2pdf

Pillow(opens in a new tab) lets you resize, crop, rotate, and reencode images before piping them into img2pdf, ensuring every page of the resulting PDF looks exactly right.

Key features

• Flexible editing — Resize, crop, rotate, filter, or watermark images.
• On-the-fly format conversion — Turn TIFF, BMP, or RAW into JPEG/PNG first.
• Smooth handoff to img2pdf — Pass cleaned images straight to img2pdf.convert(...).

Best for: Preprocessing images — resize, filter, standardize — and then compiling them into consistent, high-quality PDFs for archiving or distribution.

Installation

To use Pillow with img2pdf, install both libraries using pip:

pip install Pillow img2pdf

Code examples

The following examples show how to preprocess images and convert them into PDFs.

Example 1: Basic image preprocessing and PDF conversion

Here’s an example of how to use Pillow and img2pdf together to preprocess images and convert them into a PDF:

from PIL import Image
import img2pdf

# Open an image using Pillow.
image = Image.open('input.jpg')

# Resize the image (optional).
image = image.resize((800, 600))

# Convert the image to another format if needed (optional).
image = image.convert('RGB')

# Save the modified image temporarily.
image.save('modified_image.jpg')

# Convert the modified image to PDF.
with open('output.pdf', 'wb') as f:
    f.write(img2pdf.convert('modified_image.jpg'))

print("PDF generated successfully!")

In this example:

• Pillow is used to open an image and apply some basic processing, such as resizing and format conversion.
• The processed image is then saved temporarily before being passed to img2pdf for PDF conversion.

Example 2: Combining multiple preprocessed images into a single PDF

Here’s an example of how to preprocess multiple images and combine them into a single PDF document:

from PIL import Image
import img2pdf

# List of image file paths.
image_files = ['image1.jpg', 'image2.png', 'image3.tiff']

# Preprocess images.
processed_images = []
for image_file in image_files:
    image = Image.open(image_file)
    image = image.resize((800, 600))  # Resize image (optional).
    image = image.convert('RGB')  # Convert format (optional).
    processed_image_path = f'processed_{image_file}'
    image.save(processed_image_path)
    processed_images.append(processed_image_path)

# Convert preprocessed images to PDF.
with open('output.pdf', 'wb') as f:
    f.write(img2pdf.convert(processed_images))

print("PDF generated successfully!")

In the code example, the paths to the image files are specified first. Using Pillow, each image is resized and converted, and then saved temporarily. These preprocessed images are then combined into a single PDF using img2pdf. This process ensures the images are uniform in format and dimensions before creating the final PDF document.

8. Generating PDFs with xhtml2pdf

xhtml2pdf(opens in a new tab) converts HTML + CSS into professional-looking PDFs with a single function call.

Best for: Styled invoices, browser-ready reports, marketing flyers, or offline docs generated straight from web templates.

Key features

• Layout-faithful HTML → PDF — Preserves CSS, page breaks, headers and footers.
• Embedded assets — Packs fonts and images so the PDF matches the original design.
• Multipage and complex structures — Handles tables, floats, and long documents with ease.

Installation

To use xhtml2pdf, you can install it via pip:

pip install xhtml2pdf

Usage example

Here’s a simple example of how to convert an HTML file to a PDF using xhtml2pdf:

from xhtml2pdf import pisa

# Define a function to convert HTML to PDF.
def convert_html_to_pdf(source_html, output_filename):
    # Open output file for writing (binary mode).
    with open(output_filename, "wb") as output_file:
        # Convert HTML to PDF.
        pisa_status = pisa.CreatePDF(source_html, dest=output_file)

    # Return `true` if the conversion was successful.
    return pisa_status.err == 0

# HTML content to be converted.
html_content = """
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Sample PDF</title>
    <style>
        h1 { color: #2E86C1; }
        p { font-size: 14px; }
    </style>
</head>
<body>
    <h1>Hello, PDF!</h1>
    <p>This is a PDF generated from HTML using xhtml2pdf.</p>
</body>
</html>
"""

# Convert HTML to PDF.
if convert_html_to_pdf(html_content, "output.pdf"):
    print("PDF generated successfully!")
else:
    print("PDF generation failed!")

In this example, xhtml2pdf is used to convert a simple HTML string into a PDF file named output.pdf. The library handles the HTML structure and CSS styling, allowing you to produce a well-formatted PDF.

9. Generating PDFs with pdfdocument

pdfdocument(opens in a new tab) is a minimal Python library for creating basic PDFs with minimal setup. Its intuitive API makes it ideal for simple documents like reports, memos, or letters — without the overhead of more complex libraries.

Key features

• Straightforward API — Quickly add headings, paragraphs, and images.
• Lightweight and dependency-free — Perfect for small projects or scripting.
• Customizable layout — Basic support for formatting, heading levels, and visual structure.

Best for: Simple text-based documents and quick PDF output where you don’t need advanced layout engines.

Installation

You can install pdfdocument via pip:

pip install pdfdocument

Usage example

Here’s a simple example of how to use pdfdocument to generate a PDF:

from pdfdocument.document import PDFDocument

# Create a PDF document.
pdf = PDFDocument("output.pdf")

# Start the PDF.
pdf.init_report()

# Add a title and some text.
pdf.h1("Hello, PDFDocument!")
pdf.p("This is a PDF generated using the pdfdocument library.")

# Add an image (optional).
# pdf.image("path_to_image.jpg", width=200)

# Finalize and save the PDF.
pdf.generate()

print("PDF generated successfully!")

In this example, pdfdocument is used to create a PDF file named output.pdf. The code adds a title and a paragraph of text, demonstrating how easily you can generate a basic PDF. The generate() method finalizes and saves the document.

10. Generating PDFs with Nutrient API

Nutrient DWS API is a commercial, full-featured REST API for generating, customizing, and processing PDFs at scale — no local rendering engine required.

Key features

• High-fidelity rendering — Generate PDFs that look consistent across platforms and devices.
• Advanced operations — Supports form filling, digital signatures, annotations, and merging.
• Platform-agnostic — Call from Python, JavaScript, or any language with HTTP support.
• Extensive customization — Control fonts, layout, metadata, and security settings.

Getting started

1. Sign up — Visit the Nutrient website(opens in a new tab) and sign up for an account.
2. Request an API key — After signing up, obtain an API key from the dashboard.
3. Pricing — Nutrient offers flexible pricing based on your needs. You can start with a trial period and then choose a plan that fits your requirements.

Example: Generate PDF from HTML

import requests
import json

# Define the HTML part of the document.
instructions = {
    'parts': [
        {
            'html': 'index.html'
        }
    ]
}

# Send the request to the Nutrient API.
response = requests.request(
    'POST',
    'https://api.nutrient.io/build',
    headers={
        'Authorization': 'Bearer {YOUR_API_KEY}' # Replace with your API key.
    },
    files={
        'index.html': open('index.html', 'rb'),
    },
    data={
        'instructions': json.dumps(instructions)
    },
    stream=True
)

# Save the resulting PDF.
if response.ok:
    with open('result.pdf', 'wb') as fd:
        for chunk in response.iter_content(chunk_size=8096):
            fd.write(chunk)
else:
    print(response.text)
    exit()

To generate a PDF, the instructions dictionary specifies that the PDF should be generated from the index.html file. The code then sends a POST request to the Nutrient API with the HTML content. The API processes this data and returns a PDF file. If the request is successful, the PDF is saved as result.pdf. If there’s an error, the response is printed for troubleshooting.

Advanced usage

• Dynamic PDF content — Combine the API with dynamic data sources to generate customized PDFs on the fly, such as invoices, reports, or certificates.
• Integration with other services — Use the API in conjunction with other Nutrient services, such as annotation or form filling, to create comprehensive PDF solutions.
• Scalability — The API is designed to handle large-scale PDF generation tasks, making it suitable for enterprise-level applications.

Comparison of PDF generation libraries

Key highlights

• Nutrient API — Great for advanced features (form filling, digital signatures) with high performance but moderate community support.
• xhtml2pdf — Easy to use for simple HTML-to-PDF tasks with high community support.
• Pillow with img2pdf — Efficient for image handling and PDF creation, supported by a strong community.
• img2pdf — A straightforward tool for image-to-PDF conversion with high performance but limited functionality.
• WeasyPrint and PDFKit — Excellent for complex HTML/CSS rendering, with good performance and high community support.
• ReportLab — Ideal for advanced PDF customization with high functionality but moderate ease of use.
• FPDF and pdfdocument — Simple for basic PDFs but lacking advanced features, with moderate community support.

For simple PDFs, go with img2pdf or FPDF. For advanced features and HTML/CSS support, WeasyPrint, PDFKit, or Nutrient API are ideal. Meanwhile, ReportLab excels at customization for complex tasks.

Common issues while generating PDFs in Python

1. Handling large documents

• Problem: Generating large PDFs with many pages, images, or complex content can lead to high memory consumption and slow processing times.

• Solutions and best practices:

  • Incremental PDF writing — Instead of generating an entire document in memory, write pages to disk incrementally with streaming options using libraries like reportlab.
  • Optimize image sizes — Compress and resize images before adding them to the PDF to reduce memory usage.
  • Chunk processing — Divide content generation into smaller chunks and process them sequentially to avoid memory overload.

Example:

pdf = FPDF()
for _ in range(1000):  # Instead of loading all pages at once, process incrementally.
    pdf.add_page()
    pdf.cell(200, 10, txt="Chunk processing example", ln=True)
pdf.output("large_output.pdf")

This example generates 1,000 pages, processing each one incrementally without loading all pages at once, improving memory usage.

2. Managing memory usage

• Problem: Memory leaks or excessive memory consumption when processing multiple PDF files or handling large datasets.

• Solutions and best practices:

  • Use generators — Leverage Python generators to process data lazily instead of loading everything into memory at once.
  • Garbage collection — Explicitly clear unused objects using gc.collect() after processing large chunks of data.
  • Use streaming APIs — Libraries like pdfkit support streaming outputs instead of storing content in memory.

Example:

import gc
from fpdf import FPDF

pdf = FPDF()
pdf.add_page()
pdf.set_font("Arial", size=12)
pdf.cell(200, 10, "Memory management example", ln=True)
pdf.output("output.pdf")

# Clear memory.
del pdf
gc.collect()

This example creates a PDF, and then it explicitly clears the memory by deleting the object and invoking garbage collection to optimize memory usage.

3. Ensuring cross-platform compatibility

• Problem: PDF output may look different on various operating systems due to font availability or encoding issues.

• Solutions and best practices:

  • Embed fonts — Use built-in font embedding features in libraries like FPDF or reportlab to ensure consistency across platforms.
  • Use standard fonts — Stick to common fonts like Helvetica, Times, and Courier to avoid OS-specific font dependencies.
  • Encoding handling — Always specify text encoding (e.g. UTF-8) to avoid compatibility issues when generating multilingual PDFs.

Example:

pdf.set_font("Arial", size=12, style='B')  # Use cross-platform fonts.
pdf.set_auto_page_break(auto=True, margin=15)

This example uses a built-in font (Arial) and sets page breaks, ensuring compatibility across different systems with consistent font handling.

4. Optimizing performance

• Problem: PDF generation can be slow, especially with large datasets, high-resolution images, or complex formatting.

• Solutions and best practices:

  • Minimize draw calls — Reduce the number of drawing operations by batching similar elements together.
  • Use cached resources — Cache repeated elements (e.g. logos, headers) to avoid redundant processing.
  • Asynchronous processing — Use asynchronous processing for high-performance document generation in web applications.

Example:

from concurrent.futures import ThreadPoolExecutor

def generate_pdf_chunk(data):
    pdf = FPDF()
    pdf.add_page()
    pdf.set_font("Arial", size=12)
    pdf.cell(200, 10, txt=data, ln=True)
    pdf.output(f"chunk_{data}.pdf")

with ThreadPoolExecutor() as executor:
    executor.map(generate_pdf_chunk, ["Page 1", "Page 2", "Page 3"])

This example demonstrates parallel PDF generation with a thread pool, allowing chunks of data to be processed simultaneously, improving overall speed.

5. Maintaining layout consistency

• Problem: Inconsistent layout issues arise when adding dynamic content such as tables, charts, or paragraphs.

• Solutions and best practices:

  • Define layout templates — Use a consistent document template to standardize layout across all generated PDFs.
  • Auto-adjust layout — Use libraries that support automatic content fitting and page breaks, such as reportlab.
  • Test different screen sizes — Check the final PDF layout on different devices to ensure consistency.

Example:

pdf.set_auto_page_break(auto=True, margin=10)
pdf.multi_cell(0, 10, "This is a long paragraph that will wrap automatically.")

This example uses multi_cell to handle long paragraphs automatically, ensuring text wraps properly without breaking the layout.

By following these solutions and best practices, developers can efficiently generate PDFs in Python while overcoming common challenges related to performance, compatibility, and security.

Conclusion

This article covered 10 methods for generating PDFs in Python — from simple tools like FPDF and img2pdf, to advanced options like ReportLab, WeasyPrint, and Nutrient.

Each library has features suited to different use cases, such as creating basic documents or complex PDFs with custom styling. Incorporating these strategies into your Python projects elevates your application’s functionality.

While Nutrient DWS API comes at a higher price point than open source libraries, its capabilities may justify the investment for businesses needing robust features not typically available in free alternatives. Start your free trial today(opens in a new tab) and get 100 API credits to explore its full potential.

FAQ