Skip to content
PDF Oxide

Merge and Split PDFs in Python, Rust, Go

Binding coverage. PDF merge is available in Python, Rust, and Go. Splitting via extract_pages is currently Python + Rust only. The C# and WASM bindings do not yet expose these editor operations — use the Rust CLI (pdf-oxide merge, pdf-oxide split) as a workaround, or call through one of the supported bindings.

Merge two PDFs into one:

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("main.pdf")
doc.merge_from("appendix.pdf")
doc.save("combined.pdf")

WASM

import { WasmPdfDocument } from "pdf-oxide-wasm";

// Load both PDFs as Uint8Array
const mainDoc = new WasmPdfDocument(mainBytes);
const appendixDoc = new WasmPdfDocument(appendixBytes);
// Extract text from both and process as needed
const allText = mainDoc.extractAllText() + "\n" + appendixDoc.extractAllText();
mainDoc.free();
appendixDoc.free();

Rust

use pdf_oxide::editor::DocumentEditor;

let mut editor = DocumentEditor::open("main.pdf")?;
editor.merge_from("appendix.pdf")?;
editor.save("combined.pdf")?;

Go

package main

import (
    "log"
    pdfoxide "github.com/yfedoseev/pdf_oxide/go"
)

func main() {
    editor, err := pdfoxide.OpenEditor("main.pdf")
    if err != nil { log.Fatal(err) }
    defer editor.Close()

    if _, err := editor.MergeFrom("appendix.pdf"); err != nil { log.Fatal(err) }
    if err := editor.Save("combined.pdf"); err != nil { log.Fatal(err) }
}

PDF Oxide handles page merging at the PDF object level — fonts, images, and annotations are preserved correctly across documents.

Installation

pip install pdf_oxide

Merge PDFs

Merge All Pages

Append every page from a second PDF to the first:

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("report.pdf")
doc.merge_from("charts.pdf")
doc.save("full-report.pdf")

WASM

// WASM API: load and process multiple documents
const report = new WasmPdfDocument(reportBytes);
const charts = new WasmPdfDocument(chartsBytes);
// Process both documents together
const fullText = report.extractAllText() + "\n" + charts.extractAllText();
report.free();
charts.free();

Rust

let mut editor = DocumentEditor::open("report.pdf")?;
let pages_added = editor.merge_from("charts.pdf")?;
println!("Added {} pages", pages_added);
editor.save("full-report.pdf")?;

Go

editor, _ := pdfoxide.OpenEditor("report.pdf")
defer editor.Close()

added, _ := editor.MergeFrom("charts.pdf")
fmt.Printf("Added %d pages\n", added)
_ = editor.Save("full-report.pdf")

Merge Multiple Files

Use the static Pdf.merge() method to combine several PDFs in one call:

Python

from pdf_oxide import Pdf

pdf = Pdf.merge(["intro.pdf", "chapter1.pdf", "chapter2.pdf", "appendix.pdf"])
pdf.save("book.pdf")

You can also chain merge_from() calls on an existing document:

from pdf_oxide import PdfDocument

doc = PdfDocument("intro.pdf")
for f in ["chapter1.pdf", "chapter2.pdf", "appendix.pdf"]:
    doc.merge_from(f)
doc.save("book.pdf")

WASM

// Load and process multiple PDFs sequentially
const files = [introBytes, ch1Bytes, ch2Bytes, appendixBytes];
const allText = [];
for (const bytes of files) {
    const doc = new WasmPdfDocument(bytes);
    allText.push(doc.extractAllText());
    doc.free();
}
console.log(allText.join("\n"));

Rust

let files = ["intro.pdf", "chapter1.pdf", "chapter2.pdf", "appendix.pdf"];
let mut editor = DocumentEditor::open(files[0])?;
for f in &files[1..] {
    editor.merge_from(f)?;
}
editor.save("book.pdf")?;

Go

// Top-level Merge returns the combined PDF bytes in one call
bytes, err := pdfoxide.Merge([]string{
    "intro.pdf", "chapter1.pdf", "chapter2.pdf", "appendix.pdf",
})
if err != nil { log.Fatal(err) }
_ = os.WriteFile("book.pdf", bytes, 0644)

Merge Specific Pages

Select which pages to merge from the source document:

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("main.pdf")
# Merge only pages 0, 2, and 4 from source
doc.merge_pages_from("source.pdf", [0, 2, 4])
doc.save("selected.pdf")

Rust

let mut editor = DocumentEditor::open("main.pdf")?;
editor.merge_pages_from("source.pdf", &[0, 2, 4])?;
editor.save("selected.pdf")?;

Split PDFs

Extract Pages to a New File

Pull specific pages out of a large document:

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("book.pdf")
doc.extract_pages([0, 1, 2, 3, 4], "chapter1.pdf")

WASM

// Extract text from specific pages
const doc = new WasmPdfDocument(bytes);
const pages = [0, 1, 2, 3, 4];
for (const i of pages) {
    const text = doc.extractText(i);
    console.log(`Page ${i + 1}: ${text.slice(0, 80)}...`);
}
doc.free();

Rust

let mut editor = DocumentEditor::open("book.pdf")?;
editor.extract_pages(&[0, 1, 2, 3, 4], "chapter1.pdf")?;

Split Into Individual Pages

Save each page as a separate file:

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("document.pdf")
for i in range(doc.page_count()):
    doc.extract_pages([i], f"page_{i + 1}.pdf")

Rust

let mut editor = DocumentEditor::open("document.pdf")?;
let page_count = editor.page_count()?;
for i in 0..page_count {
    editor.extract_pages(&[i], &format!("page_{}.pdf", i + 1))?;
}

Split Into Chunks

Split a large PDF into smaller files of N pages each:

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("large.pdf")
chunk_size = 10

for start in range(0, doc.page_count(), chunk_size):
    end = min(start + chunk_size, doc.page_count())
    pages = list(range(start, end))
    doc.extract_pages(pages, f"chunk_{start // chunk_size + 1}.pdf")

Rust

let mut editor = DocumentEditor::open("large.pdf")?;
let page_count = editor.page_count()?;
let chunk_size = 10;

for start in (0..page_count).step_by(chunk_size) {
    let end = (start + chunk_size).min(page_count);
    let pages: Vec<usize> = (start..end).collect();
    editor.extract_pages(&pages, &format!("chunk_{}.pdf", start / chunk_size + 1))?;
}