MIGRATION GUIDES

How to Migrate from ZetPDF to IronPDF in C#

Updated:May 18, 2026

ZetPDF (zetpdf.com) is a commercially licensed .NET PDF SDK whose API surface closely resembles PDFsharp — to the point that the PDFsharp community has questioned whether it is a closed fork. The vendor markets it as a proprietary, 100% managed-code engine. ZetPDF is not distributed via NuGet — installation is a ZIP download from https://zetpdf.com/download/ — and the project shows no public release activity since 2021. Pricing is perpetual: $299 Single Project / $449 Multi / $599 OEM.

This guide provides a migration path from ZetPDF to IronPDF, with step-by-step instructions, code comparisons, and examples for .NET developers evaluating this transition.

Why Migrate from ZetPDF

ZetPDF's PDFsharp-shaped, coordinate-drawing API carries architectural constraints that limit modern document generation workflows. Common reasons teams consider migration:

Coordinate-Based API: ZetPDF positions every element via exact XGraphics coordinates. Manual positioning creates maintenance overhead as requirements change.

No CSS Support: No styling system — fonts and colors are managed per-element in code.

No JavaScript Rendering: Cannot render dynamic web content or execute JavaScript during PDF generation.

No Native HTML-to-PDF: ZetPDF's documented feature list does not include an HTML-to-PDF or URL-to-PDF converter; rendering is low-level XGraphics drawing only.

No NuGet, Dormant Releases: Distribution is a vendor ZIP from https://zetpdf.com/download/, with no public release activity since 2021.

Manual Page Breaks: Page overflow must be calculated and managed manually rather than via automatic pagination.

Text Measurement Required: Manual calculation for text wrapping adds development overhead.

The Fundamental Problem

ZetPDF and PDFsharp force you to position every element with exact coordinates:

// ZetPDF: Manual positioning nightmare
graphics.DrawString("Name:", font, brush, new XPoint(50, 100));
graphics.DrawString("John Doe", font, brush, new XPoint(100, 100));
graphics.DrawString("Address:", font, brush, new XPoint(50, 120));
graphics.DrawString("123 Main St", font, brush, new XPoint(100, 120));
// ... hundreds of lines for a simple form

// ZetPDF: Manual positioning nightmare
graphics.DrawString("Name:", font, brush, new XPoint(50, 100));
graphics.DrawString("John Doe", font, brush, new XPoint(100, 100));
graphics.DrawString("Address:", font, brush, new XPoint(50, 120));
graphics.DrawString("123 Main St", font, brush, new XPoint(100, 120));
// ... hundreds of lines for a simple form

' ZetPDF: Manual positioning nightmare
graphics.DrawString("Name:", font, brush, New XPoint(50, 100))
graphics.DrawString("John Doe", font, brush, New XPoint(100, 100))
graphics.DrawString("Address:", font, brush, New XPoint(50, 120))
graphics.DrawString("123 Main St", font, brush, New XPoint(100, 120))
' ... hundreds of lines for a simple form

$vbLabelText $csharpLabel

IronPDF uses HTML/CSS—the layout engine handles everything:

// IronPDF: Simple HTML
var html = @"
<p><strong>Name:</strong> John Doe</p>
<p><strong>Address:</strong> 123 Main St</p>";
var pdf = renderer.RenderHtmlAsPdf(html);

// IronPDF: Simple HTML
var html = @"
<p><strong>Name:</strong> John Doe</p>
<p><strong>Address:</strong> 123 Main St</p>";
var pdf = renderer.RenderHtmlAsPdf(html);

' IronPDF: Simple HTML
Dim html As String = "
<p><strong>Name:</strong> John Doe</p>
<p><strong>Address:</strong> 123 Main St</p>"
Dim pdf = renderer.RenderHtmlAsPdf(html)

$vbLabelText $csharpLabel

IronPDF vs ZetPDF: Feature Comparison

Understanding the architectural differences helps technical decision-makers evaluate the migration investment:

