Descubra o melhor software de redação de PDFs para 2025

PuppeteerSharp

PuppeteerSharp é uma porta .NET do Puppeteer Node.js do Google, lançado pela primeira vez em 2017. Ele dirige uma instância headless do Chromium sobre o Protocolo de Ferramentas de Desenvolvimento do Chrome. É um orquestrador de processos em vez de uma biblioteca em processo: o aplicativo faz o download de uma compilação do Chromium com BrowserFetcher, inicia o navegador, define o conteúdo da página e captura o PDF.

using PuppeteerSharp;
using System.Threading.Tasks;

public class PuppeteerExample
{
    public async Task GeneratePdfAsync()
    {
        // Download a matching Chromium build if it is not already present (the 100-300 MB fetch)
        await new BrowserFetcher().DownloadAsync();

        // Start a headless browser process; await using disposes it to avoid orphaned processes
        await using var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true });
        // Open a fresh tab to work in
        await using var page = await browser.NewPageAsync();

        // Load the HTML directly into the page instead of navigating to a URL
        await page.SetContentAsync("<h1>Invoice Report</h1><p>Rendered with PuppeteerSharp.</p>");
        // Drive Chrome's print pipeline to emit the PDF file
        await page.PdfAsync("puppeteer_output.pdf");
    }
}

using PuppeteerSharp;
using System.Threading.Tasks;

public class PuppeteerExample
{
    public async Task GeneratePdfAsync()
    {
        // Download a matching Chromium build if it is not already present (the 100-300 MB fetch)
        await new BrowserFetcher().DownloadAsync();

        // Start a headless browser process; await using disposes it to avoid orphaned processes
        await using var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true });
        // Open a fresh tab to work in
        await using var page = await browser.NewPageAsync();

        // Load the HTML directly into the page instead of navigating to a URL
        await page.SetContentAsync("<h1>Invoice Report</h1><p>Rendered with PuppeteerSharp.</p>");
        // Drive Chrome's print pipeline to emit the PDF file
        await page.PdfAsync("puppeteer_output.pdf");
    }
}

Imports PuppeteerSharp
Imports System.Threading.Tasks

Public Class PuppeteerExample
    Public Async Function GeneratePdfAsync() As Task
        ' Download a matching Chromium build if it is not already present (the 100-300 MB fetch)
        Await New BrowserFetcher().DownloadAsync()

        ' Start a headless browser process; using disposes it to avoid orphaned processes
        Using browser = Await Puppeteer.LaunchAsync(New LaunchOptions With {.Headless = True})
            ' Open a fresh tab to work in
            Using page = Await browser.NewPageAsync()
                ' Load the HTML directly into the page instead of navigating to a URL
                Await page.SetContentAsync("<h1>Invoice Report</h1><p>Rendered with PuppeteerSharp.</p>")
                ' Drive Chrome's print pipeline to emit the PDF file
                Await page.PdfAsync("puppeteer_output.pdf")
            End Using
        End Using
    End Function
End Class

Para capturar uma URL ao vivo em vez de uma string, navegue até ela antes da chamada:

// Navigate the tab to a live URL so the loaded page becomes the render source
await page.GoToAsync("https://example.com");
// Capture whatever is currently displayed as a PDF
await page.PdfAsync("from_url.pdf");

// Navigate the tab to a live URL so the loaded page becomes the render source
await page.GoToAsync("https://example.com");
// Capture whatever is currently displayed as a PDF
await page.PdfAsync("from_url.pdf");

Imports System.Threading.Tasks

' Navigate the tab to a live URL so the loaded page becomes the render source
Await page.GoToAsync("https://example.com")
' Capture whatever is currently displayed as a PDF
Await page.PdfAsync("from_url.pdf")

Pontos fortes:

• A renderização corresponde ao Google Chrome, com suporte completo a Flexbox, Grid e fontes da web.
• ExecutaJavaScripte pode esperar até que a rede esteja ociosa antes de capturar.
• Licenciado sob MIT, portanto, o uso comercial não acarreta obrigação copyleft.

