5 Best Ways to Integrate a PDF Viewer in Python Tkinter

Rate this post

πŸ’‘ Problem Formulation: Software developers and hobbyist coders using Python’s Tkinter library often need a way to display PDF files within their GUI applications. They seek smooth integration without compromising on their application’s performance. The input would be a PDF file, and the desired output is a clean and functional PDF viewing experience embedded within a Tkinter frame or window.

Method 1: Using Python’s PyMuPDF Library

PyMuPDF is a lightweight, yet powerful library that provides PDF rendering capabilities. It supports various formats and operations, making it suitable for embedding a PDF viewer in Tkinter. In conjunction with Tkinter’s canvas widget, PyMuPDF can be used to render PDF pages as images and display them to the user.

Here’s an example:

import fitz  # PyMuPDF
import tkinter as tk
from PIL import Image, ImageTk

def show_pdf(page_number):
    # Open the PDF file
    pdf_document = fitz.open('example.pdf')
    # Select a page
    page = pdf_document.load_page(page_number)
    # Get the image of the page
    pix = page.get_pixmap()
    # Store image as a string
    img_data = pix.tobytes("ppm")
    # Create an Image from the data
    img = Image.open(io.BytesIO(img_data))
    # Convert the Image to ImageTk
    photo = ImageTk.PhotoImage(image=img)
    # Add to canvas and display in the GUI
    canvas.create_image(0, 0, image=photo, anchor='nw')

# Tkinter setup
root = tk.Tk()
canvas = tk.Canvas(root, width=800, height=600)

# Display page 1 of the PDF


The output is a Tkinter window displaying the first page of the PDF document as an image within the canvas area.

This code snippet uses the fitz module from PyMuPDF to load a PDF and render its first page. The rendered image is then converted into a format compatible with Tkinter’s ImageTk, which is displayed on a canvas widget.

Method 2: Integrating with TkinterPDF Library

TkinterPDF is a Python library dedicated to rendering PDFs within Tkinter applications. It utilizes the Poppler library to accurately render pages. Its straightforward API makes it one of the preferred choices for developers looking to integrate PDF viewing functionality in Tkinter.

Here’s an example:

import tkinter as tk
from tkinter import ttk
import tkinterpdf as tkpdf

root = tk.Tk()
pdf_viewer = tkpdf.PdfViewer(root)
pdf_viewer.pack(side="top", fill="both", expand=True)


The output is a Tkinter window with full PDF viewing capability, including navigation and zoom.

Here we instantiate TkinterPDF's PdfViewer, load a PDF file into it, and pack it into the parent window. TkinterPDF handles the rendering and provides native PDF navigation tools within the GUI.

Method 3: Employing the pdf2image Library

The pdf2image library converts PDF documents into a collection of images, allowing each page to be displayed as an image within Tkinter’s canvas or label widgets. This method is beneficial for simplicity but can potentially consume more memory for large PDFs.

Here’s an example:

from pdf2image import convert_from_path
import tkinter as tk
from PIL import ImageTk

# Convert PDF to list of images
images = convert_from_path('example.pdf')

# Initialize Tkinter
root = tk.Tk()
image = ImageTk.PhotoImage(images[0])

# Create a label to display the image
label = tk.Label(root, image=image)


The output is a Tkinter window showing the first page of the PDF document as an image.

This code snippet demonstrates how to convert a PDF file into images using convert_from_path and display the first page on a Tkinter label widget. This method is straightforward but may not be the best for interacting with the PDF or navigating multi-page documents.

Method 4: Leveraging the PyPDF2 and Pillow Libraries

PyPDF2 allows you to extract text and images from PDF files. Combined with Pillow, a fork of PIL, for image handling, you can create a custom PDF viewer. This method, however, may not render complex PDFs with perfect fidelity.

Here’s an example:

import PyPDF2
import tkinter as tk
from PIL import Image, ImageTk
from io import BytesIO

# Open the PDF file
with open('example.pdf', 'rb') as file:
    reader = PyPDF2.PdfFileReader(file)
    page = reader.getPage(0)
    xObject = page['/Resources']['/XObject'].getObject()

    for obj in xObject:
        if xObject[obj]['/Subtype'] == '/Image':
            size = (xObject[obj]['/Width'], xObject[obj]['/Height'])
            data = xObject[obj]._data
            image = Image.open(BytesIO(data))
            photo = ImageTk.PhotoImage(image)

            # Initialize Tkinter window
            root = tk.Tk()
            panel = tk.Label(root, image=photo)
            panel.pack(side="bottom", fill="both", expand="yes")

The output would be a Tkinter window showing an image extracted from the first page of the PDF.

This snippet uses PyPDF2 to read and parse the PDF file, and it then extracts the images within the file using the Pillow library (PIL). These images are then displayed in a Tkinter window. This works well for simple PDFs.

Bonus One-Liner Method 5: Quick View with webbrowser Module

For a quick and dirty solution when advanced features are not necessary, Python’s webbrowser module can be used to open the default web browser to display the PDF file. This is by far the simplest method but offers no true integration with Tkinter.

Here’s an example:

import webbrowser

The output is the default web browser opened and displaying the PDF file.

This one-liner leverages the user’s installed web browser to view PDFs. It’s straightforward but takes the user outside the Tkinter application context.


  • Method 1: PyMuPDF. Offers high-quality rendering and supports extensive PDF operations. However, it requires converting pages to images, which may introduce overhead.
  • Method 2: TkinterPDF. Provides a dedicated Tkinter widget for PDFs with navigation and zoom. It depends on Poppler and works best on Unix-based systems.
  • Method 3: pdf2image. Converts PDFs into images for simple display purposes. It’s easy to use but consumes more memory and is not efficient for large or multi-page documents.
  • Method 4: PyPDF2 and Pillow. Useful for custom PDF interfaces where you can process and display PDF content manually. This method may struggle with complex PDFs.
  • Bonus One-Liner Method 5: Opens PDFs in a web browser quickly, offering no programmatic control or customization within the Tkinter app.