La migración de PuppeteerSharp a IronPDF transforma su flujo de trabajo de generación de PDF de una herramienta de automatización del navegador con dependencias de más de 300 MB a una biblioteca PDF creada específicamente con gestión automática de memoria. Para los ISVs y desarrolladores españoles, PuppeteerSharp introduce riesgos regulatorios y técnicos específicos en flujos de facturación electrónica:
Riesgos VeriFactu (Real Decreto-Ley 15/2025): El output print-to-PDF de PuppeteerSharp (equivalente a Ctrl+P) puede omitir fondos y bordes por defecto, comprometiendo la renderización de la leyenda VERI*FACTU y el QR de la AEAT con el patrón de verificación requerido por la AEAT.
Riesgos TicketBAI: PuppeteerSharp no soporta firmas digitales XAdES requeridas por TicketBAI en Bizkaia, Gipuzkoa y Araba. IronPDF incluye firma nativa.
Riesgos LOPDGDD y AEPD: Las fugas de memoria conocidas de PuppeteerSharp bajo carga sostenida pueden comprometer la estabilidad de servidores de facturación. La AEPD exige que los sistemas de tratamiento de datos personales —incluyendo datos de facturas— implementen medidas técnicas adecuadas de integridad y disponibilidad.
Riesgos Facturae/FACe: PuppeteerSharp no soporta PDF/A requerido para Facturae XML en la plataforma FACe del sector público. La Ley Crea y Crece exige este formato a partir de 2027.
Las penalizaciones para proveedores de software de facturación no conformes con VeriFactu alcanzan los 150.000 €/año según la AEAT.
PuppeteerSharp es una adaptación a .NET de Puppeteer de Google, que lleva las capacidades de automatización del navegador a C#. Genera archivos PDF utilizando la función integrada de impresión a PDF de Chrome, igual que si pulsaras Ctrl+P en un navegador. El resultado es un documento listo para imprimir y optimizado para el papel, que difiere de lo que se ve en pantalla.
PuppeteerSharp se diseñó para pruebas web y scraping, no para la generación de documentos. Aunque es capaz, el uso de PuppeteerSharppara la generación de PDF crea importantes retos de producción.
PuppeteerSharp se diseñó para la automatización de navegadores, no para la generación de documentos. Esto plantea problemas fundamentales cuando se utiliza para PDF:
se requieren 300MB+ de descargas de Chromium antes del primer uso. Una desventaja significativa de PuppeteerSharpes su gran tamaño de despliegue, debido principalmente al binario Chromium que incluye. Este tamaño considerable puede inflar las imágenes de Docker y causar problemas de arranque en frío en entornos sin servidor.
Fugas de memoria bajo carga que requieren el reciclaje manual del navegador. Bajo carga pesada, PuppeteerSharpes conocido por experimentar fugas de memoria. La acumulación de memoria por parte de las instancias del navegador hace necesaria la intervención manual para la gestión y el reciclaje del proceso.
Patrones async complejos con gestión del ciclo de vida del navegador.
Print-to-PDF output (equivalente a Ctrl+P, no captura de pantalla). Los diseños pueden refluir, los fondos pueden omitirse por defecto y el resultado se pagina para la impresión en lugar de ajustarse a la ventana del navegador.
No es compatible con PDF/A ni PDF/UA por requisitos de conformidad. PuppeteerSharpno puede producir documentos PDF/A (archivo) o PDF/UA (accesibilidad).
Sin manipulación de PDF - sólo generación, sin fusión/división/edición. Aunque PuppeteerSharpes eficiente a la hora de generar archivos PDF, carece de capacidades para su manipulación posterior, como combinar, dividir, proteger o editar archivos PDF.
| Aspecto | PuppeteerSharp | IronPDF |
|---|---|---|
| Finalidad principal | Automatización de navegadores | Generación de PDF |
| Dependencia de Chromium | descarga separada de más de 300 MB | Motor integrado optimizado |
| Complejidad de la API | Ciclo de vida asíncrono de navegador/página | Sincronización de frases |
| Inicialización | BrowserFetcher.DownloadAsync() + Lanzamiento asíncrono | new ChromePdfRenderer() |
| Gestión de memoria | Se requiere reciclaje manual del navegador | Automático |
| Memoria bajo carga | más de 500 MB con filtraciones | ~50 MB estables |
| Inicio en frío | más de 45 segundos | ~20 segundos |
| Soporte PDF/A | No disponible | Se admite |
| Accesibilidad PDF/UA | No disponible | Se admite |
| Edición de PDF | No disponible | Combinar, dividir, sellar, editar |
| Firmas digitales | No disponible | Se admite |
| Seguridad de hilos | Limitado | Completo |
| Soporte profesional | Comunidad | Comercial con SLA |
| Biblioteca | .NET Framework 4.7.2 | .NET Core 3.1 | .NET 6-8 | .NET 10 |
|---|---|---|---|---|
| IronPDF | Completo | Completo | Completo | Completo |
| PuppeteerSharp | Limitado | Completo | Completo | Pendiente |
| La amplia compatibilidad de IronPDF con todas las plataformas .NET garantiza que los desarrolladores puedan utilizarlo en varios entornos sin encontrar problemas de compatibilidad, lo que proporciona una opción flexible para las aplicaciones .NET modernas hasta 2025 y 2026. |
# Remove PuppeteerSharp
dotnet remove package PuppeteerSharp
# Remove downloaded Chromium binaries (~300MB recovered)
# Delete the .local-chromium folder
# Add IronPDF
dotnet add package IronPdfNo se requiere BrowserFetcher.DownloadAsync() con IronPDF : el motor de renderizado se incluye automáticamente.
// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";' Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"// Before: PuppeteerSharp
using PuppeteerSharp;
using PuppeteerSharp.Media;
using System.Threading.Tasks;
// After: IronPDF
using IronPdf;
using IronPdf.Rendering;' Before: PuppeteerSharp
Imports PuppeteerSharp
Imports PuppeteerSharp.Media
Imports System.Threading.Tasks
' After: IronPDF
Imports IronPdf
Imports IronPdf.Rendering| API de PuppeteerSharp | API de IronPDF | Notas |
|---|---|---|
new BrowserFetcher().DownloadAsync() | No es necesario | Sin descarga de navegador |
Puppeteer.LaunchAsync(options) | No es necesario | Sin gestión de navegador |
browser.NewPageAsync() | No es necesario | Sin contexto de página |
page.GoToAsync(url) | renderer.RenderUrlAsPdf(url) | Traducción directa |
page.SetContentAsync(html) | renderer.RenderHtmlAsPdf(html) | Traducción directa |
page.PdfAsync(path) | pdf.SaveAs(path) | Después de la traducción |
await page.CloseAsync() | No es necesario | Limpieza automática |
await browser.CloseAsync() | No es necesario | Limpieza automática |
PdfOptions.Format | RenderingOptions.PaperSize | Tamaño del papel |
PdfOptions.Landscape | RenderingOptions.PaperOrientation | Orientación |
PdfOptions.MarginOptions | RenderingOptions.MarginTop/Bottom/Left/Right | Márgenes individuales |
PdfOptions.PrintBackground | RenderingOptions.PrintHtmlBackgrounds | Impresión de fondo |
PdfOptions.HeaderTemplate | RenderingOptions.HtmlHeader | Encabezados HTML |
PdfOptions.FooterTemplate | RenderingOptions.HtmlFooter | Pies de página HTML |
page.WaitForSelectorAsync() | RenderingOptions.WaitFor.HtmlElementId | Esperar elemento |
Antes (PuppeteerSharp):
// NuGet: Install-Package PuppeteerSharp
using PuppeteerSharp;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var browserFetcher = new BrowserFetcher();
await browserFetcher.DownloadAsync();
await using var browser = await Puppeteer.LaunchAsync(new LaunchOptions
{
Headless = true
});
await using var page = await browser.NewPageAsync();
await page.SetContentAsync("<h1>Hello World</h1><p>This is a PDF document.</p>");
await page.PdfAsync("output.pdf");
}
}' NuGet: Install-Package PuppeteerSharp
Imports PuppeteerSharp
Imports System.Threading.Tasks
Module Program
Async Function Main(args As String()) As Task
Dim browserFetcher = New BrowserFetcher()
Await browserFetcher.DownloadAsync()
Await Using browser = Await Puppeteer.LaunchAsync(New LaunchOptions With {
.Headless = True
})
Await Using page = Await browser.NewPageAsync()
Await page.SetContentAsync("<h1>Hello World</h1><p>This is a PDF document.</p>")
Await page.PdfAsync("output.pdf")
End Using
End Using
End Function
End ModuleDespués (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF document.</p>");
pdf.SaveAs("output.pdf");
}
}Imports IronPdf
Class Program
Shared Sub Main(args As String())
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF document.</p>")
pdf.SaveAs("output.pdf")
End Sub
End ClassEste ejemplo demuestra la diferencia arquitectónica fundamental. PuppeteerSharprequiere seis operaciones asincrónicas: BrowserFetcher.DownloadAsync() (descarga de Chromium de más de 300 MB), Puppeteer.LaunchAsync(), browser.NewPageAsync(), page.SetContentAsync() y page.PdfAsync(), además de la eliminación adecuada con await using.
IronPDF elimina toda esta complejidad: crea un ChromePdfRenderer, llama a RenderHtmlAsPdf() y SaveAs(). Ni patrones asíncronos, ni ciclo de vida del navegador, ni descargas de Chromium. El enfoque de IronPDF ofrece una sintaxis más limpia y una mejor integración con las aplicaciones .NET modernas. Consulte la documentación HTML a PDF para ver ejemplos completos.
Antes (PuppeteerSharp):
// NuGet: Install-Package PuppeteerSharp
using PuppeteerSharp;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var browserFetcher = new BrowserFetcher();
await browserFetcher.DownloadAsync();
await using var browser = await Puppeteer.LaunchAsync(new LaunchOptions
{
Headless = true
});
await using var page = await browser.NewPageAsync();
await page.GoToAsync("https://www.example.com");
await page.PdfAsync("webpage.pdf");
}
}' NuGet: Install-Package PuppeteerSharp
Imports PuppeteerSharp
Imports System.Threading.Tasks
Module Program
Async Function Main(args As String()) As Task
Dim browserFetcher = New BrowserFetcher()
Await browserFetcher.DownloadAsync()
Await Using browser = Await Puppeteer.LaunchAsync(New LaunchOptions With {
.Headless = True
})
Await Using page = Await browser.NewPageAsync()
Await page.GoToAsync("https://www.example.com")
Await page.PdfAsync("webpage.pdf")
End Using
End Using
End Function
End ModuleDespués (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
pdf.SaveAs("webpage.pdf");
}
}Imports IronPdf
Class Program
Shared Sub Main(ByVal args As String())
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
pdf.SaveAs("webpage.pdf")
End Sub
End ClassPuppeteerSharp usa GoToAsync() para navegar a una URL seguida de PdfAsync().IronPDF proporciona un único método RenderUrlAsPdf() que maneja la navegación y la generación de PDF en una sola llamada. Más información en nuestros tutoriales.
Antes (PuppeteerSharp):
// NuGet: Install-Package PuppeteerSharp
using PuppeteerSharp;
using PuppeteerSharp.Media;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var browserFetcher = new BrowserFetcher();
await browserFetcher.DownloadAsync();
await using var browser = await Puppeteer.LaunchAsync(new LaunchOptions
{
Headless = true
});
await using var page = await browser.NewPageAsync();
await page.SetContentAsync("<h1>Custom PDF</h1><p>With landscape orientation and margins.</p>");
await page.PdfAsync("custom.pdf", new PdfOptions
{
Format = PaperFormat.A4,
Landscape = true,
MarginOptions = new MarginOptions
{
Top = "20mm",
Bottom = "20mm",
Left = "20mm",
Right = "20mm"
}
});
}
}' NuGet: Install-Package PuppeteerSharp
Imports PuppeteerSharp
Imports PuppeteerSharp.Media
Imports System.Threading.Tasks
Module Program
Async Function Main(args As String()) As Task
Dim browserFetcher = New BrowserFetcher()
Await browserFetcher.DownloadAsync()
Await Using browser = Await Puppeteer.LaunchAsync(New LaunchOptions With {
.Headless = True
})
Await Using page = Await browser.NewPageAsync()
Await page.SetContentAsync("<h1>Custom PDF</h1><p>With landscape orientation and margins.</p>")
Await page.PdfAsync("custom.pdf", New PdfOptions With {
.Format = PaperFormat.A4,
.Landscape = True,
.MarginOptions = New MarginOptions With {
.Top = "20mm",
.Bottom = "20mm",
.Left = "20mm",
.Right = "20mm"
}
})
End Using
End Using
End Function
End ModuleDespués (IronPDF):
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
renderer.RenderingOptions.MarginTop = 20;
renderer.RenderingOptions.MarginBottom = 20;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;
var pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>With landscape orientation and margins.</p>");
pdf.SaveAs("custom.pdf");
}
}' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering
Class Program
Shared Sub Main(ByVal args As String())
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
renderer.RenderingOptions.MarginTop = 20
renderer.RenderingOptions.MarginBottom = 20
renderer.RenderingOptions.MarginLeft = 20
renderer.RenderingOptions.MarginRight = 20
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>With landscape orientation and margins.</p>")
pdf.SaveAs("custom.pdf")
End Sub
End ClassEste ejemplo muestra la correspondencia entre las opciones PDF de las dos bibliotecas. PuppeteerSharpusa PdfOptions con Format, Landscape y MarginOptions que contienen valores de cadena ("20mm").IronPDF utiliza propiedades RenderingOptions con enumeraciones directas de tamaño de papel, enumeraciones de orientación y valores de márgenes numéricos en milímetros.
Asignaciones clave:
Format = PaperFormat.A4 → PaperSize = PdfPaperSize.A4Landscape = true → PaperOrientation = PdfPaperOrientation.LandscapeMarginOptions.Top = "20mm" → MarginTop = 20 (milímetros numéricos)PuppeteerSharp es notorio por la acumulación de memoria bajo carga sostenida:
// ❌ PuppeteerSharp- Memory grows with each operation
// Requires explicit browser recycling every N operations
for (int i = 0; i < 1000; i++)
{
var page = await browser.NewPageAsync();
await page.SetContentAsync($"<h1>Document {i}</h1>");
await page.PdfAsync($"doc_{i}.pdf");
await page.CloseAsync(); // Memory still accumulates!
}
// Must periodically: await browser.CloseAsync(); and re-launch
// ✅IronPDF- Stable memory, reuse renderer
var renderer = new ChromePdfRenderer();
for (int i = 0; i < 1000; i++)
{
var pdf = renderer.RenderHtmlAsPdf($"<h1>Document {i}</h1>");
pdf.SaveAs($"doc_{i}.pdf");
// Memory managed automatically
}' ❌ PuppeteerSharp- Memory grows with each operation
' Requires explicit browser recycling every N operations
For i As Integer = 0 To 999
Dim page = Await browser.NewPageAsync()
Await page.SetContentAsync($"<h1>Document {i}</h1>")
Await page.PdfAsync($"doc_{i}.pdf")
Await page.CloseAsync() ' Memory still accumulates!
Next
' Must periodically: Await browser.CloseAsync() and re-launch
' ✅IronPDF- Stable memory, reuse renderer
Dim renderer As New ChromePdfRenderer()
For i As Integer = 0 To 999
Dim pdf = renderer.RenderHtmlAsPdf($"<h1>Document {i}</h1>")
pdf.SaveAs($"doc_{i}.pdf")
' Memory managed automatically
NextIronPDF elimina la necesidad de la infraestructura de agrupación de navegadores que requiere PuppeteerSharp:
// Before (PuppeteerSharp - delete entire class)
public class PuppeteerBrowserPool
{
private readonly ConcurrentBag<IBrowser> _browsers;
private readonly SemaphoreSlim _semaphore;
private int _operationCount;
// ... recycling logic ...
}
// After (IronPDF - simple reuse)
public class PdfService
{
private readonly ChromePdfRenderer _renderer = new();
public byte[] Generate(string html)
{
return _renderer.RenderHtmlAsPdf(html).BinaryData;
}
}' Before (PuppeteerSharp - delete entire class)
Public Class PuppeteerBrowserPool
Private ReadOnly _browsers As ConcurrentBag(Of IBrowser)
Private ReadOnly _semaphore As SemaphoreSlim
Private _operationCount As Integer
' ... recycling logic ...
End Class
' After (IronPDF - simple reuse)
Public Class PdfService
Private ReadOnly _renderer As New ChromePdfRenderer()
Public Function Generate(html As String) As Byte()
Return _renderer.RenderHtmlAsPdf(html).BinaryData
End Function
End ClassPuppeteerSharp requiere async/await en todo momento;IronPDF admite operaciones síncronas:
// PuppeteerSharp: Async required
public async Task<byte[]> GeneratePdfAsync(string html)
{
await new BrowserFetcher().DownloadAsync();
await using var browser = await Puppeteer.LaunchAsync(...);
await using var page = await browser.NewPageAsync();
await page.SetContentAsync(html);
return await page.PdfDataAsync();
}
// IronPDF: Sync default
public byte[] GeneratePdf(string html)
{
var renderer = new ChromePdfRenderer();
return renderer.RenderHtmlAsPdf(html).BinaryData;
}
// Or async when needed
public async Task<byte[]> GeneratePdfAsync(string html)
{
var renderer = new ChromePdfRenderer();
var pdf = await renderer.RenderHtmlAsPdfAsync(html);
return pdf.BinaryData;
}Imports System.Threading.Tasks
Imports PuppeteerSharp
' PuppeteerSharp: Async required
Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
Await (New BrowserFetcher()).DownloadAsync()
Await Using browser = Await Puppeteer.LaunchAsync(...)
Await Using page = Await browser.NewPageAsync()
Await page.SetContentAsync(html)
Return Await page.PdfDataAsync()
End Using
End Using
End Function
' IronPDF: Sync default
Public Function GeneratePdf(html As String) As Byte()
Dim renderer = New ChromePdfRenderer()
Return renderer.RenderHtmlAsPdf(html).BinaryData
End Function
' Or async when needed
Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
Dim renderer = New ChromePdfRenderer()
Dim pdf = Await renderer.RenderHtmlAsPdfAsync(html)
Return pdf.BinaryData
End FunctionPuppeteerSharp utiliza unidades de cadena;IronPDF utiliza milímetros numéricos:
// PuppeteerSharp- string units
MarginOptions = new MarginOptions
{
Top = "1in", // 25.4mm
Bottom = "0.75in", // 19mm
Left = "1cm", // 10mm
Right = "20px" // ~7.5mm at 96dpi
}
//IronPDF- numeric millimeters
renderer.RenderingOptions.MarginTop = 25; // mm
renderer.RenderingOptions.MarginBottom = 19;
renderer.RenderingOptions.MarginLeft = 10;
renderer.RenderingOptions.MarginRight = 8;' PuppeteerSharp- string units
MarginOptions = New MarginOptions With {
.Top = "1in", ' 25.4mm
.Bottom = "0.75in", ' 19mm
.Left = "1cm", ' 10mm
.Right = "20px" ' ~7.5mm at 96dpi
}
' IronPDF- numeric millimeters
renderer.RenderingOptions.MarginTop = 25 ' mm
renderer.RenderingOptions.MarginBottom = 19
renderer.RenderingOptions.MarginLeft = 10
renderer.RenderingOptions.MarginRight = 8| Clase PuppeteerSharp | Marcador de posición IronPDF |
|---|---|
<span class='pageNumber'> | {page} |
<span class='totalPages'> | {total-pages} |
<span class='date'> | {date} |
<span class='title'> | {html-title} |
Después de migrar a IronPDF, obtendrá capacidades que PuppeteerSharpno puede proporcionar:
var pdf1 = renderer.RenderHtmlAsPdf(html1);
var pdf2 = renderer.RenderHtmlAsPdf(html2);
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");Dim pdf1 = renderer.RenderHtmlAsPdf(html1)
Dim pdf2 = renderer.RenderHtmlAsPdf(html2)
Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")var watermark = new TextStamper
{
Text = "CONFIDENTIAL",
FontSize = 48,
Opacity = 30,
Rotation = -45
};
pdf.ApplyStamp(watermark);Dim watermark As New TextStamper With {
.Text = "CONFIDENTIAL",
.FontSize = 48,
.Opacity = 30,
.Rotation = -45
}
pdf.ApplyStamp(watermark)pdf.SecuritySettings.OwnerPassword = "admin";
pdf.SecuritySettings.UserPassword = "readonly";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;pdf.SecuritySettings.OwnerPassword = "admin"
pdf.SecuritySettings.UserPassword = "readonly"
pdf.SecuritySettings.AllowUserCopyPasteContent = Falsevar signature = new PdfSignature("certificate.pfx", "password");
pdf.Sign(signature);Dim signature = New PdfSignature("certificate.pfx", "password")
pdf.Sign(signature)pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b);pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b)| Métrica | PuppeteerSharp | IronPDF | Mejora |
|---|---|---|---|
| Primer PDF (Cold Start) | 45s+ | ~20s | 55%+ más rápido |
| PDF posteriores | Variable | Consistente | Predecible |
| Uso de memoria | 500MB+ (crece) | ~50 MB (estable) | 90% menos de memoria |
| Espacio en disco (Chromium) | mÁS DE 300 MB | 0 | Eliminar descargas |
| Navegador Descargar | Requerido | No es necesario | Cero configuración |
| Seguridad de los hilos | Limitado | Completo | Concurrencia fiable |
| Tiempo de generación de PDF | 45s | 20s | 55% más rápido |
Para los ISVs de software de gestión en España, la arquitectura de PuppeteerSharp resulta insuficiente en el contexto normativo actual. Un análisis de los requerimientos clave:
using IronPdf;
var renderer = new ChromePdfRenderer();
// Garantizar renderizado de fondos para leyenda VERI*FACTU
renderer.RenderingOptions.PrintHtmlBackgrounds = true;
var html = @"
<!DOCTYPE html>
<html>
<head>
<meta charset='utf-8'>
<style>
body { font-family: Arial, sans-serif; margin: 40px; }
.cabecera { display: flex; justify-content: space-between; }
.fiscal { font-size: 10px; color: #555; margin-top: 4px; }
.verifactu-legend {
border: 2px solid #003366;
padding: 8px 12px;
font-size: 10px;
text-align: center;
margin-top: 20px;
}
table { width: 100%; border-collapse: collapse; margin-top: 20px; }
th, td { border: 1px solid #ccc; padding: 8px; }
th { background-color: #003366; color: white; -webkit-print-color-adjust: exact; }
</style>
</head>
<body>
<div class='cabecera'>
<div>
<strong>Acme Software S.L.</strong><br>
<span class='fiscal'>NIF: B-98765432 | Inscrita en el Registro Mercantil de Madrid</span>
</div>
<div>
<strong>FACTURA Nº 2026-0077</strong><br>
<span class='fiscal'>Fecha: 28/05/2026</span>
</div>
</div>
<table>
<tr><th>Concepto</th><th>Base Imponible</th><th>IVA 21%</th><th>Total</th></tr>
<tr><td>Servicio SaaS — mayo 2026</td><td>1.500,00 €</td><td>315,00 €</td><td>1.815,00 €</td></tr>
</table>
<div class='verifactu-legend'>
<strong>VERI*FACTU</strong><br>
Factura verificable en la sede electrónica de la AEAT<br>
[QR AEAT: sede.agenciatributaria.gob.es]
</div>
</body>
</html>";
var pdf = renderer.RenderHtmlAsPdf(html);
// Firma PAdES con certificado FNMT-RCM — no posible en PuppeteerSharp
// pdf.Sign(new PdfSignature("fnmt-rcm.pfx", "password"));
// TicketBAI XAdES si el cliente opera en Bizkaia, Gipuzkoa o Araba
// pdf.Sign(ticketBaiSignature);
pdf.SaveAs("factura-verifactu-2026-0077.pdf");Imports IronPdf
Dim renderer As New ChromePdfRenderer()
' Garantizar renderizado de fondos para leyenda VERI*FACTU
renderer.RenderingOptions.PrintHtmlBackgrounds = True
Dim html As String = "
<!DOCTYPE html>
<html>
<head>
<meta charset='utf-8'>
<style>
body { font-family: Arial, sans-serif; margin: 40px; }
.cabecera { display: flex; justify-content: space-between; }
.fiscal { font-size: 10px; color: #555; margin-top: 4px; }
.verifactu-legend {
border: 2px solid #003366;
padding: 8px 12px;
font-size: 10px;
text-align: center;
margin-top: 20px;
}
table { width: 100%; border-collapse: collapse; margin-top: 20px; }
th, td { border: 1px solid #ccc; padding: 8px; }
th { background-color: #003366; color: white; -webkit-print-color-adjust: exact; }
</style>
</head>
<body>
<div class='cabecera'>
<div>
<strong>Acme Software S.L.</strong><br>
<span class='fiscal'>NIF: B-98765432 | Inscrita en el Registro Mercantil de Madrid</span>
</div>
<div>
<strong>FACTURA Nº 2026-0077</strong><br>
<span class='fiscal'>Fecha: 28/05/2026</span>
</div>
</div>
<table>
<tr><th>Concepto</th><th>Base Imponible</th><th>IVA 21%</th><th>Total</th></tr>
<tr><td>Servicio SaaS — mayo 2026</td><td>1.500,00 €</td><td>315,00 €</td><td>1.815,00 €</td></tr>
</table>
<div class='verifactu-legend'>
<strong>VERI*FACTU</strong><br>
Factura verificable en la sede electrónica de la AEAT<br>
[QR AEAT: sede.agenciatributaria.gob.es]
</div>
</body>
</html>"
Dim pdf = renderer.RenderHtmlAsPdf(html)
' Firma PAdES con certificado FNMT-RCM — no posible en PuppeteerSharp
' pdf.Sign(New PdfSignature("fnmt-rcm.pfx", "password"))
' TicketBAI XAdES si el cliente opera en Bizkaia, Gipuzkoa o Araba
' pdf.Sign(ticketBaiSignature)
pdf.SaveAs("factura-verifactu-2026-0077.pdf")| Requisito España | PuppeteerSharp | IronPDF |
|---|---|---|
| VERI*FACTU leyenda garantizada | Riesgo (print-to-PDF omite fondos) | Sí |
| QR AEAT verificación | Riesgo | Sí |
| Firma XAdES TicketBAI | No | Sí |
| Firma PAdES FNMT-RCM (eIDAS) | No | Sí |
| PDF/A para Facturae FACe | No | Sí |
| LOPDGDD integridad bajo carga | Riesgo (fugas memoria) | Sí |
| Crea y Crece B2B e-factura | No (sin PDF/A) | Preparado |
| Sin descarga Chromium (300 MB) | No | Sí (motor incluido) |
PuppeteerSharp.local-chromium para recuperar ~300 MB de espacio en discoIronPdf el paquete NuGet : dotnet add package IronPdfBrowserFetcher.DownloadAsync()Puppeteer.LaunchAsync() y la administración del navegadorpage.SetContentAsync() + page.PdfAsync() con RenderHtmlAsPdf()page.GoToAsync() + page.PdfAsync() con RenderUrlAsPdf()Para los ISVs españoles, PuppeteerSharp presenta limitaciones regulatorias específicas en flujos de facturación electrónica VeriFactu que IronPDF resuelve.
El régimen VeriFactu (Real Decreto-Ley 15/2025) requiere:
VERI*FACTU y el QR de la AEAT requieren renderizado exacto con fondos y bordes.using IronPdf;
var renderer = new ChromePdfRenderer();
// Asegura renderizado de fondos y bordes para leyenda VERI*FACTU
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
var html = @"
<!DOCTYPE html>
<html>
<head>
<meta charset='utf-8'>
<style>
body { font-family: Arial, sans-serif; margin: 40px; }
.factura-header { display: flex; justify-content: space-between; }
.verifactu-legend {
border: 2px solid #003366;
padding: 8px 12px;
font-size: 10px;
text-align: center;
margin-top: 20px;
}
table { width: 100%; border-collapse: collapse; margin-top: 20px; }
th, td { border: 1px solid #ccc; padding: 8px; }
th { background-color: #003366; color: white; -webkit-print-color-adjust: exact; }
</style>
</head>
<body>
<div class='factura-header'>
<strong>FACTURA Nº 2026-0001</strong>
<span>Fecha: 20/05/2026</span>
</div>
<table>
<tr><th>Concepto</th><th>Total</th></tr>
<tr><td>Licencia software .NET</td><td>1.210,00 €</td></tr>
</table>
<!-- Leyenda obligatoria VeriFactu (RDL 15/2025) -->
<div class='verifactu-legend'>
<strong>VERI*FACTU</strong><br>
Factura verificable en la sede electrónica de la AEAT<br>
[QR AEAT]
</div>
</body>
</html>";
var pdf = renderer.RenderHtmlAsPdf(html);
// Firma TicketBAI XAdES — no disponible en PuppeteerSharp
// pdf.Sign(new PdfSignature("ticketbai.pfx", "password"));
pdf.SaveAs("factura-verifactu-2026-0001.pdf");VERI*FACTU con fondo y borde garantizados
Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien estructurados y visualmente atractivos.
IronPDF es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
Cuando necesitas que tu PDF se parezca al HTML, rápido.