Limitações:

• Uma primeira execução faz o download de uma compilação do Chromium de 100 MB a 300 MB.
• Cada instância do navegador consome memória significativa, então lotes simultâneos precisam de um pool de navegadores.
• Sem saída integrada em PDF/A ou PDF/UA.

License: MIT. Procure por ele quando você quiser uma saída de fidelidade de Chrome gratuita e a equipe puder absorver a sobrecarga de operações. Para um comparativo focado sobre essa troca, veja a comparação entre PuppeteerSharp e IronPDF.

Dramaturgo for .NET

Playwright é mantido pela Microsoft como um framework de automação cross-browser para Chromium, WebKit e Firefox. As equipes o reutilizam para HTML para PDF através de Page.PdfAsync, embora a geração de PDF funcione apenas com o Chromium. A configuração busca binários de navegador por meio de uma etapa de instalação única.

using Microsoft.Playwright;
using System.Threading.Tasks;

public class PlaywrightExample
{
    public async Task GeneratePdfAsync()
    {
        // Create the Dramaturgo driver that manages the installed browser binaries
        using var playwright = await Playwright.CreateAsync();
        // PDF output is Chromium-only, so launch the Chromium build specifically
        await using var browser = await playwright.Chromium.LaunchAsync();
        // Open a new page (tab) to render into
        var page = await browser.NewPageAsync();

        // Set the HTML content in place rather than navigating to a URL
        await page.SetContentAsync("<html><body><h1>Sales Dashboard</h1></body></html>");
        // Emit the PDF with an explicit A4 page format
        await page.PdfAsync(new PagePdfOptions { Path = "playwright_output.pdf", Format = "A4" });
    }
}

using Microsoft.Playwright;
using System.Threading.Tasks;

public class PlaywrightExample
{
    public async Task GeneratePdfAsync()
    {
        // Create the Dramaturgo driver that manages the installed browser binaries
        using var playwright = await Playwright.CreateAsync();
        // PDF output is Chromium-only, so launch the Chromium build specifically
        await using var browser = await playwright.Chromium.LaunchAsync();
        // Open a new page (tab) to render into
        var page = await browser.NewPageAsync();

        // Set the HTML content in place rather than navigating to a URL
        await page.SetContentAsync("<html><body><h1>Sales Dashboard</h1></body></html>");
        // Emit the PDF with an explicit A4 page format
        await page.PdfAsync(new PagePdfOptions { Path = "playwright_output.pdf", Format = "A4" });
    }
}

Imports Microsoft.Playwright
Imports System.Threading.Tasks

Public Class PlaywrightExample
    Public Async Function GeneratePdfAsync() As Task
        ' Create the Dramaturgo driver that manages the installed browser binaries
        Using playwright = Await Playwright.CreateAsync()
            ' PDF output is Chromium-only, so launch the Chromium build specifically
            Await Using browser = Await playwright.Chromium.LaunchAsync()
                ' Open a new page (tab) to render into
                Dim page = Await browser.NewPageAsync()

                ' Set the HTML content in place rather than navigating to a URL
                Await page.SetContentAsync("<html><body><h1>Sales Dashboard</h1></body></html>")
                ' Emit the PDF with an explicit A4 page format
                Await page.PdfAsync(New PagePdfOptions With {.Path = "playwright_output.pdf", .Format = "A4"})
            End Using
        End Using
    End Function
End Class

Antes da primeira execução, instale o navegador com pwsh bin/Debug/net10.0/playwright.ps1 install chromium (ou chame o ponto de entrada de instalação equivalente no código).

Para uma URL ao vivo, navegue até a página primeiro:

// Load a live URL so its rendered DOM becomes the PDF source
await page.GotoAsync("https://example.com");
// Export the loaded page as an A4 PDF
await page.PdfAsync(new PagePdfOptions { Path = "from_url.pdf", Format = "A4" });

