PDF to Images: Convert Every Page to JPG or PNG (Free, No Upload)

# Convert all pages to JPG at 300 DPI
gs -dNOPAUSE -dBATCH -sDEVICE=jpeg -r300 \
   -dJPEGQ=90 \
   -sOutputFile="page-%03d.jpg" \
   input.pdf
 
# Convert all pages to PNG at 300 DPI
gs -dNOPAUSE -dBATCH -sDEVICE=png16m -r300 \
   -sOutputFile="page-%03d.png" \
   input.pdf
 
# Convert a single page (page 3)
gs -dNOPAUSE -dBATCH -sDEVICE=jpeg -r300 \
   -dFirstPage=3 -dLastPage=3 \
   -sOutputFile="page-003.jpg" \
   input.pdf

from pdf2image import convert_from_path
from pathlib import Path
 
def pdf_to_images(pdf_path: str, dpi: int = 300, fmt: str = "JPEG", quality: int = 90) -> list[str]:
    pages = convert_from_path(pdf_path, dpi=dpi)
    output_paths = []
    stem = Path(pdf_path).stem
 
    for i, page in enumerate(pages, start=1):
        ext = "jpg" if fmt == "JPEG" else "png"
        out_path = f"{stem}-page-{i:03d}.{ext}"
 
        if fmt == "JPEG":
            page.save(out_path, "JPEG", quality=quality, optimize=True)
        else:
            page.save(out_path, "PNG", optimize=True)
 
        output_paths.append(out_path)
        print(f"Saved {out_path} ({page.width}x{page.height})")
 
    return output_paths
 
# Convert a range of pages (pages 2–5)
def pdf_range_to_images(pdf_path: str, first: int, last: int, dpi: int = 300):
    pages = convert_from_path(pdf_path, dpi=dpi, first_page=first, last_page=last)
    for i, page in enumerate(pages, start=first):
        page.save(f"page-{i:03d}.jpg", "JPEG", quality=90)

pip install pdf2image Pillow
# Also needs Ghostscript or poppler-utils installed on the system

import { fromPath } from "pdf2pic";
import path from "path";
 
async function convertPdfToImages(pdfPath, options = {}) {
  const { dpi = 300, format = "jpg", quality = 90, outputDir = "./output" } = options;
 
  const converter = fromPath(pdfPath, {
    density: dpi,
    saveFilename: path.basename(pdfPath, ".pdf"),
    savePath: outputDir,
    format,
    quality,
  });
 
  // Convert all pages
  const results = await converter.bulk(-1, { responseType: "image" });
  
  results.forEach((r) => {
    console.log(`Page ${r.page}: ${r.path} (${r.size} bytes)`);
  });
 
  return results;
}
 
// Usage
await convertPdfToImages("report.pdf", { dpi: 300, format: "jpg", quality: 90 });

npm install pdf2pic
# pdf2pic requires GraphicsMagick or ImageMagick + Ghostscript

import * as pdfjsLib from "pdfjs-dist";
 
pdfjsLib.GlobalWorkerOptions.workerSrc = "/pdf.worker.min.js";
 
async function pdfPageToImage(pdfFile, pageNumber, scale = 2.0) {
  const arrayBuffer = await pdfFile.arrayBuffer();
  const pdf = await pdfjsLib.getDocument({ data: arrayBuffer }).promise;
  const page = await pdf.getPage(pageNumber);
 
  const viewport = page.getViewport({ scale });
  const canvas = document.createElement("canvas");
  canvas.width = viewport.width;
  canvas.height = viewport.height;
 
  await page.render({
    canvasContext: canvas.getContext("2d"),
    viewport,
  }).promise;
 
  // Export as JPG blob
  return new Promise((resolve) => {
    canvas.toBlob(resolve, "image/jpeg", 0.92);
  });
}
 
async function convertAllPages(pdfFile, onProgress) {
  const arrayBuffer = await pdfFile.arrayBuffer();
  const pdf = await pdfjsLib.getDocument({ data: arrayBuffer }).promise;
  const images = [];
 
  for (let i = 1; i <= pdf.numPages; i++) {
    const blob = await pdfPageToImage(pdfFile, i, 2.0);
    images.push({ page: i, blob, url: URL.createObjectURL(blob) });
    onProgress?.(i, pdf.numPages);
  }
 
  return images;
}

#!/bin/bash
INPUT_DIR="./pdfs"
OUTPUT_DIR="./images"
DPI=300
 
mkdir -p "$OUTPUT_DIR"
 
for pdf in "$INPUT_DIR"/*.pdf; do
  name=$(basename "$pdf" .pdf)
  mkdir -p "$OUTPUT_DIR/$name"
  gs -dNOPAUSE -dBATCH -sDEVICE=jpeg -r$DPI \
     -dJPEGQ=90 \
     -sOutputFile="$OUTPUT_DIR/$name/page-%03d.jpg" \
     "$pdf"
  echo "Converted: $pdf → $OUTPUT_DIR/$name/"
done

import glob
from pathlib import Path
from pdf2image import convert_from_path
 
def batch_convert(input_glob: str = "./pdfs/*.pdf", dpi: int = 300):
    pdfs = glob.glob(input_glob)
    print(f"Found {len(pdfs)} PDF files")
 
    for pdf_path in pdfs:
        name = Path(pdf_path).stem
        out_dir = Path("./images") / name
        out_dir.mkdir(parents=True, exist_ok=True)
 
        pages = convert_from_path(pdf_path, dpi=dpi)
        for i, page in enumerate(pages, start=1):
            out_path = out_dir / f"page-{i:03d}.jpg"
            page.save(str(out_path), "JPEG", quality=90)
 
        print(f"  {name}: {len(pages)} pages → {out_dir}")
 
batch_convert()

import archiver from "archiver";
import fs from "fs";
 
async function zipImages(imagePaths, outputZip) {
  const output = fs.createWriteStream(outputZip);
  const archive = archiver("zip", { zlib: { level: 9 } });
 
  archive.pipe(output);
 
  for (const imgPath of imagePaths) {
    archive.file(imgPath, { name: path.basename(imgPath) });
  }
 
  await archive.finalize();
  return outputZip;
}

import JSZip from "jszip";
 
async function downloadAllAsZip(images, filename = "pages.zip") {
  const zip = new JSZip();
  images.forEach(({ page, blob }) => {
    zip.file(`page-${String(page).padStart(3, "0")}.jpg`, blob);
  });
  const content = await zip.generateAsync({ type: "blob" });
  const url = URL.createObjectURL(content);
  const a = document.createElement("a");
  a.href = url;
  a.download = filename;
  a.click();
}