Feature	ZetPDF	IronPDF
API style	PDFsharp-shaped `XGraphics` drawing	High-level HTML rendering
HTML-to-PDF Conversion	Not in documented feature list	Yes (Full Chromium)
Commercial License	Yes, Perpetual ($299 / $449 / $599)	Yes
Distribution	ZIP download (no NuGet package)	NuGet (`IronPdf`)
Last Public Activity	No releases listed since 2021	Active, frequent releases
CSS Support	No	Full CSS3
JavaScript	No	Full ES2024
Automatic Layout	No	Yes
Auto Page Breaks	No	Yes
Tables	Manual drawing	HTML `<table>`
Headers/Footers	Manual	HTML/CSS
Watermarks	Manual code	Built-in
Merge PDFs	No first-class helper	Yes
Split PDFs	No first-class helper	Yes
Digital Signatures	No	Yes
PDF/A	No	Yes

Quick Start: ZetPDF to IronPDF Migration

The migration can begin immediately with these foundational steps.

Step 1: Replace the ZetPDF reference with the IronPDF NuGet package

ZetPDF is not on NuGet — it ships as a ZIP from https://zetpdf.com/download/ and is referenced by adding ZetPDF.dll to your project. After migration, you remove that DLL reference and install IronPDF from NuGet:

# Remove the ZetPDF.dll reference from your csproj manually, then:
dotnet add package IronPdf

# Remove the ZetPDF.dll reference from your csproj manually, then:
dotnet add package IronPdf

SHELL

Step 2: Update Namespaces

Replace ZetPDF namespaces with the IronPDF namespace:

// Before (ZetPDF)
using ZetPDF;
using ZetPDF.Drawing;
using ZetPDF.Fonts;

// After (IronPDF)
using IronPdf;

// Before (ZetPDF)
using ZetPDF;
using ZetPDF.Drawing;
using ZetPDF.Fonts;

// After (IronPDF)
using IronPdf;

Imports IronPdf

$vbLabelText $csharpLabel

Step 3: Initialize License

Add license initialization at application startup:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

$vbLabelText $csharpLabel

Code Migration Examples

Converting HTML to PDF

ZetPDF's published feature list does not include a native HTML-to-PDF or URL-to-PDF converter — its documented surface covers PDF view/print, annotations, AES256 encryption, form fields, and text extraction. The pseudo-wrapper below is illustrative of how teams typically stub an HTML-to-PDF entry point on top of ZetPDF; in practice the work falls back to an external HTML renderer or to low-level XGraphics drawing.

ZetPDF Approach (illustrative — no native HTML-to-PDF):

