COMPARISON

Nutrient.io vs IronPDF: Technical Comparison Guide

Published:

When .NET developers require PDF processing capabilities, they often come across Nutrient.io (formerly PSPDFKit)—a platform that has transitioned from a PDF SDK into a complete document intelligence solution. This comparison looks at Nutrient.io and IronPDF across key technical aspects to assist developers, architects, and technical decision-makers in choosing the right tool for their PDF generation and manipulation workflows.

What Is Nutrient.io?

Nutrient.io, previously known as PSPDFKit, has shifted from a PDF-centric library to a full document intelligence platform. This change extends its capabilities beyond simple PDF processing to include AI-powered document analysis and extensive document workflow features.

The library operates through its PdfProcessor class, which must be created asynchronously using PdfProcessor.CreateAsync(). Operations like HTML-to-PDF conversion, document merging, and watermarking all use async/await patterns through methods such as GeneratePdfFromHtmlStringAsync(), MergeAsync(), and AddAnnotationAsync().

The platform architecture positions Nutrient.io for large organizations with its enterprise pricing structure. The rebrand from PSPDFKit to Nutrient.io has created documentation complexity, with package names and references sometimes using either name.

What Is IronPDF?

IronPDF is a dedicated PDF library designed specifically for .NET environments. Rather than positioning itself as a document intelligence platform, IronPDF focuses exclusively on PDF operations: generation, manipulation, merging, watermarking, and more.

The ChromePdfRenderer class serves as the primary interface for PDF generation, using a Chromium-based rendering engine to convert HTML, CSS, and JavaScript into high-fidelity PDF documents. The PdfDocument class provides extensive manipulation capabilities for existing PDFs.

IronPDF's architecture emphasizes simplicity, providing both synchronous and asynchronous methods to accommodate different application patterns. Configuration happens through the RenderingOptions property, with settings discoverable through IDE autocomplete.

Architectural Approach Comparison

The fundamental difference between these libraries lies in their scope and complexity. Nutrient.io has grown into a platform, while IronPDF remains a focused library.

AspectNutrient.io (PSPDFKit)IronPDF
ScopeDocument intelligence platformDedicated PDF library
ComplexityHigh, part of a full platformModerate, focused on PDF tasks
PricingEnterprise-levelAccessible for diverse team sizes
PDF FocusPart of a broader document frameworkExclusive PDF functionalities
IntegrationCan be complex due to extensive featuresSimple and straightforward
Target UsersLarge organizations needing advanced document techDevelopers needing reliable PDF tools
API StyleAsync-first, complexSync with async options
Learning CurveSteep (platform)Gentle (library)

Nutrient.io's platform approach means applications receive AI features and document workflow capabilities even when only basic PDF operations are needed. This can introduce unnecessary complexity for projects with straightforward requirements.

HTML to PDF Conversion

Both libraries support converting HTML content to PDF documents. The API patterns differ significantly in complexity and style.

Nutrient.io HTML-to-PDF approach:

// NuGet: Install-Package PSPDFKit.Dotnet
using PSPDFKit.Pdf;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        using var processor = await PdfProcessor.CreateAsync();
        var document = await processor.GeneratePdfFromHtmlStringAsync(htmlContent);
        await document.SaveAsync("output.pdf");
    }
}
// NuGet: Install-Package PSPDFKit.Dotnet
using PSPDFKit.Pdf;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        using var processor = await PdfProcessor.CreateAsync();
        var document = await processor.GeneratePdfFromHtmlStringAsync(htmlContent);
        await document.SaveAsync("output.pdf");
    }
}
$vbLabelText   $csharpLabel

IronPDF HTML-to-PDF approach:

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");
    }
}
$vbLabelText   $csharpLabel

Nutrient.io requires creating a processor asynchronously with await PdfProcessor.CreateAsync(), then calling async methods for generation and saving. Every operation uses the async/await pattern, and proper disposal requires the using statement.

IronPDF provides synchronous methods by default, reducing code complexity. The HTML to PDF conversion workflow involves instantiating a ChromePdfRenderer, calling RenderHtmlAsPdf(), and saving with SaveAs(). For applications that need async operations, IronPDF also offers async method variants like RenderHtmlAsPdfAsync().

The processor lifecycle in Nutrient.io requires careful management with using statements, while IronPDF's renderer can be instantiated and reused without complex lifecycle management.

