pdforge (rebranded to "pdf noodle" in 2026 - pdfnoodle.com; the api.pdforge.com hostname continues to work via 301 redirects through end of 2026) is a cloud-based, template-driven PDF generation API, offering a straightforward way to produce PDF files by integrating with your application through HTTP calls. There is no official .NET SDK on NuGet - integration is done with HttpClient against the documented REST endpoints. By offloading the task of PDF creation to an external API, developers can simplify the development process. However, pdforge presents drawbacks such as external dependencies, limited customization options, and ongoing subscription costs that developers should be aware of.
pdforge processes all documents on external cloud servers. This architecture creates significant concerns for production applications:
| Feature | pdforge | IronPDF |
|---|---|---|
| Deployment Type | Cloud-based API | Local library |
| Dependencies | Requires internet and API authentication | No external dependencies |
| Customization | Limited control over PDF generation | Full control over customization |
| Cost Structure | Ongoing subscription | One-time purchase option |
| Security | Potential concerns with data sent over the web | Keeps data processing entirely within the local environment |
| Setup Complexity | Easier initial setup due to external handling | Requires more initial setup and configuration |
IronPDF differentiates itself by providing a fully local library, granting developers complete control over the PDF creation process. This is particularly advantageous for applications where internal handling of files is preferred, or where external API calls introduce security concerns. IronPDF processes everything locally, minimizing such risks.
For teams planning .NET 10 and C# 14 adoption on current .NET versions, IronPDF provides a local processing foundation that eliminates cloud dependency while adding comprehensive PDF manipulation capabilities.
# 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 |
Response: JSON envelope with signedUrl | PdfDocument |
Return: byte[] (after fetching signedUrl) | pdf.BinaryData |
| pdforge | IronPDF |
|---|---|
POST /v1/html-to-pdf/sync with { html } | renderer.RenderHtmlAsPdf(html) |
| Fetch URL, then POST its HTML (no dedicated URL endpoint) | renderer.RenderUrlAsPdf(url) |
Download signedUrl then 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 with <span class="pageNumber"> / <span class="totalPages"> | TextFooter = new TextHeaderFooter { CenterText = "Page {page} of {total-pages}" } |
| IronPDF Feature | Description |
|---|---|
PdfDocument.Merge() | Combine multiple PDFs |
pdf.ExtractAllText() | Extract text from PDFs |
pdf.ApplyWatermark() | Add watermarks |
pdf.SecuritySettings | Password protection |
pdf.Form | Form filling |
pdf.SignWithDigitalSignature() | Digital signatures |
Before (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 ModuleAfter (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 ClassThe fundamental difference here is the processing model and return type. pdforge requires an authenticated HttpClient POST to https://api.pdfnoodle.com/v1/html-to-pdf/sync, which returns a JSON envelope containing a signed S3 URL - you then fetch the PDF bytes from that URL and write them with File.WriteAllBytes().
IronPDF uses ChromePdfRenderer with RenderHtmlAsPdf() which returns a PdfDocument object. This object can be saved directly with SaveAs(), or you can access pdf.BinaryData if you need the raw bytes. The PdfDocument also allows manipulation (add watermarks, merge with other PDFs, add security) before saving. See the HTML to PDF documentation for comprehensive examples.
Before (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 ModuleAfter (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 has no dedicated URL-to-PDF endpoint - you fetch the page yourself, then post its HTML to the sync endpoint and download the result from the returned signed URL. IronPDF uses RenderUrlAsPdf() on ChromePdfRenderer, returning a PdfDocument with the built-in SaveAs() method.
The key advantage with IronPDF is that the URL is fetched and rendered locally using a Chromium engine - no data is sent to external servers. IronPDF, being a local library, may offer better performance as there is no round-trip time involved in web requests. Learn more about URL to PDF conversion.
Before (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 ModuleAfter (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 ClassThis example shows the configuration pattern difference. pdforge passes options as JSON fields inside a pdfParams object on the POST body (format = "A4", landscape = true), following Chromium/Puppeteer naming conventions.
IronPDF uses the RenderingOptions property with strongly-typed enums: renderer.RenderingOptions.PaperSize = PdfPaperSize.A4 and renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape. This provides IntelliSense support and compile-time type safety. Note that IronPDF requires importing IronPdf.Rendering namespace for the paper size and orientation enums. See the tutorials for more configuration examples.
pdforge returns a JSON envelope with a signed URL; IronPDF returns PdfDocument:
// 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 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 passes options as JSON fields on pdfParams; IronPDF uses 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 inherits Chromium's header/footer template format - HTML fragments containing <span class="..."></span> elements that the engine substitutes at render time. IronPDF uses bracketed placeholders inside a 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-pages' 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-pagesAfter migrating to IronPDF, you gain capabilities that pdforge cannot provide:
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 to PDF | ✓ | ✓ |
| URL to PDF | ✓ | ✓ |
| Page Settings | ✓ | ✓ |
| Offline Capable | ✗ | ✓ |
| Local Processing | ✗ | ✓ |
| Merge PDFs | ✗ | ✓ |
| Split PDFs | ✗ | ✓ |
| Extract Text | ✗ | ✓ |
| Watermarks | ✗ | ✓ |
| Form Filling | ✗ | ✓ |
| Digital Signatures | ✗ | ✓ |
| Password Protection | ✗ | ✓ |
| No Rate Limits | ✗ | ✓ |
| One-Time License | ✗ | ✓ |
api.pdforge.com, api.pdfnoodle.com)pdfParams JSON configuration used (page size, orientation, margins)<span class="pageNumber">, <span class="totalPages">) to convert to IronPDF placeholders ({page}, {total-pages})IronPdf NuGet package: dotnet add package IronPdfSystem.Net.Http / System.Text.Json imports used only for pdforge callsusing IronPdf; and using IronPdf.Rendering; for paper size and orientation enumsHttpClient with ChromePdfRendererPOST /v1/html-to-pdf/sync with RenderHtmlAsPdf()RenderUrlAsPdf()GetByteArrayAsync(signedUrl) + File.WriteAllBytes() with pdf.SaveAs()pdfParams.format to RenderingOptions.PaperSizepdfParams.landscape to RenderingOptions.PaperOrientationPdfPaperSize.A4 / PdfPaperOrientation.Landscape enumsTextHeaderFooter / HtmlHeaderFooterBearer token with one-time IronPdf.License.LicenseKey at startup
Curtis Chau holds a Bachelor’s degree in Computer Science (Carleton University) and specializes in front-end development with expertise in Node.js, TypeScript, JavaScript, and React. Passionate about crafting intuitive and aesthetically pleasing user interfaces, Curtis enjoys working with modern frameworks and creating well-structured, visually appealing manuals.
IronPDF is a part of IRONSUITE
10 .NET API products for your office documents
When you need your PDF to look like HTML, fast.
