Die C# PDF-Bibliothek

HTML zu PDF

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

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

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

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

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

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

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

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

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

VIDEOS

Wie man Stempel & Wasserzeichen in PDFs in C# hinzufügt

Curtis Chau

Updated: 19. Juli 2026

Der Wechsel von PDFBoltzu IronPDF verschiebt Ihren .NET-PDF-Workflow von einem cloud-basierten SaaS-REST-Service zu einer selbst gehosteten Bibliothek mit lokaler Dokumentenverarbeitung ohne Pro-Dokument-Lizenzbeschränkungen. Diese Anleitung bietet einen schrittweisen Migrationspfad, der Netzwerkabhängigkeiten, monatliche Nutzungsbeschränkungen und externe Datenübertragung beseitigt und PDF-Manipulationsfunktionen hinzufügt, die PDFBoltnicht bietet.

Warum von PDFBoltzu IronPDF migrieren

Das Cloud-Only-Problem

PDFBolt ist eine ausschließlich cloudbasierte SaaS-Plattform, die als REST-API bereitgestellt wird; es gibt kein offizielles .NET SDK und kein PDFBolt NuGet-Paket. Die Integration erfolgt manuell mit HttpClient gegen https://api.pdfbolt.com/v1/direct. Obwohl bequem für schnelle Prototypen, schafft diese Architektur Herausforderungen für produktionsreife Anwendungen:

Nur-Cloud-Verarbeitung: Jedes Dokument durchläuft die Server von PDFBolt- es gibt keine selbst gehostete Option, was ein Hindernis für Teams sein kann, die mehr Kontrolle über den Datenfluss benötigen.
Datenschutzüberlegungen: Sensible Dokumente (Verträge, Krankenakten, finanzielle Daten) werden extern übertragen. Unternehmen, die mit regulierten Daten arbeiten, haben berechtigte Prüfungsbedenken.
Nutzungsgrenzen: Das kostenlose Tier ist auf 100 Dokumente pro Monat, 20 Anfragen pro Minute, 1 gleichzeitige Anfrage beschränkt, was für produktionsreife Workloads möglicherweise nicht ausreicht. Bezahlte Stufen (laut pdfbolt.com/preise) skalieren von $19/Monat bis $249/Monat.
Netzwerkabhängigkeit: Internetausfälle oder PDFBolt-Ausfallzeiten bedeuten, dass Ihre PDF-Erzeugung vollständig stoppt.
Latenz: Die Netzwerk-Roundtrip-Zeit verlängert jede Konvertierung um Sekunden im Vergleich zur lokalen Verarbeitung.
Compliance-Prüfung: GDPR-, HIPAA- und SOC2-Audits erfordern in der Regel zusätzliche Dokumentation, wenn externe Dokumentenverarbeitung beteiligt ist.
Sicherheit der API-Schlüssel: Durchgesickerte API-Schlüssel können zu unautorisierter Nutzung führen, die Ihrem Konto in Rechnung gestellt wird.
Vendor Lock-in: Ihre Anwendung funktioniert nicht mehr, wenn PDFBoltdie Bedingungen ändert oder eingestellt wird.

PDFBoltvs IronPDF Vergleich

Betrifft	PDFBolt	IronPDF
Datenstandort	Externe Server	Nur Ihre Server
Nutzungseinschränkungen	100 kostenlos/Monat, dann gestufte Abonnements	Unbegrenzt
Internet erforderlich	Ja, immer	Nein
Latenzzeit	Netzwerk-Round-Trip	Lokale
Konformität	Komplex (externe Bearbeitung)	Einfach (lokale Verarbeitung)
Kostenmodell	Monatliche Abo-Stufen ($19-$249/Monat)	Einmalig oder jährlich
Offline-Betrieb	Unmöglich	Vollständig unterstützt
API Hauptrisiken	Durchgesickert = in Rechnung gestellt	Lizenzschlüssel, kein Abrechnungsrisiko

IronPDF bietet eine selbst gehostete Grundlage auf moderner .NET, die die Dokumentenverarbeitung lokal hält und die Abhängigkeit von einem externen Cloud-Service entfernt.

Bevor Sie beginnen

Voraussetzungen

