Para los ISVs y equipos de desarrollo .NET en España, la migración de Telerik Document Processing a IronPDF va más allá de una mejora técnica: es una decisión con implicaciones directas en el cumplimiento del Real Decreto-Ley 15/2025 (VeriFactu), la Ley Crea y Crece, TicketBAI en el País Vasco y la LOPDGDD. El modelo de documento de flujo (Flow Document) de Telerik no fue diseñado para emitir las leyendas obligatorias VERI\*FACTU, incrustar el QR de verificación de la AEAT ni generar documentos PDF/A-3 con adjuntos Facturae XML para FACe. Los proveedores de software de facturación que no cumplan con VeriFactu se exponen a sanciones de hasta 150.000 € al año.
Telerik Document Processing se distribuye como parte de la suite DevCraft, ofreciendo capacidades de generación de PDF junto con procesamiento Word, Excel y PowerPoint. Sin embargo, a medida que los proyectos exigen compatibilidad total con CSS3, Flexbox, Bootstrap y la normativa de facturación electrónica española, muchos equipos descubren limitaciones fundamentales en su arquitectura.
Esta guía proporciona una ruta de migración completa de Telerik Document Processing a IronPDF, con instrucciones paso a paso, comparaciones de código y ejemplos prácticos para el contexto regulatorio español.
La decisión de migrar de Telerik Document Processing suele deberse a limitaciones técnicas que se hacen evidentes al trabajar con contenido web moderno y con la normativa de facturación electrónica española. El régimen VeriFactu (RDL 15/2025), obligatorio para el software de facturación desde julio de 2025, exige tres elementos que el modelo de documento de flujo de Telerik técnicamente no puede emitir: la leyenda VERI\*FACTU, el código QR verificable ante la AEAT y la cadena de huella SHA-256 encadenada. Entender estas limitaciones ayuda a justificar el esfuerzo de migración y establece las expectativas de lo que IronPDF resuelve.
El Telerik Document Processing tiene problemas fundamentales a la hora de manejar HTML y CSS modernos:
| Problema | Impacto | Solución IronPDF |
|---|---|---|
| Limitaciones del análisis sintáctico de CSS | Los marcos CSS modernos como Bootstrap fallan | Compatibilidad total con CSS de Chromium |
| Conversión de div a párrafo | Estructura HTML aplanada, diseños rotos | Representación directa en HTML |
| Modelo de documento de flujo | Obliga a una conversión intermedia | HTML nativo a PDF |
| Aspectos externos de CSS | Se ignoran los selectores complejos | Compatibilidad total con archivos CSS |
| Temas de memoria | OutOfMemoryException en documentos grandes | Transmisión eficiente |
Telerik Document Processing convierte HTML a un modelo intermedio de "documento de flujo" antes de generar PDF. Esta decisión arquitectónica crea problemas en cascada:
<div> se convierten en párrafosConsidere este HTML moderno que utiliza diseños CSS estándar:
<!-- This modern HTML/CSS BREAKS in Telerik Document Processing-->
<div class="container">
<div class="row">
<div class="col-md-6">Column 1</div>
<div class="col-md-6">Column 2</div>
</div>
</div>
<div style="display: flex; gap: 20px;">
<div style="flex: 1;">Flex Item 1</div>
<div style="flex: 1;">Flex Item 2</div>
</div>
<div style="display: grid; grid-template-columns: repeat(3, 1fr);">
<div>Grid Item 1</div>
<div>Grid Item 2</div>
<div>Grid Item 3</div>
</div>En Telerik Document Processing, todos estos diseños se representan como párrafos secuenciales. El diseño Bootstrap de dos columnas se convierte en dos líneas de texto. Los elementos flexbox se apilan verticalmente. Los elementos de CSS Grid aparecen uno tras otro.
Los desarrolladores han documentado amplios problemas de compatibilidad con CSS:
/* ❌ These CSS features DON'T WORK in Telerik Document Processing*/
/* Flexbox - No soportado */
.container { display: flex; }
.item { flex: 1; }
/* CSS Grid - No soportado */
.grid { display: grid; grid-template-columns: repeat(3, 1fr); }
/* Bootstrap columns - Converted to paragraphs */
.col-md-6 { /* Ignored, becomes linear text */ }
/* CSS Variables - No soportado */
:root { --primary: #007bff; }
.btn { color: var(--primary); }
/* Complex selectors - Often ignored */
.container > .row:first-child { }
.item:hover { }
.content::before { }
/* Modern units - Limited support */
.box { width: calc(100% - 20px); }
.text { font-size: 1.2rem; }Más allá de las limitaciones de CSS, Telerik Document Processingha documentado errores OutOfMemoryException al procesar archivos grandes. Los equipos de desarrollo que trabajan con la generación de grandes volúmenes de documentos se han encontrado con problemas de estabilidad que otras bibliotecas gestionan de forma más eficiente.
La comprensión de las diferencias de características ayuda a los responsables técnicos a evaluar la inversión en migración:
| Característica | Telerik Document Processing | IronPDF |
|---|---|---|
| Representación HTML | Conversión de documentos de flujo | Renderizado directo en Chromium |
| Soporte CSS3 | Limitadas, muchas características fallan | CSS3 completo |
| Flexbox | No soportado | Se admite |
| CSS Grid | No soportado | Se admite |
| Bootstrap | Broken (div flattening) | Compatible con Bootstrap 5 |
| CSS externo | Parcial | Se admite |
| JavaScript | No soportado | Compatibilidad total con ES2024 |
| Documentos grandes | Problemas de memoria | Transmisión eficiente |
| Complejidad de la API | Complejo (proveedores, modelos) | Simple (una clase) |
| Modelo de licencia | Comercial, parte de DevCraft | Licencias independientes sencillas |
La migración de Telerik Document Processing a IronPDF puede comenzar inmediatamente. Este es el camino más rápido para generar su primer PDF con IronPDF, ya preparado para incorporar los requisitos de VeriFactu (AEAT) y TicketBAI (Bizkaia, Gipuzkoa y Araba).
Elimine todos los paquetes de Telerik Document Processing:
# Remove Telerik packages
dotnet remove package Telerik.Documents.Core
dotnet remove package Telerik.Documents.Flow
dotnet remove package Telerik.Documents.Flow.FormatProviders.Pdf
dotnet remove package Telerik.Documents.FixedInstalar IronPDF:
# Install IronPDF
dotnet add package IronPdfSustituya los espacios de nombres Telerik por el espacio de nombres IronPdf:
// Before (Telerik Document Processing)
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using Telerik.Documents.Primitives;
// After (IronPDF)
using IronPdf;Imports Telerik.Windows.Documents.Flow.FormatProviders.Html
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Flow.Model
Imports Telerik.Documents.Primitives
' After (IronPDF)
Imports IronPdfInicialice su licencia al iniciar la aplicación:
// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";' Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"La transformación de Telerik Document Processinga IronPDF simplifica drásticamente su código base.
Antes (Telerik Document Processing):
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(htmlContent);
PdfFormatProvider pdfProvider = new PdfFormatProvider();
byte[] pdfBytes = pdfProvider.Export(document);
File.WriteAllBytes("output.pdf", pdfBytes);Imports Telerik.Windows.Documents.Flow.FormatProviders.Html
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Flow.Model
Dim htmlProvider As New HtmlFormatProvider()
Dim document As RadFlowDocument = htmlProvider.Import(htmlContent)
Dim pdfProvider As New PdfFormatProvider()
Dim pdfBytes As Byte() = pdfProvider.Export(document)
File.WriteAllBytes("output.pdf", pdfBytes)Después (IronPDF):
using IronPdf;
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("output.pdf");Imports IronPdf
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("output.pdf")La diferencia es evidente de inmediato: 3 líneas de código IronPDF sustituyen a más de 15 líneas de código de Telerik Document Processing. Y lo que es más importante, la versión IronPDF renderizará correctamente CSS moderno que el modelo Flow Document de Telerik no puede manejar.
Este es el caso de uso más común para la generación de PDF. Las diferencias arquitectónicas entre Telerik Document Processinge IronPDF quedan claras en esta comparación.
Enfoque de Telerik Document Processing:
// NuGet: Install-Package Telerik.Documents.Flow
// NuGet: Install-Package Telerik.Documents.Flow.FormatProviders.Pdf
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using System.IO;
string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(html);
PdfFormatProvider pdfProvider = new PdfFormatProvider();
using (FileStream output = File.OpenWrite("output.pdf"))
{
pdfProvider.Export(document, output);
}Imports Telerik.Windows.Documents.Flow.FormatProviders.Html
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Flow.Model
Imports System.IO
Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"
Dim htmlProvider As New HtmlFormatProvider()
Dim document As RadFlowDocument = htmlProvider.Import(html)
Dim pdfProvider As New PdfFormatProvider()
Using output As FileStream = File.OpenWrite("output.pdf")
pdfProvider.Export(document, output)
End UsingEnfoque IronPDF:
// NuGet: Install-Package IronPdf
using IronPdf;
string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");Imports IronPdf
Dim html As String = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")La versión de Telerik requiere crear un HtmlFormatProvider, importar a un RadFlowDocument, crear un PdfFormatProvider y administrar los flujos de archivos manualmente. ChromePdfRenderer de IronPDF maneja todo el proceso con una única llamada de método.
Para situaciones más avanzadas de conversión de HTML a PDF, consulte la Guía de conversión de HTML a PDF.
La captura de páginas web como PDF revela otra diferencia significativa entre las bibliotecas.
Enfoque de Telerik Document Processing:
// NuGet: Install-Package Telerik.Documents.Flow
// NuGet: Install-Package Telerik.Documents.Flow.FormatProviders.Pdf
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
string url = "https://example.com";
using HttpClient client = new HttpClient();
string html = await client.GetStringAsync(url);
HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(html);
PdfFormatProvider pdfProvider = new PdfFormatProvider();
using (FileStream output = File.OpenWrite("webpage.pdf"))
{
pdfProvider.Export(document, output);
}Imports Telerik.Windows.Documents.Flow.FormatProviders.Html
Imports Telerik.Windows.Documents.Flow.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Flow.Model
Imports System.IO
Imports System.Net.Http
Imports System.Threading.Tasks
Module Module1
Sub Main()
Dim url As String = "https://example.com"
Using client As New HttpClient()
Dim html As String = Await client.GetStringAsync(url)
Dim htmlProvider As New HtmlFormatProvider()
Dim document As RadFlowDocument = htmlProvider.Import(html)
Dim pdfProvider As New PdfFormatProvider()
Using output As FileStream = File.OpenWrite("webpage.pdf")
pdfProvider.Export(document, output)
End Using
End Using
End Sub
End ModuleEnfoque IronPDF:
// NuGet: Install-Package IronPdf
using IronPdf;
string url = "https://example.com";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf(url);
pdf.SaveAs("webpage.pdf");Imports IronPdf
Dim url As String = "https://example.com"
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderUrlAsPdf(url)
pdf.SaveAs("webpage.pdf")Telerik Document Processing no tiene capacidad nativa de URL a PDF. Debes obtener manualmente el contenido HTML usando HttpClient, perdiendo CSS externo, ejecución de JavaScript y contenido dinámico en el proceso. El método RenderUrlAsPdf de IronPDF captura la página completa renderizada exactamente como aparece en un navegador.
Explore la URL a la documentación PDF para obtener opciones adicionales, incluida la autenticación y las cabeceras personalizadas.
La fusión de PDF demuestra la diferencia de verbosidad entre estas bibliotecas PDF .NET.
Enfoque de Telerik Document Processing:
// NuGet: Install-Package Telerik.Documents.Fixed
using Telerik.Windows.Documents.Fixed.FormatProviders.Pdf;
using Telerik.Windows.Documents.Fixed.Model;
using System.IO;
PdfFormatProvider provider = new PdfFormatProvider();
RadFixedDocument document1;
using (FileStream input = File.OpenRead("document1.pdf"))
{
document1 = provider.Import(input);
}
RadFixedDocument document2;
using (FileStream input = File.OpenRead("document2.pdf"))
{
document2 = provider.Import(input);
}
RadFixedDocument mergedDocument = new RadFixedDocument();
foreach (var page in document1.Pages)
{
mergedDocument.Pages.Add(page);
}
foreach (var page in document2.Pages)
{
mergedDocument.Pages.Add(page);
}
using (FileStream output = File.OpenWrite("merged.pdf"))
{
provider.Export(mergedDocument, output);
}Imports Telerik.Windows.Documents.Fixed.FormatProviders.Pdf
Imports Telerik.Windows.Documents.Fixed.Model
Imports System.IO
Dim provider As New PdfFormatProvider()
Dim document1 As RadFixedDocument
Using input As FileStream = File.OpenRead("document1.pdf")
document1 = provider.Import(input)
End Using
Dim document2 As RadFixedDocument
Using input As FileStream = File.OpenRead("document2.pdf")
document2 = provider.Import(input)
End Using
Dim mergedDocument As New RadFixedDocument()
For Each page In document1.Pages
mergedDocument.Pages.Add(page)
Next
For Each page In document2.Pages
mergedDocument.Pages.Add(page)
Next
Using output As FileStream = File.OpenWrite("merged.pdf")
provider.Export(mergedDocument, output)
End UsingEnfoque IronPDF:
// NuGet: Install-Package IronPdf
using IronPdf;
var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");Imports IronPdf
Dim pdf1 = PdfDocument.FromFile("document1.pdf")
Dim pdf2 = PdfDocument.FromFile("document2.pdf")
Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")La versión de Telerik requiere importar cada documento por separado, iterar manualmente por las páginas, añadirlas a un nuevo documento y gestionar múltiples flujos de archivos. El método PdfDocument.Merge() de IronPDF maneja todo en una sola llamada.
Para situaciones de fusión avanzadas, incluida la extracción selectiva de páginas, consulte la guía de fusión y división de PDF.
Esta tabla de referencia acelera la migración mostrando los equivalentes directos de las API:
| Telerik Document Processing | IronPDF |
|---|---|
HtmlFormatProvider | ChromePdfRenderer |
RadFlowDocument | No es necesario |
PdfFormatProvider | pdf.SaveAs() |
RadFlowDocumentEditor | Manipulación de HTML |
Section | HTML <section> |
Paragraph | HTML <p> |
PdfExportSettings | RenderingOptions |
RadFixedDocument | PdfDocument |
| Repetición manual de páginas | PdfDocument.Merge() |
Telerik Document Processing utiliza un modelo programático para encabezados y pies de página.IronPDF proporciona encabezados basados en HTML con marcadores de posición dinámicos.
Telerik Document Processing:
section.Headers.Default.Blocks.AddParagraph().Inlines.AddRun("Header Text");
section.Footers.Default.Blocks.AddParagraph().Inlines.AddRun("Footer Text");section.Headers.Default.Blocks.AddParagraph().Inlines.AddRun("Header Text")
section.Footers.Default.Blocks.AddParagraph().Inlines.AddRun("Footer Text")IronPDF:
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
HtmlFragment = "<div style='text-align:center;'>Header Text</div>",
MaxHeight = 25
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
HtmlFragment = "<div style='text-align:center;'>Footer Text</div>",
MaxHeight = 25
};Imports System
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
.HtmlFragment = "<div style='text-align:center;'>Header Text</div>",
.MaxHeight = 25
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
.HtmlFragment = "<div style='text-align:center;'>Footer Text</div>",
.MaxHeight = 25
}El enfoque basado en HTML de IronPDF permite un estilo CSS completo en encabezados y pies de página, además de marcadores de posición dinámicos para números de página y fechas. Más información en la documentación sobre encabezados y pies de página.
Telerik Document Processing utiliza píxeles independientes del dispositivo (DIP) para las mediciones.IronPDF utiliza milímetros. Esto requiere una conversión durante la migración:
// Telerik uses DIPs (device-independent pixels)
//IronPDF uses millimeters
// 1 inch = 25.4mm
renderer.RenderingOptions.MarginTop = 25.4; // 1 inch
renderer.RenderingOptions.MarginBottom = 25.4;
// Or use the helper method for paper size
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11);' Telerik uses DIPs (device-independent pixels)
' IronPDF uses millimeters
' 1 inch = 25.4mm
renderer.RenderingOptions.MarginTop = 25.4 ' 1 inch
renderer.RenderingOptions.MarginBottom = 25.4
' Or use the helper method for paper size
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11)Audite su código base para identificar todo el uso de Telerik Document Processing:
grep -r "using Telerik.Windows.Documents" --include="*.cs" .
grep -r "RadFlowDocument\|HtmlFormatProvider\|PdfFormatProvider" --include="*.cs" .Documente las implementaciones existentes, incluidos los proveedores de formato utilizados, las configuraciones de encabezado/pie de página, los ajustes de página personalizados y cualquier modificación del modelo de documento de flujo.
Telerik.Windows.Documents a IronPdfHtmlFormatProvider con ChromePdfRendererRadFlowDocument pasos intermediosPdfFormatProvider con llamadas directas SaveAs()HtmlHeaderFooterRenderingOptionsTras la migración, verifique estas mejoras:
El cambio de Telerik Document Processinga IronPDF ofrece ventajas inmediatas:
**Motor de renderizado moderno de Chromium:**IronPDF utiliza el mismo motor de renderizado que Google Chrome, lo que garantiza que los archivos PDF se representen exactamente como aparece el contenido en los navegadores modernos. Esto elimina los problemas de compatibilidad con CSS inherentes al modelo de documento de flujo de Telerik.
Compatibilidad completa con CSS3 y JavaScript : Flexbox, Grid, Bootstrap 5, variables CSS y JavaScript moderno funcionan correctamente. A medida que aumenta la adopción de .NET 10 y C# 14 hasta 2026, la moderna renderización de IronPDF garantiza la compatibilidad con los estándares web contemporáneos.
API más simple: menos líneas de código, sin modelos de documentos intermedios y nombres de métodos intuitivos reducen el tiempo de desarrollo y la carga de mantenimiento.
**Licencias independientes:**IronPDF ofrece licencias sencillas sin necesidad de comprar una suite completa, lo que proporciona una solución rentable para equipos que solo necesitan capacidades de PDF.
Desarrollo activo: las actualizaciones periódicas garantizan la compatibilidad con versiones actuales y futuras de .NET , parches de seguridad y mejoras de funciones.
Para los ISVs en España que migran de Telerik Document Processing a IronPDF en contextos de facturación, ERP o gestión documental, la migración tiene implicaciones regulatorias directas. IronPDF actúa como componente de generación PDF dentro del software de facturación certificado — nunca como sistema de facturación certificado por sí mismo.
VeriFactu (RDL 15/2025): Los proveedores de software de facturación deben generar registros con huella anti-manipulación, código QR verificable ante la AEAT y la leyenda VERI\*FACTU en las visualizaciones de factura. El incumplimiento puede acarrear sanciones de hasta 150.000 € al año.
A continuación se muestra un ejemplo con datos de empresa española (NIF: B-28.456.789, IVA 21%, importe en formato peninsular):
using IronPdf;
using System.Security.Cryptography;
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
var renderer = new ChromePdfRenderer();
// Factura con datos de empresa española — NIF, EUR y formato es-ES
string html = @"
<html>
<body style='font-family: Arial, sans-serif; margin: 40px;'>
<h1>FACTURA Nº 2026-0042</h1>
<p>Emisor: Soluciones TI España S.L. | NIF: B-28.456.789</p>
<p>Receptor: Cliente Ejemplo S.A. | CIF: A-12.345.678</p>
<table border='1' cellpadding='5' style='width:100%;'>
<tr><th>Concepto</th><th>Base imponible</th><th>IVA 21%</th><th>Total</th></tr>
<tr><td>Licencia software .NET</td>
<td>1.000,00 €</td><td>210,00 €</td><td>1.210,00 €</td></tr>
</table>
<p style='font-weight:bold; border:2px solid #003366; padding:8px; margin-top:20px;'>
VERI*FACTU — Factura verificable en la sede electrónica de la AEAT
</p>
<img src='qr-aeat-verificacion.png' alt='QR verificación AEAT' width='80' height='80'/>
</body>
</html>";
var pdf = renderer.RenderHtmlAsPdf(html);
// Huella SHA-256 para trazabilidad VeriFactu
string hash = Convert.ToHexString(SHA256.HashData(pdf.BinaryData));
pdf.SaveAs("factura-verifactu-2026-0042.pdf");Imports IronPdf
Imports System.Security.Cryptography
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
Dim renderer As New ChromePdfRenderer()
' Factura con datos de empresa española — NIF, EUR y formato es-ES
Dim html As String = "
<html>
<body style='font-family: Arial, sans-serif; margin: 40px;'>
<h1>FACTURA Nº 2026-0042</h1>
<p>Emisor: Soluciones TI España S.L. | NIF: B-28.456.789</p>
<p>Receptor: Cliente Ejemplo S.A. | CIF: A-12.345.678</p>
<table border='1' cellpadding='5' style='width:100%;'>
<tr><th>Concepto</th><th>Base imponible</th><th>IVA 21%</th><th>Total</th></tr>
<tr><td>Licencia software .NET</td>
<td>1.000,00 €</td><td>210,00 €</td><td>1.210,00 €</td></tr>
</table>
<p style='font-weight:bold; border:2px solid #003366; padding:8px; margin-top:20px;'>
VERI*FACTU — Factura verificable en la sede electrónica de la AEAT
</p>
<img src='qr-aeat-verificacion.png' alt='QR verificación AEAT' width='80' height='80'/>
</body>
</html>"
Dim pdf = renderer.RenderHtmlAsPdf(html)
' Huella SHA-256 para trazabilidad VeriFactu
Dim hash As String = Convert.ToHexString(SHA256.HashData(pdf.BinaryData))
pdf.SaveAs("factura-verifactu-2026-0042.pdf")TicketBAI (País Vasco): Las tres haciendas forales —Bizkaia (bizkaia.eus), Gipuzkoa (gipuzkoa.eus) y Araba (araba.eus)— tienen especificaciones propias e independientes de facturación electrónica. IronPDF genera los PDFs de factura y los códigos QR requeridos; la firma XAdES de los XMLs se gestiona en la capa del ISV conforme a eIDAS, usando certificados FNMT-RCM u otros reconocidos.
Facturae, FACe y Crea y Crece: Para facturación B2G a través de FACe, IronPDF soporta la generación de documentos Facturae XML con adjuntos PDF/A-3 de forma nativa. La ley Crea y Crece extiende la obligatoriedad de factura electrónica B2B desde 2027-2028, bajo el estándar EN 16931 y el perfil CIUS-ES.
LOPDGDD (AEPD): El procesamiento on-premise con IronPDF facilita el cumplimiento del LOPDGDD para el tratamiento de documentos con datos personales de ciudadanos españoles, sin infraestructura externa que aumente el alcance del tratamiento supervisado por la AEPD. El régimen SII (Suministro Inmediato de Información) de la AEAT puede beneficiarse de la generación asíncrona nativa de IronPDF para transmisión paralela de PDF y XML fiscal.
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.
