.NET HILFE

Wie man HTML zu PDF in Rust konvertiert

Curtis Chau
Curtis Chau
Aktualisiert: 18. Oktober 2026

Die Umwandlung von HTML-Dateien oder rohen HTML-Strings in PDF ist eine häufige Anforderung für Rechnungen, Berichte und Quittungen. Rust verfügt über keine eingebaute Rendering-Engine dafür, und eine zu schreiben ist kein realistisches Nebenprojekt. Das Parsen von HTML ist der einfache Teil. Das Parsen von CSS, Layout und Paginierung sind die Bereiche, in denen die Arbeit nie endet, weshalb ein Browser eine natürliche Wahl für die PDF-Erstellung in Rust ist. Dieses Tutorial wandelt HTML in Rust mit dem Open-Source-headless_chrome-Crate in PDF um, das Chrome das Rendering überlässt und das fertige PDF an Ihr Rust-Programm zurückgibt.

Headless Chrome Crate für Rust

headless_chrome ist ein MIT-lizenziertes Rust-Crate, das einen Chrome- oder Chromium-Browser über das Chrome DevTools Protocol steuert. Es kann Seiten öffnen, Elemente anklicken, Screenshots machen und die integrierte Druck-zu-PDF-Funktion von Chrome aufrufen. Da die Seite von einem echten Browser gerendert wird, funktionieren CSS-Layouts, Webfonts und JavaScript genauso wie in Chrome.

Chrome kann eine Seite auch direkt über die Kommandozeile mit --print-to-pdf drucken. Das ist nur ein CLI-Aufruf, daher landen die Bytes auf der Festplatte statt in Ihrem Programm, und die verfügbaren Druckeinstellungen sind begrenzt. Die Steuerung des DevTools Protocols hingegen hält die Bytes in Ihrem Programm und überlässt das gesamte Web-Layout dem Browser. Es ist dasselbe Protokoll, auf dem die entsprechenden Bibliotheken in anderen Sprachen basieren. Das Crate wird von der Rust-Community gepflegt, daher erfolgt der Support über den GitHub-Issue-Tracker.

Voraussetzungen

Um einen HTML-zu-PDF-Konverter in Rust zu erstellen, stellen Sie sicher, dass folgende Voraussetzungen erfüllt sind:

  1. Rust 1.85 oder neuer. Installieren Sie das Rust-Toolchain mit rustup. Unter Windows benötigt das MSVC-Toolchain zusätzlich eine Visual Studio-Installation, da rustc dessen Linker und Bibliotheken verwendet.
  2. Google Chrome, Chromium oder Microsoft Edge installiert. headless_chrome sucht nach dem Browser im PATH, in der CHROME-Umgebungsvariable und unter Windows in der Registry, wobei Edge als Fallback dient.
  3. Grundkenntnisse in Rust und Cargo.

Dieses Tutorial wurde mit Rust 1.98.1, headless_chrome 1.0.22 und Chrome 153 unter Windows 11 getestet. Der gleiche Code läuft auch unter Linux und macOS.

Erstellen eines Rust HTML-zu-PDF-Projekts mit Cargo

Erstellen Sie das Binärprojekt und fügen Sie beide Abhängigkeiten über ein Terminal hinzu:

cargo new html_to_pdf
cd html_to_pdf
cargo add headless_chrome urlencoding
SHELL

Schritt 3 verwendet das urlencoding-Crate, um den HTML-String als Data-URL an Chrome zu übergeben.

How to Convert HTML to PDF in Rust: Figure 1 - Creating the project and adding dependencies

Überprüfung von Cargo.toml

Nach dem Ausführen von cargo add erscheinen beide Crates unter [dependencies] in der Datei Cargo.toml:

[package]
name = "html_to_pdf"
version = "0.1.0"
edition = "2024"

[dependencies]
headless_chrome = "1.0.22"
urlencoding = "2.1.3"
Text

How to Convert HTML to PDF in Rust: Figure 2 - Cargo.toml dependencies