.NET -Umgebung: .NET Framework 4.6.2+ oder .NET Core 3.1+ / .NET 5/6/7/8/9+
NuGet -Zugriff: Möglichkeit zur Installation von NuGet -Paketen
IronPDF -Lizenz: Ihren Lizenzschlüssel erhalten Sie unter IronPDF.

NuGet-Paketänderungen

PDFBolt hat kein offizielles .NET SDK und kein PDFBolt NuGet-Paket, daher gibt es nichts zu deinstallieren. Die Bereinigung auf der PDFBolt-Seite besteht darin, den manuell erstellten HttpClient Wrapper und die Anfragen-/Antwort-DTOs zu löschen. Dann IronPDF installieren:

# Install IronPDF(replaces the hand-rolled HttpClient wrapper)
dotnet add package IronPdf

# Install IronPDF(replaces the hand-rolled HttpClient wrapper)
dotnet add package IronPdf

SHELL

Lizenz-Konfiguration

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Die Verwendung von PDFBolterkennen

# Find all PDFBoltREST calls
grep -rE "api\.pdfbolt\.com|API-KEY|/v1/direct" --include="*.cs" .

# Find API key references
grep -r "PDFBOLT\|ApiKey" --include="*.cs" --include="*.json" --include="*.config" .

# Find all PDFBoltREST calls
grep -rE "api\.pdfbolt\.com|API-KEY|/v1/direct" --include="*.cs" .

# Find API key references
grep -r "PDFBOLT\|ApiKey" --include="*.cs" --include="*.json" --include="*.config" .

SHELL

Komplette API-Referenz

Kernkonzept-Zuordnungen

PDFBolt (REST)	IronPDF
`HttpClient` + `API-KEY` Header	`new ChromePdfRenderer()`
JSON-Anfragekörper	`renderer.RenderingOptions`
`POST https://api.pdfbolt.com/v1/direct`	`renderer.RenderHtmlAsPdf(...)` / `RenderUrlAsPdf(...)`
Antwort `byte[]`	`PdfDocument`

Konvertierungsmethoden-Zuordnungen

PDFBolt (REST)	IronPDF
`POST /v1/direct` mit `{ "html": <base64> }`	`renderer.RenderHtmlAsPdf(html)`
`POST /v1/direct` mit `{ "url": "..." }`	`renderer.RenderUrlAsPdf(url)`

Zuordnungen von Ausgabemethoden

PDFBolt (REST)	IronPDF
`await response.Content.ReadAsByteArrayAsync()` dann `File.WriteAllBytes`	`pdf.SaveAs(path)`
`await response.Content.ReadAsByteArrayAsync()`	`pdf.BinaryData`

Zuordnungen der Seitenkonfiguration

PDFBolt JSON	IronPDF
`"format": "A4"`	`renderer.RenderingOptions.PaperSize = PdfPaperSize.A4`
`"margin": { "top": "20mm" }`	`renderer.RenderingOptions.MarginTop = 20`
`"margin": { "bottom": "20mm" }`	`renderer.RenderingOptions.MarginBottom = 20`
`"margin": { "left": "15mm" }`	`renderer.RenderingOptions.MarginLeft = 15`
`"margin": { "right": "15mm" }`	`renderer.RenderingOptions.MarginRight = 15`

Kopf-/Fußzeilen-Platzhalter-Zuordnungen

PDFBolt (innerhalb von base64-codiertem `headerTemplate` / `footerTemplate`)	IronPDF (`HtmlFragment` Token)
`<span class="pageNumber"></span>`	`{page}`
`<span class="totalPages"></span>`	`{total-pages}`
`<span class="date"></span>`	`{date}`
`<span class="title"></span>`	`{html-title}`

Beispiele für die Code-Migration

Beispiel 1: Grundlegendes HTML zu PDF

Vorher (PDFBolt - REST über HttpClient):

// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/quick-start-guide/csharp
using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var payload = JsonSerializer.Serialize(new
        {
            html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html))
        });

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
        using var content = new StringContent(payload, Encoding.UTF8, "application/json");
        using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
        response.EnsureSuccessStatusCode();

        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("output.pdf", pdfBytes);
    }
}

// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/quick-start-guide/csharp
using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var payload = JsonSerializer.Serialize(new
        {
            html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html))
        });

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
        using var content = new StringContent(payload, Encoding.UTF8, "application/json");
        using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
        response.EnsureSuccessStatusCode();

        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("output.pdf", pdfBytes);
    }
}

Imports System
Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim payload As String = JsonSerializer.Serialize(New With {
            .html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html))
        })

        Using http As New HttpClient()
            http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
            Using content As New StringContent(payload, Encoding.UTF8, "application/json")
                Using response As HttpResponseMessage = Await http.PostAsync("https://api.pdfbolt.com/v1/direct", content)
                    response.EnsureSuccessStatusCode()

                    Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
                    Await File.WriteAllBytesAsync("output.pdf", pdfBytes)
                End Using
            End Using
        End Using
    End Function
End Module

Imports System
Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim payload As String = JsonSerializer.Serialize(New With {
            .html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html))
        })

        Using http As New HttpClient()
            http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
            Using content As New StringContent(payload, Encoding.UTF8, "application/json")
                Using response As HttpResponseMessage = Await http.PostAsync("https://api.pdfbolt.com/v1/direct", content)
                    response.EnsureSuccessStatusCode()

                    Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
                    Await File.WriteAllBytesAsync("output.pdf", pdfBytes)
                End Using
            End Using
        End Using
    End Function
End Module

Nach (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Imports IronPdf
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Der strukturelle Unterschied ist das Integrationsmodell. PDFBolterfordert, dass Sie das HTML base64-kodieren, eine JSON-Nutzlast erstellen, den API-KEY Header setzen, POST auf https://api.pdfbolt.com/v1/direct, auf die Antwort warten und die zurückgegebenen Bytes selbst auf die Festplatte schreiben.

IronPDF's ChromePdfRenderer.RenderHtmlAsPdf() gibt ein PdfDocument Objekt mit einer integrierten SaveAs() Methode zurück. Das objektorientierte Modell erlaubt es Ihnen, das PDF zu manipulieren (Wasserzeichen hinzufügen, Dokumente zusammenführen, Sicherheit anwenden), bevor Sie es speichern. Wenn Sie die Roh-Bytes für die Kompatibilität mit vorhandenem Code benötigen, verwenden Sie pdf.BinaryData. Weitere Rendering-Optionen finden Sie in der HTML to PDF Dokumentation.

Beispiel 2: Konvertierung von URL in PDF

Vorher (PDFBolt - REST über HttpClient):

// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/quick-start-guide/csharp
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var payload = JsonSerializer.Serialize(new { url = "https://www.example.com" });

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
        using var content = new StringContent(payload, Encoding.UTF8, "application/json");
        using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
        response.EnsureSuccessStatusCode();

        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("webpage.pdf", pdfBytes);
    }
}

// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/quick-start-guide/csharp
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var payload = JsonSerializer.Serialize(new { url = "https://www.example.com" });

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
        using var content = new StringContent(payload, Encoding.UTF8, "application/json");
        using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
        response.EnsureSuccessStatusCode();

        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("webpage.pdf", pdfBytes);
    }
}

Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim payload = JsonSerializer.Serialize(New With {.url = "https://www.example.com"})

        Using http As New HttpClient()
            http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
            Using content As New StringContent(payload, Encoding.UTF8, "application/json")
                Using response As HttpResponseMessage = Await http.PostAsync("https://api.pdfbolt.com/v1/direct", content)
                    response.EnsureSuccessStatusCode()

                    Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
                    Await File.WriteAllBytesAsync("webpage.pdf", pdfBytes)
                End Using
            End Using
        End Using
    End Function
End Module

Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim payload = JsonSerializer.Serialize(New With {.url = "https://www.example.com"})

        Using http As New HttpClient()
            http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
            Using content As New StringContent(payload, Encoding.UTF8, "application/json")
                Using response As HttpResponseMessage = Await http.PostAsync("https://api.pdfbolt.com/v1/direct", content)
                    response.EnsureSuccessStatusCode()

                    Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
                    Await File.WriteAllBytesAsync("webpage.pdf", pdfBytes)
                End Using
            End Using
        End Using
    End Function
End Module

