MIGRATION GUIDES

How to Migrate from pdforge to IronPDF in C#

Updated:May 18, 2026

Why Migrate from pdforge to IronPDF

Understanding pdforge

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.

The Cloud API Dependency Problem

pdforge processes all documents on external cloud servers. This architecture creates significant concerns for production applications:

External Server Processing: Every PDF you generate requires sending your HTML/data to pdforge's servers—your documents leave your infrastructure.
Privacy & Compliance Risks: Sensitive data travels over the internet to third-party servers. When using pdforge, developers need to accommodate security concerns related to data being sent to an external API. If the PDF content includes sensitive information, this could be a critical consideration.
Ongoing Subscription Costs: Monthly fees accumulate indefinitely with no asset ownership. pdforge's SaaS model introduces continuous operational expenditure which can accumulate over time.
Internet Dependency: No PDF generation when network is unavailable.
Rate Limits: API usage caps can throttle high-volume applications.
Network Latency: Round-trip time adds seconds to every PDF generation.

pdforge vs IronPDF Comparison

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.

Before You Start

Prerequisites

.NET Environment: .NET Framework 4.6.2+ or .NET Core 3.1+ / .NET 5/6/7/8/9+
NuGet Access: Ability to install NuGet packages
IronPDF License: Obtain your license key from ironpdf.com

NuGet Package Changes

# 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

# 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

SHELL

License Configuration

// 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"

$vbLabelText $csharpLabel

Identify pdforge Usage

# 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" .

# 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" .

SHELL

Complete API Reference

Namespace Changes

// 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;

// 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

$vbLabelText $csharpLabel

Core Concept Mappings

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`

Operation Mappings

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`

Configuration Mappings

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}" }`

New Features Not Available in pdforge

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

Code Migration Examples

Example 1: HTML String to PDF Conversion

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);
    }
}

// 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 Module

$vbLabelText $csharpLabel

After (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");
    }
}

// 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 Class

$vbLabelText $csharpLabel

The 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.

Example 2: URL to PDF Conversion

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);
    }
}

// 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 Module

$vbLabelText $csharpLabel

After (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");
    }
}

// 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 Class

$vbLabelText $csharpLabel

pdforge 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.

Example 3: HTML File to PDF with Custom Settings

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);
    }
}

// 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 Module

$vbLabelText $csharpLabel

After (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");
    }
}

// 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 Class

$vbLabelText $csharpLabel

This 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.

Critical Migration Notes

Return Type Change

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 needed

// 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 needed

Imports 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

$vbLabelText $csharpLabel

Generator Change

// 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 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

$vbLabelText $csharpLabel

Operation Changes

// 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 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)

$vbLabelText $csharpLabel

Save Method Change

// 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
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")

$vbLabelText $csharpLabel

Configuration Location Change

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
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.Landscape

$vbLabelText $csharpLabel

Header/Footer Placeholder Syntax

pdforge 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-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-pages

$vbLabelText $csharpLabel

New Capabilities After Migration

After migrating to IronPDF, you gain capabilities that pdforge cannot provide:

PDF Merging

var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");

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")

$vbLabelText $csharpLabel

Text Extraction

var pdf = PdfDocument.FromFile("document.pdf");
string allText = pdf.ExtractAllText();

var pdf = PdfDocument.FromFile("document.pdf");
string allText = pdf.ExtractAllText();

Dim pdf = PdfDocument.FromFile("document.pdf")
Dim allText As String = pdf.ExtractAllText()

$vbLabelText $csharpLabel

Watermarks

pdf.ApplyWatermark("<h2 style='color:red;'>CONFIDENTIAL</h2>");

pdf.ApplyWatermark("<h2 style='color:red;'>CONFIDENTIAL</h2>");

pdf.ApplyWatermark("<h2 style='color:red;'>CONFIDENTIAL</h2>")

$vbLabelText $csharpLabel

Password Protection

pdf.SecuritySettings.UserPassword = "userpassword";
pdf.SecuritySettings.OwnerPassword = "ownerpassword";

pdf.SecuritySettings.UserPassword = "userpassword";
pdf.SecuritySettings.OwnerPassword = "ownerpassword";

pdf.SecuritySettings.UserPassword = "userpassword"
pdf.SecuritySettings.OwnerPassword = "ownerpassword"

$vbLabelText $csharpLabel

Feature Comparison Summary

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	✗	✓

Migration Checklist

Pre-Migration