Das Standard-offline-Feature des Crates verwendet einen bereits installierten Browser. Falls auf dem Zielsystem kein Chrome vorhanden ist, aktivieren Sie stattdessen das fetch-Feature (cargo add headless_chrome --features fetch), und das Crate kann einen Chromium-Build für Sie herunterladen.

Schritte zur Umwandlung von HTML in PDF in Rust

Schritt 1: Importieren der Crates

Öffnen Sie src/main.rs und ersetzen Sie den Inhalt durch die Importe, die das Programm benötigt. Browser und LaunchOptions starten Chrome, und PrintToPdfOptions steuert die PDF-Ausgabe:

use std::fs;

use headless_chrome::types::PrintToPdfOptions;
use headless_chrome::{Browser, LaunchOptions};
Rust

Schritt 2: Starten von Headless Chrome

Starten Sie als Nächstes einen Headless-Browser und öffnen Sie einen Tab. main gibt ein Result zurück, sodass jeder Aufruf den ?-Operator anstelle von unwrap verwenden kann:

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Launch a headless Chrome instance
    let browser = Browser::new(LaunchOptions {
        headless: true,
        ..Default::default()
    })?;

    // Open a new tab to load the HTML into
    let tab = browser.new_tab()?;
Rust

Browser::default() liefert dasselbe Ergebnis mit weniger Code. LaunchOptions wird hier gezeigt, weil Sie dort die Fenstergröße, den Chrome-Pfad oder das Sandbox-Flag setzen können, wenn Sie diese benötigen.

Schritt 3: Setzen des HTML-Inhalts