Nach (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class

Auf der PDFBolt-Seite erfordert die URL-Konvertierung immer noch die vollständige REST-Rundreise: Erstellen Sie den JSON-Körper, setzen Sie den API-Schlüssel-Header, warten Sie auf den POST und schreiben Sie die Antwort-Bytes. Auch wenn Sie bereits auf eine öffentliche URL zeigen, erfolgen das Abrufen und Rendern auf den Servern von PDFBolt.

IronPDF's RenderUrlAsPdf() gibt ein PdfDocument zurück mit der integrierten SaveAs() Methode. Der Hauptvorteil besteht darin, dass IronPDF das URL-Abrufen und PDF-Rendern lokal durchführt - keine Dokumentendaten verlassen Ihre Infrastruktur. Erfahren Sie mehr über die URL in PDF Konvertierung.

Beispiel 3: HTML-Datei mit benutzerdefinierten Seiteneinstellungen

Vorher (PDFBolt - REST über HttpClient):

// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/parameters
using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = await File.ReadAllTextAsync("input.html");
        var payload = JsonSerializer.Serialize(new
        {
            html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html)),
            format = "A4",
            margin = new { top = "20mm", bottom = "20mm" },
            printBackground = true
        });

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
        using var content = new StringContent(payload, Encoding.UTF8, "application/json");
        using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
        response.EnsureSuccessStatusCode();

        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("output.pdf", pdfBytes);
    }
}

// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/parameters
using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = await File.ReadAllTextAsync("input.html");
        var payload = JsonSerializer.Serialize(new
        {
            html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html)),
            format = "A4",
            margin = new { top = "20mm", bottom = "20mm" },
            printBackground = true
        });

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
        using var content = new StringContent(payload, Encoding.UTF8, "application/json");
        using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
        response.EnsureSuccessStatusCode();

        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("output.pdf", pdfBytes);
    }
}

Imports System
Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim html = Await File.ReadAllTextAsync("input.html")
        Dim payload = JsonSerializer.Serialize(New With {
            .html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html)),
            .format = "A4",
            .margin = New With {.top = "20mm", .bottom = "20mm"},
            .printBackground = True
        })

        Using http As New HttpClient()
            http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
            Using content As New StringContent(payload, Encoding.UTF8, "application/json")
                Using response As HttpResponseMessage = Await http.PostAsync("https://api.pdfbolt.com/v1/direct", content)
                    response.EnsureSuccessStatusCode()

                    Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
                    Await File.WriteAllBytesAsync("output.pdf", pdfBytes)
                End Using
            End Using
        End Using
    End Function
End Module

Imports System
Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim html = Await File.ReadAllTextAsync("input.html")
        Dim payload = JsonSerializer.Serialize(New With {
            .html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html)),
            .format = "A4",
            .margin = New With {.top = "20mm", .bottom = "20mm"},
            .printBackground = True
        })

        Using http As New HttpClient()
            http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
            Using content As New StringContent(payload, Encoding.UTF8, "application/json")
                Using response As HttpResponseMessage = Await http.PostAsync("https://api.pdfbolt.com/v1/direct", content)
                    response.EnsureSuccessStatusCode()

                    Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
                    Await File.WriteAllBytesAsync("output.pdf", pdfBytes)
                End Using
            End Using
        End Using
    End Function
End Module