// Load a live URL so its rendered DOM becomes the PDF source
await page.GotoAsync("https://example.com");
// Export the loaded page as an A4 PDF
await page.PdfAsync(new PagePdfOptions { Path = "from_url.pdf", Format = "A4" });

Imports System.Threading.Tasks

' Load a live URL so its rendered DOM becomes the PDF source
Await page.GotoAsync("https://example.com")
' Export the loaded page as an A4 PDF
Await page.PdfAsync(New PagePdfOptions With {.Path = "from_url.pdf", .Format = "A4"})

Onde brilha:

• Apoiado pela Microsoft com um ciclo de lançamentos ativo.
• Baixa latência de primeiro renderização uma vez que o navegador está ativo.
• Renderiza padrões modernos da web eJavaScriptdo lado do cliente com precisão.

O problema:

• Mesmo peso pesado de binário e gerenciamento de navegador como o PuppeteerSharp.
• A memória aumenta sem manuseio cuidadoso do contexto do navegador.
• A saída de PDF é um recurso secundário do pipeline de impressão do Chrome, por isso carece de recursos de manipulação de documentos.

License: MIT. Ideal quando um projeto já está executando o Dramaturgo para testes e deseja renderização gratuita junto a ele.

wkhtmltopdf (via DinkToPdf)

Por mais de uma década, o wkhtmltopdf foi a ferramenta padrão para converter HTML em PDF. Não .NET, geralmente é consumido através do DinkToPdf, um wrapper C# sobre a biblioteca nativa libwkhtmltox. A API do wrapper é limpa, mas o motor subjacente é o problema.

using DinkToPdf;

public class DinkToPdfExample
{
    public void GeneratePdf()
    {
        // SynchronizedConverter serializes calls into the non-thread-safe native libwkhtmltox library
        var converter = new SynchronizedConverter(new PdfTools());

        // Describe the document: global page settings plus one or more HTML content objects
        var doc = new HtmlToPdfDocument
        {
            // Set the paper size and the output file path for the whole document
            GlobalSettings = { PaperSize = PaperKind.A4, Out = "legacy_output.pdf" },
            // Each object is a chunk of HTML to render into the PDF
            Objects = { new ObjectSettings { HtmlContent = "<h1>Legacy Report</h1>" } }
        };

        // Hand the descriptor to the native engine, which writes the file defined in Out
        converter.Convert(doc);
    }
}

using DinkToPdf;

public class DinkToPdfExample
{
    public void GeneratePdf()
    {
        // SynchronizedConverter serializes calls into the non-thread-safe native libwkhtmltox library
        var converter = new SynchronizedConverter(new PdfTools());

        // Describe the document: global page settings plus one or more HTML content objects
        var doc = new HtmlToPdfDocument
        {
            // Set the paper size and the output file path for the whole document
            GlobalSettings = { PaperSize = PaperKind.A4, Out = "legacy_output.pdf" },
            // Each object is a chunk of HTML to render into the PDF
            Objects = { new ObjectSettings { HtmlContent = "<h1>Legacy Report</h1>" } }
        };

        // Hand the descriptor to the native engine, which writes the file defined in Out
        converter.Convert(doc);
    }
}

Imports DinkToPdf

Public Class DinkToPdfExample
    Public Sub GeneratePdf()
        ' SynchronizedConverter serializes calls into the non-thread-safe native libwkhtmltox library
        Dim converter = New SynchronizedConverter(New PdfTools())

        ' Describe the document: global page settings plus one or more HTML content objects
        Dim doc = New HtmlToPdfDocument With {
            ' Set the paper size and the output file path for the whole document
            .GlobalSettings = New GlobalSettings With {.PaperSize = PaperKind.A4, .Out = "legacy_output.pdf"},
            ' Each object is a chunk of HTML to render into the PDF
            .Objects = {New ObjectSettings With {.HtmlContent = "<h1>Legacy Report</h1>"}}
        }

        ' Hand the descriptor to the native engine, which writes the file defined in Out
        converter.Convert(doc)
    End Sub