Geben Sie nun das HTML an, das zum PDF werden soll. Die Rust-Rohstring-Syntax r#"..."# hält die Anführungszeichen im HTML lesbar:

    let html = r#"
        <html>
        <head>
            <style>
                body { font-family: Arial, sans-serif; margin: 40px; }
                h1 { color: #2a5db0; }
                table { border-collapse: collapse; width: 100%; }
                th, td { border: 1px solid #ccc; padding: 8px; text-align: left; }
                th { background-color: #f0f4fa; }
            </style>
        </head>
        <body>
            <h1>Hello, World!</h1>
            <p>This PDF was generated from an HTML string in Rust.</p>
            <table>
                <tr><th>Item</th><th>Quantity</th><th>Price</th></tr>
                <tr><td>Widget</td><td>2</td><td>$10.00</td></tr>
                <tr><td>Gadget</td><td>1</td><td>$25.00</td></tr>
            </table>
        </body>
        </html>
    "#;

    // Load the HTML string as a data URL and wait for the page to finish loading
    let data_url = format!("data:text/html;charset=utf-8,{}", urlencoding::encode(html));
    tab.navigate_to(&data_url)?.wait_until_navigated()?;
Rust

print_to_pdf hat keine HTML-Option. Es druckt, was auch immer der Tab anzeigt, und das Crate hat keine Methode, um den Seiteninhalt direkt zu setzen, daher wird der HTML-String als data:-URL prozentkodiert und der Tab navigiert dorthin.

wait_until_navigated blockiert dann, bis die Seite bereit ist, und stoppt nicht beim Ladeereignis. Das Crate aktiviert die Lebenszyklusereignisse von Chrome und setzt das Navigations-Flag bei networkAlmostIdle zurück, dem Browser-Lebenszyklus-Meilenstein, der erreicht wird, sobald die von der Seite geladenen Anfragen (Netzwerk-Leerlauf) abgeklungen sind. Zu dem Zeitpunkt, an dem der Tab die Navigation als abgeschlossen meldet, sind in der Regel auch späte Webfonts und Bilder geladen.

Schritt 4: HTML in PDF umwandeln

Nachdem die Seite geladen wurde, rufen Sie print_to_pdf auf. PrintToPdfOptions entspricht Chromes Druckeinstellungen, und jedes Feld ist optional:

    // Print the page to PDF with background colors and 0.4 inch margins
    let options = PrintToPdfOptions {
        print_background: Some(true),
        margin_top: Some(0.4),
        margin_bottom: Some(0.4),
        margin_left: Some(0.4),
        margin_right: Some(0.4),
        ..Default::default()
    };
Rust

Ränder und Papiergrößen werden in Zoll angegeben. Ohne paper_width und paper_height verwendet Chrome US Letter (8,5 x 11 Zoll). Chrome druckt keine Hintergrundfarben oder -bilder, es sei denn, Sie fordern dies explizit an. print_background ist standardmäßig deaktiviert, und ohne diese Option wird die Schattierung des Tabellenkopfes im PDF weggelassen.

Die Felder für die Seiteneinrichtung (landscape, scale, page_ranges und die Header- und Footer-Templates) erhalten später in diesem Tutorial einen eigenen Abschnitt.

Schritt 5: Ausgabe als Byte-Vektor erhalten

print_to_pdf gibt das fertige Dokument als Vec<u8> im Speicher zurück. Es wird noch nichts auf die Festplatte geschrieben, sodass die Bytes in eine Datei, einen HTTP-Response-Body oder einen Cloud-Speicher geschrieben werden können:

    let pdf_data: Vec<u8> = tab.print_to_pdf(Some(options))?;
Rust

Schritt 6: Die PDF-Datei speichern

Um das PDF zu speichern, schreiben Sie den Byte-Vektor mit std::fs::write in eine Datei. Dieser Befehl erstellt die Datei, schreibt alle Bytes und schließt sie in einem Aufruf:

    // Write the PDF bytes to disk
    fs::write("output.pdf", &pdf_data)?;
    println!("PDF saved successfully ({} bytes).", pdf_data.len());

    Ok(())
}
Rust

Schritt 7: Aufräumen

Im Gegensatz zur wkhtmltopdf C-API gibt es keine destroy- oder deinit-Funktionen, die aufgerufen werden müssen. Wenn browser am Ende von main aus dem Gültigkeitsbereich fällt, beendet seine Drop-Implementierung den Chrome-Prozess und entfernt den temporären Profilordner, den es erstellt hat. Wenn ein Schritt fehlschlägt und ? vorzeitig zurückkehrt, wird die gleiche Bereinigung dennoch ausgeführt.

In einem lang laufenden Dienst sollten Sie eine Browser-Instanz am Leben halten und für jedes Dokument einen neuen Tab öffnen, anstatt für jede Anfrage einen neuen Chrome-Prozess zu starten.

Schritt 8: Code ausführen und PDF-Datei generieren

Bauen und führen Sie das Projekt aus dem Projektordner aus:

cargo run
SHELL

Der erste Build kompiliert 143 Crates, was auf dem hier verwendeten Rechner 45 Sekunden dauerte. Das Programm gibt dann die Größe der generierten Datei aus:

Wie man HTML in PDF in Rust umwandelt: Abbildung 3 - cargo run Ausgabe

Die Datei output.pdf wird im Projektordner gespeichert. Die CSS-Styles, einschließlich der Header-Farbe sowie der Tabellenrahmen und des Hintergrunds, bleiben erhalten:

Wie man HTML in PDF in Rust umwandelt: Abbildung 4 - PDF-Ausgabe

Hier ist das generierte output.pdf selbst:

Eine URL oder HTML-Datei in Rust in PDF umwandeln

Die gleichen navigate_to- und print_to_pdf-Aufrufe funktionieren für Webseiten und lokale HTML-Dateien. Für lokale Dateien fügen Sie das url-Crate mit cargo add url hinzu, damit Sie den Dateipfad auf jedem Betriebssystem in eine gültige file://-URL umwandeln können.

Das folgende Beispiel liest eine lokale Vorlage, speichern Sie diese also neben Cargo.toml als invoice.html:

<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 30px; }
        .box { background: #2a5db0; color: #fff; padding: 16px; }
    </style>
</head>
<body>
    <div class="box"><h2>Invoice #1024</h2></div>
    <p>Loaded from a local HTML file.</p>
</body>
</html>
HTML

Speichern Sie das folgende Programm als examples/url_and_file.rs und führen Sie es mit cargo run --example url_and_file aus:

use std::fs;

use headless_chrome::types::PrintToPdfOptions;
use headless_chrome::Browser;
use url::Url;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let browser = Browser::default()?;
    let tab = browser.new_tab()?;

    // Convert a live web page to PDF
    tab.navigate_to("https://doc.rust-lang.org/book/")?
        .wait_until_navigated()?;
    let url_pdf = tab.print_to_pdf(None)?;
    fs::write("url.pdf", url_pdf)?;

    // Convert a local HTML file to PDF
    let path = fs::canonicalize("invoice.html")?;
    let file_url = Url::from_file_path(&path).map_err(|_| "invalid file path")?;
    tab.navigate_to(file_url.as_str())?.wait_until_navigated()?;

    let options = PrintToPdfOptions {
        landscape: Some(true),
        print_background: Some(true),
        ..Default::default()
    };
    fs::write("invoice.pdf", tab.print_to_pdf(Some(options))?)?;

    println!("Saved url.pdf and invoice.pdf");
    Ok(())
}
Rust

Ein Tab verarbeitet beide Dokumente nacheinander. Die URL wird mit Chromes Standardeinstellungen gedruckt, und die lokale Rechnung wird im Querformat mit ihren Hintergrundfarben ausgegeben:

Wie man HTML in PDF in Rust umwandelt: Abbildung 5 - URL und HTML-Datei in PDF umgewandelt

Die Webseite wurde in url.pdf gespeichert:

Und die lokale HTML-Datei wurde im Querformat in invoice.pdf ausgegeben:

Speichern Sie Vorlagen mit einer .html-Endung, da Chrome anhand der Eingabeerweiterung entscheidet, wie eine lokale Datei behandelt wird. Das gleiche Markup, als .txt gespeichert, wurde als sichtbare Tags statt als gerenderte Seite ausgegeben.

Seitengröße, Seitenzahlen und Seitenumbrüche

PrintToPdfOptions spiegelt Chromes Druckdialog wider, und die unterstützten Werte sind die, die der Dialog selbst anbietet. landscape: Some(true) schaltet in den Querformatmodus, scale nimmt einen Zoomfaktor, wobei 1.0 die volle Größe ist, und page_ranges nimmt einen einsbasierten String wie "1-5, 8, 11-13".

Seitenzahlen können von beiden Seiten kommen. Geben Sie Chrome eine Footer-Vorlage, und es ersetzt pageNumber und totalPages auf jeder Seite:

let options = PrintToPdfOptions {
    display_header_footer: Some(true),
    header_template: Some("<span></span>".into()),
    footer_template: Some(
        "<div style='font-size:10px;width:100%;text-align:center'>Page <span class='pageNumber'></span> of <span class='totalPages'></span></div>".into()),
    margin_bottom: Some(0.6),
    ..Default::default()
};
Rust

Der CSS-Weg funktioniert ebenfalls. Chrome Platform Status listet @page-Margin-Boxen ab Meilenstein 131, daher ist eine ältere Anleitung historisches Verhalten. Unter Chrome 153 nummerierte diese Seitenzähler-Regel allein jede Seite eines vierseitigen Dokuments:

@page { @bottom-center { content: "Page " counter(page); } }
CSS

Auch die Steuerung, wo ein Seitenumbruch erfolgt, ist gewöhnliches CSS. Ein Testdokument mit sechs Karten zeigte den Unterschied. Ohne die Eigenschaft endete die erste Seite mitten in der dritten Karte, und der Rest dieser Karte wurde auf Seite zwei fortgesetzt. Durch Hinzufügen der CSS-Eigenschaft break-inside wurde jede Karte vollständig auf die nächste Seite verschoben, zwei pro Seite, ohne dass eine geteilt wurde:

.card { break-inside: avoid; }
CSS

Was Chrome in die PDF einfügt

Zwei Optionen verändern die Struktur der Datei, nicht das Aussehen der Seite:

let options = PrintToPdfOptions {
    generate_document_outline: Some(true),
    generate_tagged_pdf: Some(true),
    ..Default::default()
};
Rust

generate_document_outline wandelt Ihre Überschriften in PDF-Lesezeichen um. Ein Bericht mit einer h1- und zwei h2-Überschriften erzeugte mit dieser Option eine Dokumentenübersicht mit drei Einträgen, und ohne diese Option überhaupt keine Übersicht.

generate_tagged_pdf fordert eine getaggte PDF-Datei an, die Struktur, die Screenreader und PDF/UA-Prüfer lesen. Das DevTools-Protokoll dokumentiert den Standard als „embedder choice“ statt „aus“, und der Test hier entsprach dem. Auch wenn beide Optionen deaktiviert sind, enthielt die Ausgabe weiterhin einen Strukturbaum und übernahm die Dokumentensprache aus <html lang="en">. Setzen Sie dieses Attribut in Ihren Vorlagen in jedem Fall und prüfen Sie Ihre eigene Ausgabe, bevor Sie sich auf das Flag verlassen.

Schriftarten werden mit Font-Subsetting eingebettet, sodass eine Seite, die in Georgia gesetzt wurde, AAAAAA+Georgia-Bold und BAAAAA+Georgia statt der gesamten Familie erzeugte. Ein JPEG-Foto wurde als JPEG gespeichert, nicht neu kodiert.

Headless Chrome-Nutzung in einem Rust-Service

Das Crate ist blockierend, weshalb keiner der obigen Codes als async fn main geschrieben ist. Wenn Ihr Service bereits eine asynchrone Laufzeit wie Tokio verwendet, halten Sie den Browser vom Reactor fern, indem Sie ihn innerhalb von tokio::task::spawn_blocking aufrufen, sodass ein langsames Rendering den Executor nicht blockieren kann.

Nichts wird endlos abgefragt. Jeder Tab-Vorgang läuft gegen ein Timeout und gibt im Fehlerfall einen Fehler zurück, anstatt zu hängen, sodass eine Seite, die nie fertig wird, keinen Worker blockieren kann.

Chrome-Start- und -Shutdown-Zeilen erscheinen in jedem Service, der einen Logger installiert, da das Crate über das log-Crate berichtet. Um Protokolle aus der Browser-Ebene zu entfernen, ohne Ihre eigenen zu unterdrücken, filtern Sie nach Ziel, zum Beispiel RUST_LOG=info,headless_chrome=warn.

Häufige Probleme beim Konvertieren von HTML zu PDF in Rust

Dies sind die Fehlerquellen, die in der Produktion auftreten:

  • JavaScript-gerenderter Inhalt: wait_until_navigated gibt zurück, sobald das Netzwerk ruhig ist, was nicht dasselbe ist wie das vollständige Zeichnen eines Diagramms. Rufen Sie tab.wait_for_element("#report-ready") für ein Element auf, das die Seite hinzufügt, wenn sie fertig ist, und drucken Sie dann.
  • Timeouts: Tab-Vorgänge laufen standardmäßig nach 20 Sekunden ab. Erhöhen Sie das Limit mit tab.set_default_timeout(std::time::Duration::from_secs(60)) für langsame Seiten.
  • Große HTML-Strings: Chrome begrenzt URLs auf 2 MB, und das schließt data:-URLs ein. Für größere Dokumente schreiben Sie das HTML in eine temporäre Datei und laden es mit einer file://-URL wie oben gezeigt.
  • Docker- und Linux-Container: Chromes Sandbox kann nicht gestartet werden, wenn der Prozess als root läuft, und Puppeteers Troubleshooting-Guide rät dringend davon ab, ohne Sandbox zu arbeiten. Fügen Sie dem Image einen nicht privilegierten Benutzer hinzu und lassen Sie die Sandbox aktiviert, und setzen Sie sandbox: false in LaunchOptions nur, wenn Sie keine Alternative haben. In jedem Fall benötigt das Image die Systembibliotheken von Chrome.
  • Deployment: Jeder Server, der das Programm ausführt, benötigt einen kompatiblen Browser, sodass Chrome Teil Ihres Deployments wird, auch wenn der Rust-Code zu einer einzigen Binärdatei kompiliert.

Weitere Möglichkeiten, HTML zu PDF in Rust zu konvertieren

headless_chrome ist nicht der einzige Weg. Welche Methode passt, hängt davon ab, ob Ihre Dokumente JavaScript benötigen und wie viele Sie gleichzeitig rendern.

Chromium-basiert, wie in diesem Tutorial

html2pdf bezeichnet sich selbst als reine CLI über das headless_chrome-Crate und wird auch als Bibliothek ausgeliefert, deren API asynchron ist und auf tokio läuft, was Ihnen das Schreiben des spawn_blocking-Wrappers erspart.

Gotenberg verlagert den Browser komplett aus Ihrem Prozess. Es handelt sich um eine Docker-basierte API zur Konvertierung von Dokumenten in PDF: Chromium verarbeitet URLs, HTML und Markdown, LibreOffice übernimmt Office-Formate, und Ihr Rust-Service sendet eine Datei per HTTP und erhält ein PDF zurück. Das hält Chrome aus dem Deployment Ihrer Binärdatei heraus, kostet aber den Betrieb eines zusätzlichen Dienstes.

Browserfreie Rust-Engines

Headless Chrome kann bei gleichzeitiger PDF-Erstellung ressourcenintensiv sein, da jede Konvertierung einen eigenen Browser-Prozess und den dazugehörigen Speicher benötigt. Zwei Rust-Projekte setzen genau dort an.

htmltopdf ist eine MIT-lizenzierte Engine, die in einem Thread ohne Subprozess rendert. In der README wird sie als für hohe Parallelität und niedrigen RAM-Verbrauch gebaut beschrieben. Die README berichtet von etwa 92 MB Spitzen-RAM gegenüber etwa 846 MB für Chromiums Hauptprozess bei einem einzelnen 1,8 MB großen Dokument. Für 20 gleichzeitige Konvertierungen werden 12,75 PDF/s bei 1,25 GiB gegenüber Chromiums 1,18 PDF/s bei 9,35 GiB gemessen, getestet mit /usr/bin/time -l auf Apple Silicon. Dies sind die projektspezifischen Benchmarks mit eigenen Testdaten und wurden für diesen Artikel nicht reproduziert. Das Crate ist nicht auf crates.io, daher installiert man es aus dem Repository, und die JavaScript-Verarbeitung ist eine optionale, begrenzte Pre-Layout-Phase, kein vollständiges Engine.

Fulgur ist eine weitere HTML-zu-PDF-Engine in Rust, die auf den Browser verzichtet. Sie ist unter Apache-2.0 lizenziert und integriert Blitz für HTML-Parsing, Stilauflösung und Layout mit Krilla für die PDF-Erstellung. Fulgur unterstützt eine kuratierte Teilmenge von HTML und CSS, die Eigenschaft für Eigenschaft im CSS-Support-Dokument nachverfolgt wird, und die Feature-Liste enthält keine JavaScript-Engine. Was abgedeckt ist, ist der paginierte Bereich, einschließlich Seitenzähler, laufende Kopfzeilen, Randboxen, break-inside, getaggte PDF und Font-Subsetting. Fulgurs Rendering-Pipeline beinhaltet ein 2-Pass-Rendering für Genauigkeit, sodass Querverweise wie target-counter() aufgelöst werden, bevor das PDF geschrieben wird.

Kommerzielle Engines

Prince unterstützt CSS Paged Media für komplexe PDF-Erstellung, einschließlich @page-Regeln, Seitenrandboxen und eines vordefinierten Seitenzählers für laufende Kopf- und Fußzeilen. Prince ist kommerzielle Software, die Sie lizenzieren, kein Crate, das Sie mit Cargo hinzufügen.

Welche passt

Jahrelang galt die Faustregel, dass Rust-native HTML-zu-PDF-Optionen nur eingeschränkten CSS- und JavaScript-Support hatten, sodass reine Rust-Engines nur für einfache Dokumente geeignet waren. Die CSS-Hälfte davon ist überholt. htmltopdf listet Flexbox, Grid, Tabellen mit Rowspans und @font-face, und Fulgur deckt paginierte Medien vollständig ab. JavaScript ist weiterhin die Lücke.

Was Ihr Dokument zeichnet, entscheidet über die Wahl. Wenn ein Server das HTML rendert und das Styling per CSS erfolgt, nimmt eine browserfreie Engine Chrome samt Speicherbedarf aus Ihrer Bereitstellung. Wenn Ihre Seiten Diagramme im Browser zeichnen oder auf eigene Skripte einer Web-App angewiesen sind, behalten Sie einen Browser in der Pipeline – wie es dieses Tutorial tut.

IronPDF für Rust (Demnächst verfügbar)

IronPDF für Rust befindet sich in der Entwicklung. Die geplante Bibliothek wird PDFs aus HTML erstellen und bestehende PDFs bearbeiten – alles aus Rust-Code heraus.

Treten Sie dem IronPDF für Rust Beta-Programm bei, um frühzeitig Zugriff zu erhalten und die API mitzugestalten.

HTML-Datei zu PDF-Datei in C#

IronPDF

IronPDF HTML-zu-PDF-Konvertierungsbibliothek ist eine .NET- und .NET Core C#-Bibliothek, die PDF-Dokumente aus HTML-Inhalten generiert. Sie bringt ihre eigene Chrome-Rendering-Engine mit, sodass kein separater Browser installiert, gestartet oder beendet werden muss.

IronPDF verarbeitet mehr als nur einfache HTML-Dokumente. Es rendert komplexe Webseiten mit CSS-Styling und JavaScript und kann PDFs nach der Erstellung auch bearbeiten, zusammenführen, signieren und sichern.

Der gleiche Job mit IronPDF, eine HTML-Zeichenkette in PDF umwandeln in C#:

using IronPdf;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create PDF content from an HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

Die PDF-Ausgabe:

How to Convert HTML to PDF in Rust: Figure 6 - IronPDF Output

Die Schritte aus diesem Rust-Tutorial entsprechen einzelnen IronPDF-Einstellungen. Die Seiteneinrichtung wird in benutzerdefinierten Rändern und benutzerdefiniertem Papierformat behandelt, und das JavaScript-Warteproblem wird durch die WaitFor-Rendering-Verzögerungen gelöst. Die Umwandlung einer URL in PDF oder einer HTML-Datei in PDF erfordert jeweils nur einen Methodenaufruf, und Kopf- und Fußzeilen mit Seitenzahlen benötigen keine HTML-Vorlagen. Für eine vollständige Anleitung siehe das HTML-zu-PDF-Tutorial oder lesen Sie, wie die gleiche Aufgabe in HTML zu PDF in C++ funktioniert.

Sie können all dies mit einer kostenlosen Testversion der vollständigen IronPDF-Funktionalität ausprobieren. Sie läuft 30 Tage, benötigt keine Kreditkarte und funktioniert auf Live-Servern ohne Wasserzeichen während der Evaluierung. Lizenzen danach sind unbefristet, ohne wiederkehrende Gebühren, nach Entwicklern, Projekten und Standorten gestaffelt und durch eine 30-tägige Geld-zurück-Garantie abgesichert. Um loszulegen, laden Sie IronPDF herunter.

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.

Mehr lesen

Verwandte Artikel