Skip to content
PDF Oxide

Metadaten & XMP

PDF Oxide liest Metadaten auf Dokumentebene aus mehreren Quellen: dem PDF-Header (Version), den Trailer- und Catalog-Dictionaries, XMP-Metadatenströmen (ISO 16684) und Seitenbeschriftungsdefinitionen. Der XmpExtractor parst die Namespaces Dublin Core, XMP Core, PDF und XMP Rights sowie beliebige benutzerdefinierte Eigenschaften.

Verwenden Sie version() und catalog() für grundlegende Dokumenteigenschaften, XmpExtractor::extract() für umfangreiche Metadaten und PageLabelExtractor für Seitennummerierungsschemata.

Schnellbeispiel

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("report.pdf")
major, minor = doc.version()
print(f"PDF {major}.{minor}, {doc.page_count()} pages")

Node.js

const { PdfDocument } = require("pdf-oxide");

const doc = new PdfDocument("report.pdf");
const { major, minor } = doc.getVersion();
console.log(`PDF ${major}.${minor}, ${doc.pageCount()} pages`);
doc.close();

Go

import pdfoxide "github.com/yfedoseev/pdf_oxide/go"

doc, _ := pdfoxide.Open("report.pdf")
defer doc.Close()
major, minor, _ := doc.Version()
pages, _ := doc.PageCount()
fmt.Printf("PDF %d.%d, %d pages\n", major, minor, pages)

C#

using PdfOxide.Core;

using var doc = PdfDocument.Open("report.pdf");
var (major, minor) = doc.Version;
Console.WriteLine($"PDF {major}.{minor}, {doc.PageCount} pages");

WASM

const doc = new WasmPdfDocument(bytes);
const version = doc.version();
console.log(`PDF ${version}, ${doc.pageCount()} pages`);

Rust

use pdf_oxide::PdfDocument;

let mut doc = PdfDocument::open("report.pdf")?;
let (major, minor) = doc.version();
println!("PDF {}.{}", major, minor);
println!("Pages: {}", doc.page_count()?);

API Reference

version() -> (u8, u8)

Gibt die PDF-Version aus dem Datei-Header zurück.

Rückgabe: Ein Tupel aus (major, minor), z. B. (1, 7) für PDF 1.7 oder (2, 0) für PDF 2.0.

catalog() -> Result<Object>

Gibt das Catalog-Dictionary des Dokuments zurück. Der Catalog ist die Wurzel der PDF-Objekthierarchie und enthält Verweise auf den Seitenbaum, Lesezeichen, Namen und andere Strukturen auf Dokumentebene.

Rust

let mut doc = PdfDocument::open("report.pdf")?;
let catalog = doc.catalog()?;
if let Some(dict) = catalog.as_dict() {
    for (key, _) in dict {
        println!("Catalog key: {}", key);
    }
}

trailer() -> &Object

Gibt das Trailer-Dictionary des Dokuments zurück. Der Trailer enthält die Position der Querverweistabelle, die Dokument-ID, den Verweis auf das Verschlüsselungs-Dictionary und den Verweis auf das Info-Dictionary.

Rust

let doc = PdfDocument::open("report.pdf")?;
let trailer = doc.trailer();
println!("Trailer: {:?}", trailer);

XmpExtractor::extract(doc) -> Result<Option<XmpMetadata>>

Extrahiert XMP-Metadaten (Extensible Metadata Platform) aus dem Metadatenstrom des Dokuments. XMP liefert umfangreichere Metadaten als das herkömmliche Info-Dictionary und nutzt dafür standardisierte XML-Namespaces.

Parameter Typ Beschreibung
doc &mut PdfDocument Das PDF-Dokument

Rückgabe: Some(XmpMetadata), wenn XMP-Daten vorhanden sind, andernfalls None.

XmpMetadata-Felder

Dublin-Core-Namespace (dc:)

Feld Typ Beschreibung
dc_title Option<String> Dokumenttitel
dc_creator Vec<String> Liste der Autoren/Ersteller
dc_description Option<String> Dokumentbeschreibung
dc_subject Vec<String> Schlüsselwörter zum Thema
dc_language Option<String> Dokumentsprache (z. B. "en-US")
dc_rights Option<String> Copyright-Hinweis
dc_format Option<String> MIME-Format (z. B. "application/pdf")

XMP-Core-Namespace (xmp:)

Feld Typ Beschreibung
xmp_creator_tool Option<String> Zur Erstellung des Dokuments verwendetes Werkzeug
xmp_create_date Option<String> Erstellungsdatum (ISO 8601)
xmp_modify_date Option<String> Datum der letzten Änderung
xmp_metadata_date Option<String> Datum der Metadatenänderung

