Como converter HTML para PDF em C# (Guia do desenvolvedor)

Como converter uma string HTML em PDF

A operação mais fundamental é a conversão de uma string HTML para PDF. Este método é perfeito para conteúdo HTML gerado dinamicamente. O método RenderHtmlAsPdf oferece suporte completo a HTML5, CSS3, JavaScript e imagens ao converter HTML diretamente para PDF.

using IronPDF;

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

using IronPDF;

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

Imports IronPDF

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

Quando sua string HTML fizer referência a recursos locais, como imagens ou folhas de estilo, use o parâmetro BaseUrlPath para converter corretamente o conteúdo HTML com todos os recursos:

using IronPDF;

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

using IronPDF;

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#

Como exportar um URL existente para PDF

A renderização de páginas web inteiras em PDFs com C# permite que as equipes separem o trabalho de design de PDF do trabalho de renderização no back-end. Essa abordagem permite converter qualquer URL especificada diretamente para o formato PDF.

CSS de impressão vs. CSS de tela

Você pode configurar o IronPDF para renderizar usando qualquer um dos tipos de mídia CSS.

using IronPDF;
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

using IronPDF;
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
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

Suporte a JavaScript

O IronPDF oferece suporte completo a JavaScript, jQuery e até mesmo AJAX ao converter HTML para PDF. Para conteúdo HTML dinâmico, você pode configurar o IronPDF para aguardar a conclusão do JavaScript antes de renderizar as páginas da web em PDF. Isso é perfeito para aplicativos de página única e sites dinâmicos.

using IronPDF;

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

using IronPDF;

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

Imports IronPDF

' 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

A execução de JavaScript também pode ser exibida ao renderizar um gráfico de acordes avançado do d3.js de uma página da web para o formato PDF:

using IronPDF;

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

using IronPDF;

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

Imports IronPDF

' Create renderer for JavaScript-heavy HTML
Dim renderer As 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

Como as páginas web responsivas são projetadas para serem visualizadas em um navegador, e o IronPDF não abre uma janela de navegador real no sistema operacional do seu servidor, os elementos HTML responsivos podem ser renderizados em seu menor tamanho. Recomenda-se o uso do código PdfCssMediaType.Print para contornar esse problema ao renderizar páginas web inteiras.

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

Como converter um arquivo HTML em PDF

A conversão de arquivos HTML locais para PDF preserva todos os recursos relevantes, incluindo CSS, imagens e JavaScript, como se tivessem sido abertos usando o protocolo file://. Este método de conversão de HTML para PDF é ideal para converter modelos ou páginas HTML pré-formatadas em documentos PDF.

using IronPDF;

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

using IronPDF;

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

Imports IronPDF

' 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

Como converter páginas Razor para PDF

Se o seu projeto ASP.NET Core já utiliza Razor Pages, você pode convertê-las diretamente para PDF sem precisar reconstruir o seu HTML. A extensão Razor do IronPDF adiciona o método RenderRazorToPdf, que pega sua página .cshtml — completa com seu modelo e layout — e a renderiza como um documento PDF em uma única chamada.

PM > Install-Package IronPdf.Extensions.Razor

PM > Install-Package IronPdf.Extensions.Razor

using IronPDF;

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

using IronPDF;

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 IronPDF

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

Como converter visualizações MVC em PDF

Equipes que utilizam o padrão MVC podem gerar PDFs diretamente de suas Views e controllers existentes. Instale o pacote de extensão MVC Core e, em seguida, chame RenderRazorViewToPdf com o caminho da sua view e o modelo — o IronPDF lida com o pipeline de renderização Razor e gera um PDF finalizado.

Isso é especialmente útil para relatórios, faturas e qualquer página cujo HTML já esteja projetado e testado no navegador. O PDF gerado preserva a saída completa da visualização, incluindo páginas de layout e visualizações parciais.

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

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

Primeiro, registre o serviço IRazorViewRenderer em seu arquivo Program.cs para que seus controladores possam injetá-lo:

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

Em seguida, na ação do seu controlador, injete o renderizador e converta qualquer View em PDF:

using IronPDF;
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");

using IronPDF;
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
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

Como configurar cabeçalhos HTTP, cookies e credenciais de login personalizados

Ao renderizar URLs que exigem autenticação ou metadados de solicitação específicos, o IronPDF permite incluir credenciais de login, cookies de sessão e cabeçalhos HTTP na solicitação. Isso possibilita a renderização de painéis de intranet, relatórios restritos ou páginas geradas por API diretamente em PDF, sem a necessidade de recuperar o HTML separadamente.

Para autenticação básica ou NTLM, defina um objeto LoginCredentials no renderizador. Para acesso baseado em token ou baseado em sessão, passe cookies e cabeçalhos por RenderingOptions antes de chamar RenderUrlAsPdf.

