How to Compress a PDF — Reduce File Size Without Losing Quality

# Basic compression (screen quality — 72 DPI images)
gs -dBATCH -dNOPAUSE -dSAFER \
   -sDEVICE=pdfwrite \
   -dCompatibilityLevel=1.7 \
   -dPDFSETTINGS=/screen \
   -sOutputFile=compressed.pdf \
   input.pdf
 
# Recommended: ebook quality — 150 DPI images, good balance
gs -dBATCH -dNOPAUSE -dSAFER \
   -sDEVICE=pdfwrite \
   -dCompatibilityLevel=1.7 \
   -dPDFSETTINGS=/ebook \
   -sOutputFile=compressed.pdf \
   input.pdf
 
# Print quality — 300 DPI, minimal compression
gs -dBATCH -dNOPAUSE -dSAFER \
   -sDEVICE=pdfwrite \
   -dCompatibilityLevel=1.7 \
   -dPDFSETTINGS=/printer \
   -sOutputFile=compressed.pdf \
   input.pdf

# Custom DPI control (finer than PDFSETTINGS)
gs -dBATCH -dNOPAUSE -dSAFER \
   -sDEVICE=pdfwrite \
   -dCompatibilityLevel=1.7 \
   -dDownsampleColorImages=true \
   -dColorImageResolution=120 \
   -dDownsampleGrayImages=true \
   -dGrayImageResolution=120 \
   -dDownsampleMonoImages=true \
   -dMonoImageResolution=300 \
   -sOutputFile=compressed.pdf \
   input.pdf

from pypdf import PdfReader, PdfWriter
 
def compress_pdf(input_path: str, output_path: str) -> dict:
    reader = PdfReader(input_path)
    writer = PdfWriter()
 
    for page in reader.pages:
        writer.add_page(page)
        # Compress the page's content streams
        for img in page.images:
            img.replace(img.image, quality=60)
 
    # Compress object streams
    writer.compress_identical_objects(
        remove_identicals=True,
        remove_orphans=True
    )
 
    with open(output_path, 'wb') as f:
        writer.write(f)
 
    import os
    original = os.path.getsize(input_path)
    compressed = os.path.getsize(output_path)
    
    return {
        'original_mb': round(original / 1024 / 1024, 2),
        'compressed_mb': round(compressed / 1024 / 1024, 2),
        'reduction_pct': round((1 - compressed / original) * 100, 1),
    }
 
result = compress_pdf('input.pdf', 'output.pdf')
print(f"Compressed: {result['original_mb']} MB → {result['compressed_mb']} MB ({result['reduction_pct']}% reduction)")

import { PDFDocument } from 'pdf-lib';
import fs from 'fs';
 
async function compressPdf(inputPath, outputPath) {
  const existingBytes = fs.readFileSync(inputPath);
  const pdfDoc = await PDFDocument.load(existingBytes, {
    updateMetadata: false,
  });
 
  // Save with object compression
  const compressedBytes = await pdfDoc.save({
    useObjectStreams: true,  // Cross-reference streams (smaller xref table)
    addDefaultPage: false,
  });
 
  fs.writeFileSync(outputPath, compressedBytes);
  
  const originalSize = fs.statSync(inputPath).size;
  const newSize = compressedBytes.length;
  const reduction = ((1 - newSize / originalSize) * 100).toFixed(1);
  
  console.log(`${(originalSize / 1024 / 1024).toFixed(2)} MB → ${(newSize / 1024 / 1024).toFixed(2)} MB (${reduction}% smaller)`);
}
 
await compressPdf('input.pdf', 'compressed.pdf');

import { PDFDocument } from 'pdf-lib';
import sharp from 'sharp';
import fs from 'fs';
 
async function compressImages(inputPath, outputPath, quality = 60) {
  const pdfBytes = fs.readFileSync(inputPath);
  const pdfDoc = await PDFDocument.load(pdfBytes);
  
  const pages = pdfDoc.getPages();
  
  // Access raw embedded images and re-encode them
  for (const page of pages) {
    const { node } = page;
    const resources = node.Resources();
    if (!resources) continue;
    
    const xObjects = resources.XObject();
    if (!xObjects) continue;
    
    // Re-encode each image XObject
    for (const [name, ref] of Object.entries(xObjects.dict)) {
      const xObj = pdfDoc.context.lookup(ref);
      // Image re-encoding logic depends on image format
      // Use sharp for JPEG/PNG re-encoding
    }
  }
  
  const compressed = await pdfDoc.save({ useObjectStreams: true });
  fs.writeFileSync(outputPath, compressed);
}

#!/bin/bash
# Compress all PDFs in a directory
 
INPUT_DIR="./pdfs"
OUTPUT_DIR="./compressed"
mkdir -p "$OUTPUT_DIR"
 
for pdf in "$INPUT_DIR"/*.pdf; do
  filename=$(basename "$pdf")
  output="$OUTPUT_DIR/$filename"
  
  gs -dBATCH -dNOPAUSE -dSAFER \
     -sDEVICE=pdfwrite \
     -dCompatibilityLevel=1.7 \
     -dPDFSETTINGS=/ebook \
     -sOutputFile="$output" \
     "$pdf"
  
  original=$(du -k "$pdf" | cut -f1)
  compressed=$(du -k "$output" | cut -f1)
  echo "$filename: ${original}K → ${compressed}K"
done

from pathlib import Path
from pypdf import PdfReader, PdfWriter
 
def batch_compress(input_dir: str, output_dir: str):
    Path(output_dir).mkdir(exist_ok=True)
    
    for pdf_path in Path(input_dir).glob('*.pdf'):
        output_path = Path(output_dir) / pdf_path.name
        result = compress_pdf(str(pdf_path), str(output_path))
        print(f"{pdf_path.name}: {result['original_mb']} MB → {result['compressed_mb']} MB ({result['reduction_pct']}% saved)")