End Class

Este código compila, mas executá-lo em uma máquina limpa lança System.DllNotFoundException: Unable to load DLL 'libwkhtmltox' até que os binários nativos sejam copiados para o diretório de saída. Esse passo de dependência nativa é o primeiro sinal do atrito de implantação que esse mecanismo traz.

Vantagens:

• Início a frio rápido, sem navegador moderno para inicializar.
• Baixa memória, aproximadamente 50 MB por renderização.

Desvantagens:

• O motor QtWebKit que ele fornece (aproximadamente um instantâneo do WebKit de 2012-2013, que o próprio Qt depreciou em 2015 e removeu em 2016) não pode renderizar Flexbox, Grid ouJavaScriptmoderno.
• O repositório wkhtmltopdf foi arquivado em 2 de janeiro de 2023, e o último lançamento, 0.12.6, data de junho de 2020.
• Ele carrega CVE-2022-35583, uma falha de Server-Side Request Forgery classificada como CVSS 9.8 (crítica) que não está corrigida porque o projeto não é mais mantido.

Licença: O próprio DinkToPdf é MIT, mas ele vincula os binários LGPLv3 do wkhtmltopdf, então a obrigação efetiva vem do wkhtmltopdf. Adequado para fluxos de trabalho legados pendentes de migração, com o risco de segurança mantido à vista. Veja a comparação entre wkhtmltopdf e IronPDF para a imagem completa da migração.

PdfSharp and HtmlRenderer

PdfSharp é uma biblioteca de código aberto amplamente usada, mas um equívoco comum é que ela converte HTML por conta própria. Não. PdfSharp fornece uma API de desenho de baixo nível baseada em coordenadas. Para converter HTML, você a emparelha com a ponte comunitária HtmlRenderer.PdfSharp, que analisa HTML e emite comandos de desenho PdfSharp.

using PdfSharp;
using TheArtOfDev.HtmlRenderer.PdfSharp;

public class PdfSharpExample
{
    public void GeneratePdf()
    {
        string html = "<h1>Simple Title</h1><p>Statically rendered text.</p>";

        // The HtmlRenderer bridge parses the HTML and emits PdfSharp drawing commands onto an A4 page
        var pdf = PdfGenerator.GeneratePdf(html, PageSize.A4);
        // Persist the resulting PdfSharp document to disk
        pdf.Save("simple_document.pdf");
    }
}

using PdfSharp;
using TheArtOfDev.HtmlRenderer.PdfSharp;

public class PdfSharpExample
{
    public void GeneratePdf()
    {
        string html = "<h1>Simple Title</h1><p>Statically rendered text.</p>";

        // The HtmlRenderer bridge parses the HTML and emits PdfSharp drawing commands onto an A4 page
        var pdf = PdfGenerator.GeneratePdf(html, PageSize.A4);
        // Persist the resulting PdfSharp document to disk
        pdf.Save("simple_document.pdf");
    }
}

Imports PdfSharp
Imports TheArtOfDev.HtmlRenderer.PdfSharp

Public Class PdfSharpExample
    Public Sub GeneratePdf()
        Dim html As String = "<h1>Simple Title</h1><p>Statically rendered text.</p>"

        ' The HtmlRenderer bridge parses the HTML and emits PdfSharp drawing commands onto an A4 page
        Dim pdf = PdfGenerator.GeneratePdf(html, PageSize.A4)
        ' Persist the resulting PdfSharp document to disk
        pdf.Save("simple_document.pdf")
    End Sub
End Class

Dois detalhes de configuração são importantes no .NET 10. A ponte espera a página de código Windows-1252, que está ausente por padrão no .NET moderno, então registre-a uma vez na inicialização com Encoding.RegisterProvider(CodePagesEncodingProvider.Instance). Emparelha a ponte com um pacote PdfSharp 6.x mais recente também quebra em tempo de execução com um MissingMethodException, então deixe o HtmlRenderer puxar seu próprio PdfSharp compatível em vez de fixar o mais recente.