PDF-Namespace (pdf:)

Feld Typ Beschreibung
pdf_producer Option<String> PDF-Producer-Anwendung
pdf_keywords Option<String> Schlüsselwörter-Zeichenkette
pdf_version Option<String> PDF-Version aus XMP (kann vom Header abweichen)
pdf_trapped Option<String> Trapping-Status

XMP-Rights-Namespace (xmpRights:)

Feld Typ Beschreibung
xmp_rights_usage_terms Option<String> Nutzungsbedingungen
xmp_rights_marked Option<bool> Ob mit Rechten gekennzeichnet
xmp_rights_web_statement Option<String> URL der Web-Rechteerklärung

Sonstige

Feld Typ Beschreibung
custom HashMap<String, String> Benutzerdefinierte Eigenschaften (namespace:property zu Wert)
raw_xml Option<String> Das ursprüngliche XMP-XML-Paket

Rust

use pdf_oxide::extractors::xmp::XmpExtractor;

let mut doc = PdfDocument::open("report.pdf")?;
if let Some(xmp) = XmpExtractor::extract(&mut doc)? {
    if let Some(title) = &xmp.dc_title {
        println!("Title: {}", title);
    }
    for creator in &xmp.dc_creator {
        println!("Author: {}", creator);
    }
    if let Some(tool) = &xmp.xmp_creator_tool {
        println!("Created with: {}", tool);
    }
    if let Some(date) = &xmp.xmp_create_date {
        println!("Created: {}", date);
    }
    if let Some(producer) = &xmp.pdf_producer {
        println!("Producer: {}", producer);
    }
}

WASM

const doc = new WasmPdfDocument(bytes);
const xmp = doc.xmpMetadata();

if (xmp) {
  console.log(`Title: ${xmp.dc_title}`);
  console.log(`Authors: ${xmp.dc_creator}`);
  console.log(`Created with: ${xmp.xmp_creator_tool}`);
  console.log(`Created: ${xmp.xmp_create_date}`);
  console.log(`Producer: ${xmp.pdf_producer}`);
}
doc.free();

Python

doc = PdfDocument("report.pdf")
xmp = doc.xmp_metadata()

if xmp:
    print(f"Title: {xmp.get('dc_title')}")
    print(f"Authors: {xmp.get('dc_creator')}")
    print(f"Created with: {xmp.get('xmp_creator_tool')}")
    print(f"Created: {xmp.get('xmp_create_date')}")
    print(f"Producer: {xmp.get('pdf_producer')}")

<!-- Node.js: no equivalent on PdfDocumentImpl — xmp metadata not exposed in js/src/index.ts -->

Go

doc, _ := pdfoxide.Open("report.pdf")
defer doc.Close()
xmp, _ := doc.XmpMetadata() // returns JSON string
fmt.Println(xmp)

C#

using var doc = PdfDocument.Open("report.pdf");
var xmp = doc.GetXmpMetadata(); // returns JSON string
Console.WriteLine(xmp);

Pdf-Komfortmethoden

Die High-Level-API Pdf bietet Abkürzungsmethoden für häufige Metadatenabfragen.

xmp_metadata() -> Result<Option<XmpMetadata>>

Gibt das vollständige XMP-Metadatenobjekt zurück.

xmp_title() -> Result<Option<String>>

Gibt nur den Dokumenttitel aus XMP zurück.

xmp_creators() -> Result<Vec<String>>

Gibt die Liste der Ersteller/Autoren aus XMP zurück.

Rust

use pdf_oxide::api::Pdf;

let mut pdf = Pdf::open("report.pdf")?;

if let Some(title) = pdf.xmp_title()? {
    println!("Title: {}", title);
}

let creators = pdf.xmp_creators()?;
for creator in &creators {
    println!("Author: {}", creator);
}

PageLabelExtractor::extract(doc) -> Result<Vec<PageLabelRange>>

Extrahiert die Seitenbeschriftungsdefinitionen aus dem Dokument. Seitenbeschriftungen legen fest, wie Seitenzahlen angezeigt werden (z. B. römische Ziffern für den vorderen Buchteil, arabische Ziffern für den Hauptteil).

Parameter Typ Beschreibung
doc &mut PdfDocument Das PDF-Dokument

Rückgabe: Ein Vektor aus PageLabelRange-Definitionen.

PageLabelRange-Felder

Feld Typ Beschreibung
start_page usize Erster Seitenindex, für den dieser Bereich gilt
style PageLabelStyle Nummerierungsstil
prefix Option<String> Präfix-Zeichenkette der Beschriftung
start_number u32 Startzahl für diesen Bereich

