Reorder PDF Pages: Change the Page Order in Any PDF (Free)

import { PDFDocument } from "pdf-lib";
 
/**
 * Reorder PDF pages.
 * @param pdfBytes - Input PDF as Uint8Array or ArrayBuffer
 * @param newOrder  - Array of 0-based source page indices in the desired output order
 *                    e.g. [2, 0, 1] → source pages 3, 1, 2
 */
async function reorderPdfPages(pdfBytes, newOrder) {
  const srcPdf = await PDFDocument.load(pdfBytes);
  const outPdf = await PDFDocument.create();
 
  const copiedPages = await outPdf.copyPages(srcPdf, newOrder);
  copiedPages.forEach((page) => outPdf.addPage(page));
 
  return outPdf.save();
}
 
// Parse a range expression like "3, 1-2, 4-6" into a 0-based index array
function parseRangeExpression(expr, totalPages) {
  const indices = [];
  const parts = expr.split(",").map((s) => s.trim());
 
  for (const part of parts) {
    const rangeParts = part.split("-").map((s) => s.trim());
    if (rangeParts.length === 1) {
      const n = parseInt(rangeParts[0], 10);
      if (!isNaN(n) && n >= 1 && n <= totalPages) {
        indices.push(n - 1);   // Convert to 0-based
      }
    } else {
      let start = parseInt(rangeParts[0], 10);
      let end = parseInt(rangeParts[1], 10);
      if (isNaN(start)) start = 1;
      if (isNaN(end)) end = totalPages;
      const step = start <= end ? 1 : -1;
      for (let i = start; step > 0 ? i <= end : i >= end; i += step) {
        if (i >= 1 && i <= totalPages) indices.push(i - 1);
      }
    }
  }
 
  return indices;
}
 
// Browser usage
async function handleReorder(file, rangeExpression) {
  const buffer = await file.arrayBuffer();
  const srcPdf = await PDFDocument.load(buffer);
  const total = srcPdf.getPageCount();
 
  const order = parseRangeExpression(rangeExpression, total);
  const reorderedBytes = await reorderPdfPages(buffer, order);
 
  const blob = new Blob([reorderedBytes], { type: "application/pdf" });
  const url = URL.createObjectURL(blob);
 
  const a = document.createElement("a");
  a.href = url;
  a.download = "reordered.pdf";
  a.click();
}

from pypdf import PdfReader, PdfWriter
import re
 
def parse_range_expression(expr: str, total_pages: int) -> list[int]:
    """Parse '3, 1-2, 4-end' into a list of 1-based page numbers."""
    indices = []
    for part in expr.split(","):
        part = part.strip().replace("end", str(total_pages))
        if "-" in part:
            match = re.match(r"(\d+)-(\d+)", part)
            if match:
                start, end = int(match.group(1)), int(match.group(2))
                step = 1 if start <= end else -1
                indices.extend(range(start, end + step, step))
        elif part.isdigit():
            indices.append(int(part))
    return [i for i in indices if 1 <= i <= total_pages]
 
 
def reorder_pdf(input_path: str, output_path: str, range_expr: str):
    reader = PdfReader(input_path)
    writer = PdfWriter()
    total = len(reader.pages)
 
    page_order = parse_range_expression(range_expr, total)
 
    for page_num in page_order:
        writer.add_page(reader.pages[page_num - 1])   # PdfReader is 0-indexed
 
    with open(output_path, "wb") as f:
        writer.write(f)
 
    print(f"Reordered: {total} → {len(page_order)} pages in new order → {output_path}")
 
 
# Usage examples
reorder_pdf("report.pdf", "out.pdf", "3, 1-2, 4-end")  # Cover page first
reorder_pdf("scan.pdf",   "out.pdf", "8-1")             # Reverse all pages
reorder_pdf("book.pdf",   "out.pdf", "1, 3, 5, 7, 9")  # Odd pages only

# Move page 3 to the front
pdftk input.pdf cat 3 1-2 4-end output reordered.pdf
 
# Reverse all pages in a 10-page PDF
pdftk input.pdf cat 10-1 output reversed.pdf
 
# Extract odd pages (1, 3, 5, 7, 9) from a 10-page PDF
pdftk input.pdf cat 1 3 5 7 9 output odd-pages.pdf
 
# Extract even pages
pdftk input.pdf cat 2 4 6 8 10 output even-pages.pdf
 
# Interleave two halves of a PDF (useful for certain scanning workflows)
pdftk A=input.pdf cat A1-5 A10-6 output interleaved.pdf

# Page 3 at front (rotated 90° clockwise), then rest in original order
pdftk input.pdf cat 3east 1-2 4-end output out.pdf

pdftk input.pdf cat 12 1-11 output fixed.pdf

reorder_pdf("input.pdf", "fixed.pdf", "12, 1-11")

pdftk input.pdf cat end-1 output reversed.pdf

async function interleaveScans(oddPdfBytes, evenPdfBytes) {
  const oddPdf = await PDFDocument.load(oddPdfBytes);
  const evenPdf = await PDFDocument.load(evenPdfBytes);
  const outPdf = await PDFDocument.create();
 
  const oddCount = oddPdf.getPageCount();
  const evenCount = evenPdf.getPageCount();
 
  for (let i = 0; i < Math.max(oddCount, evenCount); i++) {
    if (i < oddCount) {
      const [p] = await outPdf.copyPages(oddPdf, [i]);
      outPdf.addPage(p);
    }
    if (i < evenCount) {
      // Even pages from scanner are in reverse — mirror the index
      const evenIdx = evenCount - 1 - i;
      const [p] = await outPdf.copyPages(evenPdf, [evenIdx]);
      outPdf.addPage(p);
    }
  }
 
  return outPdf.save();
}