Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Usando IronPDF
  4. Convertir HTML a PDF ASP.NET C#
USANDO IRONPDF

HTML a PDF en ASP.NET con VeriFactu VERI*FACTU, Facturae, TicketBAI y LOPDGDD: IronPDF

Curtis Chau
Curtis Chau
Actualizado:

IronPDF convierte HTML a PDF en ASP.NET utilizando un motor de renderizado basado en Chrome que transforma sus cadenas HTML, archivos o URL en documentos PDF con píxeles perfectos con solo unas pocas líneas de código C#.

Cuando su aplicación ASP.NET necesita generar facturas, informes o documentos de cumplimiento a pedido, la calidad del resultado en PDF es importante. En España, esta necesidad es especialmente crítica para la generación de representaciones visuales de facturas VeriFactu con la leyenda obligatoria VERI*FACTU verificable en la sede electrónica de la AEAT, documentos Facturae para la plataforma FACe de facturación B2G, y expedientes con datos personales regulados por la LOPDGDD supervisada por la AEPD.

IronPDF es una biblioteca PDF de C# creada para este desafío. Su motor de renderizado basado en Chrome procesa HTML de la misma manera que lo hace un navegador real, lo que significa que las propiedades CSS3, las consultas de medios y el contenido renderizado en JavaScript aparecen correctamente en el documento final. Las secciones a continuación explican la instalación, los tres métodos de representación principales, el manejo de datos de formularios, las funciones de formato avanzadas y el soporte de autenticación: todo lo necesario para integrar la generación de PDF lista para producción en su aplicación ASP.NET Core.

Caso de uso España: factura VeriFactu con VERI*FACTU en ASP.NET

En aplicaciones ASP.NET para el mercado español, uno de los casos de uso más habituales es generar la representación visual PDF de facturas conformes con VeriFactu. El controlador MVC puede recibir los datos de la factura y generar el PDF con la leyenda obligatoria VERI*FACTU en una sola llamada:

