HiQPdf vs IronPDF: Technical Comparison Guide
When .NET developers assess HTML-to-PDF solutions, HiQPdf stands out as a commercial library utilizing WebKit-based rendering. Although HiQPdf supports HTML5/CSS3, its older WebKit engine may struggle with modern JavaScript frameworks, and the free version is limited to 3 pages with noticeable watermarks. In contrast, IronPDF uses a modern Chromium-based rendering engine, offering full JavaScript support and a unified package across all .NET platforms.
This comparison evaluates both libraries across relevant technical aspects to assist professional developers and architects in making informed decisions for their .NET PDF needs.
Overview of HiQPdf
HiQPdf is a commercial HTML-to-PDF library that employs a WebKit-based rendering engine. The library's main converter class, HtmlToPdf, includes methods like ConvertHtmlToMemory() and ConvertUrlToMemory() that return raw byte[] data. Configuration is managed through property chains on the Document object, such as Document.Header, Document.Footer, and Document.PageSize.
The free version of HiQPdf imposes a significant limitation—a maximum of 3 pages on PDF outputs with an intrusive watermark, making thorough testing on larger documents challenging during evaluation. The library offers multiple NuGet package variants for different platforms (HiQPdf, HiQPdf.Free, HiQPdf.NetCore, HiQPdf.NetCore.x64, HiQPdf.Client), and documentation does not clearly specify .NET Core or .NET 5+ support.
For headers and footers, HiQPdf uses HtmlToPdfVariableElement objects added to Document.Header and Document.Footer collections. Page number placeholders use the syntax {CrtPage} for the current page and {PageCount} for total pages.
Overview of IronPDF
IronPDF is a .NET PDF library that utilizes a modern Chromium rendering engine, providing full support for HTML5, CSS3, and JavaScript frameworks including React, Angular, and Vue. The library's primary rendering class, ChromePdfRenderer, includes methods like RenderHtmlAsPdf() and RenderUrlAsPdf() that return PdfDocument objects.
IronPDF offers a single unified NuGet package for all platforms with documented compatibility for .NET 6, 7, 8, 9, and 10. Configuration uses RenderingOptions properties directly on the renderer. Headers and footers can use TextHeaderFooter with properties like CenterText and FontSize. Page number placeholders use {page} and {total-pages} syntax.
Rendering Engine and Compatibility Comparison
The fundamental difference between these libraries lies in their rendering engines and platform support.
| Aspect | HiQPdf | IronPDF |
|---|---|---|
| Rendering Engine | WebKit-based (older) | Modern Chromium |
| Free Tier | 3-page limit + watermark | 30-day full trial |
| Modern JS Support | Limited | Full (React, Angular, Vue) |
| .NET Core/5+ Support | Multiple packages needed | Single unified package |
| API Design | Complex property chains | Clean fluent API |
| CSS3 Support | Partial | Supported |
| Documentation | Fragmented | Thorough |
| NuGet Package | Multiple variants | Single package |
HiQPdf's WebKit-based engine is older technology that can have challenges with modern JavaScript frameworks and complex HTML structures. IronPDF's Chromium engine provides the same rendering quality as Google Chrome, ensuring accurate conversion of modern web content.
Code Comparison: Common PDF Operations
HTML and URL to PDF Conversion
The most fundamental operations demonstrate the API design differences.
HiQPdf:
// NuGet: Install-Package HiQPdf
using HiQPdf;
using System;
class Program
{
static void Main()
{
HtmlToPdf htmlToPdfConverter = new HtmlToPdf();
byte[] pdfBuffer = htmlToPdfConverter.ConvertUrlToMemory("https://example.com");
System.IO.File.WriteAllBytes("output.pdf", pdfBuffer);
// Convert HTML string
string html = "<h1>Hello World</h1><p>This is a PDF document.</p>";
byte[] pdfFromHtml = htmlToPdfConverter.ConvertHtmlToMemory(html, "");
System.IO.File.WriteAllBytes("fromhtml.pdf", pdfFromHtml);
}
}// NuGet: Install-Package HiQPdf
using HiQPdf;
using System;
class Program
{
static void Main()
{
HtmlToPdf htmlToPdfConverter = new HtmlToPdf();
byte[] pdfBuffer = htmlToPdfConverter.ConvertUrlToMemory("https://example.com");
System.IO.File.WriteAllBytes("output.pdf", pdfBuffer);
// Convert HTML string
string html = "<h1>Hello World</h1><p>This is a PDF document.</p>";
byte[] pdfFromHtml = htmlToPdfConverter.ConvertHtmlToMemory(html, "");
System.IO.File.WriteAllBytes("fromhtml.pdf", pdfFromHtml);
}
}IronPDF:
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf("https://example.com");
pdf.SaveAs("output.pdf");
// Convert HTML string
string html = "<h1>Hello World</h1><p>This is a PDF document.</p>";
var pdfFromHtml = renderer.RenderHtmlAsPdf(html);
pdfFromHtml.SaveAs("fromhtml.pdf");
}
}// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf("https://example.com");
pdf.SaveAs("output.pdf");
// Convert HTML string
string html = "<h1>Hello World</h1><p>This is a PDF document.</p>";
var pdfFromHtml = renderer.RenderHtmlAsPdf(html);
pdfFromHtml.SaveAs("fromhtml.pdf");
}
}HiQPdf creates an HtmlToPdf converter, calls ConvertUrlToMemory() or ConvertHtmlToMemory() to get raw byte[] data, then manually writes to disk using File.WriteAllBytes(). The ConvertHtmlToMemory() method requires a second parameter for the base URL (empty string if not needed).
IronPDF creates a ChromePdfRenderer, calls RenderUrlAsPdf() or RenderHtmlAsPdf() to get a PdfDocument object, then saves directly with SaveAs(). The API is more concise with object-oriented document handling.
For advanced HTML rendering options, explore the HTML to PDF conversion guide.
Merging Multiple PDFs
PDF merging demonstrates the different approaches to document manipulation.
HiQPdf:
// NuGet: Install-Package HiQPdf
using HiQPdf;
using System;
class Program
{
static void Main()
{
// Create first PDF
HtmlToPdf converter1 = new HtmlToPdf();
byte[] pdf1 = converter1.ConvertHtmlToMemory("<h1>First Document</h1>", "");
System.IO.File.WriteAllBytes("doc1.pdf", pdf1);
// Create second PDF
HtmlToPdf converter2 = new HtmlToPdf();
byte[] pdf2 = converter2.ConvertHtmlToMemory("<h1>Second Document</h1>", "");
System.IO.File.WriteAllBytes("doc2.pdf", pdf2);
// Merge PDFs
PdfDocument document1 = PdfDocument.FromFile("doc1.pdf");
PdfDocument document2 = PdfDocument.FromFile("doc2.pdf");
document1.AddDocument(document2);
document1.WriteToFile("merged.pdf");
}
}// NuGet: Install-Package HiQPdf
using HiQPdf;
using System;
class Program
{
static void Main()
{
// Create first PDF
HtmlToPdf converter1 = new HtmlToPdf();
byte[] pdf1 = converter1.ConvertHtmlToMemory("<h1>First Document</h1>", "");
System.IO.File.WriteAllBytes("doc1.pdf", pdf1);
// Create second PDF
HtmlToPdf converter2 = new HtmlToPdf();
byte[] pdf2 = converter2.ConvertHtmlToMemory("<h1>Second Document</h1>", "");
System.IO.File.WriteAllBytes("doc2.pdf", pdf2);
// Merge PDFs
PdfDocument document1 = PdfDocument.FromFile("doc1.pdf");
PdfDocument document2 = PdfDocument.FromFile("doc2.pdf");
document1.AddDocument(document2);
document1.WriteToFile("merged.pdf");
}
}IronPDF:
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
// Create first PDF
var pdf1 = renderer.RenderHtmlAsPdf("<h1>First Document</h1>");
pdf1.SaveAs("doc1.pdf");
// Create second PDF
var pdf2 = renderer.RenderHtmlAsPdf("<h1>Second Document</h1>");
pdf2.SaveAs("doc2.pdf");
// Merge PDFs
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");
}
}// NuGet: Install-Package IronPdf
using IronPdf;
using System;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
// Create first PDF
var pdf1 = renderer.RenderHtmlAsPdf("<h1>First Document</h1>");
pdf1.SaveAs("doc1.pdf");
// Create second PDF
var pdf2 = renderer.RenderHtmlAsPdf("<h1>Second Document</h1>");
pdf2.SaveAs("doc2.pdf");
// Merge PDFs
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");
}
}HiQPdf requires saving PDFs to disk first, loading them with PdfDocument.FromFile(), then using AddDocument() to append one to another, and finally WriteToFile() to save the result. This modifies the first document in place.
IronPDF can merge documents directly in memory using the static PdfDocument.Merge() method, which returns a new merged document. This approach is cleaner and doesn't require intermediate file I/O.
Headers and Footers with Page Numbers
Header and footer configuration shows the different approaches to dynamic content.
HiQPdf:
// NuGet: Install-Package HiQPdf
using HiQPdf;
using System;
class Program
{
static void Main()
{
HtmlToPdf htmlToPdfConverter = new HtmlToPdf();
// Add header
htmlToPdfConverter.Document.Header.Height = 50;
HtmlToPdfVariableElement headerHtml = new HtmlToPdfVariableElement("<div style='text-align:center'>Page Header</div>", "");
htmlToPdfConverter.Document.Header.Add(headerHtml);
// Add footer with page number
htmlToPdfConverter.Document.Footer.Height = 50;
HtmlToPdfVariableElement footerHtml = new HtmlToPdfVariableElement("<div style='text-align:center'>Page {CrtPage} of {PageCount}</div>", "");
htmlToPdfConverter.Document.Footer.Add(footerHtml);
byte[] pdfBuffer = htmlToPdfConverter.ConvertHtmlToMemory("<h1>Document with Headers and Footers</h1>", "");
System.IO.File.WriteAllBytes("header-footer.pdf", pdfBuffer);
}
}// NuGet: Install-Package HiQPdf
using HiQPdf;
using System;
class Program
{
static void Main()
{
HtmlToPdf htmlToPdfConverter = new HtmlToPdf();
// Add header
htmlToPdfConverter.Document.Header.Height = 50;
HtmlToPdfVariableElement headerHtml = new HtmlToPdfVariableElement("<div style='text-align:center'>Page Header</div>", "");
htmlToPdfConverter.Document.Header.Add(headerHtml);
// Add footer with page number
htmlToPdfConverter.Document.Footer.Height = 50;
HtmlToPdfVariableElement footerHtml = new HtmlToPdfVariableElement("<div style='text-align:center'>Page {CrtPage} of {PageCount}</div>", "");
htmlToPdfConverter.Document.Footer.Add(footerHtml);
byte[] pdfBuffer = htmlToPdfConverter.ConvertHtmlToMemory("<h1>Document with Headers and Footers</h1>", "");
System.IO.File.WriteAllBytes("header-footer.pdf", pdfBuffer);
}
}IronPDF:
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
// Configure header and footer
renderer.RenderingOptions.TextHeader = new TextHeaderFooter()
{
CenterText = "Page Header",
FontSize = 12
};
renderer.RenderingOptions.TextFooter = new TextHeaderFooter()
{
CenterText = "Page {page} of {total-pages}",
FontSize = 10
};
var pdf = renderer.RenderHtmlAsPdf("<h1>Document with Headers and Footers</h1>");
pdf.SaveAs("header-footer.pdf");
}
}// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
// Configure header and footer
renderer.RenderingOptions.TextHeader = new TextHeaderFooter()
{
CenterText = "Page Header",
FontSize = 12
};
renderer.RenderingOptions.TextFooter = new TextHeaderFooter()
{
CenterText = "Page {page} of {total-pages}",
FontSize = 10
};
var pdf = renderer.RenderHtmlAsPdf("<h1>Document with Headers and Footers</h1>");
pdf.SaveAs("header-footer.pdf");
}
}HiQPdf configures headers and footers through Document.Header and Document.Footer properties, setting Height and adding HtmlToPdfVariableElement objects. Page number placeholders use {CrtPage} for current page and {PageCount} for total pages.
IronPDF uses RenderingOptions.TextHeader and RenderingOptions.TextFooter with TextHeaderFooter objects. Properties like CenterText and FontSize provide direct configuration. Page number placeholders use {page} and {total-pages}.
Learn more about header and footer configuration in the IronPDF tutorials.
API Mapping Reference
For developers evaluating HiQPdf migration or comparing capabilities, this mapping shows equivalent operations:
Main Class Mapping
| HiQPdf Class | IronPDF Class |
|---|---|
HtmlToPdf | ChromePdfRenderer |
PdfDocument | PdfDocument |
PdfPage | pdf.Pages[i] |
PdfDocumentControl | RenderingOptions |
PdfHeader / PdfDocumentHeader | HtmlHeaderFooter |
PdfFooter / PdfDocumentFooter | HtmlHeaderFooter |
HtmlToPdfVariableElement | HtmlHeaderFooter.HtmlFragment |
Conversion Method Mapping
| HiQPdf Method | IronPDF Method |
|---|---|
ConvertHtmlToMemory(html, baseUrl) | RenderHtmlAsPdf(html, baseUrl) |
ConvertUrlToMemory(url) | RenderUrlAsPdf(url) |
ConvertHtmlToFile(html, baseUrl, path) | RenderHtmlAsPdf(html).SaveAs(path) |
ConvertUrlToFile(url, path) | RenderUrlAsPdf(url).SaveAs(path) |
Property Mapping
| HiQPdf Property | IronPDF Property |
|---|---|
BrowserWidth | RenderingOptions.ViewPortWidth |
BrowserHeight | RenderingOptions.ViewPortHeight |
Document.PageSize | RenderingOptions.PaperSize |
Document.PageOrientation | RenderingOptions.PaperOrientation |
Document.Margins.Top | RenderingOptions.MarginTop |
Document.Margins.Bottom | RenderingOptions.MarginBottom |
Document.Margins.Left | RenderingOptions.MarginLeft |
Document.Margins.Right | RenderingOptions.MarginRight |
Document.Header.Height | HtmlHeader.MaxHeight |
Document.Footer.Height | HtmlFooter.MaxHeight |
SerialNumber | IronPdf.License.LicenseKey |
Placeholder Syntax Mapping
Header and footer placeholders differ between the libraries:
| HiQPdf | IronPDF |
|---|---|
{CrtPage} | {page} |
{PageCount} | {total-pages} |
{CrtPageUri} | {url} |
{CrtPageTitle} | {html-title} |
Feature Comparison Summary
| Feature | HiQPdf | IronPDF |
|---|---|---|
| Chromium Rendering | ❌ (WebKit) | ✅ |
| Modern JavaScript (React, Angular, Vue) | ⚠️ Limited | ✅ |
| Full CSS3 Support | ⚠️ Partial | ✅ |
| .NET 6/7/8/9/10 Support | ⚠️ Unclear documentation | ✅ |
| Single NuGet Package | ❌ (Multiple variants) | ✅ |
| Free Full Trial | ❌ (3-page limit + watermark) | ✅ (30-day) |
| HTML to PDF | ✅ | ✅ |
| URL to PDF | ✅ | ✅ |
| PDF Merging | ✅ (AddDocument) | ✅ (Merge) |
| Headers/Footers | ✅ (HtmlToPdfVariableElement) | ✅ (TextHeaderFooter) |
When Teams Consider Moving from HiQPdf to IronPDF
Development teams evaluate transitioning from HiQPdf to IronPDF for several reasons:
Restrictive Free Version: HiQPdf's free version imposes a 3-page limit with intrusive watermarks, making it essentially unusable for production and difficult to evaluate thoroughly. IronPDF provides a 30-day full-featured trial without page limits.
Older WebKit Engine: HiQPdf's WebKit-based rendering engine struggles with modern JavaScript frameworks like React, Angular, and Vue. IronPDF's Chromium engine provides the same rendering quality as Google Chrome, ensuring accurate conversion of complex modern web content.
Unclear .NET Core Support: HiQPdf documentation doesn't explicitly clarify .NET Core or .NET 5+ support, and the library requires separate NuGet packages for different platforms. IronPDF provides a single unified package with documented support for .NET 6, 7, 8, 9, and 10.
Fragmented NuGet Packages: HiQPdf requires different package variants (HiQPdf, HiQPdf.Free, HiQPdf.NetCore, HiQPdf.NetCore.x64, HiQPdf.Client) for different scenarios. IronPDF uses a single package for all platforms.
Complex API Design: HiQPdf requires verbose configuration through property chains like Document.Header.Height and Document.Footer.Add(). IronPDF's fluent API with RenderingOptions properties provides cleaner configuration.
Different Placeholder Syntax: HiQPdf uses {CrtPage} and {PageCount} placeholders, while IronPDF uses {page} and {total-pages}. Migration requires updating all header/footer templates.
Strengths and Considerations
HiQPdf Strengths
- HTML5/CSS3 Support: Provides HTML5 and CSS3 rendering capabilities
- Established Library: Commercial library with existing user base
HiQPdf Considerations
- WebKit Engine: Older rendering technology with limited modern JavaScript support
- 3-Page Limit: Free version significantly restricted
- Fragmented Packages: Multiple NuGet packages for different platforms
- Unclear .NET Support: Documentation doesn't explicitly clarify modern .NET compatibility
- Complex Property Chains: Verbose configuration through nested properties
- Point-Based Units: Uses points (72 per inch) for measurements
IronPDF Strengths
- Chromium Engine: Modern rendering with full JavaScript support
- Unified Package: Single NuGet package for all platforms
- Full Trial: 30-day full-featured trial
- Modern .NET Support: Documented for .NET 6, 7, 8, 9, 10
- Clean API: Fluent
RenderingOptionsconfiguration - Comprehensive Resources: Extensive tutorials and documentation
IronPDF Considerations
- Commercial License: Required for production use
- Millimeter Units: Uses millimeters rather than points for margins
Conclusion
HiQPdf and IronPDF represent different generations of HTML-to-PDF technology in .NET applications. HiQPdf's WebKit-based engine provides basic HTML5/CSS3 support but struggles with modern JavaScript frameworks and offers unclear .NET Core compatibility with multiple fragmented packages. The 3-page limit in the free version significantly restricts evaluation.
IronPDF provides a modern Chromium-based alternative with full JavaScript support for React, Angular, and Vue applications. The single unified NuGet package with documented .NET 6/7/8/9/10 support simplifies deployment, and the clean API design reduces configuration complexity.
As organizations plan for .NET 10, C# 14, and application development through 2026, the choice between older WebKit rendering with fragmented packages and modern Chromium rendering with unified support significantly impacts both development velocity and output quality. Teams requiring modern JavaScript framework support, clear .NET compatibility, or streamlined package management will find IronPDF addresses these requirements effectively.
Start evaluating IronPDF with a free trial and explore the comprehensive documentation to assess fit for your specific requirements.