pdforge (umbenannt zu "pdf noodle" im Jahr 2026 — pdfnoodle.com; der api.pdforge.com Hostname funktioniert weiterhin über 301-Weiterleitungen bis Ende 2026) ist eine cloud-basierte, vorlagengetriebene PDF-Generierungs-API, die eine einfache Möglichkeit bietet, PDF-Dateien zu erstellen, indem sie über HTTP-Aufrufe in Ihre Anwendung integriert wird. Es gibt kein offizielles .NET SDK auf NuGet — die Integration erfolgt mit HttpClient gegen die dokumentierten REST-Endpunkte. Indem sie die Aufgabe der PDF-Erstellung an eine externe API auslagern, können Entwickler den Entwicklungsprozess vereinfachen. Allerdings hat pdforge auch Nachteile, wie z. B. externe Abhängigkeiten, begrenzte Anpassungsmöglichkeiten und laufende Abonnementkosten, derer sich Entwickler bewusst sein sollten.
pdforge verarbeitet alle Dokumente auf externen Cloud-Servern. Diese Architektur schafft erhebliche Probleme für Produktionsanwendungen:
Externe Serververarbeitung: Jedes von Ihnen generierte PDF erfordert das Senden Ihrer HTML-/Daten an die Server von pdforge – Ihre Dokumente verlassen somit Ihre Infrastruktur.
Datenschutz- und Compliance-Risiken: Sensible Daten werden über das Internet an Server von Drittanbietern übertragen. Bei der Verwendung von pdforge müssen die Entwickler Sicherheitsbedenken in Bezug auf die Übermittlung von Daten an eine externe API berücksichtigen. Wenn der PDF-Inhalt sensible Informationen enthält, könnte dies ein kritischer Punkt sein.
Laufende Abonnementkosten: Monatliche Gebühren fallen unbegrenzt an, ohne dass Eigentumsrechte erworben werden. Das SaaS-Modell von pdforge führt zu kontinuierlichen Betriebskosten, die sich im Laufe der Zeit summieren können.
Internetabhängigkeit: Es wird keine PDF-Datei generiert, wenn keine Netzwerkverbindung besteht.
Ratenbegrenzungen: API-Nutzungsbeschränkungen können Anwendungen mit hohem Datenaufkommen ausbremsen.
Netzwerklatenz: Die Roundtrip-Zeit verlängert die Generierung jeder PDF-Datei um einige Sekunden.
| Feature | pdforge | IronPDF |
|---|---|---|
| Bereitstellungsart | Cloud-basierte API | Lokale Bibliothek |
| Abhängigkeiten | Erfordert Internet und API-Authentifizierung | Keine externen Abhängigkeiten |
| Anpassung | Begrenzte Kontrolle über die PDF-Erzeugung | Volle Kontrolle über Anpassungen |
| Kostenstruktur | Laufendes Abonnement | Einmalige Kaufoption |
| Sicherheit | Mögliche Probleme mit Daten, die über das Internet gesendet werden | Die Datenverarbeitung bleibt vollständig in der lokalen Umgebung |
| Komplexität der Einrichtung | Leichtere Ersteinrichtung durch externe Bearbeitung | Erfordert mehr anfängliche Einrichtung und Konfiguration |
IronPDF hebt sich durch die Bereitstellung einer vollständig lokalen Bibliothek ab, die Entwicklern die vollständige Kontrolle über den PDF-Erstellungsprozess ermöglicht. Dies ist besonders vorteilhaft für Anwendungen, bei denen die interne Handhabung von Dateien bevorzugt wird oder bei denen externe API-Aufrufe Sicherheitsbedenken aufwerfen.IronPDF verarbeitet alles lokal und minimiert so die Risiken.
Für Teams, die die Einführung von .NET 10 und C# 14 auf den aktuellen .NET-Versionen planen, bietet IronPDF eine lokale Verarbeitungsgrundlage, die die Abhängigkeit von der Cloud eliminiert und gleichzeitig umfassende PDF-Manipulationsfunktionen hinzufügt.
# pdforge has no official .NET SDK on NuGet — integration is HttpClient + JSON.
# If your project depends only on built-in System.Net.Http, there is no
# competitor package to remove. Just install IronPDF:
dotnet add package IronPdf// 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"# Find pdforge / pdf noodle endpoint usage
grep -r "api\.pdforge\.com\|api\.pdfnoodle\.com" --include="*.cs" .
# Find API key / Bearer token references
grep -r "pdfnoodle_api_\|pdforge_api_" --include="*.cs" --include="*.json" --include="*.config" .
# Find Chromium header/footer templates that need migrating
grep -r "totalPages\|pageNumber\|footerTemplate\|headerTemplate" --include="*.cs" .// Before: pdforge — raw HttpClient against api.pdfnoodle.com
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
// After: IronPDF
using IronPdf;
using IronPdf.Rendering;Imports System.Net.Http
Imports System.Net.Http.Headers
Imports System.Text
Imports System.Text.Json
Imports IronPdf
Imports IronPdf.Rendering| pdforge (REST) | IronPDF |
|---|---|
HttpClient + Authorization: Bearer pdfnoodle_api_... | new ChromePdfRenderer() |
POST https://api.pdfnoodle.com/v1/html-to-pdf/sync | renderer.RenderHtmlAsPdf(html) |
JSON-Body { html, pdfParams } | ChromePdfRenderer + RenderingOptions |
Antwort: JSON-Umschlag mit signedUrl | PdfDocument |
Rückgabe: byte[] (nach Abrufen von signedUrl) | pdf.BinaryData |
| pdforge | IronPDF |
|---|---|
POST /v1/html-to-pdf/sync mit { html } | renderer.RenderHtmlAsPdf(html) |
| URL abrufen, dann HTML POSTen (kein dedizierter URL-Endpunkt) | renderer.RenderUrlAsPdf(url) |
Download signedUrl dann File.WriteAllBytes(path, bytes) | pdf.SaveAs(path) |
await http.GetByteArrayAsync(signedUrl) | pdf.BinaryData |
pdforge pdfParams | IronPDF(RenderingOptions) |
|---|---|
format: "A4" | renderer.RenderingOptions.PaperSize = PdfPaperSize.A4 |
landscape: true | renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape |
margin: { top: "20px" } | renderer.RenderingOptions.MarginTop = 20 |
footerTemplate mit <span class="pageNumber"> / <span class="totalPages"> | TextFooter = new TextHeaderFooter { CenterText = "Page {page} of {total-pages}" } |
| IronPDF Merkmal | Beschreibung |
|---|---|
PdfDocument.Merge() | Kombinieren mehrerer PDFs |
pdf.ExtractAllText() | Extrahieren von Text aus PDFs |
pdf.ApplyWatermark() | Wasserzeichen hinzufügen |
pdf.SecuritySettings | Passwortschutz |
pdf.Form | Ausfüllen von Formularen |
pdf.SignWithDigitalSignature() | Digitale Signaturen |
Vor (pdforge):
// REST API — no .NET SDK on NuGet. Integration is HttpClient + JSON POST.
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", "pdfnoodle_api_YOUR_KEY");
var body = new { html = "<html><body><h1>Hello World</h1></body></html>" };
var json = new StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json");
var resp = await http.PostAsync("https://api.pdfnoodle.com/v1/html-to-pdf/sync", json);
resp.EnsureSuccessStatusCode();
using var doc = JsonDocument.Parse(await resp.Content.ReadAsStringAsync());
var pdfBytes = await http.GetByteArrayAsync(doc.RootElement.GetProperty("signedUrl").GetString());
File.WriteAllBytes("output.pdf", pdfBytes);
}
}Imports System.IO
Imports System.Net.Http
Imports System.Net.Http.Headers
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks
Module Program
Async Function Main() As Task
Using http As New HttpClient()
http.DefaultRequestHeaders.Authorization = New AuthenticationHeaderValue("Bearer", "pdfnoodle_api_YOUR_KEY")
Dim body = New With {.html = "<html><body><h1>Hello World</h1></body></html>"}
Dim json As New StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json")
Dim resp = Await http.PostAsync("https://api.pdfnoodle.com/v1/html-to-pdf/sync", json)
resp.EnsureSuccessStatusCode()
Using doc = JsonDocument.Parse(Await resp.Content.ReadAsStringAsync())
Dim pdfBytes = Await http.GetByteArrayAsync(doc.RootElement.GetProperty("signedUrl").GetString())
File.WriteAllBytes("output.pdf", pdfBytes)
End Using
End Using
End Function
End ModuleNach (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
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
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 ClassDer grundlegende Unterschied ist das Verarbeitungsmodell und der Rückgabetyp. pdforge erfordert ein authentifiziertes HttpClient POST an https://api.pdfnoodle.com/v1/html-to-pdf/sync, das einen JSON-Umschlag mit einer signierten S3-URL zurückgibt — dann rufen Sie die PDF-Bytes von dieser URL ab und schreiben sie mit File.WriteAllBytes().
IronPDF verwendet ChromePdfRenderer mit RenderHtmlAsPdf(), das ein PdfDocument Objekt zurückgibt. Dieses Objekt kann direkt mit SaveAs() gespeichert werden, oder Sie können auf pdf.BinaryData zugreifen, wenn Sie die Rohbytes benötigen. Das PdfDocument ermöglicht auch die Bearbeitung (Wasserzeichen hinzufügen, mit anderen PDFs zusammenführen, Sicherheit hinzufügen) vor dem Speichern. Umfassende Beispiele finden Sie in der HTML to PDF Dokumentation.
Vor (pdforge):
// REST API — no .NET SDK on NuGet. pdforge has no dedicated URL endpoint;
// fetch the page yourself and POST its HTML to /v1/html-to-pdf/sync.
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", "pdfnoodle_api_YOUR_KEY");
var sourceHtml = await http.GetStringAsync("https://example.com");
var body = new { html = sourceHtml };
var json = new StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json");
var resp = await http.PostAsync("https://api.pdfnoodle.com/v1/html-to-pdf/sync", json);
resp.EnsureSuccessStatusCode();
using var doc = JsonDocument.Parse(await resp.Content.ReadAsStringAsync());
var pdfBytes = await http.GetByteArrayAsync(doc.RootElement.GetProperty("signedUrl").GetString());
File.WriteAllBytes("webpage.pdf", pdfBytes);
}
}Imports System.IO
Imports System.Net.Http
Imports System.Net.Http.Headers
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks
Module Program
Async Function Main() As Task
Using http As New HttpClient()
http.DefaultRequestHeaders.Authorization = New AuthenticationHeaderValue("Bearer", "pdfnoodle_api_YOUR_KEY")
Dim sourceHtml As String = Await http.GetStringAsync("https://example.com")
Dim body = New With {Key .html = sourceHtml}
Dim json As New StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json")
Dim resp As HttpResponseMessage = Await http.PostAsync("https://api.pdfnoodle.com/v1/html-to-pdf/sync", json)
resp.EnsureSuccessStatusCode()
Using doc As JsonDocument = JsonDocument.Parse(Await resp.Content.ReadAsStringAsync())
Dim pdfBytes As Byte() = Await http.GetByteArrayAsync(doc.RootElement.GetProperty("signedUrl").GetString())
File.WriteAllBytes("webpage.pdf", pdfBytes)
End Using
End Using
End Function
End ModuleNach (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf("https://example.com");
pdf.SaveAs("webpage.pdf");
}
}Imports IronPdf
Class Program
Shared Sub Main()
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
pdf.SaveAs("webpage.pdf")
End Sub
End Classpdforge hat keinen dedizierten URL-zu-PDF-Endpunkt — Sie holen sich die Seite selbst, posten dann ihr HTML an den synchronen Endpunkt und laden das Ergebnis von der zurückgegebenen signierten URL herunter.IronPDF verwendet RenderUrlAsPdf() auf ChromePdfRenderer, wobei ein PdfDocument mit der eingebauten SaveAs() Methode zurückgegeben wird.
Der Hauptvorteil von IronPDF besteht darin, dass die URL lokal mit einer Chromium-Engine abgerufen und gerendert wird - es werden keine Daten an externe Server gesendet. Da IronPDF eine lokale Bibliothek ist, bietet es möglicherweise eine bessere Leistung, da bei Webanfragen keine Round-Trip-Zeit anfällt. Erfahren Sie mehr über die URL in PDF Konvertierung.
Vor (pdforge):
// REST API — no .NET SDK on NuGet. Page size / orientation flow through the
// optional `pdfParams` object using Chromium/Puppeteer-style names.
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", "pdfnoodle_api_YOUR_KEY");
var htmlContent = File.ReadAllText("input.html");
var body = new { html = htmlContent, pdfParams = new { format = "A4", landscape = true } };
var json = new StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json");
var resp = await http.PostAsync("https://api.pdfnoodle.com/v1/html-to-pdf/sync", json);
resp.EnsureSuccessStatusCode();
using var doc = JsonDocument.Parse(await resp.Content.ReadAsStringAsync());
var pdfBytes = await http.GetByteArrayAsync(doc.RootElement.GetProperty("signedUrl").GetString());
File.WriteAllBytes("output.pdf", pdfBytes);
}
}Imports System.IO
Imports System.Net.Http
Imports System.Net.Http.Headers
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks
Module Program
Async Function Main() As Task
Using http As New HttpClient()
http.DefaultRequestHeaders.Authorization = New AuthenticationHeaderValue("Bearer", "pdfnoodle_api_YOUR_KEY")
Dim htmlContent As String = File.ReadAllText("input.html")
Dim body = New With {
.html = htmlContent,
.pdfParams = New With {
.format = "A4",
.landscape = True
}
}
Dim json As New StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json")
Dim resp As HttpResponseMessage = Await http.PostAsync("https://api.pdfnoodle.com/v1/html-to-pdf/sync", json)
resp.EnsureSuccessStatusCode()
Using doc As JsonDocument = JsonDocument.Parse(Await resp.Content.ReadAsStringAsync())
Dim pdfBytes As Byte() = Await http.GetByteArrayAsync(doc.RootElement.GetProperty("signedUrl").GetString())
File.WriteAllBytes("output.pdf", pdfBytes)
End Using
End Using
End Function
End ModuleNach (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
var htmlContent = System.IO.File.ReadAllText("input.html");
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("output.pdf");
}
}Imports IronPdf
Imports IronPdf.Rendering
Class Program
Shared Sub Main()
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
Dim htmlContent = System.IO.File.ReadAllText("input.html")
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("output.pdf")
End Sub
End ClassDieses Beispiel zeigt den Unterschied im Konfigurationsmuster. pdforge übergibt Optionen als JSON-Felder innerhalb eines pdfParams Objekts im POST-Body (format = "A4", landscape = true), nach den Chromium/Puppeteer-Namenskonventionen.
IronPDF verwendet die RenderingOptions Eigenschaft mit stark typisierten Enums: renderer.RenderingOptions.PaperSize = PdfPaperSize.A4 und renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape. Dies bietet IntelliSense-Unterstützung und Kompilierzeit-Typensicherheit. Beachten Sie, dass IronPDF das Importieren des IronPdf.Rendering Namespace für die Papierformat- und Ausrichtungs-Enums erfordert. In den Tutorials finden Sie weitere Konfigurationsbeispiele.
pdforge gibt einen JSON-Umschlag mit einer signierten URL zurück;IronPDF gibt PdfDocument zurück:
// pdforge: Two-step — parse signedUrl from JSON, then fetch bytes from it
var resp = await http.PostAsync("https://api.pdfnoodle.com/v1/html-to-pdf/sync", json);
using var doc = JsonDocument.Parse(await resp.Content.ReadAsStringAsync());
var pdfBytes = await http.GetByteArrayAsync(doc.RootElement.GetProperty("signedUrl").GetString());
File.WriteAllBytes("output.pdf", pdfBytes);
// IronPDF: Returns PdfDocument
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf"); // Direct save
byte[] bytes = pdf.BinaryData; // Get bytes if neededImports System.IO
Imports System.Net.Http
Imports System.Text.Json
Imports IronPdf
' pdforge: Two-step — parse signedUrl from JSON, then fetch bytes from it
Dim resp = Await http.PostAsync("https://api.pdfnoodle.com/v1/html-to-pdf/sync", json)
Using doc As JsonDocument = JsonDocument.Parse(Await resp.Content.ReadAsStringAsync())
Dim pdfBytes = Await http.GetByteArrayAsync(doc.RootElement.GetProperty("signedUrl").GetString())
File.WriteAllBytes("output.pdf", pdfBytes)
End Using
' IronPDF: Returns PdfDocument
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf") ' Direct save
Dim bytes As Byte() = pdf.BinaryData ' Get bytes if needed// pdforge: HttpClient against the REST endpoint
using var http = new HttpClient();
http.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("Bearer", "pdfnoodle_api_YOUR_KEY");
// IronPDF: ChromePdfRenderer
var renderer = new ChromePdfRenderer();' pdforge: HttpClient against the REST endpoint
Using http As New HttpClient()
http.DefaultRequestHeaders.Authorization = New AuthenticationHeaderValue("Bearer", "pdfnoodle_api_YOUR_KEY")
' IronPDF: ChromePdfRenderer
Dim renderer As New ChromePdfRenderer()
End Using// pdforge operations
await http.PostAsync("https://api.pdfnoodle.com/v1/html-to-pdf/sync", json); // HTML to PDF
// URL to PDF: fetch the page first, then POST its HTML to the same endpoint
//IronPDF methods
renderer.RenderHtmlAsPdf(html)
renderer.RenderUrlAsPdf(url)// pdforge: Two-step — fetch bytes from signed URL, then write to disk
var pdfBytes = await http.GetByteArrayAsync(signedUrl);
File.WriteAllBytes("output.pdf", pdfBytes);
// IronPDF: Built-in save method
pdf.SaveAs("output.pdf");' pdforge: Two-step — fetch bytes from signed URL, then write to disk
Dim pdfBytes = Await http.GetByteArrayAsync(signedUrl)
File.WriteAllBytes("output.pdf", pdfBytes)
' IronPDF: Built-in save method
pdf.SaveAs("output.pdf")pdforge übergibt Optionen als JSON-Felder auf pdfParams;IronPDF verwendet RenderingOptions:
// pdforge: JSON pdfParams object on the POST body
var body = new { html, pdfParams = new { format = "A4", landscape = true } };
// IronPDF: Properties on RenderingOptions
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;' pdforge: JSON pdfParams object on the POST body
Dim body = New With {Key .html = html, Key .pdfParams = New With {Key .format = "A4", Key .landscape = True}}
' IronPDF: Properties on RenderingOptions
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscapepdforge übernimmt Chromiums Kopf-/Fußzeilen-Vorlagenformat — HTML-Fragmente, die <span class="..."></span> Elemente enthalten, die die Engine zur Renderzeit ersetzt.IronPDF verwendet klammergeschlossene Platzhalter innerhalb eines TextHeaderFooter / HtmlHeaderFooter:
// pdforge: Chromium template HTML inside pdfParams.footerTemplate
// "<div>Page <span class=\"pageNumber\"></span> of <span class=\"totalPages\"></span></div>"
//IronPDF placeholders
"Page {page} of {total-pages}" // Note: hyphen in total-pagesNach der Migration zu IronPDF erhalten Sie Funktionen, die pdforge nicht bieten kann:
var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");Dim pdf1 = PdfDocument.FromFile("document1.pdf")
Dim pdf2 = PdfDocument.FromFile("document2.pdf")
Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")var pdf = PdfDocument.FromFile("document.pdf");
string allText = pdf.ExtractAllText();Dim pdf = PdfDocument.FromFile("document.pdf")
Dim allText As String = pdf.ExtractAllText()pdf.ApplyWatermark("<h2 style='color:red;'>CONFIDENTIAL</h2>");pdf.ApplyWatermark("<h2 style='color:red;'>CONFIDENTIAL</h2>")pdf.SecuritySettings.UserPassword = "userpassword";
pdf.SecuritySettings.OwnerPassword = "ownerpassword";pdf.SecuritySettings.UserPassword = "userpassword"
pdf.SecuritySettings.OwnerPassword = "ownerpassword"| Feature | pdforge | IronPDF |
|---|---|---|
| HTML zu PDF | ✓ | ✓ |
| URL zu PDF | ✓ | ✓ |
| Seite Einstellungen | ✓ | ✓ |
| Offline-fähig | ✗ | ✓ |
| Lokale Verarbeitung | ✗ | ✓ |
| PDFs zusammenführen | ✗ | ✓ |
| PDFs teilen | ✗ | ✓ |
| Text extrahieren | ✗ | ✓ |
| Wasserzeichen | ✗ | ✓ |
| Formular ausfüllen | ✗ | ✓ |
| Digitale Signaturen | ✗ | ✓ |
| Passwortschutz | ✗ | ✓ |
| Keine Preisbeschränkung | ✗ | ✓ |
| Einmallizenz | ✗ | ✓ |
api.pdforge.com, api.pdfnoodle.com)pdfParams JSON-Konfiguration (Seitenformat, Ausrichtung, Ränder)<span class="pageNumber">, <span class="totalPages">), um sie in IronPDF-Platzhalter ({page}, {total-pages}) zu konvertierenIronPdf NuGet-Paket: dotnet add package IronPdfSystem.Net.Http / System.Text.Json Importe, die nur für pdforge-Aufrufe verwendet werdenusing IronPdf; und using IronPdf.Rendering; für Papierformat- und Ausrichtungs-Enums hinzuHttpClient mit ChromePdfRendererPOST /v1/html-to-pdf/sync mit RenderHtmlAsPdf()RenderUrlAsPdf()GetByteArrayAsync(signedUrl) + File.WriteAllBytes() mit pdf.SaveAs()pdfParams.format zu RenderingOptions.PaperSizepdfParams.landscape zu RenderingOptions.PaperOrientationPdfPaperSize.A4 / PdfPaperOrientation.Landscape EnumsTextHeaderFooter / HtmlHeaderFooterBearer Token pro Anfrage durch ein einmaliges IronPdf.License.LicenseKey beim Start
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.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
