Api2pdf ofrece un servicio en la nube para generar archivos PDF, pero enviar documentos confidenciales a servidores externos puede conllevar riesgos de seguridad, problemas de cumplimiento normativo y costos continuos que pueden acumularse con el tiempo. Para los ISVs y desarrolladores españoles que generan facturas VeriFactu, TicketBAI o Facturae, enviar datos de facturación a servidores externos de terceros puede ser incompatible con las obligaciones de la AEAT y la LOPDGDD: los registros de facturación electrónica deben mantenerse bajo control del emisor. Esta guía proporciona una ruta de migración detallada de Api2pdf a IronPDF, una biblioteca PDF nativa de .NET que procesa documentos completamente en su propia infraestructura, eliminando las preocupaciones por la transmisión de datos y convirtiendo los costos por conversión en una inversión única.
Si bien Api2pdfproporciona una conveniente generación de PDF basada en la nube, varios factores llevan a los equipos de desarrollo a buscar alternativas locales para sus necesidades de generación de PDF.
Api2pdf funciona como un servicio basado en la nube en el que el HTML y los documentos confidenciales se envían a servidores de terceros para su procesamiento. Esto plantea importantes problemas a las organizaciones que manejan datos regulados.
| Riesgo | Api2pdf | IronPDF |
|---|---|---|
| Transmisión de datos | Todo el contenido se envía a servidores externos | Procesa localmente en tu infraestructura |
| Cumplimiento del GDPR | Los datos cruzan jurisdicciones | Los datos nunca salen de su entorno |
| Cumplimiento de la HIPAA | PHI transmitida externamente | PHI permanece dentro de sus sistemas |
| SOC 2 | Dependencia de terceros | Control total sobre el manejo de datos |
| PCI DSS | Datos de tarjetas potencialmente expuestos | Sin transmisión externa |
Api2pdf cobra aproximadamente 0,005 dólares por conversión de forma indefinida, mientras que IronPDF ofrece una licencia perpetua única. En el caso de las aplicaciones que generan grandes volúmenes de PDF, la diferencia de coste es considerable:
| Volumen | Api2pdf(anual) | IronPDF(una sola vez) |
|---|---|---|
| 10.000 PDF/mes | ~600 $/año | 749 $ (Lite) |
| 50.000 PDF/mes | ~3.000 $/año | 749 $ (Lite) |
| 100.000 PDF al mes | ~6.000 $/año | 1.499 $ (Plus) |
IronPDF se amortiza en meses para la mayoría de las aplicaciones de producción.
Api2pdf requiere viajes de ida y vuelta por la red que añaden de 2 a 5 segundos de latencia a cada solicitud de generación de PDF.IronPDF procesa localmente en 100-500 milisegundos. Además,IronPDF funciona totalmente fuera de línea y en entornos aislados, algo fundamental para las aplicaciones que no pueden depender de la disponibilidad de servicios externos.
| Aspecto | Api2pdf | IronPDF |
|---|---|---|
| Manejo de datos | Envío a servidores en la nube de terceros | Procesado localmente en su infraestructura |
| Precios | Pago por conversión (~0,005 $/PDF) | Licencia perpetua única |
| Latencia | 2-5 segundos (ida y vuelta en red) | 100-500ms (procesamiento local) |
| Offline | No disponible | Funciona totalmente fuera de línea |
| Instalación | Clave API + cliente HTTP | Paquete simple NuGet |
| Cumplimiento | Preocupaciones GDPR/HIPAA (los datos salen de la red) | Control total de la conformidad |
Para ISVs y desarrolladores españoles, el modelo de nube de Api2pdf tiene implicaciones específicas bajo la normativa española:
VeriFactu y soberanía de datos (RDL 15/2025): los sistemas de facturación electrónica deben mantener registros íntegros y auditables. Enviar datos de facturación (importes, NIF del emisor, receptor, conceptos) a servidores de terceros en la nube puede dificultar la demostración de la integridad de la cadena de auditoría ante la AEAT. Con IronPDF procesando localmente, los datos de facturación nunca salen de la infraestructura del ISV.
LOPDGDD y datos fiscales: la Ley Orgánica de Protección de Datos y Garantía de los Derechos Digitales aplica a los datos de facturación que incluyan datos personales (nombre, NIF, domicilio del cliente). Transmitir estos datos a Api2pdf (servidores en EE.UU. u otras jurisdicciones) requiere garantías adicionales bajo RGPD/LOPDGDD que IronPDF, procesando en local, evita por diseño.
TicketBAI (Bizkaia, Gipuzkoa, Araba): la firma XAdES de las facturas TicketBAI debe realizarse en la infraestructura del emisor. Un flujo que genera el PDF en la nube de Api2pdf y luego firma localmente introduce complejidad adicional. IronPDF genera y firma en el mismo proceso .NET.
Penalización de hasta 150.000 €/año: el régimen VeriFactu sanciona a proveedores no conformes. Una arquitectura donde los datos de facturación se procesan en servidores de terceros añade complejidad de cumplimiento que IronPDF elimina.
using IronPdf;
// IronPDF: datos de facturación nunca salen de la infraestructura del ISV
var renderer = new ChromePdfRenderer();
var html = @"
<!DOCTYPE html>
<html>
<head>
<meta charset='utf-8'>
<style>
body { font-family: Arial, sans-serif; margin: 40px; }
.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; }
</style>
</head>
<body>
<h2>FACTURA Nº 2026-0099</h2>
<p>NIF: B12345678 | Cliente: Empresa SA | NIF Cliente: A87654321</p>
<table>
<tr><th>Concepto</th><th>Total</th></tr>
<tr><td>Servicio anual</td><td>2.400,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 placeholder]
</div>
</body>
</html>";
// Los datos personales (NIF, nombre) nunca se envían a servidores externos
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("factura-verifactu-2026-0099.pdf");Imports IronPdf
' IronPDF: datos de facturación nunca salen de la infraestructura del ISV
Dim renderer As New ChromePdfRenderer()
Dim html As String = "
<!DOCTYPE html>
<html>
<head>
<meta charset='utf-8'>
<style>
body { font-family: Arial, sans-serif; margin: 40px; }
.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; }
</style>
</head>
<body>
<h2>FACTURA Nº 2026-0099</h2>
<p>NIF: B12345678 | Cliente: Empresa SA | NIF Cliente: A87654321</p>
<table>
<tr><th>Concepto</th><th>Total</th></tr>
<tr><td>Servicio anual</td><td>2.400,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 placeholder]
</div>
</body>
</html>"
' Los datos personales (NIF, nombre) nunca se envían a servidores externos
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("factura-verifactu-2026-0099.pdf")Elimine el paquete Api2pdfe instale IronPDF:
# Remove Api2pdf
dotnet remove package Api2Pdf
# Install IronPDF
dotnet add package IronPdfO a través de Package Manager Console:
Uninstall-Package Api2Pdf
Install-Package IronPdfSustituya los espacios de nombres Api2pdfpor IronPDF:
// Remove these
using Api2Pdf;
using Api2Pdf.DotNet;
// Add these
using IronPdf;
using IronPdf.Rendering;Imports IronPdf
Imports IronPdf.RenderingEstablezca la clave de licencia de IronPDFal iniciar la aplicación:
// Set once at application startup
IronPdf.License.LicenseKey = "YOUR-IRONPDF-LICENSE-KEY";
// Or configure via appsettings.json:
// { "IronPdf.LicenseKey": "YOUR-IRONPDF-LICENSE-KEY" }' Set once at application startup
IronPdf.License.LicenseKey = "YOUR-IRONPDF-LICENSE-KEY"
' Or configure via appsettings.json:
' { "IronPdf.LicenseKey": "YOUR-IRONPDF-LICENSE-KEY" }IronPDF se ejecuta localmente y no requiere claves API:
// Remove this Api2pdfpattern
var client = new Api2PdfClient("API_KEY");
// Just create the renderer directly
var renderer = new ChromePdfRenderer();' Remove this Api2pdfpattern
Dim client = New Api2PdfClient("API_KEY")
' Just create the renderer directly
Dim renderer = New ChromePdfRenderer()| Clase Api2pdf | Equivalente de IronPDF |
|---|---|
Api2PdfClient | ChromePdfRenderer |
Api2PdfResult | PdfDocument |
HeadlessChromeOptions | ChromePdfRenderOptions |
| Método Api2pdf | Método IronPDF |
|---|---|
client.HeadlessChrome.FromHtmlAsync(html) | renderer.RenderHtmlAsPdf(html) |
client.HeadlessChrome.FromUrlAsync(url) | renderer.RenderUrlAsPdf(url) |
response.Pdf (URL) | pdf.SaveAs(path) |
response.Pdf (descargar) | pdf.BinaryData |
client.PdfSharp.MergePdfsAsync(urls) | PdfDocument.Merge(pdfs) |
client.PdfSharp.SetPasswordAsync(url, pwd) | pdf.SecuritySettings.OwnerPassword |
| Opción Api2pdf | Opción IronPDF |
|---|---|
Landscape = true | RenderingOptions.PaperOrientation = Landscape |
PageSize = "A4" | RenderingOptions.PaperSize = PdfPaperSize.A4 |
PrintBackground = true | RenderingOptions.PrintHtmlBackgrounds = true |
MarginTop, etc. | RenderingOptions.MarginTop, etc. |
Delay = 5000 | RenderingOptions.WaitFor.RenderDelay(5000) |
La operación Api2pdfmás común demuestra el cambio fundamental: de llamadas API en la nube al procesamiento local.
Implementación de API2pdf:
// NuGet: Install-Package Api2Pdf.DotNet
using System;
using System.Threading.Tasks;
using Api2Pdf.DotNet;
class Program
{
static async Task Main(string[] args)
{
var a2pClient = new Api2PdfClient("your-api-key");
var apiResponse = await a2pClient.HeadlessChrome.FromHtmlAsync("<h1>Hello World</h1>");
Console.WriteLine(apiResponse.Pdf);
}
}Imports System
Imports System.Threading.Tasks
Imports Api2Pdf.DotNet
Module Program
Async Function Main(args As String()) As Task
Dim a2pClient = New Api2PdfClient("your-api-key")
Dim apiResponse = Await a2pClient.HeadlessChrome.FromHtmlAsync("<h1>Hello World</h1>")
Console.WriteLine(apiResponse.Pdf)
End Function
End ModuleImplementación de IronPDF:
// NuGet: Install-Package IronPdf
using System;
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
pdf.SaveAs("output.pdf");
Console.WriteLine("PDF created successfully");
}
}Imports System
Imports IronPdf
Class Program
Shared Sub Main(ByVal args As String())
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>")
pdf.SaveAs("output.pdf")
Console.WriteLine("PDF created successfully")
End Sub
End ClassIronPDF elimina la ida y vuelta por la red, la gestión de claves API y el paso de descarga independiente que requiere el patrón de respuesta basado en URL de Api2pdf.
Implementación de API2pdf:
// NuGet: Install-Package Api2Pdf.DotNet
using System;
using System.Threading.Tasks;
using Api2Pdf.DotNet;
class Program
{
static async Task Main(string[] args)
{
var a2pClient = new Api2PdfClient("your-api-key");
var apiResponse = await a2pClient.HeadlessChrome.FromUrlAsync("https://www.example.com");
Console.WriteLine(apiResponse.Pdf);
}
}Imports System
Imports System.Threading.Tasks
Imports Api2Pdf.DotNet
Module Program
Async Function Main(args As String()) As Task
Dim a2pClient = New Api2PdfClient("your-api-key")
Dim apiResponse = Await a2pClient.HeadlessChrome.FromUrlAsync("https://www.example.com")
Console.WriteLine(apiResponse.Pdf)
End Function
End ModuleImplementación de IronPDF:
// NuGet: Install-Package IronPdf
using System;
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");
Console.WriteLine("PDF created from URL successfully");
}
}Imports System
Imports IronPdf
Module Program
Sub Main(args As String())
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
pdf.SaveAs("webpage.pdf")
Console.WriteLine("PDF created from URL successfully")
End Sub
End ModuleImplementación de API2pdf:
// NuGet: Install-Package Api2Pdf.DotNet
using System;
using System.IO;
using System.Threading.Tasks;
using Api2Pdf.DotNet;
class Program
{
static async Task Main(string[] args)
{
var a2pClient = new Api2PdfClient("your-api-key");
string html = File.ReadAllText("input.html");
var options = new HeadlessChromeOptions
{
Landscape = true,
PrintBackground = true
};
var apiResponse = await a2pClient.HeadlessChrome.FromHtmlAsync(html, options);
Console.WriteLine(apiResponse.Pdf);
}
}no response after 91 secondsImplementación de IronPDF:
// NuGet: Install-Package IronPdf
using System;
using System.IO;
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperOrientation = IronPdf.Rendering.PdfPaperOrientation.Landscape;
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
string html = File.ReadAllText("input.html");
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
Console.WriteLine("PDF created with options successfully");
}
}Imports System
Imports System.IO
Imports IronPdf
Module Program
Sub Main(args As String())
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperOrientation = IronPdf.Rendering.PdfPaperOrientation.Landscape
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
Dim html As String = File.ReadAllText("input.html")
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")
Console.WriteLine("PDF created with options successfully")
End Sub
End ModuleIronPDF configura las opciones de renderizado directamente en el objeto renderizador en lugar de pasarlas como un parámetro de opciones independiente a cada llamada a la API.
Implementación de API2pdf:
using Api2Pdf.DotNet;
var a2pClient = new Api2PdfClient("YOUR_API_KEY");
var pdfUrls = new List<string>
{
"https://example.com/pdf1.pdf",
"https://example.com/pdf2.pdf",
"https://example.com/pdf3.pdf"
};
var request = new PdfMergeRequest { Urls = pdfUrls };
var response = await a2pClient.PdfSharp.MergePdfsAsync(request);
if (response.Success)
{
// Download merged PDF from response.Pdf URL
}Imports Api2Pdf.DotNet
Dim a2pClient = New Api2PdfClient("YOUR_API_KEY")
Dim pdfUrls = New List(Of String) From {
"https://example.com/pdf1.pdf",
"https://example.com/pdf2.pdf",
"https://example.com/pdf3.pdf"
}
Dim request = New PdfMergeRequest With {.Urls = pdfUrls}
Dim response = Await a2pClient.PdfSharp.MergePdfsAsync(request)
If response.Success Then
' Download merged PDF from response.Pdf URL
End IfImplementación de IronPDF:
using IronPdf;
// Load PDFs from files
var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");
var pdf3 = PdfDocument.FromFile("document3.pdf");
// Merge all PDFs
var merged = PdfDocument.Merge(pdf1, pdf2, pdf3);
merged.SaveAs("merged.pdf");Imports IronPdf
' Load PDFs from files
Dim pdf1 = PdfDocument.FromFile("document1.pdf")
Dim pdf2 = PdfDocument.FromFile("document2.pdf")
Dim pdf3 = PdfDocument.FromFile("document3.pdf")
' Merge all PDFs
Dim merged = PdfDocument.Merge(pdf1, pdf2, pdf3)
merged.SaveAs("merged.pdf")El método estático Merge de IronPDF acepta múltiples documentos directamente, eliminando el flujo de trabajo basado en URL.
Implementación de API2pdf:
using Api2Pdf.DotNet;
var a2pClient = new Api2PdfClient("YOUR_API_KEY");
// Generate PDF first
var pdfResponse = await a2pClient.HeadlessChrome.FromHtmlAsync("<h1>Confidential</h1>");
// Then add password protection in separate call
var protectedResponse = await a2pClient.PdfSharp.SetPasswordAsync(
pdfResponse.Pdf,
"secretpassword"
);Imports Api2Pdf.DotNet
Dim a2pClient = New Api2PdfClient("YOUR_API_KEY")
' Generate PDF first
Dim pdfResponse = Await a2pClient.HeadlessChrome.FromHtmlAsync("<h1>Confidential</h1>")
' Then add password protection in separate call
Dim protectedResponse = Await a2pClient.PdfSharp.SetPasswordAsync(pdfResponse.Pdf, "secretpassword")Implementación de IronPDF:
using IronPdf;
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>");
// Set security in one step
pdf.SecuritySettings.OwnerPassword = "owner123";
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit;
pdf.SaveAs("protected.pdf");Imports IronPdf
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>")
' Set security in one step
pdf.SecuritySettings.OwnerPassword = "owner123"
pdf.SecuritySettings.UserPassword = "user123"
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit
pdf.SaveAs("protected.pdf")IronPDF proporciona un control granular sobre los permisos de PDF a través de la propiedad SecuritySettings.
Implementación de API2pdf:
using Api2Pdf.DotNet;
var a2pClient = new Api2PdfClient("YOUR_API_KEY");
var options = new HeadlessChromeOptions
{
HeaderHtml = "<div style='font-size:10px'>Company Header</div>",
FooterHtml = "<div style='font-size:10px'>Page <span class='pageNumber'></span></div>"
};
var response = await a2pClient.HeadlessChrome.FromHtmlAsync(html, options);Imports Api2Pdf.DotNet
Dim a2pClient = New Api2PdfClient("YOUR_API_KEY")
Dim options = New HeadlessChromeOptions With {
.HeaderHtml = "<div style='font-size:10px'>Company Header</div>",
.FooterHtml = "<div style='font-size:10px'>Page <span class='pageNumber'></span></div>"
}
Dim response = Await a2pClient.HeadlessChrome.FromHtmlAsync(html, options)Implementación de IronPDF:
using IronPdf;
var renderer = new ChromePdfRenderer();
// HTML headers and footers with full styling
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
HtmlFragment = "<div style='font-size:10px; text-align:center;'>Company Header</div>",
DrawDividerLine = true
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
HtmlFragment = "<div style='font-size:10px; text-align:center;'>Page {page} of {total-pages}</div>",
DrawDividerLine = true
};
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("with-headers.pdf");Imports IronPdf
Dim renderer As New ChromePdfRenderer()
' HTML headers and footers with full styling
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
.HtmlFragment = "<div style='font-size:10px; text-align:center;'>Company Header</div>",
.DrawDividerLine = True
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
.HtmlFragment = "<div style='font-size:10px; text-align:center;'>Page {page} of {total-pages}</div>",
.DrawDividerLine = True
}
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("with-headers.pdf")IronPDF admite tokens de marcador de posición como {page} y {total-pages} para la numeración de páginas dinámica. Para más opciones, consulte la documentación sobre encabezados y pies de página.
El patrón HTTP asíncrono de Api2pdfdifiere significativamente de la generación directa de PDF de IronPDF.
Patrón Api2pdf:
[ApiController]
public class PdfController : ControllerBase
{
private readonly Api2PdfClient _client;
public PdfController()
{
_client = new Api2PdfClient("YOUR_API_KEY");
}
[HttpGet("generate")]
public async Task<IActionResult> GeneratePdf()
{
var response = await _client.HeadlessChrome.FromHtmlAsync("<h1>Report</h1>");
if (!response.Success)
return BadRequest(response.Error);
// Redirect to download URL
return Redirect(response.Pdf);
}
}Imports Microsoft.AspNetCore.Mvc
<ApiController>
Public Class PdfController
Inherits ControllerBase
Private ReadOnly _client As Api2PdfClient
Public Sub New()
_client = New Api2PdfClient("YOUR_API_KEY")
End Sub
<HttpGet("generate")>
Public Async Function GeneratePdf() As Task(Of IActionResult)
Dim response = Await _client.HeadlessChrome.FromHtmlAsync("<h1>Report</h1>")
If Not response.Success Then
Return BadRequest(response.Error)
End If
' Redirect to download URL
Return Redirect(response.Pdf)
End Function
End ClassPatrón IronPDF:
[ApiController]
public class PdfController : ControllerBase
{
[HttpGet("generate")]
public IActionResult GeneratePdf()
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Report</h1>");
// Return PDF directly - no download step needed
return File(pdf.BinaryData, "application/pdf", "report.pdf");
}
[HttpGet("generate-async")]
public async Task<IActionResult> GeneratePdfAsync()
{
var renderer = new ChromePdfRenderer();
var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Report</h1>");
return File(pdf.Stream, "application/pdf", "report.pdf");
}
}Imports Microsoft.AspNetCore.Mvc
Imports System.Threading.Tasks
<ApiController>
Public Class PdfController
Inherits ControllerBase
<HttpGet("generate")>
Public Function GeneratePdf() As IActionResult
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Report</h1>")
' Return PDF directly - no download step needed
Return File(pdf.BinaryData, "application/pdf", "report.pdf")
End Function
<HttpGet("generate-async")>
Public Async Function GeneratePdfAsync() As Task(Of IActionResult)
Dim renderer = New ChromePdfRenderer()
Dim pdf = Await renderer.RenderHtmlAsPdfAsync("<h1>Report</h1>")
Return File(pdf.Stream, "application/pdf", "report.pdf")
End Function
End ClassIronPDF devuelve el PDF directamente a través de BinaryData o Stream, eliminando el patrón de redirección a descarga.
// Program.cs or Startup.cs
public void ConfigureServices(IServiceCollection services)
{
services.AddScoped<IPdfService, IronPdfService>();
}
// IPdfService.cs
public interface IPdfService
{
PdfDocument GenerateFromHtml(string html);
Task<PdfDocument> GenerateFromHtmlAsync(string html);
}
// IronPdfService.cs
public class IronPdfService : IPdfService
{
private readonly ChromePdfRenderer _renderer;
public IronPdfService()
{
_renderer = new ChromePdfRenderer();
_renderer.RenderingOptions.PrintHtmlBackgrounds = true;
_renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
}
public PdfDocument GenerateFromHtml(string html) =>
_renderer.RenderHtmlAsPdf(html);
public Task<PdfDocument> GenerateFromHtmlAsync(string html) =>
_renderer.RenderHtmlAsPdfAsync(html);
}' Program.vb or Startup.vb
Public Sub ConfigureServices(services As IServiceCollection)
services.AddScoped(Of IPdfService, IronPdfService)()
End Sub
' IPdfService.vb
Public Interface IPdfService
Function GenerateFromHtml(html As String) As PdfDocument
Function GenerateFromHtmlAsync(html As String) As Task(Of PdfDocument)
End Interface
' IronPdfService.vb
Public Class IronPdfService
Implements IPdfService
Private ReadOnly _renderer As ChromePdfRenderer
Public Sub New()
_renderer = New ChromePdfRenderer()
_renderer.RenderingOptions.PrintHtmlBackgrounds = True
_renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
End Sub
Public Function GenerateFromHtml(html As String) As PdfDocument Implements IPdfService.GenerateFromHtml
Return _renderer.RenderHtmlAsPdf(html)
End Function
Public Function GenerateFromHtmlAsync(html As String) As Task(Of PdfDocument) Implements IPdfService.GenerateFromHtmlAsync
Return _renderer.RenderHtmlAsPdfAsync(html)
End Function
End ClassApi2pdf utiliza comprobaciones de objetos de respuesta.IronPDF utiliza las excepciones estándar de .NET.
Patrón Api2pdf:
var response = await a2pClient.HeadlessChrome.FromHtmlAsync(html);
if (!response.Success)
{
Console.WriteLine($"Error: {response.Error}");
return;
}Imports System
Dim response = Await a2pClient.HeadlessChrome.FromHtmlAsync(html)
If Not response.Success Then
Console.WriteLine($"Error: {response.Error}")
Return
End IfPatrón IronPDF:
try
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
}
catch (IronPdf.Exceptions.IronPdfLicenseException ex)
{
Console.WriteLine($"License error: {ex.Message}");
}
catch (IronPdf.Exceptions.IronPdfRenderingException ex)
{
Console.WriteLine($"Rendering error: {ex.Message}");
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
}Imports IronPdf.Exceptions
Try
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")
Catch ex As IronPdfLicenseException
Console.WriteLine($"License error: {ex.Message}")
Catch ex As IronPdfRenderingException
Console.WriteLine($"Rendering error: {ex.Message}")
Catch ex As Exception
Console.WriteLine($"Error: {ex.Message}")
End Try| Métrica | Api2pdf | IronPDF |
|---|---|---|
| Simple HTML | 2-5 segundos (red) | 100-500ms (local) |
| Página compleja | 5-10 segundos | 500ms-2s |
| Lote de 100 | Minutos (límites de tarifa) | Segundos (paralelo) |
| Offline | No disponible | Trabajo completo |
| Inicio en frío | Ninguno | ~2s (primer renderizado) |
// 1. Reuse renderer instance
private static readonly ChromePdfRenderer SharedRenderer = new ChromePdfRenderer();
public PdfDocument GeneratePdf(string html)
{
return SharedRenderer.RenderHtmlAsPdf(html);
}
// 2. Parallel generation
var tasks = htmlDocs.Select(html =>
Task.Run(() => SharedRenderer.RenderHtmlAsPdf(html)));
var results = await Task.WhenAll(tasks);
// 3. Disable unnecessary features for speed
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = false; // If not needed
renderer.RenderingOptions.WaitFor.RenderDelay(0); // No delayImports System.Threading.Tasks
' 1. Reuse renderer instance
Private Shared ReadOnly SharedRenderer As New ChromePdfRenderer()
Public Function GeneratePdf(html As String) As PdfDocument
Return SharedRenderer.RenderHtmlAsPdf(html)
End Function
' 2. Parallel generation
Dim tasks = htmlDocs.Select(Function(html) Task.Run(Function() SharedRenderer.RenderHtmlAsPdf(html)))
Dim results = Await Task.WhenAll(tasks)
' 3. Disable unnecessary features for speed
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = False ' If not needed
renderer.RenderingOptions.WaitFor.RenderDelay(0) ' No delayCoincidir con la configuración Headless Chrome de Api2pdf:
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;
renderer.RenderingOptions.ViewPortWidth = 1280;
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1000);Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
renderer.RenderingOptions.PrintHtmlBackgrounds = True
renderer.RenderingOptions.ViewPortWidth = 1280
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.RenderDelay(1000)Configurar tiempos de espera de carga de recursos:
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.AllFontsLoaded(timeout: 10000);
renderer.RenderingOptions.WaitFor.NetworkIdle(timeout: 10000);
// Or use base URL for relative paths
var pdf = renderer.RenderHtmlAsPdf(html, baseUrl: "https://example.com/");Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.WaitFor.AllFontsLoaded(timeout:=10000)
renderer.RenderingOptions.WaitFor.NetworkIdle(timeout:=10000)
' Or use base URL for relative paths
Dim pdf = renderer.RenderHtmlAsPdf(html, baseUrl:="https://example.com/")Comprima las imágenes después de generarlas:
renderer.RenderingOptions.ImageQuality = 80;
// Or compress after generation
pdf.CompressImages(quality: 75);
pdf.SaveAs("compressed.pdf");renderer.RenderingOptions.ImageQuality = 80
' Or compress after generation
pdf.CompressImages(quality:=75)
pdf.SaveAs("compressed.pdf")Después de completar la migración del código, verifique lo siguiente:
Con .NET 10 a la vuelta de la esquina y C# 14 introduciendo nuevas características del lenguaje, elegir una biblioteca PDF nativa de .NET garantiza la compatibilidad con las capacidades de tiempo de ejecución en evolución. El compromiso de IronPDFde admitir las últimas versiones de .NET significa que su inversión en migración le reportará beneficios cuando los proyectos se extiendan hasta 2025 y 2026, sin que se acumulen los costes continuos por conversión.
La migración de Api2pdfa IronPDF transforma la generación de PDF de un modelo de costes por conversión dependiente de la nube a una inversión local única. Sus documentos confidenciales permanecen en su infraestructura, la latencia se reduce de segundos a milisegundos y se elimina la dependencia del proveedor para esta capacidad crítica de la aplicación.
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.