Inventory all pdforge / pdf noodle endpoint calls in codebase (api.pdforge.com, api.pdfnoodle.com)
Document current pdfParams JSON configuration used (page size, orientation, margins)
Identify Chromium-style header/footer templates (<span class="pageNumber">, <span class="totalPages">) to convert to IronPDF placeholders ({page}, {total-pages})
Plan IronPDF license key storage (environment variables recommended)
Test with IronPDF trial license first

Package Changes

pdforge has no .NET SDK on NuGet — there is no competitor package to remove
Install IronPdf NuGet package: dotnet add package IronPdf

Code Changes

Remove System.Net.Http / System.Text.Json imports used only for pdforge calls
Add using IronPdf; and using IronPdf.Rendering; for paper size and orientation enums
Replace authenticated HttpClient with ChromePdfRenderer
Replace POST /v1/html-to-pdf/sync with RenderHtmlAsPdf()
Replace fetch-URL-then-POST pattern with RenderUrlAsPdf()
Replace the two-step GetByteArrayAsync(signedUrl) + File.WriteAllBytes() with pdf.SaveAs()
Move pdfParams.format to RenderingOptions.PaperSize
Move pdfParams.landscape to RenderingOptions.PaperOrientation
Use PdfPaperSize.A4 / PdfPaperOrientation.Landscape enums
Convert Chromium templates to IronPDF placeholders inside TextHeaderFooter / HtmlHeaderFooter
Replace per-request Bearer token with one-time IronPdf.License.LicenseKey at startup

Post-Migration

Test PDF output quality matches expectations
Verify offline operation works
Remove API credentials from configuration
Add new capabilities (merging, watermarks, security) as needed

Please notepdforge and pdf noodle are trademarks of their respective owner. This site is not affiliated with, endorsed by, or sponsored by the owner of pdforge / pdf noodle. All product names, logos, and brands are property of their respective owners. Comparisons are for informational purposes only and reflect publicly available information at the time of writing.

Curtis Chau

Chat with engineering team now

Technical Writer

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.

...

Updated May 18, 2026

How to Migrate from ZetPDF to IronPDF in C#

Master the migration from ZetPDF to IronPDF with this complete C# guide. Switch from a coordinate-based library to a modern HTML-to-PDF solution. Includes code examples for HTML conversion, merging PDFs, and removing PDFSharp dependencies.

Updated May 18, 2026

How to Migrate from Scryber.Core to IronPDF in C#

Master the migration from Scryber.Core to IronPDF with this complete C# guide. Switch from custom XML/HTML parsing to a modern Chromium renderer. Includes code examples for HTML conversion, URL rendering, and replacing proprietary bindings.

Updated May 18, 2026

How to Migrate from XFINIUM.PDF to IronPDF in C#

Master the migration from XFINIUM.PDF to IronPDF with this complete C# guide. Switch from manual coordinate-based positioning to declarative HTML/CSS rendering. Includes code examples for replacing graphics primitives and automatic layout.

How to Migrate from PdfPig to IronPDF in C#

How to Migrate from PdfiumViewer to...

Start Free 30 Day Trial

How to Migrate from pdforge to IronPDF in C#

Why Migrate from pdforge to IronPDF

Understanding pdforge

The Cloud API Dependency Problem

pdforge vs IronPDF Comparison

Before You Start

Prerequisites

NuGet Package Changes

License Configuration

Identify pdforge Usage

Complete API Reference

Namespace Changes

Core Concept Mappings

Operation Mappings

Configuration Mappings

New Features Not Available in pdforge

Code Migration Examples

Example 1: HTML String to PDF Conversion

Example 2: URL to PDF Conversion

Example 3: HTML File to PDF with Custom Settings

Critical Migration Notes

Return Type Change

Generator Change

Operation Changes

Save Method Change

Configuration Location Change

Header/Footer Placeholder Syntax

New Capabilities After Migration

PDF Merging

Text Extraction

Watermarks

Password Protection

Feature Comparison Summary

Migration Checklist

Pre-Migration

Package Changes

Code Changes

Post-Migration

Related Articles

How to Migrate from ZetPDF to IronPDF in C#

How to Migrate from Scryber.Core to IronPDF in C#

How to Migrate from XFINIUM.PDF to IronPDF in C#

Next step: Start free 30-day Trial

Thank You

Next step: Start free 30-day Trial

Want to deploy IronSuite to a live project for FREE?

What’s included?

Trusted by Millions of Engineers Worldwide

Iron Support Team