O que funciona:

• LicençaMITgenuinamente permissiva sem limites de receita.
• Leve, sem binários nativos ou capturadores de navegador.
• C# puro, então a implantação em sistemas operacionais é direta.

O que quebra:

• A ponte HTML é limitada a aproximadamente HTML 4.01 e CSS Nível 2, e teve apenas um conjunto de lançamentos no final de 2025 após nove anos de dormência.
• Nenhuma execução de JavaScript.
• Regras de impressão como page-break-inside: avoid não são suportadas, então linhas de tabela se dividem entre páginas.

License: PdfSharp MIT, HtmlRenderer BSD-3-Clause. A escolha certa para documentos estáticos simples sem layout complexo. Para uma análise detalhada dos recursos, veja a comparação entre PdfSharp e IronPDF.

QuestPDF

QuestPDF segue um caminho diferente: ele descarta HTML e define layouts em C# através de uma API fluente. Para dados que se originam como objetos em vez de marcação, isso remove a etapa de geração de HTML apenas para analisá-lo de volta.

using QuestPDF.Fluent;
using QuestPDF.Helpers;
using QuestPDF.Infrastructure;

public class QuestPdfExample
{
    public void GeneratePdf()
    {
        // The revenue-gated license tier must be declared before any document is built
        QuestPDF.Settings.License = LicenseType.Community;

        // Compose the layout in C# through the fluent API; no HTML anywhere
        var document = Document.Create(container =>
        {
            container.Page(page =>
            {
                // Define the physical page size and margins
                page.Size(PageSizes.A4);
                page.Margin(2, Unit.Centimetre);
                // Place content into named page regions (header and body)
                page.Header().Text("Programmatic Invoice").FontSize(24);
                page.Content().Text("This document is generated without HTML.");
            });
        });

        // Run the layout engine and write the composed document to a file
        document.GeneratePdf("fluent_layout.pdf");
    }
}

using QuestPDF.Fluent;
using QuestPDF.Helpers;
using QuestPDF.Infrastructure;

public class QuestPdfExample
{
    public void GeneratePdf()
    {
        // The revenue-gated license tier must be declared before any document is built
        QuestPDF.Settings.License = LicenseType.Community;

        // Compose the layout in C# through the fluent API; no HTML anywhere
        var document = Document.Create(container =>
        {
            container.Page(page =>
            {
                // Define the physical page size and margins
                page.Size(PageSizes.A4);
                page.Margin(2, Unit.Centimetre);
                // Place content into named page regions (header and body)
                page.Header().Text("Programmatic Invoice").FontSize(24);
                page.Content().Text("This document is generated without HTML.");
            });
        });

        // Run the layout engine and write the composed document to a file
        document.GeneratePdf("fluent_layout.pdf");
    }
}

Imports QuestPDF.Fluent
Imports QuestPDF.Helpers
Imports QuestPDF.Infrastructure

Public Class QuestPdfExample
    Public Sub GeneratePdf()
        ' The revenue-gated license tier must be declared before any document is built
        QuestPDF.Settings.License = LicenseType.Community

        ' Compose the layout in VB.NET through the fluent API; no HTML anywhere
        Dim document = Document.Create(Sub(container)
                                           container.Page(Sub(page)
                                                              ' Define the physical page size and margins
                                                              page.Size(PageSizes.A4)
                                                              page.Margin(2, Unit.Centimetre)
                                                              ' Place content into named page regions (header and body)
                                                              page.Header().Text("Programmatic Invoice").FontSize(24)
                                                              page.Content().Text("This document is generated without HTML.")
                                                          End Sub)
                                       End Sub)

        ' Run the layout engine and write the composed document to a file
        document.GeneratePdf("fluent_layout.pdf")
    End Sub
End Class

Pontos fortes:

• Muito rápido, já que ignora a análise de DOM e layout de navegador.
• Memória previsível e linear que se adapta a trabalhos em lote de alto rendimento.
• Um aplicativo complementar oferece visualização ao vivo e atualização instantânea durante o design.