Merging PDF Documents

Document merging demonstrates the API complexity differences between these libraries.

Nutrient.io merge approach:

// NuGet: Install-Package PSPDFKit.Dotnet
using PSPDFKit.Pdf;
using System.Threading.Tasks;
using System.Collections.Generic;

class Program
{
    static async Task Main()
    {
        using var processor = await PdfProcessor.CreateAsync();

        var document1 = await processor.OpenAsync("document1.pdf");
        var document2 = await processor.OpenAsync("document2.pdf");

        var mergedDocument = await processor.MergeAsync(new List<PdfDocument> { document1, document2 });
        await mergedDocument.SaveAsync("merged.pdf");
    }
}
// NuGet: Install-Package PSPDFKit.Dotnet
using PSPDFKit.Pdf;
using System.Threading.Tasks;
using System.Collections.Generic;

class Program
{
    static async Task Main()
    {
        using var processor = await PdfProcessor.CreateAsync();

        var document1 = await processor.OpenAsync("document1.pdf");
        var document2 = await processor.OpenAsync("document2.pdf");

        var mergedDocument = await processor.MergeAsync(new List<PdfDocument> { document1, document2 });
        await mergedDocument.SaveAsync("merged.pdf");
    }
}
$vbLabelText   $csharpLabel

IronPDF merge approach:

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

class Program
{
    static void Main()
    {
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        var merged = PdfDocument.Merge(pdf1, pdf2);
        merged.SaveAs("merged.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pdf1 = PdfDocument.FromFile("document1.pdf");
        var pdf2 = PdfDocument.FromFile("document2.pdf");

        var merged = PdfDocument.Merge(pdf1, pdf2);
        merged.SaveAs("merged.pdf");
    }
}
$vbLabelText   $csharpLabel

Nutrient.io requires:

  1. Creating a processor asynchronously
  2. Opening each document asynchronously with await processor.OpenAsync()
  3. Creating a List<PdfDocument> for the merge operation
  4. Calling the async MergeAsync() method
  5. Saving the result asynchronously

IronPDF simplifies this to loading files with PdfDocument.FromFile() and calling the static PdfDocument.Merge() method. The PDF merging functionality accepts multiple documents directly without requiring list construction for simple merges.

Adding Watermarks

Watermarking reveals a fundamental design philosophy difference: Nutrient.io uses annotation objects while IronPDF uses HTML strings.

Nutrient.io watermark approach:

// NuGet: Install-Package PSPDFKit.Dotnet
using PSPDFKit.Pdf;
using PSPDFKit.Pdf.Annotation;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var processor = await PdfProcessor.CreateAsync();
        var document = await processor.OpenAsync("document.pdf");

        for (int i = 0; i < document.PageCount; i++)
        {
            var watermark = new TextAnnotation("CONFIDENTIAL")
            {
                Opacity = 0.5,
                FontSize = 48
            };
            await document.AddAnnotationAsync(i, watermark);
        }

        await document.SaveAsync("watermarked.pdf");
    }
}
// NuGet: Install-Package PSPDFKit.Dotnet
using PSPDFKit.Pdf;
using PSPDFKit.Pdf.Annotation;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var processor = await PdfProcessor.CreateAsync();
        var document = await processor.OpenAsync("document.pdf");

        for (int i = 0; i < document.PageCount; i++)
        {
            var watermark = new TextAnnotation("CONFIDENTIAL")
            {
                Opacity = 0.5,
                FontSize = 48
            };
            await document.AddAnnotationAsync(i, watermark);
        }

        await document.SaveAsync("watermarked.pdf");
    }
}
$vbLabelText   $csharpLabel

IronPDF watermark approach:

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Editing;