using IronPDF;

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

using IronPDF;

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

ARTIGOS RELACIONADOS COM TUTORIAIS: Render PDFs Behind Login Authentication | Custom HTTP Request Headers

Como configurar o proxy para renderização de PDF

Ao renderizar HTML que carrega recursos externos por trás de um proxy corporativo, passe o endereço do proxy como o terceiro parâmetro em RenderHtmlAsPdf(). Este é um parâmetro de método, não uma propriedade em ChromePdfRenderOptions — portanto, é definido por chamada de renderização, não na instância do renderizador.

Para proxies autenticados, incorpore as credenciais diretamente na URL usando o formato http://user:pass@host:port. Codifique caracteres especiais em senhas usando Uri.EscapeDataString().

using IronPDF;

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

using IronPDF;

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

Imports IronPDF

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

Observe que RenderUrlAsPdf() não aceita um parâmetro proxy. Para renderizar uma URL ao vivo por trás de um proxy, busque o HTML primeiro com HttpClient configurado com um WebProxy, depois passe-o para RenderHtmlAsPdf() com o parâmetro de proxy para carregamento de recursos.

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

Como gerar um modelo HTML para criação em lote de PDFs

Criação básica de PDFs em lote

A criação em lote de PDFs é essencial para gerar vários documentos PDF personalizados de forma eficiente. Para cenários básicos, o método String.Format em C# funciona melhor para manipulação simples de PDFs.

// 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 modelos mais longos, quando você precisar gerar documentos PDF, use a substituição de marcadores de posição no seu conteúdo HTML: using IronPDF;

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

Criação de modelos HTML para PDF com Handlebars .NET

Para modelos complexos com loops e condicionais ao converter HTML para PDF, use modelos avançados com Handlebars.NET para gerar documentos PDF com conteúdo HTML dinâmico.

# 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;
using IronPDF;

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

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

' 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 renderer = New ChromePdfRenderer()
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>

Como gerar um PDF usando um método assíncrono

O IronPDF oferece desempenho de nível empresarial com suporte completo a operações assíncronas e multithreading para suas necessidades de conversão de HTML para PDF, quando você precisa gerar arquivos PDF em grande escala.

using IronPDF;
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> htmlModelos)
{
    var renderer = new ChromePdfRenderer();

    // Create parallel conversion tasks to generate PDF documents
    var tasks = htmlModelos.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");
    }
}

