How to delete pages from a PDF (free, fast, no upload required)

pip install pypdf

from pypdf import PdfReader, PdfWriter
 
def delete_pages(input_path: str, output_path: str, pages_to_delete: list[int]) -> None:
    """
    Delete specified pages from a PDF.
    
    Args:
        input_path: Path to the source PDF
        output_path: Path for the output PDF  
        pages_to_delete: 0-indexed list of page numbers to remove
    """
    reader = PdfReader(input_path)
    writer = PdfWriter()
 
    pages_to_delete_set = set(pages_to_delete)
 
    for i, page in enumerate(reader.pages):
        if i not in pages_to_delete_set:
            writer.add_page(page)
 
    with open(output_path, "wb") as f:
        writer.write(f)
 
# Remove pages 0 (first), 4, and 7 (0-indexed)
delete_pages("input.pdf", "output.pdf", [0, 4, 7])

from pypdf import PdfReader, PdfWriter
 
def remove_blank_pages(input_path: str, output_path: str, threshold: int = 100) -> int:
    """
    Remove pages with very little content (likely blank).
    
    Returns the number of pages removed.
    """
    reader = PdfReader(input_path)
    writer = PdfWriter()
    removed = 0
 
    for page in reader.pages:
        text = page.extract_text() or ""
        # Count images on this page
        image_count = len(page.images)
        
        if len(text.strip()) > threshold or image_count > 0:
            writer.add_page(page)
        else:
            removed += 1
 
    with open(output_path, "wb") as f:
        writer.write(f)
 
    return removed
 
count = remove_blank_pages("report.pdf", "report_clean.pdf")
print(f"Removed {count} blank pages")

npm install pdf-lib

import { PDFDocument } from "pdf-lib";
import { readFileSync, writeFileSync } from "fs";
 
async function deletePages(
  inputPath: string,
  outputPath: string,
  pagesToDelete: number[] // 0-indexed
): Promise<void> {
  const pdfBytes = readFileSync(inputPath);
  const doc = await PDFDocument.load(pdfBytes);
 
  // Remove pages from highest index to lowest
  // to avoid index shift as pages are deleted
  const sortedDesc = [...pagesToDelete].sort((a, b) => b - a);
 
  for (const pageIndex of sortedDesc) {
    doc.removePage(pageIndex);
  }
 
  const outputBytes = await doc.save();
  writeFileSync(outputPath, outputBytes);
}
 
// Remove pages 0 (first), 4, and 7 (0-indexed)
await deletePages("input.pdf", "output.pdf", [0, 4, 7]);

import express from "express";
import { PDFDocument } from "pdf-lib";
import multer from "multer";
 
const upload = multer({ storage: multer.memoryStorage() });
const app = express();
 
app.post(
  "/delete-pages",
  upload.single("pdf"),
  async (req, res) => {
    const pagesParam = req.body.pages as string; // e.g. "0,3,5-7"
    const pageIndices = parsePageRanges(pagesParam);
 
    const doc = await PDFDocument.load(req.file!.buffer);
    const sorted = [...pageIndices].sort((a, b) => b - a);
 
    for (const idx of sorted) {
      if (idx < doc.getPageCount()) {
        doc.removePage(idx);
      }
    }
 
    const pdfBytes = await doc.save();
    res.setHeader("Content-Type", "application/pdf");
    res.send(Buffer.from(pdfBytes));
  }
);
 
function parsePageRanges(input: string): number[] {
  const indices: number[] = [];
  for (const part of input.split(",")) {
    const trimmed = part.trim();
    if (trimmed.includes("-")) {
      const [start, end] = trimmed.split("-").map(Number);
      for (let i = start; i <= end; i++) indices.push(i);
    } else {
      indices.push(Number(trimmed));
    }
  }
  return indices;
}

# Keep pages 2-10 (removes page 1 from an 10-page PDF)
pdftk input.pdf cat 2-10 output result.pdf
 
# Keep pages 1-3 and 7-end (removes pages 4-6)
pdftk input.pdf cat 1-3 7-end output result.pdf

# Keep pages 2 through end (removes page 1)
qpdf input.pdf --pages input.pdf 2-z -- output.pdf
 
# Keep pages 1-4 and 8-end (removes pages 5-7)
qpdf input.pdf --pages input.pdf 1-4,8-z -- output.pdf

import os
from pathlib import Path
from pypdf import PdfReader, PdfWriter
 
def batch_delete_pages(
    input_dir: str,
    output_dir: str,
    pages_to_delete: list[int]
) -> dict[str, str]:
    """
    Delete specified pages from all PDFs in a directory.
    
    Returns a dict mapping filename to "ok" or error message.
    """
    results = {}
    Path(output_dir).mkdir(parents=True, exist_ok=True)
    pages_set = set(pages_to_delete)
 
    for pdf_path in Path(input_dir).glob("*.pdf"):
        try:
            reader = PdfReader(str(pdf_path))
            writer = PdfWriter()
 
            for i, page in enumerate(reader.pages):
                if i not in pages_set:
                    writer.add_page(page)
 
            output_path = Path(output_dir) / pdf_path.name
            with open(output_path, "wb") as f:
                writer.write(f)
 
            results[pdf_path.name] = "ok"
        except Exception as e:
            results[pdf_path.name] = str(e)
 
    return results
 
# Remove the last page (index -1 doesn't work in sets, use the count)
# Example: remove page 0 (cover) from all PDFs in /reports
results = batch_delete_pages("/reports", "/reports/clean", [0])
for name, status in results.items():
    print(f"{name}: {status}")

// Generate a PDF with only the invoice section (no cover, no appendix)
const response = await fetch("https://pdf4.dev/api/v1/render", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Authorization": `Bearer ${process.env.PDF4_API_KEY}`,
  },
  body: JSON.stringify({
    templateId: "invoice-template",
    data: {
      showCover: false,
      showAppendix: false,
      invoice: { /* ... */ },
    },
  }),
});
 
const pdfBuffer = await response.arrayBuffer();