Pontos fracos:

• É um motor de layout, não um renderizador de HTML, então não pode converter uma URL ou um modelo HTML existente.
• Documentos HTML ou Razor existentes precisariam de uma reescrita completa na API fluente.
• A licença passou deMITpara um modelo limitado por receita.

Licença: Licença Comunitária (gratuita para empresas com receita anual inferior a USD 1.000.000) ou um nível pago Professional e Enterprise. Encaixa-se em documentos de layout fixo definidos por código dirigidos por dados estruturados. Veja a comparação entreQuestPDFe IronPDF para a troca HTML versus layout fluente.

iText (pdfHTML)

iText 7 e 8 são reconhecidos pela manipulação programática de PDF, e o add-on pdfHTML converte HTML. Ao contrário das ferramentas Chromium, pdfHTML usa um analisador personalizado que mapeia tags HTML para objetos iText em vez de executar um navegador.

using iText.Html2pdf;
using System.IO;

public class iTextExample
{
    public void GeneratePdf()
    {
        string html = "<h1>Report</h1><p>Converted with pdfHTML.</p>";

        // Open the destination stream; using ensures the file handle is released after writing
        using var dest = File.Create("output.pdf");
        // pdfHTML maps the HTML tags to iText objects and writes them to the stream (no browser involved)
        HtmlConverter.ConvertToPdf(html, dest);
    }
}

using iText.Html2pdf;
using System.IO;

public class iTextExample
{
    public void GeneratePdf()
    {
        string html = "<h1>Report</h1><p>Converted with pdfHTML.</p>";

        // Open the destination stream; using ensures the file handle is released after writing
        using var dest = File.Create("output.pdf");
        // pdfHTML maps the HTML tags to iText objects and writes them to the stream (no browser involved)
        HtmlConverter.ConvertToPdf(html, dest);
    }
}

Imports iText.Html2pdf
Imports System.IO

Public Class iTextExample
    Public Sub GeneratePdf()
        Dim html As String = "<h1>Report</h1><p>Converted with pdfHTML.</p>"

        ' Open the destination stream; using ensures the file handle is released after writing
        Using dest As FileStream = File.Create("output.pdf")
            ' pdfHTML maps the HTML tags to iText objects and writes them to the stream (no browser involved)
            HtmlConverter.ConvertToPdf(html, dest)
        End Using
    End Sub
End Class

Em um projeto novo, isso lança erros até você adicionar o pacote itext7.bouncy-castle-adapter, que o iText requer para seu caminho de criptografia. Essa dependência extra é fácil de perder e produz um erro opaco sem ela.

Vantagens:

• Manipulação profunda de PDF, assinatura e redação em todo o ecossistema iText.
• Produz PDF/A e PDF/UA a partir de HTML semântico, o que se adapta ao trabalho de conformidade.
• Tempo de inicialização rápido, já que não lança navegador.

Desvantagens:

• Sem execução de script, então o conteúdo dinâmico não é renderizado.
• Recursos CSS3, como Grid não são compatíveis e falham silenciosamente.
• A licença AGPLv3 exige uma licença comercial para aplicativos de código fechado, e arquivos grandes são armazenados em buffer em vez de transmitidos.

License: AGPLv3 or Commercial. Escolha-o para manipulação pesada de PDF e fluxos de trabalho de conformidade com HTML estático e controlado. Para os detalhes de licenciamento e manipulação, veja a comparação entre iText 7 e IronPDF.

IronPDF

IronPDF incorpora um mecanismo Chromium dentro de seu pacote NuGet e o expõe por meio de uma API C#, portanto, nada externo precisa ser iniciado ou agrupado. Ele fica entre as ferramentas de navegador gratuitas e as bibliotecas programáticas, trocando um custo de licença por fidelidade de renderização sem o navegador para gerenciar.

using IronPdf;
using System.Threading.Tasks;

