PDF Automation: Merge, Split, Watermark

By the end of this lesson you can:

• Build a new PDF page-by-page with PdfWriter.
• Merge multiple PDFs and split one into ranges.
• Rotate pages and delete unwanted ones.
• Stamp a watermark/footer onto every page by overlaying one PDF on another.

The mental model for editing PDFs: a reader hands you page objects; a writer collects pages and saves them as a new file. You build the output by picking pages from one or more sources, in any order.

Merging PDFs

from pypdf import PdfReader, PdfWriter
from pathlib import Path

def merge(paths: list[str], out: str) -> None:
    writer = PdfWriter()
    for path in paths:
        reader = PdfReader(path)
        for page in reader.pages:
            writer.add_page(page)        # collect every page in order
    with open(out, "wb") as f:           # note "wb" — PDFs are binary
        writer.write(f)

merge(["cover.pdf", "body.pdf", "appendix.pdf"], "combined.pdf")

Add pages in the order you want them; write the writer to a binary file ("wb"). That's the whole merge.

Splitting by page range

def split(path: str, start: int, end: int, out: str) -> None:
    reader = PdfReader(path)
    writer = PdfWriter()
    for i in range(start, end):          # 0-based, end exclusive
        writer.add_page(reader.pages[i])
    with open(out, "wb") as f:
        writer.write(f)

split("report.pdf", 0, 5, "chapter1.pdf")   # pages 1-5 (human numbering)

Pages are 0-based here, so "pages 1-5" for a human is range(0, 5). Select whatever subset you like.

Rotating and deleting

writer = PdfWriter()
for i, page in enumerate(reader.pages):
    if i == 2:
        continue                         # delete page 3 by skipping it
    if i == 0:
        page.rotate(90)                  # rotate cover 90° clockwise
    writer.add_page(page)

Deleting = simply not adding a page. Rotating = call page.rotate(90) (multiples of 90) before adding it.

Watermarking by overlay

# stamp.pdf is a single page: e.g. faint "DRAFT" or a footer
stamp = PdfReader("stamp.pdf").pages[0]

writer = PdfWriter()
for page in PdfReader("report.pdf").pages:
    page.merge_page(stamp)               # overlay stamp ON TOP of the page
    writer.add_page(page)
with open("stamped.pdf", "wb") as f:
    writer.write(f)

merge_page(stamp) draws the stamp page over the content page — transparent areas show the original through. That single line watermarks an entire document.

Goal: merge a cover, body, and appendix into one report, then stamp a "Confidential — page footer" on every page using a reportlab-generated stamp. A complete document-assembly pipeline.

from pypdf import PdfReader, PdfWriter
from reportlab.pdfgen import canvas
from reportlab.lib.pagesizes import A4
from pathlib import Path
import logging

logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
log = logging.getLogger("pdf")

def make_stamp(text: str, path: str) -> str:
    c = canvas.Canvas(path, pagesize=A4)
    c.setFont("Helvetica", 8)
    c.setFillGray(0.5)
    c.drawString(40, 20, text)            # footer near bottom-left
    c.save()
    return path

def assemble(parts: list[str], stamp_text: str, out: str) -> None:
    stamp = PdfReader(make_stamp(stamp_text, "_stamp.pdf")).pages[0]
    writer = PdfWriter()
    total = 0
    for part in parts:
        reader = PdfReader(part)
        for page in reader.pages:
            page.merge_page(stamp)        # footer on every page
            writer.add_page(page)
            total += 1
        log.info("added %s (%d pages)", Path(part).name, len(reader.pages))

    with open(out, "wb") as f:
        writer.write(f)
    Path("_stamp.pdf").unlink(missing_ok=True)   # clean up temp stamp
    log.info("wrote %s — %d pages", out, total)

assemble(["cover.pdf", "body.pdf", "appendix.pdf"],
         "Confidential — Acme Corp 2026", "final_report.pdf")

INFO added cover.pdf (1 pages)
INFO added body.pdf (18 pages)
INFO added appendix.pdf (4 pages)
INFO wrote final_report.pdf — 23 pages

Read the code

Two tools combine cleanly: reportlab draws the footer once onto a throwaway one-page PDF, and pypdf overlays it on every content page while merging the parts. The temp stamp is cleaned up with unlink(missing_ok=True) (a tidy pathlib touch). The result is a single, branded, page-stamped report assembled from raw parts — the kind of task people pay for, done in 30 lines. Lesson 22 wraps this into a full multi-format report generator.

Editing PDFs means assembling a new one: a PdfReader gives pages, a PdfWriter collects them, and you write to a binary ("wb") file. Merge by adding pages from several files in order; split by adding a 0-based range; delete by skipping; rotate with page.rotate(90). Watermark by overlaying a stamp page with page.merge_page(stamp) — and generate that stamp with reportlab, since pypdf moves pages but doesn't draw text. These page-level operations, plus Lesson 20's text extraction, cover the vast majority of real PDF automation.