Cómo convertir HTML a PDF en C# (Guía para desarrolladores)

Cómo convertir una cadena HTML a PDF

La operación más fundamental es convertir una cadena HTML a PDF. Este método es perfecto para contenido HTML generado dinámicamente. The RenderHtmlAsPdf method fully supports HTML5, CSS3, JavaScript, and images when you convert HTML to PDF directly.

var renderer = new ChromePdfRenderer();

// Create the Chrome renderer
var renderer = new ChromePdfRenderer();

// Convert HTML string to PDF
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello IronPdf</h1>");

// Save the PDF
pdf.SaveAs("output.pdf");

var renderer = new ChromePdfRenderer();

// Create the Chrome renderer
var renderer = new ChromePdfRenderer();

// Convert HTML string to PDF
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello IronPdf</h1>");

// Save the PDF
pdf.SaveAs("output.pdf");

Dim renderer As New ChromePdfRenderer()

' Create the Chrome renderer
Dim renderer As New ChromePdfRenderer()

' Convert HTML string to PDF
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello IronPdf</h1>")

' Save the PDF
pdf.SaveAs("output.pdf")

When your HTML string references local assets like images or stylesheets, use the BaseUrlPath parameter to properly convert HTML content with all resources:

var renderer = new ChromePdfRenderer();

var renderer = new ChromePdfRenderer();

// Convert HTML content with local image and CSS references
string html = @"
    <link rel='stylesheet' href='styles.css'>
    <img src='logo.png' alt='Company Logo'>
    <h1>Company Report</h1>
    <p>Annual report content...</p>";