Nach (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        var html = File.ReadAllText("input.html");
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        var html = File.ReadAllText("input.html");
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf
Imports IronPdf.Rendering
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 20
        renderer.RenderingOptions.MarginBottom = 20
        Dim html = File.ReadAllText("input.html")
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Imports IronPdf
Imports IronPdf.Rendering
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 20
        renderer.RenderingOptions.MarginBottom = 20
        Dim html = File.ReadAllText("input.html")
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Dieses Beispiel zeigt die Seitenkonfigurationszuordnung. PDFBoltakzeptiert Top-Level format plus ein verschachteltes margin Objekt, dessen Werte CSS-ähnliche Zeichenfolgen ("20mm") sind.IronPDF verwendet ein RenderingOptions Objekt auf dem Renderer mit stark typisierten Eigenschaften.

Die wichtigsten Mappings:

"format": "A4" → PdfPaperSize.A4 (stark typisiertes Enum)
"margin": { "top": "20mm" } → RenderingOptions.MarginTop = 20 (numerisch mm)

IronPDF-Ränder sind immer numerische Millimeter, daher werden PDFBoltCSS-Einheiten wie "20mm" direkt zugeordnet. Das IronPdf.Rendering Namespace ist erforderlich, um auf das PdfPaperSize Enum zuzugreifen. Für zusätzliche Seitenkonfigurationen, siehe die Rendering-Optionen-Dokumentation.

Kritische Hinweise zur Migration

Rückgabetyp ändern

PDFBolt's /v1/direct Endpoint gibt das rohe PDF als HTTP-Antwort zurück;IronPDF gibt ein PdfDocument zurück:

// PDFBoltpattern:
var pdfBytes = await response.Content.ReadAsByteArrayAsync();
await File.WriteAllBytesAsync("output.pdf", pdfBytes);

//IronPDF pattern:
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// Or if you need bytes:
byte[] pdfBytes = renderer.RenderHtmlAsPdf(html).BinaryData;

// PDFBoltpattern:
var pdfBytes = await response.Content.ReadAsByteArrayAsync();
await File.WriteAllBytesAsync("output.pdf", pdfBytes);

//IronPDF pattern:
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// Or if you need bytes:
byte[] pdfBytes = renderer.RenderHtmlAsPdf(html).BinaryData;

Integrationsmodelländerung

Die Integrationsform ändert sich vom REST-Client zur In-Prozess-Bibliothek:

// PDFBolt
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
// ... build JSON, POST to https://api.pdfbolt.com/v1/direct

// IronPDF
var renderer = new ChromePdfRenderer();

// PDFBolt
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
// ... build JSON, POST to https://api.pdfbolt.com/v1/direct

// IronPDF
var renderer = new ChromePdfRenderer();

Imports System.Net.Http

' PDFBolt
Using http As New HttpClient()
    http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
    ' ... build JSON, POST to https://api.pdfbolt.com/v1/direct
End Using

' IronPDF
Dim renderer As New ChromePdfRenderer()

Imports System.Net.Http

' PDFBolt
Using http As New HttpClient()
    http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
    ' ... build JSON, POST to https://api.pdfbolt.com/v1/direct
End Using

' IronPDF
Dim renderer As New ChromePdfRenderer()

Änderung von Konfigurationsmustern

PDFBolt-Konfiguration sind JSON-Felder im Anforderungskörper;IronPDF verwendet RenderingOptions:

// PDFBolt: JSON request fields
new { format = "A4", margin = new { top = "20mm" } }

// IronPDF: RenderingOptions properties
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 20;

// PDFBolt: JSON request fields
new { format = "A4", margin = new { top = "20mm" } }

// IronPDF: RenderingOptions properties
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 20;

' PDFBolt: JSON request fields
New With {Key .format = "A4", Key .margin = New With {Key .top = "20mm"}}

' IronPDF: RenderingOptions properties
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 20

' PDFBolt: JSON request fields
New With {Key .format = "A4", Key .margin = New With {Key .top = "20mm"}}

' IronPDF: RenderingOptions properties
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 20

API-Schlüssel-Eliminierung

PDFBolt erfordert einen API-KEY Header bei jeder Anfrage;IronPDF verwendet einen einmaligen Lizenzschlüssel:

// PDFBolt: API key per HTTP call (security risk if leaked)
http.DefaultRequestHeaders.Add("API-KEY", config["PDFBolt:ApiKey"]);

// IronPDF: License key once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
var renderer = new ChromePdfRenderer();

// PDFBolt: API key per HTTP call (security risk if leaked)
http.DefaultRequestHeaders.Add("API-KEY", config["PDFBolt:ApiKey"]);

// IronPDF: License key once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
var renderer = new ChromePdfRenderer();

' PDFBolt: API key per HTTP call (security risk if leaked)
http.DefaultRequestHeaders.Add("API-KEY", config("PDFBolt:ApiKey"))

' IronPDF: License key once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
Dim renderer As New ChromePdfRenderer()

' PDFBolt: API key per HTTP call (security risk if leaked)
http.DefaultRequestHeaders.Add("API-KEY", config("PDFBolt:ApiKey"))

' IronPDF: License key once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
Dim renderer As New ChromePdfRenderer()

Entfernen der Netzwerk-Fehlerbehandlung

Lokale Verarbeitung bedeutet, dass keine Netzwerkfehler zu behandeln sind:

// PDFBolt: Network error handling required
catch (HttpRequestException ex)
catch (TaskCanceledException)
catch (TimeoutException)

// IronPDF: Remove network-specific catches entirely

// PDFBolt: Network error handling required
catch (HttpRequestException ex)
catch (TaskCanceledException)
catch (TimeoutException)

// IronPDF: Remove network-specific catches entirely

net

net

Neue Funktionen verfügbar

Nach der Migration zu IronPDF erhalten Sie Fähigkeiten, die PDFBoltnicht bietet:

// PDF Merging (not available in PDFBolt)
var merged = PdfDocument.Merge(pdf1, pdf2);

// Watermarks (not available in PDFBolt)
pdf.ApplyWatermark("<h1 style='opacity:0.3;'>DRAFT</h1>");

// Password Protection (not available in PDFBolt)
pdf.SecuritySettings.UserPassword = "secret";

// Text Extraction (not available in PDFBolt)
string text = pdf.ExtractAllText();

// PDF to Images (not available in PDFBolt)
pdf.RasterizeToImageFiles("page_*.png");

// PDF Merging (not available in PDFBolt)
var merged = PdfDocument.Merge(pdf1, pdf2);

// Watermarks (not available in PDFBolt)
pdf.ApplyWatermark("<h1 style='opacity:0.3;'>DRAFT</h1>");

// Password Protection (not available in PDFBolt)
pdf.SecuritySettings.UserPassword = "secret";

// Text Extraction (not available in PDFBolt)
string text = pdf.ExtractAllText();

// PDF to Images (not available in PDFBolt)
pdf.RasterizeToImageFiles("page_*.png");

' PDF Merging (not available in PDFBolt)
Dim merged = PdfDocument.Merge(pdf1, pdf2)

' Watermarks (not available in PDFBolt)
pdf.ApplyWatermark("<h1 style='opacity:0.3;'>DRAFT</h1>")

' Password Protection (not available in PDFBolt)
pdf.SecuritySettings.UserPassword = "secret"

' Text Extraction (not available in PDFBolt)
Dim text As String = pdf.ExtractAllText()

' PDF to Images (not available in PDFBolt)
pdf.RasterizeToImageFiles("page_*.png")

' PDF Merging (not available in PDFBolt)
Dim merged = PdfDocument.Merge(pdf1, pdf2)

' Watermarks (not available in PDFBolt)
pdf.ApplyWatermark("<h1 style='opacity:0.3;'>DRAFT</h1>")

' Password Protection (not available in PDFBolt)
pdf.SecuritySettings.UserPassword = "secret"

' Text Extraction (not available in PDFBolt)
Dim text As String = pdf.ExtractAllText()

' PDF to Images (not available in PDFBolt)
pdf.RasterizeToImageFiles("page_*.png")

Fehlerbehebung

Problem 1: Kein `PDFBolt` Paket auf NuGet

Problem: Nach using PDFBolt; / new HtmlToPdfConverter() in IronPDF suchen.

Lösung: PDFBolthat kein .NET SDK — die Integration erfolgt mit HttpClient gegen https://api.pdfbolt.com/v1/direct.IronPDF ersetzt diesen Wrapper vollständig durch ChromePdfRenderer:

// IronPDF
var renderer = new ChromePdfRenderer();

// IronPDF
var renderer = new ChromePdfRenderer();

' IronPDF
Dim renderer As New ChromePdfRenderer()

' IronPDF
Dim renderer As New ChromePdfRenderer()

Problem 2: Wo ist `ConvertHtmlString` hin?

Problem: Eine interne PDFBolt-Wrap-Unterstützung migrieren, die eine ConvertHtmlString(html) Methode bereitstellte.

Lösung: Verwenden Sie RenderHtmlAsPdf():

// IronPDF
var pdf = renderer.RenderHtmlAsPdf(html);

// IronPDF
var pdf = renderer.RenderHtmlAsPdf(html);

net

net

Problem 3: Wo ist `ConvertUrl` hin?

Problem: Eine interne PDFBolt-Wrap-Unterstützung migrieren, die eine ConvertUrl(url) Methode bereitstellte.

Lösung: Verwenden Sie RenderUrlAsPdf():

// IronPDF
var pdf = renderer.RenderUrlAsPdf(url);

// IronPDF
var pdf = renderer.RenderUrlAsPdf(url);

net

net

Issue 4: `format` JSON Field → Enum

Problem: Das JSON-Feld "format": "A4" von PDFBoltübersetzen.

Lösung: Verwenden Sie PdfPaperSize von IronPdf.Rendering:

// IronPDF
using IronPdf.Rendering;
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

// IronPDF
using IronPdf.Rendering;
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

Imports IronPdf.Rendering

renderer.RenderingOptions.PaperSize = PdfPaperSize.A4

Imports IronPdf.Rendering

renderer.RenderingOptions.PaperSize = PdfPaperSize.A4

Ausgabe 5: Erste PDF-Erzeugung ist langsam

Problem: Das erste Rendern dauert länger als erwartet.

Lösung: Die Chromium-Engine initialisiert sich bei der ersten Verwendung. Bei Bedarf vorwärmen:

// Warm up during application startup
var renderer = new ChromePdfRenderer();
renderer.RenderHtmlAsPdf("<html><body></body></html>");

// Warm up during application startup
var renderer = new ChromePdfRenderer();
renderer.RenderHtmlAsPdf("<html><body></body></html>");

' Warm up during application startup
Dim renderer As New ChromePdfRenderer()
renderer.RenderHtmlAsPdf("<html><body></body></html>")

' Warm up during application startup
Dim renderer As New ChromePdfRenderer()
renderer.RenderHtmlAsPdf("<html><body></body></html>")

Migrations-Checkliste

Vor der Migration

Alle PDFBoltREST-Aufrufe im Codebestand inventarisieren (api.pdfbolt.com)
Aktuelle JSON-Anforderungsfelder dokumentieren (format, margin, printBackground, headerTemplate, usw.)
API-Schlüsselverwaltungscode identifizieren, der entfernt werden soll
Listen Sie die 429 / Kontingent-Wiederholungsbehandlung auf, die gelöscht werden soll -IronPDF-Lizenzschlüssel erhalten

Paketänderungen

Den manuell erstellten PDFBoltHttpClient Wrapper und DTOs löschen (kein NuGet-Paket zum Deinstallieren)
IronPdf NuGet-Paket installieren: dotnet add package IronPdf
using IronPdf; Namespace hinzufügen
using IronPdf.Rendering; für Papiergrößen-Enums hinzufügen

Code-Änderungen

Lizenzschlüsselkonfiguration beim Start hinzufügen
Die HttpClient + API-KEY Integration durch ChromePdfRenderer ersetzen
POST /v1/direct mit RenderHtmlAsPdf() / RenderUrlAsPdf() ersetzen
await response.Content.ReadAsByteArrayAsync() + File.WriteAllBytes() durch pdf.SaveAs() ersetzen (oder pdf.BinaryData, wenn noch Bytes benötigt werden)
"format" / "margin" JSON-Felder zu RenderingOptions.PaperSize / RenderingOptions.MarginTop usw. zuordnen.
API-Schlüsselverwaltungscode entfernen
Entfernen Sie 429 / Ratenlimitbehandlung
Netzwerkfehlerbehandlung entfernen

Nach der Migration

API-Schlüssel aus Konfigurationsdateien löschen
API-Schlüssel aus Secret Managern entfernen
Führen Sie alle Tests durch und vergleichen Sie die PDF-Ausgabe.
Überprüfen Sie, ob Seitengrößen und Ränder korrekt dargestellt werden.
Erwägen Sie die Hinzufügung neuer Funktionen (Wasserzeichen, Sicherheit, Zusammenführung)

Hinweis:: PDFBolt ist ein eingetragenes Warenzeichen seines jeweiligen Eigentümers. Diese Seite steht in keiner Verbindung zu, wird nicht unterstützt von und nicht gesponsert von PDFBolt. Alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Eigentümer. Vergleiche dienen nur zu Informationszwecken und spiegeln öffentlich zugängliche Informationen zum Zeitpunkt des Schreibens wider.

Curtis Chau

Jetzt mit dem Ingenieurteam chatten

Technischer Autor

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.

...