How to Split a PDF — Divide Pages by Range, Interval, or One Page at a Time

import { PDFDocument } from 'pdf-lib';
import fs from 'fs';
 
// Split by a list of page ranges
// ranges: array of {start, end} objects (0-based indices, end exclusive)
async function splitPdf(inputPath, outputDir, ranges) {
  const pdfBytes = fs.readFileSync(inputPath);
  const sourcePdf = await PDFDocument.load(pdfBytes);
  const results = [];
  
  for (let i = 0; i < ranges.length; i++) {
    const { start, end } = ranges[i];
    const newPdf = await PDFDocument.create();
    const pageIndices = Array.from(
      { length: end - start },
      (_, j) => start + j
    );
    const copiedPages = await newPdf.copyPages(sourcePdf, pageIndices);
    copiedPages.forEach(page => newPdf.addPage(page));
    
    const outputBytes = await newPdf.save();
    const outputPath = `${outputDir}/part-${String(i + 1).padStart(2, '0')}.pdf`;
    fs.writeFileSync(outputPath, outputBytes);
    results.push(outputPath);
    console.log(`Created ${outputPath} (${copiedPages.length} pages)`);
  }
  
  return results;
}
 
// Helper: parse "1-5, 6-12, 13-end" into 0-based ranges
function parseRanges(rangeStr, totalPages) {
  return rangeStr.split(',').map(part => {
    const [startStr, endStr] = part.trim().split('-');
    const start = parseInt(startStr) - 1; // 0-based
    const end = endStr === 'end' ? totalPages : parseInt(endStr);
    return { start, end };
  });
}
 
// Split every N pages
async function splitEveryN(inputPath, outputDir, n) {
  const pdfBytes = fs.readFileSync(inputPath);
  const sourcePdf = await PDFDocument.load(pdfBytes);
  const totalPages = sourcePdf.getPageCount();
  
  const ranges = [];
  for (let start = 0; start < totalPages; start += n) {
    ranges.push({ start, end: Math.min(start + n, totalPages) });
  }
  
  return splitPdf(inputPath, outputDir, ranges);
}
 
// Usage
const pdfBytes = fs.readFileSync('document.pdf');
const pdfDoc = await PDFDocument.load(pdfBytes);
const total = pdfDoc.getPageCount();
 
await splitPdf('document.pdf', './output', parseRanges('1-5, 6-12, 13-end', total));
await splitEveryN('document.pdf', './chunks', 10);

from pypdf import PdfReader, PdfWriter
from pathlib import Path
import re
 
def split_by_ranges(input_path: str, output_dir: str, ranges: list[tuple]) -> list[str]:
    """
    ranges: list of (start, end) tuples with 1-based, inclusive page numbers
    e.g. [(1, 5), (6, 12), (13, None)] where None means 'last page'
    """
    reader = PdfReader(input_path)
    total = len(reader.pages)
    Path(output_dir).mkdir(exist_ok=True)
    outputs = []
    
    for i, (start, end) in enumerate(ranges):
        writer = PdfWriter()
        actual_end = end if end is not None else total
        
        for page_num in range(start - 1, actual_end):
            writer.add_page(reader.pages[page_num])
        
        output_path = f"{output_dir}/part-{i + 1:02d}.pdf"
        with open(output_path, 'wb') as f:
            writer.write(f)
        
        outputs.append(output_path)
        print(f"Created {output_path} (pages {start}–{actual_end})")
    
    return outputs
 
def split_every_n(input_path: str, output_dir: str, n: int) -> list[str]:
    reader = PdfReader(input_path)
    total = len(reader.pages)
    ranges = [(start + 1, min(start + n, total)) for start in range(0, total, n)]
    return split_by_ranges(input_path, output_dir, ranges)
 
def split_to_individual(input_path: str, output_dir: str) -> list[str]:
    return split_every_n(input_path, output_dir, n=1)
 
# Usage
split_by_ranges('document.pdf', './output', [(1, 5), (6, 12), (13, None)])
split_every_n('document.pdf', './chunks', n=10)

# Extract pages 1-5 into part1.pdf
pdftk input.pdf cat 1-5 output part1.pdf
 
# Extract pages 6-12
pdftk input.pdf cat 6-12 output part2.pdf
 
# Split every PDF into individual pages (uses burst)
pdftk input.pdf burst output page_%04d.pdf
 
# Extract specific pages in one command using handles
pdftk A=input.pdf cat A1-5 output part1.pdf
pdftk A=input.pdf cat A6-12 output part2.pdf
pdftk A=input.pdf cat A13-end output part3.pdf

# Extract pages 1-5
gs -dBATCH -dNOPAUSE -dSAFER \
   -sDEVICE=pdfwrite \
   -dFirstPage=1 -dLastPage=5 \
   -sOutputFile=part1.pdf \
   input.pdf
 
# Extract pages 6-12
gs -dBATCH -dNOPAUSE -dSAFER \
   -sDEVICE=pdfwrite \
   -dFirstPage=6 -dLastPage=12 \
   -sOutputFile=part2.pdf \
   input.pdf

#!/usr/bin/env python3
"""
Split all PDFs in a directory into individual pages.
Outputs: ./split/{filename}/page-001.pdf, page-002.pdf, ...
"""
from pypdf import PdfReader, PdfWriter
from pathlib import Path
 
INPUT_DIR = Path('./pdfs')
OUTPUT_DIR = Path('./split')
 
for pdf_path in INPUT_DIR.glob('*.pdf'):
    reader = PdfReader(str(pdf_path))
    out_dir = OUTPUT_DIR / pdf_path.stem
    out_dir.mkdir(parents=True, exist_ok=True)
    
    for i, page in enumerate(reader.pages):
        writer = PdfWriter()
        writer.add_page(page)
        out_path = out_dir / f"page-{i + 1:03d}.pdf"
        with open(out_path, 'wb') as f:
            writer.write(f)
    
    print(f"{pdf_path.name}: {len(reader.pages)} pages extracted")