:path=GenerarFacturaVeriFactu.cs
public IActionResult GenerarFacturaVeriFactu(FacturaViewModel modelo)
{
    // Formato de importe con locale España: 1.234,56 €
    var baseImponible = modelo.Base.ToString("N2", new System.Globalization.CultureInfo("es-ES")) + " €";
    var iva21 = (modelo.Base * 0.21m).ToString("N2", new System.Globalization.CultureInfo("es-ES")) + " €";
    var total = (modelo.Base * 1.21m).ToString("N2", new System.Globalization.CultureInfo("es-ES")) + " €";

    string html = $@"
        <!DOCTYPE html><html lang='es'><head><meta charset='UTF-8'>
        <style>body{{font-family:Arial,sans-serif;margin:40px}}
        .verifactu{{font-weight:bold;border:2px solid #c00;padding:4px;font-size:11pt}}</style></head>
        <body>
        <h1>Factura Núm. {modelo.NumFactura}</h1>
        <p><strong>NIF Emisor:</strong> {modelo.NifEmisor} &nbsp;
           <strong>NIF Receptor:</strong> {modelo.NifReceptor}</p>
        <table border='1' cellpadding='8' style='width:100%;border-collapse:collapse'>
            <tr><th>Concepto</th><th>Base</th><th>IVA 21%</th><th>Total</th></tr>
            <tr><td>{modelo.Concepto}</td><td>{baseImponible}</td><td>{iva21}</td><td>{total}</td></tr>
        </table>
        <p class='verifactu'>VERI*FACTU</p>
        <p>Factura verificable en la sede electrónica de la AEAT</p>
        </body></html>";

    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf(html);
    return File(pdf.BinaryData, "application/pdf", $"factura-{modelo.NumFactura}.pdf");
}
// ¡ESTE FRAGMENTO DE CÓDIGO NO ESTÁ DISPONIBLE!
public IActionResult GenerarFacturaVeriFactu(FacturaViewModel modelo)
{
    // Formato de importe con locale España: 1.234,56 €
    var baseImponible = modelo.Base.ToString("N2", new System.Globalization.CultureInfo("es-ES")) + " €";
    var iva21 = (modelo.Base * 0.21m).ToString("N2", new System.Globalization.CultureInfo("es-ES")) + " €";
    var total = (modelo.Base * 1.21m).ToString("N2", new System.Globalization.CultureInfo("es-ES")) + " €";

    string html = $@"
        <!DOCTYPE html><html lang='es'><head><meta charset='UTF-8'>
        <style>body{{font-family:Arial,sans-serif;margin:40px}}
        .verifactu{{font-weight:bold;border:2px solid #c00;padding:4px;font-size:11pt}}</style></head>
        <body>
        <h1>Factura Núm. {modelo.NumFactura}</h1>
        <p><strong>NIF Emisor:</strong> {modelo.NifEmisor} &nbsp;
           <strong>NIF Receptor:</strong> {modelo.NifReceptor}</p>
        <table border='1' cellpadding='8' style='width:100%;border-collapse:collapse'>
            <tr><th>Concepto</th><th>Base</th><th>IVA 21%</th><th>Total</th></tr>
            <tr><td>{modelo.Concepto}</td><td>{baseImponible}</td><td>{iva21}</td><td>{total}</td></tr>
        </table>
        <p class='verifactu'>VERI*FACTU</p>
        <p>Factura verificable en la sede electrónica de la AEAT</p>
        </body></html>";

    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf(html);
    return File(pdf.BinaryData, "application/pdf", $"factura-{modelo.NumFactura}.pdf");
}
Imports System.Globalization
Imports IronPdf

Public Function GenerarFacturaVeriFactu(modelo As FacturaViewModel) As IActionResult
    ' Formato de importe con locale España: 1.234,56 €
    Dim baseImponible As String = modelo.Base.ToString("N2", New CultureInfo("es-ES")) & " €"
    Dim iva21 As String = (modelo.Base * 0.21D).ToString("N2", New CultureInfo("es-ES")) & " €"
    Dim total As String = (modelo.Base * 1.21D).ToString("N2", New CultureInfo("es-ES")) & " €"

    Dim html As String = $"
        <!DOCTYPE html><html lang='es'><head><meta charset='UTF-8'>
        <style>body{{font-family:Arial,sans-serif;margin:40px}}
        .verifactu{{font-weight:bold;border:2px solid #c00;padding:4px;font-size:11pt}}</style></head>
        <body>
        <h1>Factura Núm. {modelo.NumFactura}</h1>
        <p><strong>NIF Emisor:</strong> {modelo.NifEmisor} &nbsp;
           <strong>NIF Receptor:</strong> {modelo.NifReceptor}</p>
        <table border='1' cellpadding='8' style='width:100%;border-collapse:collapse'>
            <tr><th>Concepto</th><th>Base</th><th>IVA 21%</th><th>Total</th></tr>
            <tr><td>{modelo.Concepto}</td><td>{baseImponible}</td><td>{iva21}</td><td>{total}</td></tr>
        </table>
        <p class='verifactu'>VERI*FACTU</p>
        <p>Factura verificable en la sede electrónica de la AEAT</p>
        </body></html>"

    Dim renderer As New ChromePdfRenderer()
    Dim pdf = renderer.RenderHtmlAsPdf(html)
    Return File(pdf.BinaryData, "application/pdf", $"factura-{modelo.NumFactura}.pdf")
End Function
$vbLabelText   $csharpLabel

Este patrón incluye el formateo de importes con el estándar español (punto miles, coma decimal, símbolo € al final), el NIF/CIF del emisor y receptor, e integra la leyenda VERI*FACTU directamente en el HTML que IronPDF renderiza. Para facturas Facturae enviadas a la plataforma FACe (facturación B2G), el mismo controlador puede generar el PDF de representación visual que acompaña al XML estructurado.

¿Cómo convertir rápidamente HTML a PDF en ASP.NET Core?

Para comenzar a convertir HTML a PDF en ASP.NET Core solo se necesitan unas pocas líneas de código. Primero, instale IronPDF a través del Administrador de paquetes NuGet :

Install-Package IronPdf

Una vez instalado, la clase ChromePdfRenderer es el punto de entrada principal para todas las operaciones de renderizado. Aquí hay un ejemplo completo que muestra cómo convertir una cadena HTML en un PDF descargable dentro de un controlador ASP.NET Core MVC:

  1. Instala IronPDF con el Administrador de Paquetes NuGet

    PM > Install-Package IronPdf

  2. Copie y ejecute este fragmento de código.

    using IronPdf;
using Microsoft.AspNetCore.Mvc;

// program.cs
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
var app = builder.Build();
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();

// PdfController.cs
public class PdfController : Controller
{
    public IActionResult GeneratePdf()
    {
        var renderer = new ChromePdfRenderer();
        string html = @"
            <h1>Invoice #2024-001</h1>
            <p>Generated on: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
            <table>
                <tr><th>Item</th><th>Price</th></tr>
                <tr><td>Professional License</td><td>$799</td></tr>
            </table>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        return File(pdf.BinaryData, "application/pdf", "invoice.pdf");
    }
}

  3. Despliegue para probar en su entorno real

    Comienza a usar IronPDF en tu proyecto hoy mismo con una prueba gratuita

    arrow pointer

¿Qué aspecto tiene el PDF generado?

PDF viewer displaying a simple invoice document with number #2024-001, showing an invoice header, generation date, and a table with Item and Price columns containing a Professional License entry for $799

La clase ChromePdfRenderer maneja toda la representación compleja, garantizando que la estructura HTML, los estilos CSS e incluso JavaScript se representen correctamente en la salida PDF final. El valor de retorno es un objeto PdfDocument cuya propiedad BinaryData puedes transmitir directamente al navegador como una descarga de archivo.

¿Cómo elegir el método de renderizado adecuado para su fuente?

IronPDF ofrece tres métodos de renderizado principales, cada uno diseñado para una fuente de contenido específica. Comprender qué método se adapta a su escenario evita complejidad innecesaria y mantiene limpio el código de su controlador.

Métodos de representación de IronPDF según la fuente de contenido
Tipo de fuente Método Mejor para
Cadena HTML en memoria `RenderHtmlAsPdf` Informes basados ​​en bases de datos, facturas con plantillas y contenido dinámico
Archivo HTML en el disco `RenderHtmlFileAsPdf` Plantillas estáticas en wwwroot, diseños proporcionados por agencias de diseño
URL web en vivo `RenderUrlAsPdf` Archivar páginas, capturar SPA después de renderizar JavaScript

¿Cómo convertir cadenas HTML dinámicas?

Cuando trabajes con contenido dinámico como informes basados en bases de datos, utiliza RenderHtmlAsPdf para convertir cadenas HTML directamente. Este método acepta cualquier marcado HTML válido y devuelve un PDF completamente renderizado:

var renderer = new ChromePdfRenderer();
string htmlContent = BuildDynamicHtml(); // your method to generate HTML
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("dynamic-report.pdf");
var renderer = new ChromePdfRenderer();
string htmlContent = BuildDynamicHtml(); // your method to generate HTML
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("dynamic-report.pdf");
Dim renderer As New ChromePdfRenderer()
Dim htmlContent As String = BuildDynamicHtml() ' your method to generate HTML
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("dynamic-report.pdf")
$vbLabelText   $csharpLabel

Informe de prueba de IronPDF que muestra contenido HTML renderizado con estilo CSS, incluyendo un encabezado azul que dice 'Informe de Prueba de IronPDF', texto de párrafo estilizado en verde y una tabla de datos formateada que contiene información de productos con ítems como widgets y herramientas

Este enfoque funciona bien para generar documentos PDF a partir de plantillas HTML rellenas con datos en tiempo real, envíos de formularios o cualquier contenido generado dinámicamente. El motor de renderizado conserva todo el estilo CSS, incluidas las fuentes, los colores y el formato de tabla personalizados. Cuando tu HTML hace referencia a hojas de estilo externas o imágenes usando rutas relativas, pasa un baseUrl como el segundo argumento para que el renderizador pueda resolver esos recursos correctamente.

¿Cómo convertir archivos HTML estáticos desde el disco?

Para plantillas HTML almacenadas como archivos físicos, utiliza RenderHtmlFileAsPdf para convertirlas sin cargarlas primero en memoria. Esto es eficiente para plantillas grandes y evita la concatenación de cadenas:

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report-template.html");
pdf.SaveAs("report.pdf");
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report-template.html");
pdf.SaveAs("report.pdf");
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report-template.html")
pdf.SaveAs("report.pdf")
$vbLabelText   $csharpLabel

Este método resuelve automáticamente las rutas relativas de las hojas de estilo CSS, imágenes y otros recursos externos referenciados en el archivo. Funciona bien cuando el equipo de diseño mantiene archivos de plantilla HTML separados fuera del código base de C# de la aplicación. El método admite consultas de medios de impresión CSS y fuentes personalizadas , por lo que las plantillas creadas para entornos de impresión se representan fielmente sin configuración adicional.

¿Cómo convertir la URL de una página web a PDF?

Para capturar una página web en vivo o renderizar una página accesible por URL como un PDF, utiliza RenderUrlAsPdf. Este método inicia el motor de Chrome, navega hasta la URL, espera a que la página se cargue por completo y luego captura la salida renderizada:

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1000);
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Screen;
var pdf = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/PDF");
pdf.SaveAs("webpage.pdf");
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1000);
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Screen;
var pdf = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/PDF");
pdf.SaveAs("webpage.pdf");
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.RenderDelay(1000)
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Screen
Dim pdf = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/PDF")
pdf.SaveAs("webpage.pdf")
$vbLabelText   $csharpLabel

Página principal de Wikipedia mostrada en un visor de PDF mostrando el diseño completo de la página web con navegación, secciones de contenido, vista previa de artículo destacado y logo de Wikipedia, demostrando una conversión exitosa de HTML a PDF con formato e imágenes preservadas

La opción WaitFor.RenderDelay indica al renderizador que pause después de cargar la página antes de capturar. Esto es valioso para aplicaciones de una sola página que construyen su DOM a través de JavaScript después de que llega la respuesta HTML inicial. Configurar EnableJavaScript = true activa el motor JavaScript completo de Chrome, de modo que gráficos, cuadrículas de datos y otros componentes renderizados por JavaScript aparecen en el PDF tal como lo hacen en un navegador.

¿Cómo se gestionan los datos del formulario y las solicitudes POST?

El procesamiento de datos de formulario antes de la generación del PDF es un patrón común en las aplicaciones ASP.NET : las confirmaciones de pedidos, los recibos de entrega y los recibos siguen este modelo. El enfoque es vincular los datos del formulario publicado a un modelo, crear una cadena HTML a partir de ese modelo y luego representar la cadena como PDF:

[HttpPost]
public IActionResult ProcessFormToPdf(OrderModel model)
{
    var renderer = new ChromePdfRenderer();
    string html = $@"
        <h2>Order Confirmation</h2>
        <p>Customer: {model.CustomerName}</p>
        <p>Order Date: {model.OrderDate:yyyy-MM-dd}</p>
        <ul>
            {string.Join("", model.Items.Select(i => $"<li>{i.Name} -- ${i.Price}</li>"))}
        </ul>
        <p><strong>Total: ${model.Total}</strong></p>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    string fileName = $"order-{model.OrderId}.pdf";
    return File(pdf.BinaryData, "application/pdf", fileName);
}
[HttpPost]
public IActionResult ProcessFormToPdf(OrderModel model)
{
    var renderer = new ChromePdfRenderer();
    string html = $@"
        <h2>Order Confirmation</h2>
        <p>Customer: {model.CustomerName}</p>
        <p>Order Date: {model.OrderDate:yyyy-MM-dd}</p>
        <ul>
            {string.Join("", model.Items.Select(i => $"<li>{i.Name} -- ${i.Price}</li>"))}
        </ul>
        <p><strong>Total: ${model.Total}</strong></p>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    string fileName = $"order-{model.OrderId}.pdf";
    return File(pdf.BinaryData, "application/pdf", fileName);
}
Imports System
Imports System.Linq
Imports Microsoft.AspNetCore.Mvc

<HttpPost>
Public Function ProcessFormToPdf(model As OrderModel) As IActionResult
    Dim renderer = New ChromePdfRenderer()
    Dim html As String = $"
        <h2>Order Confirmation</h2>
        <p>Customer: {model.CustomerName}</p>
        <p>Order Date: {model.OrderDate:yyyy-MM-dd}</p>
        <ul>
            {String.Join("", model.Items.Select(Function(i) $"<li>{i.Name} -- ${i.Price}</li>"))}
        </ul>
        <p><strong>Total: ${model.Total}</strong></p>"
    Dim pdf = renderer.RenderHtmlAsPdf(html)
    Dim fileName As String = $"order-{model.OrderId}.pdf"
    Return File(pdf.BinaryData, "application/pdf", fileName)
End Function
$vbLabelText   $csharpLabel

¿Cómo se ve la interfaz del formulario?

Interfaz de formulario web mostrando una página de creación de pedidos con sección de detalles del cliente que contiene el campo de nombre 'Jane Doe' y fecha '19/11/2025', sección de artículos del pedido mostrando 'Laptop' con precio de '1300', resumen del pedido mostrando total y un botón azul 'Generar PDF'

¿Cómo aparecen los datos del formulario en el PDF generado?

PDF viewer showing a clean order confirmation document with header 'Order Confirmation', customer name 'Jane Doe', order date '2025-11-19', itemized list showing laptop purchase for $1300, demonstrating successful form-to-PDF conversion

Para escenarios de documentos más avanzados, puede integrar formularios PDF o editar plantillas PDF existentes con campos precargados. La biblioteca también admite firmas digitales para documentos legales y contratos, lo que le permite agregar firmas criptográficamente verificables a cualquier documento generado.

Una consideración importante al incrustar datos de usuario en cadenas HTML es la desinfección. Siempre escape las cadenas proporcionadas por el usuario antes de insertarlas en HTML para evitar problemas de inyección. Una simple llamada System.Web.HttpUtility.HtmlEncode(model.CustomerName) en cada campo mantiene la plantilla segura antes de pasarla al renderizador.

¿Cómo agregar formato profesional, encabezados y marcas de agua?

¿Cómo configurar encabezados, pies de página y marcas de agua?

Los documentos PDF profesionales a menudo requieren encabezados y pies de página en cada página, junto con marcas de agua para borradores o documentos confidenciales. IronPDF maneja ambos a través de propiedades en el objeto RenderingOptions y el método ApplyWatermark en el PdfDocument resultante:

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    MaxHeight = 25,
    HtmlFragment = "<div style='text-align:center'>Annual Report 2024</div>"
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    MaxHeight = 20,
    HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
};
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.ApplyWatermark("<h2 style='color:red;opacity:0.3'>CONFIDENTIAL</h2>",
    30, VerticalAlignment.Middle, HorizontalAlignment.Center);
pdf.SaveAs("report-with-watermark.pdf");
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    MaxHeight = 25,
    HtmlFragment = "<div style='text-align:center'>Annual Report 2024</div>"
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    MaxHeight = 20,
    HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
};
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.ApplyWatermark("<h2 style='color:red;opacity:0.3'>CONFIDENTIAL</h2>",
    30, VerticalAlignment.Middle, HorizontalAlignment.Center);
pdf.SaveAs("report-with-watermark.pdf");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .MaxHeight = 25,
    .HtmlFragment = "<div style='text-align:center'>Annual Report 2024</div>"
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .MaxHeight = 20,
    .HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
}
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.ApplyWatermark("<h2 style='color:red;opacity:0.3'>CONFIDENTIAL</h2>", 30, VerticalAlignment.Middle, HorizontalAlignment.Center)
pdf.SaveAs("report-with-watermark.pdf")
$vbLabelText   $csharpLabel

Informe de prueba de IronPDF mostrando un documento PDF con encabezado azul personalizado 'Informe de Prueba de IronPDF', formato de texto en línea en verde, una tabla de datos con información de productos y una marca de agua 'CONFIDENTIAL' en rojo posicionada diagonalmente a través de la página

Los marcadores de posición {page} y {total-pages} en HTML del pie de página se reemplazan automáticamente en el momento de renderizado, por lo que obtienes números de página correctos sin procesamiento posterior. También puede agregar números de página , imágenes de fondo o superposiciones de primer plano y sellos de texto o imágenes personalizados .

¿Cómo utilizar medios de impresión CSS para controlar el diseño de PDF?

Para asegurar que la salida PDF coincida con las expectativas, usa reglas CSS @media print y el ajuste PdfCssMediaType.Print. IronPDF admite totalmente el control de saltos de página y tamaños de papel personalizados :

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
renderer.RenderingOptions.ViewPortWidth = 1024;
renderer.RenderingOptions.MarginTop = 10;
renderer.RenderingOptions.MarginBottom = 10;
renderer.RenderingOptions.MarginLeft = 10;
renderer.RenderingOptions.MarginRight = 10;
string html = @"
    <style>
        @media print {
            .no-print { display: none; }
            body { font-size: 12pt; }
            .page-break { page-break-after: always; }
        }
        @page {
            size: A4;
            margin: 1cm;
        }
    </style>
    <div class='content'>
        <h1>Professional Report</h1>
        <div class='page-break'></div>
        <h2>Section 2</h2>
    </div>";
var pdf = renderer.RenderHtmlAsPdf(html);
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
renderer.RenderingOptions.ViewPortWidth = 1024;
renderer.RenderingOptions.MarginTop = 10;
renderer.RenderingOptions.MarginBottom = 10;
renderer.RenderingOptions.MarginLeft = 10;
renderer.RenderingOptions.MarginRight = 10;
string html = @"
    <style>
        @media print {
            .no-print { display: none; }
            body { font-size: 12pt; }
            .page-break { page-break-after: always; }
        }
        @page {
            size: A4;
            margin: 1cm;
        }
    </style>
    <div class='content'>
        <h1>Professional Report</h1>
        <div class='page-break'></div>
        <h2>Section 2</h2>
    </div>";
var pdf = renderer.RenderHtmlAsPdf(html);
Imports IronPdf

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
renderer.RenderingOptions.ViewPortWidth = 1024
renderer.RenderingOptions.MarginTop = 10
renderer.RenderingOptions.MarginBottom = 10
renderer.RenderingOptions.MarginLeft = 10
renderer.RenderingOptions.MarginRight = 10

Dim html As String = "
    <style>
        @media print {
            .no-print { display: none; }
            body { font-size: 12pt; }
            .page-break { page-break-after: always; }
        }
        @page {
            size: A4;
            margin: 1cm;
        }
    </style>
    <div class='content'>
        <h1>Professional Report</h1>
        <div class='page-break'></div>
        <h2>Section 2</h2>
    </div>"

Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

Visor de documentos PDF mostrando un informe profesional de dos páginas con un zoom del 76% con el título 'Informe Profesional' en la página 1 y el encabezado 'Sección 2' en la página 2, mostrando un diseño limpio con saltos de página adecuados y formato CSS aplicado

El uso de CSS de impresión garantiza que los documentos PDF mantengan un formato profesional a la vez que se ocultan elementos web innecesarios, como menús de navegación o botones interactivos. Configurar CssMediaType = PdfCssMediaType.Print le dice al renderizador aplicar tus reglas @media print en lugar de los estilos de pantalla, lo que típicamente elimina decoraciones de fondo y ajusta la tipografía para la salida de impresión. También puede configurar márgenes personalizados por página y controlar la orientación y rotación de la página para informes de formato ancho o rotados.

La especificación de W3C CSS Páginas Medias define cómo deben comportarse propiedades como @page, page-break-before y widows en la salida paginada. El motor Chrome de IronPDF sigue esta especificación de cerca, por lo que los estilos escritos según el estándar CSS se traducen con precisión al PDF sin necesidad de ajustes manuales.

Cumplimiento LOPDGDD y eIDAS: consideraciones para PDF en ASP.NET con datos españoles

Cuando una aplicación ASP.NET genera PDFs que contienen datos personales de ciudadanos españoles (NIF, domicilio, datos financieros), la LOPDGDD establece obligaciones específicas. La AEPD puede exigir que el procesamiento de estos datos cuente con base legitimadora y medidas de seguridad técnicas adecuadas. IronPDF genera el PDF en el servidor, sin exponer los datos al cliente, lo que facilita el cumplimiento técnico.

Para documentos con valor legal (contratos firmados digitalmente, facturas con firma PAdES conforme a eIDAS emitida por la FNMT-RCM), el flujo habitual es:

  1. IronPDF renderiza el HTML a PDF en la capa de servidor ASP.NET.
  2. La firma electrónica PAdES se aplica sobre el PDF resultante con el certificado digital del emisor.
  3. El documento firmado se entrega al cliente o se archiva en el sistema de gestión documental.

Para organizaciones bajo TicketBAI en el País Vasco (Bizkaia, Gipuzkoa, Araba), el PDF generado por IronPDF actúa como representación visual de la factura XAdES-firmada que el sistema de facturación envía a la Hacienda foral. La firma XAdES sobre el XML es independiente de IronPDF; la biblioteca se encarga únicamente de la representación visual del documento. Bajo la Ley Crea y Crece, los PDFs de representación son la capa de legibilidad humana que complementa el intercambio electrónico estructurado.

¿Cómo se gestiona la autenticación para páginas protegidas?

Para aplicaciones seguras, IronPDF admite varios métodos de autenticación, incluidas cookies , encabezados de solicitud HTTP y credenciales de red . Esto le permite representar páginas que requieren una sesión iniciada o autenticación básica:

var renderer = new ChromePdfRenderer();
renderer.RequestContext.Cookies.Add(new Cookie
{
    Name = "SessionId",
    Value = "your-session-token",
    Domain = "example.com"
});
renderer.ChromePdfRenderOptions.HttpLoginCredentials = new HttpLoginCredentials
{
    Username = "user",
    Password = "password"
};
var pdf = renderer.RenderUrlAsPdf("https://app.example.com/protected/report");
var renderer = new ChromePdfRenderer();
renderer.RequestContext.Cookies.Add(new Cookie
{
    Name = "SessionId",
    Value = "your-session-token",
    Domain = "example.com"
});
renderer.ChromePdfRenderOptions.HttpLoginCredentials = new HttpLoginCredentials
{
    Username = "user",
    Password = "password"
};
var pdf = renderer.RenderUrlAsPdf("https://app.example.com/protected/report");
Dim renderer = New ChromePdfRenderer()
renderer.RequestContext.Cookies.Add(New Cookie With {
    .Name = "SessionId",
    .Value = "your-session-token",
    .Domain = "example.com"
})
renderer.ChromePdfRenderOptions.HttpLoginCredentials = New HttpLoginCredentials With {
    .Username = "user",
    .Password = "password"
}
Dim pdf = renderer.RenderUrlAsPdf("https://app.example.com/protected/report")
$vbLabelText   $csharpLabel

También puede cifrar el PDF resultante con una contraseña de propietario y una contraseña de usuario, restringiendo acciones como imprimir, copiar o editar. La combinación de la representación basada en autenticación con permisos a nivel de PDF le brinda control sobre quién puede generar un documento y qué pueden hacer los destinatarios con él una vez que lo tienen.

Para entornos empresariales, considere utilizar la API de representación asincrónica al generar archivos PDF dentro de los controladores de solicitudes web. La representación asincrónica mantiene libre el grupo de subprocesos ASP.NET mientras el motor Chrome procesa el documento, lo que mejora el rendimiento bajo carga simultánea. La biblioteca también admite la representación multiproceso para escenarios de generación de documentos por lotes.

¿Por qué es importante el motor de renderizado Chrome para convertir HTML a PDF?

La mayoría de las bibliotecas de generación de PDF funcionan analizando HTML mediante un motor personalizado. Esto significa que solo admiten un subconjunto de propiedades CSS, carecen de ejecución de JavaScript y presentan dificultades con técnicas de diseño modernas como CSS Grid o Flexbox. IronPDF adopta un enfoque diferente al incorporar el motor Chrome, la misma tecnología que impulsa el navegador Google Chrome.

El resultado práctico es que cualquier página HTML que se muestre correctamente en Chrome se representará correctamente como PDF a través de IronPDF. Esto elimina una clase común de errores en los que la salida del PDF difiere de la apariencia esperada porque el motor de renderizado interpreta el CSS de manera diferente al navegador que el desarrollador utilizó durante el diseño.

La referencia de MDN Web Docs para CSS Paged Media y la documentación de ASP.NET Core de Microsoft describen características que IronPDF admite a través de su base basada en Chrome. Los desarrolladores que ya están familiarizados con HTML, CSS y JavaScript estándar pueden aplicar ese conocimiento directamente a la generación de PDF sin tener que aprender un lenguaje de diseño de documentos independiente.

Las opciones de representación de IronPDF exponen controles para el tamaño del papel, los márgenes, la ejecución de JavaScript y los retrasos en la representación. La biblioteca maneja texto UTF-8 y conjuntos de caracteres internacionales, fuentes web referenciadas a través de Google Fonts o archivos locales, e incluso puede convertir documentos Markdown a PDF . Para requisitos de cumplimiento de archivo o accesibilidad, admite los formatos de salida PDF/A y PDF/UA . La biblioteca se ejecuta en Windows, Linux y macOS y se implementa en Azure y AWS sin configuración adicional.

SII y Facturae: integración de IronPDF en flujos de facturación electrónica ASP.NET

Para empresas sujetas al SII (Suministro Inmediato de Información), la generación PDF en ASP.NET puede integrarse directamente en el flujo de envío de datos a la AEAT. IronPDF renderiza la representación visual en el mismo request que registra la factura, garantizando que el documento PDF y el XML SII compartan el mismo identificador de factura y fecha de emisión. Esto facilita la trazabilidad ante auditorías.

El estándar Facturae 3.2.2, exigido por la plataforma FACe para facturación B2G, requiere también una representación PDF legible. IronPDF genera este PDF desde una plantilla HTML mantenida por el equipo de desarrollo, lo que desacopla el diseño visual de la lógica de generación del XML. La plataforma FACe acepta el PDF como adjunto al XML firmado, mejorando la experiencia del receptor administrativo.

¿Cuales son tus próximos pasos?

Convertir HTML a PDF en ASP.NET C# con IronPDF proporciona a su aplicación un flujo de trabajo de generación de documentos fiable y preciso para el navegador. Los tres métodos de renderizado (cadena HTML, archivo HTML y URL) abarcan toda la gama de fuentes de contenido que encontrará en la práctica. Funciones avanzadas como encabezados, pies de página, marcas de agua y CSS de impresión le permiten generar resultados profesionales sin posprocesar el PDF manualmente.

El siguiente paso es instalar el paquete NuGet y ejecutar el ejemplo de inicio rápido de la primera sección de esta guía. A partir de ahí, explore el tutorial completo de PDF en C# para profundizar en la estructura del documento o revise la guía de edición de PDF para aprender a fusionar, dividir, anotar y extraer contenido de archivos PDF existentes.

Si su proyecto apunta a Blazor, el tutorial en PDF de Blazor lo guía a través de la integración del lado del servidor y de WebAssembly. Para proyectos MVC, la guía de PDF para MVC Core y la guía de Razor Pages cubren la renderización basada en plantillas con vistas de .cshtml. Para la depuración y el ajuste del rendimiento, IronPDF proporciona un registro personalizado y una guía de rendimiento que ayudan a identificar cuellos de botella en flujos de trabajo de generación de documentos de gran volumen.

Comienza una prueba gratuita para probar cada característica de la biblioteca en tu propio proyecto antes de comprometerte con una licencia. Para implementaciones de producción, hay opciones de licencia disponibles para desarrolladores individuales, equipos y escenarios de redistribución empresarial.

Preguntas Frecuentes

¿Cómo se genera en ASP.NET Core una factura VeriFactu con la leyenda VERI*FACTU obligatoria?

El controlador MVC construye el HTML de la factura incluyendo el texto literal VERI*FACTU (con asterisco) en el cuerpo. Luego llama a ChromePdfRenderer.RenderHtmlAsPdf() para generar el PDF. IronPDF preserva fielmente el texto gracias a su motor Chrome, y el PDF incluye la leyenda conforme al Real Decreto 1007/2023.

¿Cómo se formatea correctamente en ASP.NET el importe de una factura española (1.234,56 €)?

Use CultureInfo('es-ES') al formatear los decimales: valor.ToString('N2', new CultureInfo('es-ES')) + ' €'. Esto produce el formato punto-miles/coma-decimal estándar en España. Inserte el string formateado en la plantilla HTML antes de llamar a RenderHtmlAsPdf.

¿Puede IronPDF en ASP.NET generar PDFs para Facturae y la plataforma FACe?

Sí. IronPDF genera la representación visual PDF que acompaña al XML Facturae enviado a FACe. El controlador ASP.NET puede generar ambos documentos en el mismo request: el XML Facturae lo gestiona el motor de facturación, e IronPDF genera el PDF de representación legible para el receptor administrativo.

¿Qué medidas de seguridad de LOPDGDD se aplican al generar PDFs con datos personales en ASP.NET?

IronPDF procesa todo en el servidor, sin exponer datos al cliente. Para cumplir la LOPDGDD supervisada por la AEPD, los PDFs con NIF, domicilio o datos financieros deben procesarse con base legitimadora y medidas de seguridad técnicas. En Azure, use la región Spain Central para garantizar residencia de datos en territorio español.

¿Cómo se integra la firma PAdES eIDAS con IronPDF en una aplicación ASP.NET?

IronPDF genera el documento PDF base. La firma PAdES conforme a eIDAS se aplica con el certificado digital (habitualmente FNMT-RCM) mediante una biblioteca de firma separada. El flujo típico en ASP.NET: RenderHtmlAsPdf() → aplicar firma PAdES → devolver el PDF firmado al cliente.

Curtis Chau
Curtis Chau
  Chatea con el equipo de ingeniería ahora
Escritor Técnico

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

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis

Equipo de soporte de Iron

Estamos disponibles online las 24 horas, 5 días a la semana.
Chat
Email
Llámame