// Set base path for resolving relative URLs in HTML to PDF conversion
var pdf = renderer.RenderHtmlAsPdf(html, @"C:\MyProject\Assets\");
pdf.SaveAs("report.pdf");

var renderer = new ChromePdfRenderer();

var renderer = new ChromePdfRenderer();

// Convert HTML content with local image and CSS references
string html = @"
    <link rel='stylesheet' href='styles.css'>
    <img src='logo.png' alt='Company Logo'>
    <h1>Company Report</h1>
    <p>Annual report content...</p>";

// Set base path for resolving relative URLs in HTML to PDF conversion
var pdf = renderer.RenderHtmlAsPdf(html, @"C:\MyProject\Assets\");
pdf.SaveAs("report.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Convert HTML content with local image and CSS references
Dim html As String = "
    <link rel='stylesheet' href='styles.css'>
    <img src='logo.png' alt='Company Logo'>
    <h1>Company Report</h1>
    <p>Annual report content...</p>"

' Set base path for resolving relative URLs in HTML to PDF conversion
Dim pdf = renderer.RenderHtmlAsPdf(html, "C:\MyProject\Assets\")
pdf.SaveAs("report.pdf")

RELATED HOW-TO ARTICLE: How to Convert HTML String to PDF in C#

Cómo exportar una URL existente a PDF

Renderizar páginas web completas a PDFs con C# permite a los equipos separar el diseño del PDF y el trabajo de renderizado del back-end. Este enfoque le permite convertir cualquier URL específica directamente al formato PDF.

CSS de Impresión vs Pantalla

Puede configurar IronPDF para renderizar usando cualquier tipo de medios CSS.

var renderer = new ChromePdfRenderer();
using IronPdf.Rendering;

// Initialize HTML to PDF converter
var renderer = new ChromePdfRenderer();

// Configure CSS media type for rendering specified URLs
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

// Screen media type shows the entire web page as displayed on screen

var renderer = new ChromePdfRenderer();
using IronPdf.Rendering;

// Initialize HTML to PDF converter
var renderer = new ChromePdfRenderer();

// Configure CSS media type for rendering specified URLs
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

// Screen media type shows the entire web page as displayed on screen

Imports IronPdf.Rendering

' Initialize HTML to PDF converter
Dim renderer As New ChromePdfRenderer()

' Configure CSS media type for rendering specified URLs
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print

' Screen media type shows the entire web page as displayed on screen

Soporte de JavaScript

IronPDF soporta completamente JavaScript, jQuery e incluso AJAX cuando convierte HTML a PDF. Para contenido HTML dinámico, puede configurar IronPDF para esperar la finalización del JavaScript antes de renderizar páginas web en PDF. Esto es perfecto para aplicaciones de una sola página y sitios web dinámicos.

var renderer = new ChromePdfRenderer();

// Configure JavaScript rendering for dynamic HTML content to PDF
var renderer = new ChromePdfRenderer();

// Enable JavaScript execution during PDF generation
renderer.RenderingOptions.EnableJavaScript = true;

// WaitFor.RenderDelay pauses before capturing the HTML
renderer.RenderingOptions.WaitFor.RenderDelay = 500; // milliseconds

var renderer = new ChromePdfRenderer();

// Configure JavaScript rendering for dynamic HTML content to PDF
var renderer = new ChromePdfRenderer();

// Enable JavaScript execution during PDF generation
renderer.RenderingOptions.EnableJavaScript = true;

// WaitFor.RenderDelay pauses before capturing the HTML
renderer.RenderingOptions.WaitFor.RenderDelay = 500; // milliseconds

Dim renderer As New ChromePdfRenderer()

' Configure JavaScript rendering for dynamic HTML content to PDF
Dim renderer As New ChromePdfRenderer()

' Enable JavaScript execution during PDF generation
renderer.RenderingOptions.EnableJavaScript = True

' WaitFor.RenderDelay pauses before capturing the HTML
renderer.RenderingOptions.WaitFor.RenderDelay = 500 ' milliseconds

La ejecución de JavaScript también se puede mostrar cuando se renderiza un gráfico de acordes d3.js avanzado desde una página web al formato PDF:

var renderer = new ChromePdfRenderer();

// Create renderer for JavaScript-heavy HTML
var renderer = new ChromePdfRenderer();

// Convert d3.js visualization web page to PDF
var pdf = renderer.RenderUrlAsPdf("https://bl.ocks.org/mbostock/4062006");

// Save the interactive chart as static PDF
pdf.SaveAs("chart.pdf");

var renderer = new ChromePdfRenderer();

// Create renderer for JavaScript-heavy HTML
var renderer = new ChromePdfRenderer();

// Convert d3.js visualization web page to PDF
var pdf = renderer.RenderUrlAsPdf("https://bl.ocks.org/mbostock/4062006");

// Save the interactive chart as static PDF
pdf.SaveAs("chart.pdf");

Dim renderer As New ChromePdfRenderer()

' Create renderer for JavaScript-heavy HTML
renderer = New ChromePdfRenderer()

' Convert d3.js visualization web page to PDF
Dim pdf = renderer.RenderUrlAsPdf("https://bl.ocks.org/mbostock/4062006")

' Save the interactive chart as static PDF
pdf.SaveAs("chart.pdf")

CSS Responsivo

As responsive web pages are designed to be viewed in a browser, and IronPDF does not open a real browser window in your server's OS, responsive HTML elements may render at their smallest size. PdfCssMediaType.Print is recommended to navigate this issue when rendering entire web pages.

// Configure for optimal responsive design handling in HTML to PDF

renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

// Configure for optimal responsive design handling in HTML to PDF

renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

```vbnet
' Configure for optimal responsive design handling in HTML to PDF

renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
```

RELATED HOW-TO ARTICLE: How to Render URL to PDF

Cómo convertir un archivo HTML a PDF

Convertir archivos HTML locales a PDF preserva todos los recursos relativos incluyendo CSS, imágenes y JavaScript, como si se abrieran usando el protocolo file://. Este método de HTML a PDF es mejor para convertir plantillas o páginas HTML pre-diseñadas a documentos PDF.

var renderer = new ChromePdfRenderer();

// Initialize ChromePdfRenderer for HTML file conversion
var renderer = new ChromePdfRenderer();

// Convert HTML file to PDF documents
// Preserves all relative paths and linked resources in HTML
var pdf = renderer.RenderHtmlFileAsPdf("Assets/TestInvoice1.html");

// Save the HTML file as PDF 
pdf.SaveAs("Invoice.pdf");

// All CSS, JavaScript, and images load correctly in the generated PDF

var renderer = new ChromePdfRenderer();

// Initialize ChromePdfRenderer for HTML file conversion
var renderer = new ChromePdfRenderer();

// Convert HTML file to PDF documents
// Preserves all relative paths and linked resources in HTML
var pdf = renderer.RenderHtmlFileAsPdf("Assets/TestInvoice1.html");

// Save the HTML file as PDF 
pdf.SaveAs("Invoice.pdf");

// All CSS, JavaScript, and images load correctly in the generated PDF

Dim renderer As New ChromePdfRenderer()

' Initialize ChromePdfRenderer for HTML file conversion
Dim renderer As New ChromePdfRenderer()

' Convert HTML file to PDF documents
' Preserves all relative paths and linked resources in HTML
Dim pdf = renderer.RenderHtmlFileAsPdf("Assets/TestInvoice1.html")

' Save the HTML file as PDF 
pdf.SaveAs("Invoice.pdf")

' All CSS, JavaScript, and images load correctly in the generated PDF

RELATED HOW-TO Article: Render HTML File to PDF

How to Convert Razor Pages to PDF

If your ASP.NET Core project already uses Razor Pages, you can convert them directly to PDF without rebuilding your HTML. IronPDF's Razor extension adds the RenderRazorToPdf method, which takes your .cshtml page — complete with its model and layout — and renders it as a PDF document in a single call.

PM > Install-Package IronPdf.Extensions.Razor

PM > Install-Package IronPdf.Extensions.Razor

var renderer = new ChromePdfRenderer();

var renderer = new ChromePdfRenderer();

// Render a Razor Page directly to PDF
PdfDocument pdf = renderer.RenderRazorToPdf(this);

Response.Headers.Add("Content-Disposition", "inline");
return new FileContentResult(pdf.BinaryData, "application/pdf");

var renderer = new ChromePdfRenderer();

var renderer = new ChromePdfRenderer();

// Render a Razor Page directly to PDF
PdfDocument pdf = renderer.RenderRazorToPdf(this);

Response.Headers.Add("Content-Disposition", "inline");
return new FileContentResult(pdf.BinaryData, "application/pdf");

Imports System.IO
Imports Microsoft.AspNetCore.Mvc

Dim renderer As New ChromePdfRenderer()

' Render a Razor Page directly to PDF
Dim pdf As PdfDocument = renderer.RenderRazorToPdf(Me)

Response.Headers.Add("Content-Disposition", "inline")
Return New FileContentResult(pdf.BinaryData, "application/pdf")

RELATED HOW-TO Article: How to Convert CSHTML to PDF in Razor Pages

How to Convert MVC Views to PDF

Teams using the MVC pattern can generate PDFs straight from their existing Views and controllers. Install the MVC Core extension package, then call RenderRazorViewToPdf with your view path and model — IronPDF handles the Razor rendering pipeline and outputs a finished PDF.

This is especially useful for reports, invoices, and any page where the HTML is already designed and tested in the browser. The generated PDF preserves the full View output, including layout pages and partial views.

PM > Install-Package IronPdf.Extensions.Mvc.Core

PM > Install-Package IronPdf.Extensions.Mvc.Core

First, register the IRazorViewRenderer service in your Program.cs so your controllers can inject it:

using IronPdf.Extensions.Mvc.Core;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();

// Register the Razor view renderer for IronPDF
builder.Services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
builder.Services.AddSingleton<IRazorViewRenderer, RazorViewRenderer>();

using IronPdf.Extensions.Mvc.Core;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();

// Register the Razor view renderer for IronPDF
builder.Services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
builder.Services.AddSingleton<IRazorViewRenderer, RazorViewRenderer>();

Imports IronPdf.Extensions.Mvc.Core

Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllersWithViews()

' Register the Razor view renderer for IronPDF
builder.Services.AddSingleton(Of IHttpContextAccessor, HttpContextAccessor)()
builder.Services.AddSingleton(Of IRazorViewRenderer, RazorViewRenderer)()

Then in your controller action, inject the renderer and convert any View to PDF:

var renderer = new ChromePdfRenderer();
using IronPdf.Extensions.Mvc.Core;

var renderer = new ChromePdfRenderer();

// Render an MVC View with model data to PDF
PdfDocument pdf = renderer.RenderRazorViewToPdf(
    _viewRenderService, "Views/Home/Report.cshtml", reportModel);

Response.Headers.Add("Content-Disposition", "inline");
return new FileContentResult(pdf.BinaryData, "application/pdf");

var renderer = new ChromePdfRenderer();
using IronPdf.Extensions.Mvc.Core;

var renderer = new ChromePdfRenderer();

// Render an MVC View with model data to PDF
PdfDocument pdf = renderer.RenderRazorViewToPdf(
    _viewRenderService, "Views/Home/Report.cshtml", reportModel);

Response.Headers.Add("Content-Disposition", "inline");
return new FileContentResult(pdf.BinaryData, "application/pdf");

Imports IronPdf.Extensions.Mvc.Core

Dim renderer As New ChromePdfRenderer()

' Render an MVC View with model data to PDF
Dim pdf As PdfDocument = renderer.RenderRazorViewToPdf(_viewRenderService, "Views/Home/Report.cshtml", reportModel)

Response.Headers.Add("Content-Disposition", "inline")
Return New FileContentResult(pdf.BinaryData, "application/pdf")

RELATED HOW-TO Article: How to Convert Views to PDF in ASP.NET Core MVC

How to Set Custom HTTP Headers, Cookies, and Login Credentials

When rendering URLs that require authentication or specific request metadata, IronPDF allows you to include login credentials, session cookies, and HTTP headers with the request. This enables rendering of intranet dashboards, restricted reports, or API-generated pages directly to PDF without needing to retrieve the HTML separately.

For basic or NTLM authentication, set a LoginCredentials object on the renderer. For token-based or session-based access, pass cookies and headers through RenderingOptions before calling RenderUrlAsPdf.

var renderer = new ChromePdfRenderer();

var renderer = new ChromePdfRenderer();

// Network authentication (Basic, Digest, NTLM)
renderer.LoginCredentials = new ChromeHttpLoginCredentials
{
    NetworkUsername = "user@domain.com",
    NetworkPassword = "securePassword"
};

// Session cookies for authenticated pages
renderer.RenderingOptions.CustomCookies["sessionId"] = "abc123";

// Custom HTTP headers (e.g., Bearer tokens, API keys)
renderer.RenderingOptions.CustomHttpRequestHeaders["Authorization"] = "Bearer eyJhbGciOi...";

var pdf = renderer.RenderUrlAsPdf("https://intranet.company.com/quarterly-report");
pdf.SaveAs("quarterly-report.pdf");

var renderer = new ChromePdfRenderer();

var renderer = new ChromePdfRenderer();

// Network authentication (Basic, Digest, NTLM)
renderer.LoginCredentials = new ChromeHttpLoginCredentials
{
    NetworkUsername = "user@domain.com",
    NetworkPassword = "securePassword"
};

// Session cookies for authenticated pages
renderer.RenderingOptions.CustomCookies["sessionId"] = "abc123";

// Custom HTTP headers (e.g., Bearer tokens, API keys)
renderer.RenderingOptions.CustomHttpRequestHeaders["Authorization"] = "Bearer eyJhbGciOi...";

var pdf = renderer.RenderUrlAsPdf("https://intranet.company.com/quarterly-report");
pdf.SaveAs("quarterly-report.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Network authentication (Basic, Digest, NTLM)
renderer.LoginCredentials = New ChromeHttpLoginCredentials With {
    .NetworkUsername = "user@domain.com",
    .NetworkPassword = "securePassword"
}

' Session cookies for authenticated pages
renderer.RenderingOptions.CustomCookies("sessionId") = "abc123"

' Custom HTTP headers (e.g., Bearer tokens, API keys)
renderer.RenderingOptions.CustomHttpRequestHeaders("Authorization") = "Bearer eyJhbGciOi..."

Dim pdf = renderer.RenderUrlAsPdf("https://intranet.company.com/quarterly-report")
pdf.SaveAs("quarterly-report.pdf")

ARTÍCULOS RELACIONADOS: Render PDFs Behind Login Authentication | Custom HTTP Request Headers

How to Configure Proxy for PDF Rendering

When rendering HTML that loads external resources behind a corporate proxy, pass the proxy address as the third parameter on RenderHtmlAsPdf(). This is a method parameter, not a property on ChromePdfRenderOptions — so it's set per render call, not on the renderer instance.

For authenticated proxies, embed credentials directly in the URL using http://user:pass@host:port format. URL-encode special characters in passwords with Uri.EscapeDataString().

var renderer = new ChromePdfRenderer();

var renderer = new ChromePdfRenderer();

// Proxy is the third parameter — not a render option
PdfDocument pdf = renderer.RenderHtmlAsPdf(
    "<h1>Report</h1><link rel='stylesheet' href='https://cdn.example.com/styles.css'>",
    baseUrlOrPath: null,
    proxy: "http://proxy.corp.local:8080"
);
pdf.SaveAs("proxied-report.pdf");

var renderer = new ChromePdfRenderer();

var renderer = new ChromePdfRenderer();

// Proxy is the third parameter — not a render option
PdfDocument pdf = renderer.RenderHtmlAsPdf(
    "<h1>Report</h1><link rel='stylesheet' href='https://cdn.example.com/styles.css'>",
    baseUrlOrPath: null,
    proxy: "http://proxy.corp.local:8080"
);
pdf.SaveAs("proxied-report.pdf");

Dim renderer As New ChromePdfRenderer()

' Proxy is the third parameter — not a render option
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(
    "<h1>Report</h1><link rel='stylesheet' href='https://cdn.example.com/styles.css'>",
    baseUrlOrPath:=Nothing,
    proxy:="http://proxy.corp.local:8080"
)
pdf.SaveAs("proxied-report.pdf")

Note that RenderUrlAsPdf() does not accept a proxy parameter. To render a live URL behind a proxy, fetch the HTML first with HttpClient configured with a WebProxy, then pass it to RenderHtmlAsPdf() with the proxy parameter for asset loading.

RELATED HOW-TO Article: How to Configure Proxy Servers for PDF Rendering

Cómo generar una plantilla HTML para la creación de PDF por lotes

Creación Básica de PDF en Lote

La creación de PDF en lote es esencial para generar múltiples documentos PDF personalizados de manera eficiente. For basic scenarios, the String.Format method in C# works best for simple PDF manipulation.

// Simple HTML templating with String.Format
string htmlTemplate = String.Format("<h1>Hello {0}!</h1>", "World");

// Results in HTML content: <h1>Hello World!</h1>

// Simple HTML templating with String.Format
string htmlTemplate = String.Format("<h1>Hello {0}!</h1>", "World");

// Results in HTML content: <h1>Hello World!</h1>

' Simple HTML templating with String.Format
Dim htmlTemplate As String = String.Format("<h1>Hello {0}!</h1>", "World")

' Results in HTML content: <h1>Hello World!</h1>

Para plantillas más largas cuando necesita generar documentos PDF, use la sustitución de marcadores de posición en su contenido HTML: var renderer = new ChromePdfRenderer();

// Define reusable HTML template for PDF files
var htmlTemplate = "<p>Dear [[NAME]],</p><p>Thank you for your order.</p>";

// Customer names for batch PDF conversion processing
var names = new[] { "John", "James", "Jenny" };

// Create personalized PDF documents for each customer
var renderer = new ChromePdfRenderer();

foreach (var name in names)
{
    // Replace placeholder with actual data in HTML string
    var htmlInstance = htmlTemplate.Replace("[[NAME]]", name);

    // Generate personalized PDF document from HTML content
    var pdf = renderer.RenderHtmlAsPdf(htmlInstance);

    // Save with customer-specific filename as PDF files
    pdf.SaveAs($"{name}-invoice.pdf");
}

// Define reusable HTML template for PDF files
var htmlTemplate = "<p>Dear [[NAME]],</p><p>Thank you for your order.</p>";

// Customer names for batch PDF conversion processing
var names = new[] { "John", "James", "Jenny" };

// Create personalized PDF documents for each customer
var renderer = new ChromePdfRenderer();

foreach (var name in names)
{
    // Replace placeholder with actual data in HTML string
    var htmlInstance = htmlTemplate.Replace("[[NAME]]", name);

    // Generate personalized PDF document from HTML content
    var pdf = renderer.RenderHtmlAsPdf(htmlInstance);

    // Save with customer-specific filename as PDF files
    pdf.SaveAs($"{name}-invoice.pdf");
}

' Define reusable HTML template for PDF files
Dim htmlTemplate As String = "<p>Dear [[NAME]],</p><p>Thank you for your order.</p>"

' Customer names for batch PDF conversion processing
Dim names As String() = {"John", "James", "Jenny"}

' Create personalized PDF documents for each customer
Dim renderer As New ChromePdfRenderer()

For Each name In names
    ' Replace placeholder with actual data in HTML string
    Dim htmlInstance As String = htmlTemplate.Replace("[[NAME]]", name)

    ' Generate personalized PDF document from HTML content
    Dim pdf = renderer.RenderHtmlAsPdf(htmlInstance)

    ' Save with customer-specific filename as PDF files
    pdf.SaveAs($"{name}-invoice.pdf")
Next

Plantillas de HTML a PDF con Handlebars.NET

For complex templates with loops and conditionals when you convert HTML to PDF, use advanced templating with Handlebars.NET to generate PDF documents with dynamic HTML content.

# First, install Handlebars.NET for HTML to PDF templating
PM > Install-Package Handlebars.NET

# First, install Handlebars.NET for HTML to PDF templating
PM > Install-Package Handlebars.NET

using HandlebarsDotNet;
var renderer = new ChromePdfRenderer();

// Define Handlebars template with placeholders for HTML content
var source = 
    @"<div class=""entry"">
        <h1>{{title}}</h1>
        <div class=""body"">
            {{body}}
        </div>
    </div>";

// Compile template for reuse in PDF conversion
var template = Handlebars.Compile(source);

// Create data object (can be database records) for HTML to PDF directly
var data = new { 
    title = "Monthly Report", 
    body = "Sales increased by 15% this month." 
};

// Merge template with data to create HTML content
var htmlResult = template(data);

// Convert templated HTML to PDF using the PDF converter
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlResult);

pdf.SaveAs("monthly-report.pdf");

using HandlebarsDotNet;
var renderer = new ChromePdfRenderer();

// Define Handlebars template with placeholders for HTML content
var source = 
    @"<div class=""entry"">
        <h1>{{title}}</h1>
        <div class=""body"">
            {{body}}
        </div>
    </div>";

// Compile template for reuse in PDF conversion
var template = Handlebars.Compile(source);

// Create data object (can be database records) for HTML to PDF directly
var data = new { 
    title = "Monthly Report", 
    body = "Sales increased by 15% this month." 
};

// Merge template with data to create HTML content
var htmlResult = template(data);

// Convert templated HTML to PDF using the PDF converter
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlResult);

pdf.SaveAs("monthly-report.pdf");

Imports HandlebarsDotNet

Dim renderer As New ChromePdfRenderer()

' Define Handlebars template with placeholders for HTML content
Dim source As String = 
    "<div class=""entry"">
        <h1>{{title}}</h1>
        <div class=""body"">
            {{body}}
        </div>
    </div>"

' Compile template for reuse in PDF conversion
Dim template = Handlebars.Compile(source)

' Create data object (can be database records) for HTML to PDF directly
Dim data = New With {
    .title = "Monthly Report",
    .body = "Sales increased by 15% this month."
}

' Merge template with data to create HTML content
Dim htmlResult = template(data)

' Convert templated HTML to PDF using the PDF converter
Dim pdf = renderer.RenderHtmlAsPdf(htmlResult)

pdf.SaveAs("monthly-report.pdf")

RELATED HOW-TO ARTICLE: Learn more about Handlebars.NET on GitHub

<!DOCTYPE html>
<html>
  <head>
    <style type="text/css" media="print">
      .page {
        page-break-after: always;
        page-break-inside: avoid;
      }
    </style>
  </head>
  <body>
    <div class="page">
      <h1>Page 1 Content</h1>
    </div>
    <div class="page">
      <h1>Page 2 Content</h1>
    </div>
    <div class="page">
      <h1>Page 3 Content</h1>
    </div>
  </body>
</html>

<!DOCTYPE html>
<html>
  <head>
    <style type="text/css" media="print">
      .page {
        page-break-after: always;
        page-break-inside: avoid;
      }
    </style>
  </head>
  <body>
    <div class="page">
      <h1>Page 1 Content</h1>
    </div>
    <div class="page">
      <h1>Page 2 Content</h1>
    </div>
    <div class="page">
      <h1>Page 3 Content</h1>
    </div>
  </body>
</html>

Cómo generar un PDF mediante el método asíncrono

IronPDF ofrece rendimiento a nivel empresarial con soporte completo para async y multihilos para sus requisitos de conversión de HTML a PDF cuando necesita generar archivos PDF a gran escala.

var renderer = new ChromePdfRenderer();
using System.Threading.Tasks;

// Async method for non-blocking PDF generation from HTML content
public async Task<byte[]> GeneratePdfAsync(string html)
{
    var renderer = new ChromePdfRenderer();

    // Async HTML to PDF conversion preserves thread pool
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);

    // Return PDF files as byte array for web responses
    return pdf.BinaryData;
}

// Concurrent batch PDF generation for multiple HTML strings
public async Task GenerateMultiplePdfsAsync(List<string> htmlPlantillas)
{
    var renderer = new ChromePdfRenderer();

    // Create parallel conversion tasks to generate PDF documents
    var tasks = htmlPlantillas.Select(html => 
        renderer.RenderHtmlAsPdfAsync(html)
    );

    // Await all PDF conversions simultaneously
    var pdfs = await Task.WhenAll(tasks);

    // Save generated PDF files from HTML content
    for (int i = 0; i < pdfs.Length; i++)
    {
        pdfs[i].SaveAs($"document-{i}.pdf");
    }
}

var renderer = new ChromePdfRenderer();
using System.Threading.Tasks;

// Async method for non-blocking PDF generation from HTML content
public async Task<byte[]> GeneratePdfAsync(string html)
{
    var renderer = new ChromePdfRenderer();

    // Async HTML to PDF conversion preserves thread pool
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);

    // Return PDF files as byte array for web responses
    return pdf.BinaryData;
}

// Concurrent batch PDF generation for multiple HTML strings
public async Task GenerateMultiplePdfsAsync(List<string> htmlPlantillas)
{
    var renderer = new ChromePdfRenderer();

    // Create parallel conversion tasks to generate PDF documents
    var tasks = htmlPlantillas.Select(html => 
        renderer.RenderHtmlAsPdfAsync(html)
    );

    // Await all PDF conversions simultaneously
    var pdfs = await Task.WhenAll(tasks);

    // Save generated PDF files from HTML content
    for (int i = 0; i < pdfs.Length; i++)
    {
        pdfs[i].SaveAs($"document-{i}.pdf");
    }
}

Imports System.Threading.Tasks

' Async method for non-blocking PDF generation from HTML content
Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
    Dim renderer As New ChromePdfRenderer()

    ' Async HTML to PDF conversion preserves thread pool
    Dim pdf = Await renderer.RenderHtmlAsPdfAsync(html)

    ' Return PDF files as byte array for web responses
    Return pdf.BinaryData
End Function

' Concurrent batch PDF generation for multiple HTML strings
Public Async Function GenerateMultiplePdfsAsync(htmlPlantillas As List(Of String)) As Task
    Dim renderer As New ChromePdfRenderer()

    ' Create parallel conversion tasks to generate PDF documents
    Dim tasks = htmlPlantillas.Select(Function(html) renderer.RenderHtmlAsPdfAsync(html))

    ' Await all PDF conversions simultaneously
    Dim pdfs = Await Task.WhenAll(tasks)

    ' Save generated PDF files from HTML content
    For i As Integer = 0 To pdfs.Length - 1
        pdfs(i).SaveAs($"document-{i}.pdf")
    Next
End Function

• Use sistemas de 64 bits para un rendimiento óptimo de generación de PDF.
• Asegúrese de contar con recursos de servidor adecuados cuando genere documentos PDF (evite niveles gratuitos con poca capacidad)
• Permita RenderDelay suficiente for JavaScript complejo en contenido HTML.
• Reuse ChromePdfRenderer instances when possible.
• Aproveche correcciones de memoria de v2025.9.4 para operaciones por lotes/async y reducir recursos. pruebe con tamaños de archivo reducidos con encabezados/pies de página personalizados repetidos.

RELATED HOW-TO Article: How to Generate PDFs with Async and Multithreading

Cómo agregar funciones de seguridad avanzadas

Cómo Agregar Protección por Contraseña para Archivos PDF en .NET

Proteja documentos PDF generados sensibles con contraseñas y permisos cuando convierta contenido HTML a un formato PDF protegido.

var renderer = new ChromePdfRenderer();
var renderer = new ChromePdfRenderer();

// Convert HTML to PDF with security
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential Report</h1>");

// Configure security settings for PDF files
pdf.SecuritySettings.UserPassword = "user123";     // Password to open PDF documents
pdf.SecuritySettings.OwnerPassword = "owner456";   // Password to modify PDF files

// Set granular permissions for PDF format
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserAnnotations = false;
pdf.SecuritySettings.AllowUserPrinting = PrintPermissions.LowQualityPrint;

// Apply strong encryption to PDF documents
pdf.SecuritySettings.EncryptionAlgorithm = PdfEncryptionAlgorithm.AES256;
pdf.SaveAs("secure-document.pdf");

var renderer = new ChromePdfRenderer();
var renderer = new ChromePdfRenderer();

// Convert HTML to PDF with security
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential Report</h1>");

// Configure security settings for PDF files
pdf.SecuritySettings.UserPassword = "user123";     // Password to open PDF documents
pdf.SecuritySettings.OwnerPassword = "owner456";   // Password to modify PDF files

// Set granular permissions for PDF format
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserAnnotations = false;
pdf.SecuritySettings.AllowUserPrinting = PrintPermissions.LowQualityPrint;

// Apply strong encryption to PDF documents
pdf.SecuritySettings.EncryptionAlgorithm = PdfEncryptionAlgorithm.AES256;
pdf.SaveAs("secure-document.pdf");

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Confidential Report</h1>")

' Configure security settings for PDF files
pdf.SecuritySettings.UserPassword = "user123"     ' Password to open PDF documents
pdf.SecuritySettings.OwnerPassword = "owner456"   ' Password to modify PDF files

' Set granular permissions for PDF format
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserAnnotations = False
pdf.SecuritySettings.AllowUserPrinting = PrintPermissions.LowQualityPrint

' Apply strong encryption to PDF documents
pdf.SecuritySettings.EncryptionAlgorithm = PdfEncryptionAlgorithm.AES256
pdf.SaveAs("secure-document.pdf")

Cómo Agregar Firmas Digitales a Archivos PDF

Agregue firmas criptográficas para asegurar la autenticidad del documento PDF cuando genere archivos PDF a partir de contenido HTML.

var renderer = new ChromePdfRenderer();
using IronPdf.Signing;

var renderer = new ChromePdfRenderer();

// Generate PDF from HTML page
var pdf = renderer.RenderHtmlAsPdf("<h1>Contract Agreement</h1>");

// Create digital signature with certificate for PDF files
var signature = new PdfSignature("certificate.pfx", "password")
{
    SigningContact = "legal@company.com",
    SigningLocation = "New York, NY",
    SigningReason = "Contract Approval",
    SignerName = "Authorized Signer"  // New property in v2025.8.8 for enhanced signature details
};

// Apply signature to PDF documents
pdf.Sign(signature);
pdf.SaveAs("signed-contract.pdf");

var renderer = new ChromePdfRenderer();
using IronPdf.Signing;

var renderer = new ChromePdfRenderer();

// Generate PDF from HTML page
var pdf = renderer.RenderHtmlAsPdf("<h1>Contract Agreement</h1>");

// Create digital signature with certificate for PDF files
var signature = new PdfSignature("certificate.pfx", "password")
{
    SigningContact = "legal@company.com",
    SigningLocation = "New York, NY",
    SigningReason = "Contract Approval",
    SignerName = "Authorized Signer"  // New property in v2025.8.8 for enhanced signature details
};

// Apply signature to PDF documents
pdf.Sign(signature);
pdf.SaveAs("signed-contract.pdf");

Imports IronPdf.Signing

Dim renderer = New ChromePdfRenderer()

' Generate PDF from HTML page
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Contract Agreement</h1>")

' Create digital signature with certificate for PDF files
Dim signature = New PdfSignature("certificate.pfx", "password") With {
    .SigningContact = "legal@company.com",
    .SigningLocation = "New York, NY",
    .SigningReason = "Contract Approval",
    .SignerName = "Authorized Signer"  ' New property in v2025.8.8 for enhanced signature details
}

' Apply signature to PDF documents
pdf.Sign(signature)
pdf.SaveAs("signed-contract.pdf")

RELATED HOW-TO Article: Digitally Signing PDF Documents with C#

How to Convert HTML Forms to Fillable PDFs

To convert standard HTML form elements into interactive, fillable PDF form fields, enable the CreatePdfFormsFromHtml rendering option. This preserves text inputs, checkboxes, radio buttons, and dropdown menus as editable fields in the generated PDF document.

var renderer = new ChromePdfRenderer();

var renderer = new ChromePdfRenderer();

// Enable HTML form to PDF form conversion
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;

string htmlForm = @"
    <h2>Employee Onboarding Form</h2>
    <form>
        <label>Full Name:</label>
        <input type='text' name='fullName' value='' /><br/>
        <label>Department:</label>
        <select name='department'>
            <option value='engineering'>Engineering</option>
            <option value='marketing'>Marketing</option>
            <option value='sales'>Sales</option>
        </select><br/>
        <label>Agree to Terms:</label>
        <input type='checkbox' name='agreeTerms' />
    </form>";

var pdf = renderer.RenderHtmlAsPdf(htmlForm);
pdf.SaveAs("onboarding-form.pdf");

var renderer = new ChromePdfRenderer();

var renderer = new ChromePdfRenderer();

// Enable HTML form to PDF form conversion
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;

string htmlForm = @"
    <h2>Employee Onboarding Form</h2>
    <form>
        <label>Full Name:</label>
        <input type='text' name='fullName' value='' /><br/>
        <label>Department:</label>
        <select name='department'>
            <option value='engineering'>Engineering</option>
            <option value='marketing'>Marketing</option>
            <option value='sales'>Sales</option>
        </select><br/>
        <label>Agree to Terms:</label>
        <input type='checkbox' name='agreeTerms' />
    </form>";

var pdf = renderer.RenderHtmlAsPdf(htmlForm);
pdf.SaveAs("onboarding-form.pdf");

Dim renderer As New ChromePdfRenderer()

' Enable HTML form to PDF form conversion
renderer.RenderingOptions.CreatePdfFormsFromHtml = True

Dim htmlForm As String = "
    <h2>Employee Onboarding Form</h2>
    <form>
        <label>Full Name:</label>
        <input type='text' name='fullName' value='' /><br/>
        <label>Department:</label>
        <select name='department'>
            <option value='engineering'>Engineering</option>
            <option value='marketing'>Marketing</option>
            <option value='sales'>Sales</option>
        </select><br/>
        <label>Agree to Terms:</label>
        <input type='checkbox' name='agreeTerms' />
    </form>"

Dim pdf = renderer.RenderHtmlAsPdf(htmlForm)
pdf.SaveAs("onboarding-form.pdf")

RELATED HOW-TO Article: How to Create Fillable PDF Forms in C#

How to Convert Specific HTML Elements to PDF

To render a specific section of a page rather than the full document, isolate the target element before rendering. The most direct approach uses the JavaScript rendering option to replace the document body with the target element's content, combined with WaitFor.HtmlQuerySelector() to ensure the element exists before extraction. The snippet below preserves document.head so stylesheets and fonts carry over — without that step, CSS rules relying on ancestor selectors would be lost in the extracted PDF.

For server-side scenarios where you have access to the raw HTML, extract the target fragment with a parser like AngleSharp and pass it to RenderHtmlAsPdf() — no JavaScript execution needed.

var renderer = new ChromePdfRenderer();

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;

// Replace the body with only the target element
renderer.RenderingOptions.JavaScript = @"
    var el = document.querySelector('#invoice-summary');
    if (el) {
        var head = document.head.innerHTML;
        document.body.innerHTML = el.outerHTML;
        document.head.innerHTML = head;
    }
";

// Wait for the target element before JS executes
renderer.RenderingOptions.WaitFor.HtmlQuerySelector("#invoice-summary", 10000);

var pdf = renderer.RenderHtmlAsPdf(fullPageHtml);
pdf.SaveAs("invoice-summary.pdf");

var renderer = new ChromePdfRenderer();

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;

// Replace the body with only the target element
renderer.RenderingOptions.JavaScript = @"
    var el = document.querySelector('#invoice-summary');
    if (el) {
        var head = document.head.innerHTML;
        document.body.innerHTML = el.outerHTML;
        document.head.innerHTML = head;
    }
";

// Wait for the target element before JS executes
renderer.RenderingOptions.WaitFor.HtmlQuerySelector("#invoice-summary", 10000);

var pdf = renderer.RenderHtmlAsPdf(fullPageHtml);
pdf.SaveAs("invoice-summary.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

renderer.RenderingOptions.EnableJavaScript = True

' Replace the body with only the target element
renderer.RenderingOptions.JavaScript = "
    var el = document.querySelector('#invoice-summary');
    if (el) {
        var head = document.head.innerHTML;
        document.body.innerHTML = el.outerHTML;
        document.head.innerHTML = head;
    }
"

' Wait for the target element before JS executes
renderer.RenderingOptions.WaitFor.HtmlQuerySelector("#invoice-summary", 10000)

Dim pdf = renderer.RenderHtmlAsPdf(fullPageHtml)
pdf.SaveAs("invoice-summary.pdf")

RELATED HOW-TO Article: How to Convert HTML Elements and Partial Pages to PDF

How to Render Authenticated Pages to PDF

There are three mechanisms for rendering pages that sit behind authentication: network login credentials, custom cookies, and HTTP request headers. These cover the most common authentication scenarios when converting protected web content to PDF.

Login Credentials

Use ChromeHttpLoginCredentials for basic, digest, or NTLM authentication when converting protected URLs to PDF.

var renderer = new ChromePdfRenderer();

var renderer = new ChromePdfRenderer();

// Configure network authentication
renderer.LoginCredentials = new ChromeHttpLoginCredentials
{
    NetworkUsername = "user@domain.com",
    NetworkPassword = "securePassword",
    AuthenticationType = ChromeHttpLoginCredentials.AuthType.Basic
};

var pdf = renderer.RenderUrlAsPdf("https://intranet.company.com/reports");
pdf.SaveAs("authenticated-report.pdf");

var renderer = new ChromePdfRenderer();

var renderer = new ChromePdfRenderer();

// Configure network authentication
renderer.LoginCredentials = new ChromeHttpLoginCredentials
{
    NetworkUsername = "user@domain.com",
    NetworkPassword = "securePassword",
    AuthenticationType = ChromeHttpLoginCredentials.AuthType.Basic
};

var pdf = renderer.RenderUrlAsPdf("https://intranet.company.com/reports");
pdf.SaveAs("authenticated-report.pdf");

Imports System

Dim renderer As New ChromePdfRenderer()

' Configure network authentication
renderer.LoginCredentials = New ChromeHttpLoginCredentials With {
    .NetworkUsername = "user@domain.com",
    .NetworkPassword = "securePassword",
    .AuthenticationType = ChromeHttpLoginCredentials.AuthType.Basic
}

Dim pdf = renderer.RenderUrlAsPdf("https://intranet.company.com/reports")
pdf.SaveAs("authenticated-report.pdf")

Cookies and HTTP Headers

For token-based or session-based authentication, attach custom cookies and HTTP headers directly to the rendering request.

var renderer = new ChromePdfRenderer();

var renderer = new ChromePdfRenderer();

// Add session cookies
renderer.RenderingOptions.CustomCookies["sessionId"] = "abc123token";
renderer.RenderingOptions.CustomCookies["authToken"] = "bearer-xyz";

// Add custom HTTP headers (e.g., API key or Bearer token)
renderer.RenderingOptions.CustomHttpRequestHeaders["Authorization"] = "Bearer eyJhbGciOi...";

var pdf = renderer.RenderUrlAsPdf("https://app.example.com/dashboard");
pdf.SaveAs("dashboard.pdf");

var renderer = new ChromePdfRenderer();

var renderer = new ChromePdfRenderer();

// Add session cookies
renderer.RenderingOptions.CustomCookies["sessionId"] = "abc123token";
renderer.RenderingOptions.CustomCookies["authToken"] = "bearer-xyz";

// Add custom HTTP headers (e.g., API key or Bearer token)
renderer.RenderingOptions.CustomHttpRequestHeaders["Authorization"] = "Bearer eyJhbGciOi...";

var pdf = renderer.RenderUrlAsPdf("https://app.example.com/dashboard");
pdf.SaveAs("dashboard.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Add session cookies
renderer.RenderingOptions.CustomCookies("sessionId") = "abc123token"
renderer.RenderingOptions.CustomCookies("authToken") = "bearer-xyz"

' Add custom HTTP headers (e.g., API key or Bearer token)
renderer.RenderingOptions.CustomHttpRequestHeaders("Authorization") = "Bearer eyJhbGciOi..."

Dim pdf = renderer.RenderUrlAsPdf("https://app.example.com/dashboard")
pdf.SaveAs("dashboard.pdf")

RELATED HOW-TO Article: How to Convert HTML Behind Login Authentication to PDF

How to Deploy on Azure

When deploying to Azure Functions or App Service, disable GPU acceleration and ensure your hosting tier provides enough memory for Chrome-based rendering. Add these settings at application startup, before any rendering calls.

Azure sandboxes run headless with no GPU access, and Free/Shared tiers (F1, D1) lack the resources Chrome requires. Target a B1 (Basic) tier or higher.

var renderer = new ChromePdfRenderer();

// Azure sandboxes block GPU access — always disable
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;
// Required on non-GUI Linux systems
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = true;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Azure PDF Report</h1>");
pdf.SaveAs("azure-report.pdf");

var renderer = new ChromePdfRenderer();

// Azure sandboxes block GPU access — always disable
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;
// Required on non-GUI Linux systems
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = true;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Azure PDF Report</h1>");
pdf.SaveAs("azure-report.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Azure sandboxes block GPU access — always disable
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled
' Required on non-GUI Linux systems
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = True

Dim pdf = renderer.RenderHtmlAsPdf("<h1>Azure PDF Report</h1>")
pdf.SaveAs("azure-report.pdf")

RELATED GET-STARTED Guide: How to Deploy IronPDF on Azure

How to Deploy on AWS Lambda

AWS Lambda requires Docker-based deployment for Chrome-based PDF rendering. The default Lambda filesystem is read-only, so all temp and deployment paths must point to /tmp.

Configure these settings at the top of your function handler, before any rendering calls.

using Amazon.Lambda.Core;
var renderer = new ChromePdfRenderer();

public class PdfFunction
{
    public string FunctionHandler(string input, ILambdaContext context)
    {
        // Lambda's only writable directory
        var tmpPath = "/tmp/";

        IronPdf.Installation.TempFolderPath = tmpPath;
        IronPdf.Installation.CustomDeploymentDirectory = tmpPath;
        IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;
        // Let IronPDF install Chrome dependencies on first cold start
        IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = true;

        context.Logger.LogLine("Rendering PDF...");

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(input);

        // Save to /tmp before uploading to S3 or returning
        var outputPath = $"{tmpPath}output.pdf";
        pdf.SaveAs(outputPath);

        return outputPath;
    }
}

using Amazon.Lambda.Core;
var renderer = new ChromePdfRenderer();

public class PdfFunction
{
    public string FunctionHandler(string input, ILambdaContext context)
    {
        // Lambda's only writable directory
        var tmpPath = "/tmp/";

        IronPdf.Installation.TempFolderPath = tmpPath;
        IronPdf.Installation.CustomDeploymentDirectory = tmpPath;
        IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;
        // Let IronPDF install Chrome dependencies on first cold start
        IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = true;

        context.Logger.LogLine("Rendering PDF...");

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(input);

        // Save to /tmp before uploading to S3 or returning
        var outputPath = $"{tmpPath}output.pdf";
        pdf.SaveAs(outputPath);

        return outputPath;
    }
}

Imports Amazon.Lambda.Core

Dim renderer As New ChromePdfRenderer()

Public Class PdfFunction
    Public Function FunctionHandler(input As String, context As ILambdaContext) As String
        ' Lambda's only writable directory
        Dim tmpPath As String = "/tmp/"

        IronPdf.Installation.TempFolderPath = tmpPath
        IronPdf.Installation.CustomDeploymentDirectory = tmpPath
        IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled
        ' Let IronPDF install Chrome dependencies on first cold start
        IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = True

        context.Logger.LogLine("Rendering PDF...")

        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(input)

        ' Save to /tmp before uploading to S3 or returning
        Dim outputPath As String = $"{tmpPath}output.pdf"
        pdf.SaveAs(outputPath)

        Return outputPath
    End Function
End Class

RELATED GET-STARTED Guide: How to Deploy IronPDF on AWS Lambda

How to Deploy with Docker

For Docker deployments, use the IronPdf.Linux NuGet package to reduce image size and avoid runtime asset downloads. This package includes pre-bundled Linux-native binaries optimized for containerized environments.

Set LinuxAndDockerDependenciesAutoConfig = false when your Dockerfile already installs Chrome's shared-library dependencies via apt-get. The runtime auto-install is redundant in that case and can cause permission errors or longer cold starts.

A minimal multi-stage Dockerfile for an Ubuntu/Debian-based image:

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /app
COPY . .
RUN dotnet publish -c Release -o /out

FROM mcr.microsoft.com/dotnet/aspnet:8.0
# Install Chrome dependencies for PDF rendering
RUN apt-get update && apt-get install -y \
    libglib2.0-0 libnss3 libatk1.0-0 libatk-bridge2.0-0 \
    libcups2 libdrm2 libxkbcommon0 libxcomposite1 \
    libxdamage1 libxrandr2 libgbm1 libpango-1.0-0 \
    libcairo2 libasound2 libxshmfence1 && \
    rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY --from=build /out .
ENTRYPOINT ["dotnet", "MyApp.dll"]

var renderer = new ChromePdfRenderer();

// Dependencies handled by Dockerfile apt-get — disable runtime install
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = false;
// No GPU in containers
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Dockerized PDF</h1>");
pdf.SaveAs("output.pdf");

var renderer = new ChromePdfRenderer();

// Dependencies handled by Dockerfile apt-get — disable runtime install
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = false;
// No GPU in containers
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Dockerized PDF</h1>");
pdf.SaveAs("output.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Dependencies handled by Dockerfile apt-get — disable runtime install
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = False
' No GPU in containers
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled

Dim pdf = renderer.RenderHtmlAsPdf("<h1>Dockerized PDF</h1>")
pdf.SaveAs("output.pdf")

RELATED GET-STARTED Guide: How to Use IronPDF with Docker

Matriz de decisión rápida: IronPDF frente a otros convertidores de PDF .NET

COMPARACIONES RELACIONADAS:

• Comparar IronPDF y Syncfusion
• Comparar IronPDF y Aspose

Comparación detallada: IronPDF frente a otros convertidores de PDF .NET

Comparación de conversión de HTML a PDF en la vida real: Representación de la página de inicio de Reddit

Para evaluar la calidad del PDF de salida, probamos estas bibliotecas con la página principal de Reddit que contiene contenido web dinámico, CSS moderno y elementos HTML de JavaScript. Esta página sirve como un caso de prueba ideal para la generación de PDF de salida.

https://www.reddit.com/

IronPDF

IronPDF ofrece resultados pixel-perfect, preservando todo el contenido web dinámico, el estilo de fuentes web modernas y los elementos interactivos exactamente como se muestran en Chrome, todo en tan solo unas pocas líneas de código.

Syncfusion

Syncfusion renderizó el PDF con la mayoría de las secciones y estilos ausentes, especialmente el contenido dinámico. Inicialmente bloqueado por la seguridad de Reddit. Lograr mejores resultados requiere una extensa configuración de línea de comandos, pero la salida sigue siendo incompleta.

Aspose.PDF

Aspose.PDF requirió primero una descarga manual de HTML (sin soporte para URL directo). Después de la conversión, el resultado carecía de un formato adecuado y se perdieron casi todas las secciones de contenido, lo que lo hace inadecuado para la web moderna con contenido dinámico.

wkhtmltopdf

wkhtmltopdf se completó rápidamente, pero produjo una página plana y estática que carece de contenido crítico como actualizaciones en vivo, elementos dinámicos y secciones interactivas. Esto demuestra la incompatibilidad de wkhtmltopdf con sitios web modernos impulsados por JavaScript.

Conclusión sobre el rendimiento y la calidad del PDF de salida

Para los desarrolladores .NET que necesitan un conversor confiable de HTML a PDF, IronPDF se destaca con un código mínimo, APIs fáciles de usar y mejoras frecuentes del producto.

En una prueba del mundo real en contenido web, ofreció los resultados más rápidos y precisos, mientras que Syncfusion quedó rezagado, Aspose requirió pasos adicionales y wkhtmltopdf careció de estilo moderno. IronPDF ofrece el mejor equilibrio de velocidad, precisión y simplicidad para los flujos de trabajo de conversión de HTML a PDF de hoy.

Por favor note: Aspose, SyncFusion y wkhtmltopdf son marcas comerciales de sus respectivos propietarios. Este sitio no está afiliado ni es patrocinado por ellos. Todos los nombres, logotipos y marcas pertenecen a sus propietarios, y las comparaciones se basan en la información públicamente disponible al momento de escribir.

Resumen

Esta guía cubrió todo lo necesario para convertir HTML a PDF en .NET: desde la conversión básica de cadenas hasta funciones avanzadas como procesamiento asíncrono, firmas digitales y generación de lotes. Demostramos tres métodos de conversión, configuraciones esenciales, funciones avanzadas y configuraciones de seguridad, y comparamos IronPDF con otras bibliotecas mediante pruebas del mundo real de generación de documentos dinámicos.

Mientras los competidores lucharon con sitios web modernos o requerían soluciones complejas, IronPDF ofreció resultados impecables con un código mínimo y un potente motor de renderización.

¿Listo para simplificar tu flujo de trabajo de PDF y experimentar una generación versátil de PDF en solo unas pocas líneas de código? Instala IronPDF a través del Administrador de Paquetes NuGet (o selecciona Administrar Paquetes NuGet en Visual Studio) y convierte tu primer HTML a PDF hoy.

Comienza tu prueba gratuita de 30 días para realizar pruebas de producción sin marcas de agua. Flexible licensing starts at $799 with transparent team pricing that scales with your needs.

Ver licencias de IronPDF

Soluciones rápidas a errores comunes

• ¿Lenta primera renderización? Normal. Chrome se inicializa en 2–3s, luego acelera.
• ¿Problemas en la nube? Usa al menos Azure B1 o recursos equivalentes.
• ¿Recursos faltantes? Configura rutas base o incrusta como base64.
• ¿Elementos faltantes? Agrega RenderDelay para la ejecución de JavaScript.
• ¿Memoria en renderización? Actualiza a v2025.9.4 para correcciones en HTML a PDF, sellos y encabezados/pies.
• ¿Problemas con campos de formulario (p.ej., áreas de texto largas, casillas de verificación)? Corregido en v2025.7.17; asegúrate de nombres únicos para casillas de verificación.
• ¿Recorte de encabezado/pie personalizado o caracteres especiales corruptos? Resuelto en v2025.8.8; prueba el ajuste de palabras y metadatos.

Obtenga ayuda de los ingenieros que construyeron IronPDF, 24/7

• Guía completa de solución de problemas
• Estrategias de optimización del rendimiento
• Solicitudes de soporte de ingeniería
• Lista de verificación rápida para la resolución de problemas

Próximos pasos