PageLabelStyle-Varianten

Variante Beschreibung Beispiel
DecimalArabic Arabische Ziffern 1, 2, 3
UppercaseRoman Römisch in Großbuchstaben I, II, III
LowercaseRoman Römisch in Kleinbuchstaben i, ii, iii
UppercaseLetters Großbuchstaben A, B, C
LowercaseLetters Kleinbuchstaben a, b, c
None Keine Nummerierung (nur Präfix) –

Pdf-Komfortmethoden für Seitenbeschriftungen

page_labels() -> Result<Vec<PageLabelRange>>

Gibt alle Seitenbeschriftungsbereich-Definitionen zurück.

page_label(page) -> Result<String>

Gibt die Anzeigebeschriftung für einen bestimmten Seitenindex zurück.

Rust

use pdf_oxide::api::Pdf;

let mut pdf = Pdf::open("book.pdf")?;

// Get all label ranges
let ranges = pdf.page_labels()?;
for range in &ranges {
    println!(
        "Pages from {}: {:?} style, prefix={:?}, start={}",
        range.start_page, range.style, range.prefix, range.start_number
    );
}

// Get label for a specific page
let label = pdf.page_label(0)?;
println!("Page 0 label: {}", label); // e.g., "i" or "Cover"

WASM

const doc = new WasmPdfDocument(bytes);
const labels = doc.pageLabels();

for (const range of labels) {
  console.log(`Pages from ${range.start_page}: style=${range.style}, prefix=${range.prefix}`);
}
doc.free();

Python

doc = PdfDocument("book.pdf")
labels = doc.page_labels()

for range in labels:
    print(f"Pages from {range['start_page']}: style={range['style']}, prefix={range['prefix']}")

<!-- Node.js: no equivalent on PdfDocumentImpl — pageLabels not exposed on class, only via properties mixin -->

Go

doc, _ := pdfoxide.Open("book.pdf")
defer doc.Close()
labels, _ := doc.PageLabels() // returns JSON string
fmt.Println(labels)

C#

using var doc = PdfDocument.Open("book.pdf");
var labels = doc.GetPageLabels(); // returns JSON string
Console.WriteLine(labels);

Erweiterte Beispiele

Vollständige Dokumentmetadaten anzeigen

use pdf_oxide::PdfDocument;
use pdf_oxide::extractors::xmp::XmpExtractor;

let mut doc = PdfDocument::open("report.pdf")?;

// Basic info
let (major, minor) = doc.version();
println!("PDF Version: {}.{}", major, minor);
println!("Pages: {}", doc.page_count()?);

// XMP metadata
if let Some(xmp) = XmpExtractor::extract(&mut doc)? {
    println!("\nXMP Metadata:");
    println!("  Title:       {:?}", xmp.dc_title);
    println!("  Authors:     {:?}", xmp.dc_creator);
    println!("  Description: {:?}", xmp.dc_description);
    println!("  Keywords:    {:?}", xmp.pdf_keywords);
    println!("  Creator:     {:?}", xmp.xmp_creator_tool);
    println!("  Producer:    {:?}", xmp.pdf_producer);
    println!("  Created:     {:?}", xmp.xmp_create_date);
    println!("  Modified:    {:?}", xmp.xmp_modify_date);
    println!("  Language:    {:?}", xmp.dc_language);
    println!("  Rights:      {:?}", xmp.dc_rights);

    if !xmp.custom.is_empty() {
        println!("\n  Custom properties:");
        for (key, value) in &xmp.custom {
            println!("    {}: {}", key, value);
        }
    }
}

Auf das rohe XMP-XML zugreifen

use pdf_oxide::extractors::xmp::XmpExtractor;

let mut doc = PdfDocument::open("report.pdf")?;
if let Some(xmp) = XmpExtractor::extract(&mut doc)? {
    if let Some(xml) = &xmp.raw_xml {
        std::fs::write("metadata.xml", xml)?;
        println!("Raw XMP saved ({} bytes)", xml.len());
    }
}

Anzeigezeichenketten für Seitenzahlen erzeugen

use pdf_oxide::api::Pdf;

let mut pdf = Pdf::open("thesis.pdf")?;
let page_count = pdf.page_count()?;

for i in 0..page_count {
    let label = pdf.page_label(i)?;
    println!("Physical page {} -> display label '{}'", i + 1, label);
}
// Example output:
//   Physical page 1 -> display label 'i'
//   Physical page 2 -> display label 'ii'
//   Physical page 3 -> display label 'iii'
//   Physical page 4 -> display label '1'
//   Physical page 5 -> display label '2'

Verwandte Seiten