// ZetPDF is NOT on NuGet — install via SDK ZIP from https://zetpdf.com/download/
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        // No native HtmlToPdfConverter exists in ZetPDF — illustrative call only.
        var converter = new HtmlToPdfConverter();
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";
        converter.ConvertHtmlToPdf(htmlContent, "output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}

// ZetPDF is NOT on NuGet — install via SDK ZIP from https://zetpdf.com/download/
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        // No native HtmlToPdfConverter exists in ZetPDF — illustrative call only.
        var converter = new HtmlToPdfConverter();
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";
        converter.ConvertHtmlToPdf(htmlContent, "output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}

Imports ZetPDF
Imports System

Class Program
    Shared Sub Main()
        ' No native HtmlToPdfConverter exists in ZetPDF — illustrative call only.
        Dim converter = New HtmlToPdfConverter()
        Dim htmlContent = "<html><body><h1>Hello World</h1></body></html>"
        converter.ConvertHtmlToPdf(htmlContent, "output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Class

$vbLabelText $csharpLabel

IronPDF Approach:

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

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var renderer = new ChromePdfRenderer();
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}

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

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var renderer = new ChromePdfRenderer();
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}

Imports IronPdf
Imports System

Module Program
    Sub Main()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
        Dim renderer As New ChromePdfRenderer()
        Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
        pdf.SaveAs("output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Module

$vbLabelText $csharpLabel

IronPDF provides ChromePdfRenderer with RenderHtmlAsPdf(), which returns a PdfDocument object — you can save to file, retrieve binary data, or perform additional operations before saving.

For advanced HTML-to-PDF scenarios, see the HTML to PDF conversion guide.

Converting URLs to PDF

ZetPDF also has no native URL-to-PDF converter; HTML/URL rendering is not part of the documented feature list. Practical migration paths usually pair ZetPDF with an external HTML renderer or move to a Chromium-based library like IronPDF.

ZetPDF Approach (illustrative — no native URL-to-PDF):

// ZetPDF is NOT on NuGet — install via SDK ZIP from https://zetpdf.com/download/
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        // No native ConvertUrlToPdf exists in ZetPDF — illustrative call only.
        var converter = new HtmlToPdfConverter();
        var url = "https://www.example.com";
        converter.ConvertUrlToPdf(url, "webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}

// ZetPDF is NOT on NuGet — install via SDK ZIP from https://zetpdf.com/download/
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        // No native ConvertUrlToPdf exists in ZetPDF — illustrative call only.
        var converter = new HtmlToPdfConverter();
        var url = "https://www.example.com";
        converter.ConvertUrlToPdf(url, "webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}

Imports ZetPDF
Imports System

Class Program
    Shared Sub Main()
        ' No native ConvertUrlToPdf exists in ZetPDF — illustrative call only.
        Dim converter As New HtmlToPdfConverter()
        Dim url As String = "https://www.example.com"
        converter.ConvertUrlToPdf(url, "webpage.pdf")
        Console.WriteLine("PDF from URL created successfully")
    End Sub
End Class

$vbLabelText $csharpLabel

IronPDF Approach:

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

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var renderer = new ChromePdfRenderer();
        var url = "https://www.example.com";
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}

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

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var renderer = new ChromePdfRenderer();
        var url = "https://www.example.com";
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}

Imports IronPdf
Imports System

Module Program
    Sub Main()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
        Dim renderer As New ChromePdfRenderer()
        Dim url As String = "https://www.example.com"
        Dim pdf = renderer.RenderUrlAsPdf(url)
        pdf.SaveAs("webpage.pdf")
        Console.WriteLine("PDF from URL created successfully")
    End Sub
End Module

$vbLabelText $csharpLabel

IronPDF's RenderUrlAsPdf() on ChromePdfRenderer leverages a full Chromium rendering engine for web page capture including JavaScript execution and modern CSS.

Explore the URL to PDF documentation for authentication and custom header options.

Merging Multiple PDFs

ZetPDF does not ship a one-line PdfMerger.MergeFiles() helper. Merging follows the same pattern as PDFsharp (which ZetPDF resembles): open each input with PdfReader, then loop pages into an output PdfDocument and Save(). The illustrative wrapper below mirrors the IronPDF surface for comparison; in real ZetPDF code you write the manual loop.

ZetPDF Approach (illustrative — no built-in PdfMerger):

// ZetPDF is NOT on NuGet — install via SDK ZIP from https://zetpdf.com/download/
using ZetPDF;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // ZetPDF has no built-in PdfMerger — illustrative call only.
        var merger = new PdfMerger();
        var files = new List<string> { "document1.pdf", "document2.pdf" };
        merger.MergeFiles(files, "merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}

// ZetPDF is NOT on NuGet — install via SDK ZIP from https://zetpdf.com/download/
using ZetPDF;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // ZetPDF has no built-in PdfMerger — illustrative call only.
        var merger = new PdfMerger();
        var files = new List<string> { "document1.pdf", "document2.pdf" };
        merger.MergeFiles(files, "merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}

Imports ZetPDF
Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        ' ZetPDF has no built-in PdfMerger — illustrative call only.
        Dim merger As New PdfMerger()
        Dim files As New List(Of String) From {"document1.pdf", "document2.pdf"}
        merger.MergeFiles(files, "merged.pdf")
        Console.WriteLine("PDFs merged successfully")
    End Sub
End Module

$vbLabelText $csharpLabel

IronPDF Approach:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var pdfs = new List<PdfDocument>
        {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf")
        };
        var merged = PdfDocument.Merge(pdfs);
        merged.SaveAs("merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var pdfs = new List<PdfDocument>
        {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf")
        };
        var merged = PdfDocument.Merge(pdfs);
        merged.SaveAs("merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}

Imports IronPdf
Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
        Dim pdfs As New List(Of PdfDocument) From {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf")
        }
        Dim merged As PdfDocument = PdfDocument.Merge(pdfs)
        merged.SaveAs("merged.pdf")
        Console.WriteLine("PDFs merged successfully")
    End Sub
End Module

$vbLabelText $csharpLabel

IronPDF loads documents as PdfDocument objects using PdfDocument.FromFile(), then merges them with the static PdfDocument.Merge() method. The object-oriented approach allows additional operations on the merged document before saving.

Explore the PDF merging documentation for additional merge options.

Coordinate-Based Drawing vs HTML

For developers with existing ZetPDF code using coordinate-based graphics, the migration path involves converting drawing commands to HTML/CSS.

ZetPDF Coordinate-Based Approach:

using ZetPDF;
using ZetPDF.Drawing;

var document = new PdfDocument();
var page = document.AddPage();
page.Width = XUnit.FromMillimeter(210);
page.Height = XUnit.FromMillimeter(297);

var graphics = XGraphics.FromPdfPage(page);
var titleFont = new XFont("Arial", 24, XFontStyle.Bold);
var bodyFont = new XFont("Arial", 12);

graphics.DrawString("Company Report", titleFont, XBrushes.Navy,
    new XPoint(50, 50));
graphics.DrawString("This is the introduction paragraph.", bodyFont, XBrushes.Black,
    new XPoint(50, 80));
graphics.DrawString("Generated: " + DateTime.Now.ToString(), bodyFont, XBrushes.Gray,
    new XPoint(50, 100));

document.Save("report.pdf");

using ZetPDF;
using ZetPDF.Drawing;

var document = new PdfDocument();
var page = document.AddPage();
page.Width = XUnit.FromMillimeter(210);
page.Height = XUnit.FromMillimeter(297);

var graphics = XGraphics.FromPdfPage(page);
var titleFont = new XFont("Arial", 24, XFontStyle.Bold);
var bodyFont = new XFont("Arial", 12);

graphics.DrawString("Company Report", titleFont, XBrushes.Navy,
    new XPoint(50, 50));
graphics.DrawString("This is the introduction paragraph.", bodyFont, XBrushes.Black,
    new XPoint(50, 80));
graphics.DrawString("Generated: " + DateTime.Now.ToString(), bodyFont, XBrushes.Gray,
    new XPoint(50, 100));

document.Save("report.pdf");

Imports ZetPDF
Imports ZetPDF.Drawing

Dim document As New PdfDocument()
Dim page = document.AddPage()
page.Width = XUnit.FromMillimeter(210)
page.Height = XUnit.FromMillimeter(297)

Dim graphics = XGraphics.FromPdfPage(page)
Dim titleFont As New XFont("Arial", 24, XFontStyle.Bold)
Dim bodyFont As New XFont("Arial", 12)

graphics.DrawString("Company Report", titleFont, XBrushes.Navy, New XPoint(50, 50))
graphics.DrawString("This is the introduction paragraph.", bodyFont, XBrushes.Black, New XPoint(50, 80))
graphics.DrawString("Generated: " & DateTime.Now.ToString(), bodyFont, XBrushes.Gray, New XPoint(50, 100))

document.Save("report.pdf")

$vbLabelText $csharpLabel

IronPDF HTML Approach:

using IronPdf;

var html = $@"
<html>
<head>
    <style>
        body {{ font-family: Arial, sans-serif; padding: 50px; }}
        h1 {{ color: navy; }}
        .date {{ color: gray; }}
    </style>
</head>
<body>
    <h1>Company Report</h1>
    <p>This is the introduction paragraph.</p>
    <p class='date'>Generated: {DateTime.Now}</p>
</body>
</html>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("report.pdf");

using IronPdf;

var html = $@"
<html>
<head>
    <style>
        body {{ font-family: Arial, sans-serif; padding: 50px; }}
        h1 {{ color: navy; }}
        .date {{ color: gray; }}
    </style>
</head>
<body>
    <h1>Company Report</h1>
    <p>This is the introduction paragraph.</p>
    <p class='date'>Generated: {DateTime.Now}</p>
</body>
</html>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("report.pdf");

Imports IronPdf

Dim html As String = $"
<html>
<head>
    <style>
        body {{ font-family: Arial, sans-serif; padding: 50px; }}
        h1 {{ color: navy; }}
        .date {{ color: gray; }}
    </style>
</head>
<body>
    <h1>Company Report</h1>
    <p>This is the introduction paragraph.</p>
    <p class='date'>Generated: {DateTime.Now}</p>
</body>
</html>"

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("report.pdf")

$vbLabelText $csharpLabel

The ZetPDF approach requires creating font objects, calculating exact pixel positions, and manually managing the graphics context. The IronPDF approach uses standard HTML and CSS that web developers already know—fonts, colors, and layout are handled through familiar CSS properties.

ZetPDF API to IronPDF Mapping Reference

This mapping accelerates migration by showing direct API equivalents:

ZetPDF	IronPDF
`new PdfDocument()`	`new ChromePdfRenderer()`
`document.AddPage()`	Automatic
`XGraphics.FromPdfPage(page)`	N/A (HTML/CSS instead)
`graphics.DrawString()`	HTML text elements
`graphics.DrawImage()`	`<img>` tag
`graphics.DrawLine()`	CSS borders / `<hr>`
`graphics.DrawRectangle()`	CSS `border` + `div`
`new XFont()`	CSS `font-family`
`XBrushes.Black`	CSS `color`
`document.Save()`	`pdf.SaveAs()`
`PdfReader.Open()`	`PdfDocument.FromFile()`
(no native HTML-to-PDF)	`ChromePdfRenderer.RenderHtmlAsPdf()`
(no native URL-to-PDF)	`ChromePdfRenderer.RenderUrlAsPdf()`
(manual page-copy loop)	`PdfDocument.Merge()`

Common Migration Issues and Solutions

Issue 1: Coordinate-Based Layout

ZetPDF: Everything requires exact X,Y coordinates with manual positioning.

Solution: Use HTML/CSS flow layout. For absolute positioning when needed, use CSS:

.positioned-element {
    position: absolute;
    top: 100px;
    left: 50px;
}

Issue 2: Font Object Management

ZetPDF: Create XFont objects for each font variation.

Solution: Use CSS font-family—fonts are handled automatically:

<style>
    body { font-family: Arial, sans-serif; }
    h1 { font-family: 'Times New Roman', serif; font-size: 24px; font-weight: bold; }
</style>

<style>
    body { font-family: Arial, sans-serif; }
    h1 { font-family: 'Times New Roman', serif; font-size: 24px; font-weight: bold; }
</style>

HTML

Issue 3: Color Handling

ZetPDF: Use XBrushes and color objects.

Solution: Use standard CSS colors:

.header { color: navy; background-color: #f5f5f5; }
.warning { color: rgb(255, 0, 0); }

Issue 4: Manual Page Breaks

ZetPDF: Track Y position and create new pages manually when content overflows.

Solution: IronPDF handles automatic page breaks. For explicit control, use CSS:

.section { page-break-after: always; }
.keep-together { page-break-inside: avoid; }

Issue 5: Table Creation

ZetPDF: Requires manual drawing of rectangles, lines, and text positioning.

Solution: Use standard HTML tables with CSS styling:

<table style="border-collapse: collapse; width: 100%;">
    <tr>
        <th style="border: 1px solid black; padding: 8px;">Header</th>
    </tr>
    <tr>
        <td style="border: 1px solid black; padding: 8px;">Data</td>
    </tr>
</table>

<table style="border-collapse: collapse; width: 100%;">
    <tr>
        <th style="border: 1px solid black; padding: 8px;">Header</th>
    </tr>
    <tr>
        <td style="border: 1px solid black; padding: 8px;">Data</td>
    </tr>
</table>

HTML

ZetPDF Migration Checklist

Pre-Migration Tasks

Audit your codebase to identify all ZetPDF usage:

grep -r "using ZetPDF" --include="*.cs" .
grep -r "XGraphics\|XFont\|XBrushes\|PdfReader" --include="*.cs" .

grep -r "using ZetPDF" --include="*.cs" .
grep -r "XGraphics\|XFont\|XBrushes\|PdfReader" --include="*.cs" .

SHELL

Document coordinate-based drawing code that needs conversion to HTML. Note font and color usage patterns. Map layout structures to HTML equivalents.

Code Update Tasks

Remove the manual ZetPDF.dll reference from your .csproj
Install IronPDF NuGet package (dotnet add package IronPdf)
Update namespace imports from ZetPDF to IronPdf
Replace any in-house HTML-to-PDF wrappers around ZetPDF with ChromePdfRenderer.RenderHtmlAsPdf()
Replace any URL-to-PDF wrappers with ChromePdfRenderer.RenderUrlAsPdf()
Replace manual page-copy merge loops with PdfDocument.Merge()
Convert DrawString() calls to HTML text elements
Convert XFont to CSS font-family
Replace XBrushes with CSS colors
Add IronPDF license initialization at startup (IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";)

Post-Migration Testing

After migration, verify these aspects:

Compare visual output to ensure appearance matches or improves
Verify fonts render as expected with CSS styling
Test page breaks occur correctly with automatic pagination
Verify images are positioned and displayed correctly
Test PDF merging operations produce correct output
Confirm all existing functionality works with the new implementation

Key Benefits of Migrating to IronPDF

Moving from ZetPDF to IronPDF provides several critical advantages:

Modern Chromium Rendering Engine: IronPDF uses Chromium for HTML-to-PDF conversion, ensuring full CSS3 and ES2024 JavaScript support. Modern frameworks and responsive designs render correctly.

HTML-Based Content Creation: Web developers can leverage existing HTML and CSS skills. No need to learn coordinate-based drawing APIs or manage font objects.

Automatic Layout and Pagination: Text wrapping, page breaks, and flow layout happen automatically. No manual calculation of element positions.

Simplified API: Single-method calls for common operations. PdfDocument.Merge() replaces complex file path handling patterns.

Active Development: IronPDF's regular release cadence keeps the library current with modern .NET versions, in contrast to ZetPDF's lack of public release activity since 2021.

Comprehensive Feature Set: Built-in watermarking, digital signatures, PDF/A compliance, and advanced PDF manipulation features that are absent from ZetPDF's documented surface.

Please notePDFSharp and ZetPDF are registered trademarks of their respective owners. This site is not affiliated with, endorsed by, or sponsored by ZetPDF or empira Software GmbH. 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 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.

Updated May 18, 2026

How to Migrate from PdfPig to IronPDF in C#

Master the migration from PdfPig to IronPDF with this complete C# guide. Switch from a reading-only library to a comprehensive PDF solution. Includes code examples for text extraction, HTML conversion, and metadata access.

How to Migrate from XFINIUM.PDF to ...

Customer Highlight:

Developer Spotlight:

Webinars:

Start Free 30 Day Trial

How to Migrate from ZetPDF to IronPDF in C#

Why Migrate from ZetPDF

The Fundamental Problem

IronPDF vs ZetPDF: Feature Comparison

Quick Start: ZetPDF to IronPDF Migration

Step 1: Replace the ZetPDF reference with the IronPDF NuGet package

Step 2: Update Namespaces

Step 3: Initialize License

Code Migration Examples

Converting HTML to PDF

Converting URLs to PDF

Merging Multiple PDFs

Coordinate-Based Drawing vs HTML

ZetPDF API to IronPDF Mapping Reference

Common Migration Issues and Solutions

Issue 1: Coordinate-Based Layout

Issue 2: Font Object Management

Issue 3: Color Handling

Issue 4: Manual Page Breaks

Issue 5: Table Creation

ZetPDF Migration Checklist

Pre-Migration Tasks

Code Update Tasks

Post-Migration Testing

Key Benefits of Migrating to IronPDF

Iron Support Team

Start Free 30 Day Trial

How to Migrate from ZetPDF to IronPDF in C#

Why Migrate from ZetPDF

The Fundamental Problem

IronPDF vs ZetPDF: Feature Comparison

Quick Start: ZetPDF to IronPDF Migration

Step 1: Replace the ZetPDF reference with the IronPDF NuGet package

Step 2: Update Namespaces

Step 3: Initialize License

Code Migration Examples

Converting HTML to PDF

Converting URLs to PDF

Merging Multiple PDFs

Coordinate-Based Drawing vs HTML

ZetPDF API to IronPDF Mapping Reference

Common Migration Issues and Solutions

Issue 1: Coordinate-Based Layout

Issue 2: Font Object Management

Issue 3: Color Handling

Issue 4: Manual Page Breaks

Issue 5: Table Creation

ZetPDF Migration Checklist

Pre-Migration Tasks

Code Update Tasks

Post-Migration Testing

Key Benefits of Migrating to IronPDF

Related Articles

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

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

How to Migrate from PdfPig 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