class Program
{
    static void Main()
    {
        var pdf = PdfDocument.FromFile("document.pdf");

        pdf.ApplyWatermark("<h1 style='color:gray;opacity:0.5;'>CONFIDENTIAL</h1>",
            50,
            VerticalAlignment.Middle,
            HorizontalAlignment.Center);

        pdf.SaveAs("watermarked.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Editing;

class Program
{
    static void Main()
    {
        var pdf = PdfDocument.FromFile("document.pdf");

        pdf.ApplyWatermark("<h1 style='color:gray;opacity:0.5;'>CONFIDENTIAL</h1>",
            50,
            VerticalAlignment.Middle,
            HorizontalAlignment.Center);

        pdf.SaveAs("watermarked.pdf");
    }
}
$vbLabelText   $csharpLabel

Nutrient.io requires iterating through each page, creating TextAnnotation objects with properties like Opacity and FontSize, and adding each annotation asynchronously with await document.AddAnnotationAsync(). This approach requires understanding the annotation API and manual page iteration.

IronPDF's watermark functionality uses HTML strings with CSS styling. The ApplyWatermark() method accepts HTML content, rotation angle, and alignment parameters, applying the watermark to all pages automatically. CSS properties like opacity and color handle styling that would otherwise require separate annotation properties.

The HTML-based approach offers several advantages:

  • Familiar web development syntax
  • Full CSS styling capabilities
  • Single method call applies to all pages
  • No manual page iteration required

API Mapping Reference

For teams evaluating Nutrient.io migration to IronPDF, understanding the API mappings helps estimate effort.

Core Method Mappings

Nutrient.io (PSPDFKit)IronPDF
await PdfProcessor.CreateAsync()new ChromePdfRenderer()
await processor.OpenAsync(path)PdfDocument.FromFile(path)
await processor.GeneratePdfFromHtmlStringAsync(html)renderer.RenderHtmlAsPdf(html)
await processor.MergeAsync(docs)PdfDocument.Merge(pdfs)
await document.SaveAsync(path)pdf.SaveAs(path)
document.ToBytes()pdf.BinaryData
document.ToStream()pdf.Stream

Configuration Mappings

Nutrient.io (PSPDFKit)IronPDF
new PdfConfiguration { PageSize = ... }renderer.RenderingOptions.PaperSize = ...
config.Margins = new Margins(t, r, b, l)Individual margin properties
config.Orientation = Orientation.LandscapeRenderingOptions.PaperOrientation

Watermark and Annotation Mappings

Nutrient.io (PSPDFKit)IronPDF
new TextAnnotation("text")HTML string
annotation.Opacity = 0.5CSS opacity: 0.5
annotation.FontSize = 48CSS font-size: 48px
await document.AddAnnotationAsync(index, annotation)pdf.ApplyWatermark(html)
Nutrient.io (PSPDFKit)IronPDF
(complex annotation approach)RenderingOptions.HtmlHeader
(complex annotation approach)RenderingOptions.HtmlFooter
(manual page counting){page} placeholder
(manual calculation){total-pages} placeholder

Nutrient.io requires manual page counting and iteration to add page numbers to headers or footers. IronPDF provides built-in placeholders that automatically insert page numbers and totals.

Namespace and Package Changes

Teams migrating from Nutrient.io to IronPDF need to update namespace imports:

Nutrient.io (PSPDFKit)IronPDF
using PSPDFKit.Pdf;using IronPdf;
using PSPDFKit.Pdf.Document;using IronPdf;
using PSPDFKit.Pdf.Rendering;using IronPdf.Rendering;
using PSPDFKit.Pdf.Annotation;using IronPdf;
using Nutrient.Pdf;using IronPdf;

NuGet package migration:

# Remove Nutrient/PSPDFKit packages
dotnet remove package PSPDFKit.NET
dotnet remove package PSPDFKit.PDF
dotnet remove package Nutrient
dotnet remove package Nutrient.PDF

# Install IronPDF
dotnet add package IronPdf
# Remove Nutrient/PSPDFKit packages
dotnet remove package PSPDFKit.NET
dotnet remove package PSPDFKit.PDF
dotnet remove package Nutrient
dotnet remove package Nutrient.PDF

# Install IronPDF
dotnet add package IronPdf
SHELL

Async vs Sync API Design

Nutrient.io uses an async-first architecture where nearly every operation requires async/await:

// Nutrient.io pattern - async everywhere
using var processor = await PdfProcessor.CreateAsync();
var document = await processor.OpenAsync(path);
await document.SaveAsync(outputPath);
// Nutrient.io pattern - async everywhere
using var processor = await PdfProcessor.CreateAsync();
var document = await processor.OpenAsync(path);
await document.SaveAsync(outputPath);
$vbLabelText   $csharpLabel

IronPDF provides synchronous methods by default with async alternatives available:

// IronPDF sync pattern (simpler)
var pdf = PdfDocument.FromFile(path);
pdf.SaveAs(outputPath);

// IronPDF async pattern (when needed)
var pdf = await renderer.RenderHtmlAsPdfAsync(html);
// IronPDF sync pattern (simpler)
var pdf = PdfDocument.FromFile(path);
pdf.SaveAs(outputPath);

// IronPDF async pattern (when needed)
var pdf = await renderer.RenderHtmlAsPdfAsync(html);
$vbLabelText   $csharpLabel

For applications where PDF operations don't need to be asynchronous—such as background jobs, console applications, or synchronous service methods—IronPDF's default sync API reduces code complexity. When async is beneficial, the methods are available.

When Teams Consider Moving from Nutrient.io to IronPDF

Several factors drive teams to evaluate IronPDF as an alternative to Nutrient.io:

Platform Complexity: Teams needing only PDF generation and manipulation may find Nutrient.io's document intelligence platform includes unnecessary features. The AI capabilities and document workflow features add complexity for projects with straightforward requirements.

Pricing Transparency: Nutrient.io's enterprise pricing requires contacting sales for quotes, complicating budget planning. Organizations with limited budgets or those needing predictable costs may prefer IronPDF's published pricing model.

API Simplicity: Nutrient.io's async-first design requires async/await patterns throughout the codebase, even for simple operations. Teams preferring synchronous code or wanting flexibility between sync and async benefit from IronPDF's approach.

Rebrand Confusion: The PSPDFKit to Nutrient.io transition has created documentation fragmentation, with some resources referencing old names and package identifiers. Teams encountering this confusion may seek libraries with stable naming.

Integration Simplicity: Creating processors, managing lifecycle, and handling async patterns adds integration overhead. IronPDF's straightforward instantiation and method calls reduce onboarding time for new developers.

Watermark Implementation: The annotation-based watermarking in Nutrient.io requires page iteration and annotation object creation. IronPDF's HTML-based approach leverages familiar web development skills and applies watermarks in a single call.

Installation Comparison

Nutrient.io installation:

Install-Package PSPDFKit.Dotnet
Install-Package PSPDFKit.Dotnet
SHELL

IronPDF installation:

Install-Package IronPdf
Install-Package IronPdf
SHELL

IronPDF requires a license key configuration at application startup:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
$vbLabelText   $csharpLabel

Both libraries support .NET Framework and modern .NET versions, making them compatible with applications targeting .NET 10 and C# 14.

Making the Decision

The choice between Nutrient.io and IronPDF depends on your specific requirements:

Consider Nutrient.io if: Your organization needs the full document intelligence platform with AI capabilities, you have enterprise budgets and procurement processes that work with sales-negotiated pricing, and your application architecture is already async-first throughout.

Consider IronPDF if: You need focused PDF functionality without platform overhead, you prefer transparent pricing and simpler procurement, you want flexibility between sync and async API patterns, you value HTML-based watermarks over annotation objects, or you want built-in header/footer placeholders for page numbers.

For teams building modern .NET applications in 2025 and planning toward 2026, evaluating the actual PDF features needed versus the full platform capabilities helps determine the appropriate tool. Many projects find that a focused PDF library meets their requirements without the complexity of a document intelligence platform.

Getting Started with IronPDF

To evaluate IronPDF for your PDF processing needs:

  1. Install the IronPDF NuGet package: Install-Package IronPdf
  2. Review the HTML to PDF tutorial for basic conversion patterns
  3. Explore watermark functionality for document branding
  4. Check PDF merging capabilities for document assembly

The IronPDF tutorials provide comprehensive examples for common scenarios, and the API reference documents all available classes and methods.

Conclusion

Nutrient.io and IronPDF represent different approaches to PDF functionality in .NET applications. Nutrient.io has evolved into a document intelligence platform with AI features and enterprise positioning, while IronPDF maintains focus as a dedicated PDF library with straightforward integration.

For teams that need PDF generation, manipulation, watermarking, and merging without additional platform features, IronPDF's focused approach offers simpler APIs, flexible sync/async patterns, and HTML-based watermarking. The reduced complexity translates to faster integration and easier maintenance.

Evaluate both options against your actual PDF requirements, team preferences for API patterns, and budget constraints. Understanding the architectural differences outlined in this comparison will help you make an informed decision that aligns with your PDF processing needs and development practices.