public class IronPdfExample
{
    public async Task GeneratePdfAsync()
    {
        // Create the in-process Chromium renderer (no external browser to launch)
        var renderer = new ChromePdfRenderer();
        // Turn on theJavaScriptengine so client-side chart scripts execute before capture
        renderer.RenderingOptions.EnableJavaScript = true;
        // Wait 500 ms after load to let JavaScript-built content settle before rendering
        renderer.RenderingOptions.WaitFor.RenderDelay(500);

        // Render the HTML string asynchronously into an in-memory PDF
        var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Quarterly Report</h1><div class='chart'></div>");
        // Save the finished PDF to disk
        pdf.SaveAs("report.pdf");
    }
}

using IronPdf;
using System.Threading.Tasks;

public class IronPdfExample
{
    public async Task GeneratePdfAsync()
    {
        // Create the in-process Chromium renderer (no external browser to launch)
        var renderer = new ChromePdfRenderer();
        // Turn on theJavaScriptengine so client-side chart scripts execute before capture
        renderer.RenderingOptions.EnableJavaScript = true;
        // Wait 500 ms after load to let JavaScript-built content settle before rendering
        renderer.RenderingOptions.WaitFor.RenderDelay(500);

        // Render the HTML string asynchronously into an in-memory PDF
        var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Quarterly Report</h1><div class='chart'></div>");
        // Save the finished PDF to disk
        pdf.SaveAs("report.pdf");
    }
}

Imports IronPdf
Imports System.Threading.Tasks

Public Class IronPdfExample
    Public Async Function GeneratePdfAsync() As Task
        ' Create the in-process Chromium renderer (no external browser to launch)
        Dim renderer As New ChromePdfRenderer()
        ' Turn on the JavaScript engine so client-side chart scripts execute before capture
        renderer.RenderingOptions.EnableJavaScript = True
        ' Wait 500 ms after load to let JavaScript-built content settle before rendering
        renderer.RenderingOptions.WaitFor.RenderDelay(500)

        ' Render the HTML string asynchronously into an in-memory PDF
        Dim pdf = Await renderer.RenderHtmlAsPdfAsync("<h1>Quarterly Report</h1><div class='chart'></div>")
        ' Save the finished PDF to disk
        pdf.SaveAs("report.pdf")
    End Function
End Class

O mesmo renderizador converte uma URL para PDF com uma chamada:

// RenderUrlAsPdf fetches and renders the live page in one call, no navigation step needed
var fromUrl = new ChromePdfRenderer().RenderUrlAsPdf("https://example.com");
// Write the captured page to disk
fromUrl.SaveAs("from_url.pdf");

// RenderUrlAsPdf fetches and renders the live page in one call, no navigation step needed
var fromUrl = new ChromePdfRenderer().RenderUrlAsPdf("https://example.com");
// Write the captured page to disk
fromUrl.SaveAs("from_url.pdf");

' RenderUrlAsPdf fetches and renders the live page in one call, no navigation step needed
Dim fromUrl = (New ChromePdfRenderer()).RenderUrlAsPdf("https://example.com")
' Write the captured page to disk
fromUrl.SaveAs("from_url.pdf")

Ele também renderiza vistas Razor e MVC para PDF e converte arquivos HTML diretamente. O guia completo de recursos está no tutorial HTML para PDF.

Prós:

• Renderização de grau de navegador que lida com Grid, Flexbox e scripts do lado do cliente.
• Implantação sem executáveis externos ou pool de navegadores.
• Gera PDF/A e aplica assinaturas digitais, o que o separa dos frameworks de teste.

Contras:

• É necessária uma licença comercial, sem nível de produção gratuito.
• Após uma implantação nova, a primeira renderização carrega um custo de inicialização único, mas renderizações posteriores se estabilizam em um caminho rápido.

License: Commercial, perpetual. Use-o onde o CSS atual em volume importa e as prioridades são cortar a sobrecarga de operações enquanto mantém alta fidelidade.