Automate PDF Merging and Watermarking with Python

Hey there, Darian here. Let’s talk about a real time-sink: manually preparing documents. A few months back, I was tasked with helping our finance team compile weekly reports. They had several documents from different sources that needed to be merged into one master PDF, and every single page had to be stamped with a “Confidential” watermark. Doing it by hand with some clunky software was tedious and, frankly, a perfect recipe for human error. A simple Python script turned that 30-minute weekly chore into a 10-second, fully automated job. Let me show you how I built it.

Prerequisites

Before we dive in, make sure you have the following ready:

• Python 3.6 or newer installed.
• A good code editor, like VS Code or PyCharm.
• A few sample PDF files you want to merge.
• A one-page PDF that will serve as your watermark (e.g., a “Confidential” stamp).

The Step-by-Step Guide

Step 1: Project Setup and Dependencies

I’ll skip the standard virtualenv setup since you likely have your own workflow for that. Let’s jump straight to the Python logic. The core library we’ll need for this task is PyPDF2. Once your virtual environment is active, you can install it using pip. It’s a powerful library for all sorts of PDF manipulation.

For our project structure, I recommend something simple: create a main project folder, and inside it, place your Python script. Also, create a subdirectory called input_docs for the PDFs you want to merge, and place your watermark.pdf in the main folder.

Step 2: The Merging Logic

First, we need a function that can take a list of PDF files and combine them into a single document. The logic here is straightforward: we’ll create a merger object, loop through our input files, and append each one to the object. Finally, we’ll write the combined result to a new file.

Here’s the Python function to handle that:

from PyPDF2 import PdfMerger, PdfReader, PdfWriter
import os

def merge_pdfs(input_folder, output_path):
    """Merges all PDF files in a given folder."""
    pdf_merger = PdfMerger()
    
    # Find all PDF files in the input folder
    pdf_files = [f for f in os.listdir(input_folder) if f.endswith('.pdf')]
    pdf_files.sort() # Sort files for a consistent order

    if not pdf_files:
        print("No PDF files found in the input folder.")
        return False

    print(f"Found files to merge: {pdf_files}")

    for filename in pdf_files:
        filepath = os.path.join(input_folder, filename)
        pdf_merger.append(filepath)
    
    # Write out the merged PDF
    with open(output_path, 'wb') as output_file:
        pdf_merger.write(output_file)
    
    print(f"Successfully merged PDFs into {output_path}")
    return True

Step 3: The Watermarking Logic

Now for the slightly more complex part: adding the watermark. The process involves reading our source document (the one we just merged) and the watermark PDF. We then iterate through every page of the source document and overlay the watermark page on top of it. This creates a new, watermarked page that we add to a writer object, which will become our final file.

Pro Tip: In my production setups, I always use Python’s pathlib module instead of os.path. It provides an object-oriented interface for filesystem paths, which makes the code cleaner and less prone to OS-specific pathing issues. For this tutorial, os is simple enough.

Here’s the watermarking function:

def watermark_pdf(input_path, output_path, watermark_path):
    """Applies a watermark to each page of a PDF."""
    try:
        with open(input_path, 'rb') as input_file, \
             open(watermark_path, 'rb') as watermark_file:
            
            reader = PdfReader(input_file)
            watermark_reader = PdfReader(watermark_file)
            writer = PdfWriter()
            
            # The watermark is assumed to be the first page of the watermark file
            watermark_page = watermark_reader.pages[0]
            
            # Iterate over all pages of the source PDF
            for page in reader.pages:
                # Merge the watermark onto the page
                page.merge_page(watermark_page)
                writer.add_page(page)
            
            # Write the result to the output file
            with open(output_path, 'wb') as output_file:
                writer.write(output_file)

        print(f"Successfully applied watermark to {output_path}")
    except FileNotFoundError:
        print(f"Error: One of the files was not found. Check paths.")
        return

Step 4: Putting It All Together

Finally, let’s create a main execution block to run our workflow. This script will define our file paths, call the merge function, and then use the output of that function as the input for the watermarking function.

if __name__ == "__main__":
    INPUT_FOLDER = 'input_docs'
    MERGED_FILE = 'merged_report.pdf'
    WATERMARKED_FILE = 'final_confidential_report.pdf'
    WATERMARK_FILE = 'watermark.pdf'
    
    # Step 1: Merge all PDFs in the input folder
    if merge_pdfs(INPUT_FOLDER, MERGED_FILE):
        # Step 2: Apply a watermark to the merged file
        watermark_pdf(MERGED_FILE, WATERMARKED_FILE, WATERMARK_FILE)

Common Pitfalls

Here are a couple of things that have tripped me up in the past. Hopefully, you can avoid them.

• File Paths: This is where I usually mess up first. A simple typo in a folder or file name will throw a FileNotFoundError. Always double-check your paths, especially when deploying this to a server.
• Corrupted PDFs: PyPDF2 is robust, but it can struggle with oddly formatted or encrypted PDFs. If you get a PdfReadError, the first thing I do is open the problematic PDF in a viewer and re-save it. This often cleans up any structural issues.
• Watermark Placement: The watermark is overlaid exactly as it appears in its own PDF. If your watermark is a small stamp in the top-left corner of an A4 page, that’s where it will appear on the final pages. For a centered, faded watermark, you need to design your watermark.pdf that way first.

Conclusion

And there you have it—a clean, reusable script to automate a common document processing task. This is a fantastic starting point. From here, you could easily extend it to pull files from a cloud storage bucket, send the final document via email, or run it on a schedule. For example, you could set up a simple cron job to run this every Monday morning:

0 2 * * 1 python3 your_script_name.py

The real value in DevOps is identifying these small, manual tasks and building simple, robust automation around them. It frees up time for everyone to focus on more important work. Happy scripting!

Darian Vance

Lead Cloud Architect & DevOps Strategist

With over 12 years in system architecture and automation, Darian specializes in simplifying complex cloud infrastructures. An advocate for open-source solutions, he founded TechResolve to provide engineers with actionable, battle-tested troubleshooting guides and robust software alternatives.

🤖 Frequently Asked Questions