using IronPDF;
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> htmlModelos)
{
    var renderer = new ChromePdfRenderer();

    // Create parallel conversion tasks to generate PDF documents
    var tasks = htmlModelos.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 IronPDF
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(htmlModelos As List(Of String)) As Task
    Dim renderer As New ChromePdfRenderer()

    ' Create parallel conversion tasks to generate PDF documents
    Dim tasks = htmlModelos.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

• Utilize sistemas de 64 bits para obter o melhor desempenho na geração de PDFs.
• Ao gerar documentos PDF, assegure-se de que o servidor tenha recursos suficientes (evite planos gratuitos com capacidade insuficiente).
• Permitir um tempo de renderização (RenderDelay) suficiente for JavaScript complexo em conteúdo HTML.
• Reutilize instâncias de ChromePdfRenderer sempre que possível.
• Aproveite as correções de memória da versão 2025.9.4 para operações em lote/assíncronas para reduzir o uso de recursos; Teste para redução do tamanho dos arquivos com cabeçalhos/rodapés personalizados repetidos.

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

Como adicionar recursos avançados de segurança

Como adicionar proteção por senha a arquivos PDF no .NET

Proteja documentos PDF confidenciais gerados com senhas e permissões ao converter conteúdo HTML para o formato PDF protegido.

using IronPDF;
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");

using IronPDF;
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");

Imports IronPDF

Dim renderer As New ChromePdfRenderer()

' Convert HTML to PDF with security
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")

Como adicionar assinaturas digitais a arquivos PDF

Adicione assinaturas criptográficas para garantir a autenticidade de documentos PDF ao gerar arquivos PDF a partir de conteúdo HTML.

using IronPDF;
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");

using IronPDF;
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
Imports IronPdf.Signing

Dim renderer As 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 As 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#

Como converter formulários HTML em PDFs preenchíveis

Para converter elementos de formulário HTML padrão em campos de formulário PDF interativos e preenchíveis, habilite a opção de renderização CreatePdfFormsFromHtml. Isso preserva os campos de texto, caixas de seleção, botões de opção e menus suspensos como campos editáveis ​​no documento PDF gerado.

using IronPDF;

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

using IronPDF;

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

Imports IronPDF

Dim renderer = 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#

Como converter elementos HTML específicos em PDF

Para renderizar uma seção específica de uma página em vez do documento inteiro, isole o elemento desejado antes da renderização. A abordagem mais direta utiliza a opção de renderização JavaScript para substituir o corpo do documento pelo conteúdo do elemento alvo, combinada com WaitFor.HtmlQuerySelector() para garantir que o elemento exista antes da extração. O trecho de código abaixo preserva document.head para que as folhas de estilo e as fontes sejam mantidas — sem essa etapa, as regras CSS que dependem de seletores ancestrais seriam perdidas no PDF extraído.

Para cenários do lado do servidor onde você tem acesso ao HTML bruto, extraia o fragmento de destino com um analisador como o AngleSharp e passe-o para RenderHtmlAsPdf() — nenhuma execução de JavaScript é necessária.

using IronPDF;

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

using IronPDF;

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

Como converter páginas autenticadas em PDF

Existem três mecanismos para renderizar páginas que exigem autenticação: credenciais de login de rede, cookies personalizados e cabeçalhos de solicitação HTTP. Estas diretrizes abrangem os cenários de autenticação mais comuns na conversão de conteúdo web protegido para PDF.

Credenciais de login

Use ChromeHttpLoginCredentials para autenticação básica, digest ou NTLM ao converter URLs protegidas em PDF.

using IronPDF;

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

using IronPDF;

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 IronPDF

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 e cabeçalhos HTTP

Para autenticação baseada em token ou em sessão, anexe cookies personalizados e cabeçalhos HTTP diretamente à solicitação de renderização.

using IronPDF;

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

using IronPDF;

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

Como implantar no Azure

Ao implantar no Azure Functions ou no Serviço de Aplicativos, desative a aceleração por GPU e certifique-se de que sua camada de hospedagem forneça memória suficiente para a renderização baseada no Chrome. Adicione essas configurações na inicialização do aplicativo, antes de qualquer chamada de renderização.

Os ambientes de teste do Azure são executados sem interface gráfica e sem acesso à GPU, e os níveis Gratuito/Compartilhado (F1, D1) não possuem os recursos necessários para o Chrome. Almeje um nível B1 (Básico) ou superior.

using IronPDF;

// Azure sandboxes block GPU access — always disable
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;
// Required on non-GUI Linux systems
IronPdf.Installation.LinuxAndDockerDependenciesConfiguração automática = true;

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

using IronPDF;

// Azure sandboxes block GPU access — always disable
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;
// Required on non-GUI Linux systems
IronPdf.Installation.LinuxAndDockerDependenciesConfiguração automática = true;

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

Imports IronPDF

' 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 renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Azure PDF Report</h1>")
pdf.SaveAs("azure-report.pdf")

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

Como fazer a implantação no AWS Lambda

O AWS Lambda requer uma implantação baseada em Docker para renderização de PDFs no Chrome. O sistema de arquivos padrão do Lambda é somente leitura, portanto, todos os caminhos temporários e de implantação devem apontar para /tmp.

Configure essas definições no início do seu manipulador de função, antes de qualquer chamada de renderização.

using Amazon.Lambda.Core;
using IronPDF;

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.LinuxAndDockerDependenciesConfiguração automática = 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;
using IronPDF;

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.LinuxAndDockerDependenciesConfiguração automática = 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
Imports IronPDF

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

Como fazer deploy com Docker

Para implantações do Docker, use o pacote NuGet IronPdf.Linux para reduzir o tamanho da imagem e evitar downloads de recursos de tempo de execução. Este pacote inclui binários nativos do Linux pré-compilados e otimizados para ambientes conteinerizados.

Defina LinuxAndDockerDependenciesConfiguração automática = false quando seu Dockerfile já instalar as dependências da biblioteca compartilhada do Chrome via apt-get. A instalação automática em tempo de execução é redundante nesse caso e pode causar erros de permissão ou inicializações a frio mais demoradas.

Um Dockerfile mínimo de múltiplas etapas para uma imagem baseada em Ubuntu/Debian:

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

using IronPDF;

// Dependencies handled by Dockerfile apt-get — disable runtime install
IronPdf.Installation.LinuxAndDockerDependenciesConfiguração automática = 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");

using IronPDF;

// Dependencies handled by Dockerfile apt-get — disable runtime install
IronPdf.Installation.LinuxAndDockerDependenciesConfiguração automática = 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

' 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 renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Dockerized PDF</h1>")
pdf.SaveAs("output.pdf")

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

Matriz de decisão rápida: IronPDF versus outros conversores de PDF .NET

COMPARAÇÕES RELACIONADAS:

• Compare IronPDF e Syncfusion.
• Compare IronPDF e Aspose

Comparação detalhada: IronPDF versus outros conversores de PDF .NET

Comparação real de conversão de HTML para PDF: Renderizando a página inicial do Reddit

Para avaliar a qualidade do PDF gerado, testamos essas bibliotecas com a página inicial do Reddit, que contém conteúdo web dinâmico, CSS moderno e elementos HTML em JavaScript . Esta página serve como um caso de teste ideal para a geração de PDFs de saída.

https://www.reddit.com/

IronPDF

O IronPDF oferece resultados perfeitos em cada pixel, preservando todo o conteúdo dinâmico da web, o estilo das fontes modernas e os elementos interativos exatamente como são exibidos no Chrome, tudo com apenas algumas linhas de código.

Syncfusion

O PDF gerado pela Syncfusion apresenta a maioria das seções e estilos ausentes, especialmente o conteúdo dinâmico. Inicialmente bloqueado pela segurança do Reddit. Para obter melhores resultados, é necessário um ajuste extenso da linha de comando, mas a saída ainda permanece incompleta.

Aspose.PDF

O Aspose.PDF requer primeiro o download manual do HTML (não há suporte para URL direta). Após a conversão, o resultado apresentou formatação inadequada e faltaram quase todas as seções de conteúdo, tornando-o inadequado para a web moderna com conteúdo dinâmico.

wkhtmltopdf

O wkhtmltopdf foi executado rapidamente, mas gerou uma página estática e simples, sem conteúdo essencial como atualizações em tempo real, elementos dinâmicos e seções interativas. Isso demonstra a incompatibilidade do wkhtmltopdf com sites modernos baseados em JavaScript.

Conclusão sobre o desempenho e a qualidade do PDF de saída

Para desenvolvedores .NET que precisam de um conversor confiável de HTML para PDF, o IronPDF se destaca por seu código minimalista, APIs fáceis de usar e frequentes melhorias no produto.

Em um teste prático com conteúdo da web, o wkhtmltopdf apresentou os resultados mais rápidos e precisos, enquanto o Syncfusion ficou para trás, o Aspose exigiu etapas adicionais e o wkhtmltopdf não conseguiu implementar estilos modernos. O IronPDF oferece o melhor equilíbrio entre velocidade, precisão e simplicidade para os fluxos de trabalho de conversão de HTML para PDF atuais.

Observe: Aspose, SyncFusion e wkhtmltopdf são marcas registradas de seus respectivos proprietários. Este site não possui qualquer vínculo ou endosso por parte deles. Todos os nomes, logotipos e marcas pertencem aos seus respectivos proprietários, e as comparações são baseadas em informações publicamente disponíveis no momento da redação deste texto.

Resumo

Este guia abordou tudo o que é necessário para converter HTML em PDF em .NET: desde a conversão básica de strings até recursos avançados como processamento assíncrono, assinaturas digitais e geração em lote. Demonstramos três métodos de conversão, configurações essenciais, recursos avançados e configurações de segurança, e comparamos o IronPDF com outras bibliotecas por meio de testes práticos de geração dinâmica de documentos.

Enquanto os concorrentes enfrentavam dificuldades com sites modernos ou exigiam soluções alternativas complexas, o IronPDF oferecia resultados impecáveis ​​com código mínimo e um mecanismo de renderização poderoso.

Pronto para simplificar seu fluxo de trabalho com PDFs e experimentar a geração versátil de PDFs com apenas algumas linhas de código? Instale o IronPDF através do Gerenciador de Pacotes NuGet (ou selecione "Gerenciar Pacotes NuGet " no Visual Studio) e converta seu primeiro HTML para PDF hoje mesmo.

Inicie seu teste gratuito de 30 dias para testes de produção sem marcas d'água. Licenciamento flexível a partir de $799 com preços transparentes para equipes que se adaptam às suas necessidades.

Veja o licenciamento do IronPDF

Soluções rápidas para erros comuns

• Renderização inicial lenta? Normal. O Chrome inicializa em 2 a 3 segundos e depois acelera.
• Problemas com a nuvem? Utilize pelo menos o Azure B1 ou recursos equivalentes.
• Ativos desaparecidos? Defina os caminhos base ou incorpore como base64.
• Faltam elementos? Adicione um RenderDelay para a execução do JavaScript .
• Memória durante a renderização? Atualize para a versão 2025.9.4 para correções na conversão de HTML para PDF, carimbos e cabeçalhos/rodapés.
• Problemas com campos de formulário (ex.: áreas de texto longas, caixas de seleção)? Corrigido na versão 2025.7.17; Garanta nomes únicos para as caixas de seleção.
• O cabeçalho/rodapé personalizado está sendo cortado ou os caracteres especiais estão corrompidos? Resolvido na versão 2025.8.8; Testar quebra automática de linha e metadados.

Obtenha ajuda dos engenheiros que construíram o IronPDF, 24 horas por dia, 7 dias por semana.

• Guia completo de resolução de problemas
• Estratégias de otimização de desempenho
• Solicitações de suporte de engenharia
• Lista de verificação rápida para solução de problemas

Próximos passos