iTextSharp C# Alternativa de HTML a PDF para .NET Core

iText 7 es una biblioteca PDF poderosa y flexible que proporciona amplias capacidades de manipulación de PDFs, incluida la creación, encriptación y firma de documentos. Sin embargo, su biblioteca principal no admite la conversión de HTML-a-PDF de forma nativa.

Características clave

• Personalización avanzada de PDF – Proporciona control detallado sobre la estructura, metadatos y renderizado del PDF.
• Accesibilidad y cumplimiento: Genera PDF/A, PDF/UA y PDF/X para archivo a largo plazo y cumplimiento de accesibilidad.
• Conversión de HTML-a-PDF: El complemento pago pdfHTML permite la conversión de contenido HTML en PDFs.
• Soporte para Java y .NET: Diseñado principalmente para Java, con soporte para C# a través de iText 7 para .NET.
• Gestión de formularios PDF: Crea y edita formularios AcroForms y XFA para formularios PDF interactivos.

Ideal para: Desarrolladores que necesitan una solución PDF altamente personalizable y están dispuestos a adquirir complementos adicionales para obtener características ampliadas.

IronPDF cuenta con un conjunto rico de características para trabajar con documentos PDF. Estas van desde la creación de PDF hasta la manipulación y seguridad de PDF. Para obtener una idea más clara del amplio rango de características que tiene para ofrecer esta biblioteca, examinaremos algunas pocas características clave.

Conversión de HTML a PDF

Convierte contenido HTML en documentos PDF de alta calidad con el potente motor de renderizado de IronPDF. El renderizador de IronPDF no simplemente convierte el contenido HTML; con él, podrás mantener todo el estilo CSS original y la interactividad de JavaScript.

using IronPdf;

public class Program
{
    static void Main(string[] args)
    {
        // Create a new ChromePdfRenderer instance for rendering HTML to PDF
        ChromePdfRenderer renderer = new ChromePdfRenderer();

        // Render the specified HTML file as a PDF document
        PdfDocument pdf = renderer.RenderHtmlFileAsPdf("example.html");

        // Save the rendered PDF to the specified file path
        pdf.SaveAs("HtmlToPdf.pdf");
    }
}

using IronPdf;

public class Program
{
    static void Main(string[] args)
    {
        // Create a new ChromePdfRenderer instance for rendering HTML to PDF
        ChromePdfRenderer renderer = new ChromePdfRenderer();

        // Render the specified HTML file as a PDF document
        PdfDocument pdf = renderer.RenderHtmlFileAsPdf("example.html");

        // Save the rendered PDF to the specified file path
        pdf.SaveAs("HtmlToPdf.pdf");
    }
}

Imports IronPdf

Public Class Program
	Shared Sub Main(ByVal args() As String)
		' Create a new ChromePdfRenderer instance for rendering HTML to PDF
		Dim renderer As New ChromePdfRenderer()

		' Render the specified HTML file as a PDF document
		Dim pdf As PdfDocument = renderer.RenderHtmlFileAsPdf("example.html")

		' Save the rendered PDF to the specified file path
		pdf.SaveAs("HtmlToPdf.pdf")
	End Sub
End Class

Entrada HTML

PDF de salida

En este ejemplo de código, primero hemos creado una nueva instancia de ChromePdfRenderer, que nos da acceso al potente motor de renderizado que IronPDF usa para renderizar HTML a PDF. Luego, pasamos un archivo HTML al método RenderHtmlFileAsPdf(), que a su vez renderiza el HTML en un PDF, almacenado en el objeto PdfDocument. Finalmente, guardaremos el PDF en la ubicación de archivo especificada.

URL a PDF

Para los desarrolladores que buscan convertir el contenido de URL en PDFs, no busques más allá de IronPDF. Con esta biblioteca, podrás crear documentos PDF con precisión de píxeles mediante el uso del motor de renderizado ChromePdfRenderer, que mantendrá todo el estilo y los diseños originales cuando renderice la URL a PDF. Para este ejemplo, usaremos esta URL para demostrar cómo IronPDF puede manejar estilos CSS más complejos.

using IronPdf;

public class Program
{
    static void Main(string[] args)
    {
        // Create a new ChromePdfRenderer instance
        ChromePdfRenderer renderer = new ChromePdfRenderer();

        // Render the specified URL as a PDF document
        PdfDocument pdf = renderer.RenderUrlAsPdf("https://www.apple.com");

        // Save the rendered PDF to the specified file path
        pdf.SaveAs("UrlToPdf.pdf");
    }
}

using IronPdf;

public class Program
{
    static void Main(string[] args)
    {
        // Create a new ChromePdfRenderer instance
        ChromePdfRenderer renderer = new ChromePdfRenderer();

        // Render the specified URL as a PDF document
        PdfDocument pdf = renderer.RenderUrlAsPdf("https://www.apple.com");

        // Save the rendered PDF to the specified file path
        pdf.SaveAs("UrlToPdf.pdf");
    }
}

Imports IronPdf

Public Class Program
	Shared Sub Main(ByVal args() As String)
		' Create a new ChromePdfRenderer instance
		Dim renderer As New ChromePdfRenderer()

		' Render the specified URL as a PDF document
		Dim pdf As PdfDocument = renderer.RenderUrlAsPdf("https://www.apple.com")

		' Save the rendered PDF to the specified file path
		pdf.SaveAs("UrlToPdf.pdf")
	End Sub
End Class

PDF de salida:

Al igual que en nuestro ejemplo de HTML a PDF, el primer paso para convertir cualquier URL en PDF usando IronPDF es primero crear una nueva instancia de ChromePdfRenderer. Una vez que el método haya renderizado el contenido de la URL en formato PDF, usando RenderUrlAsPdf, guarda el PDF resultante en un nuevo objeto PdfDocument, antes de que utilicemos el método SaveAs para guardar el PDF.

Firmas PDF

Asegura la autenticidad de tu documento PDF aplicando una firma digital a tus documentos PDF. Existen diferentes métodos que los desarrolladores pueden considerar para aplicar firmas digitales, como firmar digitalmente el PDF con un certificado seguro, añadir una imagen de una firma manuscrita a un PDF, o estampar una imagen del certificado directamente en el PDF.

using IronPdf;
using IronPdf.Signing;
using System.Security.Cryptography.X509Certificates;
using IronSoftware.Drawing;

public class Program
{
    static void Main(string[] args)
    {
        // Load the certificate used for signing the PDF
        X509Certificate2 cert = new X509Certificate2("IronSoftware.pfx", "your-password", X509KeyStorageFlags.Exportable);

        // Create a PdfSignature instance and set the signature image
        var sig = new PdfSignature(cert);
        sig.SignatureImage = new PdfSignatureImage("IronPdf.png", 0, new Rectangle(150, 100, 350, 250));

        // Sign the existing PDF file and save the signed version
        sig.SignPdfFile("product_report.pdf");
    }
}

using IronPdf;
using IronPdf.Signing;
using System.Security.Cryptography.X509Certificates;
using IronSoftware.Drawing;

public class Program
{
    static void Main(string[] args)
    {
        // Load the certificate used for signing the PDF
        X509Certificate2 cert = new X509Certificate2("IronSoftware.pfx", "your-password", X509KeyStorageFlags.Exportable);

        // Create a PdfSignature instance and set the signature image
        var sig = new PdfSignature(cert);
        sig.SignatureImage = new PdfSignatureImage("IronPdf.png", 0, new Rectangle(150, 100, 350, 250));

        // Sign the existing PDF file and save the signed version
        sig.SignPdfFile("product_report.pdf");
    }
}

Imports IronPdf
Imports IronPdf.Signing
Imports System.Security.Cryptography.X509Certificates
Imports IronSoftware.Drawing

Public Class Program
	Shared Sub Main(ByVal args() As String)
		' Load the certificate used for signing the PDF
		Dim cert As New X509Certificate2("IronSoftware.pfx", "your-password", X509KeyStorageFlags.Exportable)

		' Create a PdfSignature instance and set the signature image
		Dim sig = New PdfSignature(cert)
		sig.SignatureImage = New PdfSignatureImage("IronPdf.png", 0, New Rectangle(150, 100, 350, 250))

		' Sign the existing PDF file and save the signed version
		sig.SignPdfFile("product_report.pdf")
	End Sub
End Class

PDF de salida

Para este ejemplo, hemos cargado nuestro objeto certificado, creado una representación visual de la firma, o en nuestro caso la imagen de IronPDF, y creado un nuevo objeto PdfSignature, que maneja la firma del documento PDF en sí. Finalmente, utilizamos SignPdfFile para firmar y guardar nuestro documento PDF.

If you want to explore more of the features IronPDF has to offer, be sure to check out its informative features page, or the How-to Guides which contain in-depth code examples for each feature.

iText7 ofrece una amplia gama de características para personalizar y mejorar tus documentos PDF. Con un amplio soporte de formato para varios estándares PDF y manipulación avanzada de PDFs, hay mucho contenido en esta biblioteca PDF. Sin embargo, como se mencionó antes, iText7 puede requerir paquetes adicionales para llevar a cabo ciertas tareas relacionadas con PDF como HTML a PDF.

Conversión de HTML a PDF

Aunque iText7 por sí solo no puede manejar la conversión de HTML a PDF, podemos usar el pdfHTML, un complemento de pago encontrado bajo la licencia comercial de iText7, para convertir el archivo HTML que usamos en nuestro ejemplo de IronPDF en un documento PDF.

using iText.Html2pdf;
using System.IO;

public class Program
{
    static void Main(string[] args)
    {
        // Open the HTML file stream
        using (FileStream htmlSource = File.Open("example.html", FileMode.Open))
        // Create the output PDF file stream
        using (FileStream pdf = File.Open("HtmlToPdfOutput.pdf", FileMode.Create))
        {
            // Initialize ConverterProperties for HTML to PDF conversion
            ConverterProperties converterProperties = new ConverterProperties();

            // Convert the HTML source to a PDF document
            HtmlConverter.ConvertToPdf(htmlSource, pdf, converterProperties);

            // Close the PDF file
            pdf.Close();
        }
    }
}

using iText.Html2pdf;
using System.IO;

public class Program
{
    static void Main(string[] args)
    {
        // Open the HTML file stream
        using (FileStream htmlSource = File.Open("example.html", FileMode.Open))
        // Create the output PDF file stream
        using (FileStream pdf = File.Open("HtmlToPdfOutput.pdf", FileMode.Create))
        {
            // Initialize ConverterProperties for HTML to PDF conversion
            ConverterProperties converterProperties = new ConverterProperties();

            // Convert the HTML source to a PDF document
            HtmlConverter.ConvertToPdf(htmlSource, pdf, converterProperties);

            // Close the PDF file
            pdf.Close();
        }
    }
}

Imports iText.Html2pdf
Imports System.IO

Public Class Program
	Shared Sub Main(ByVal args() As String)
		' Open the HTML file stream
		Using htmlSource As FileStream = File.Open("example.html", FileMode.Open)
		' Create the output PDF file stream
		Using pdf As FileStream = File.Open("HtmlToPdfOutput.pdf", FileMode.Create)
			' Initialize ConverterProperties for HTML to PDF conversion
			Dim converterProperties As New ConverterProperties()

			' Convert the HTML source to a PDF document
			HtmlConverter.ConvertToPdf(htmlSource, pdf, converterProperties)

			' Close the PDF file
			pdf.Close()
		End Using
		End Using
	End Sub
End Class

PDF de salida

Para este ejemplo, cargamos el archivo HTML y especificamos la ubicación del archivo para guardar el PDF renderizado. Luego, usando el método ConvertToPdf, podemos convertir fácilmente el archivo HTML en un documento PDF.

URL a PDF

Ahora es el momento de comparar cómo se mide iText7 frente a IronPDF cuando se trata de convertir URLs a PDF. Para esto, usaremos exactamente la misma URL que antes para asegurar una comparación justa.

using System;
using System.Net.Http;
using System.IO;
using iText.Html2pdf;

public class Program
{
    public static async System.Threading.Tasks.Task Main(string[] args)
    {
        string url = "https://www.apple.com";  // Replace with your target URL
        string outputPdfPath = "output.pdf";

        try
        {
            // Download HTML content from the URL
            using (HttpClient client = new HttpClient())
            {
                string htmlContent = await client.GetStringAsync(url);

                // Convert HTML to PDF
                using (FileStream pdfStream = new FileStream(outputPdfPath, FileMode.Create))
                {
                    ConverterProperties properties = new ConverterProperties();
                    HtmlConverter.ConvertToPdf(htmlContent, pdfStream, properties);
                }
            }

            Console.WriteLine("PDF created successfully: " + outputPdfPath);
        }
        catch (Exception ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

using System;
using System.Net.Http;
using System.IO;
using iText.Html2pdf;

public class Program
{
    public static async System.Threading.Tasks.Task Main(string[] args)
    {
        string url = "https://www.apple.com";  // Replace with your target URL
        string outputPdfPath = "output.pdf";

        try
        {
            // Download HTML content from the URL
            using (HttpClient client = new HttpClient())
            {
                string htmlContent = await client.GetStringAsync(url);

                // Convert HTML to PDF
                using (FileStream pdfStream = new FileStream(outputPdfPath, FileMode.Create))
                {
                    ConverterProperties properties = new ConverterProperties();
                    HtmlConverter.ConvertToPdf(htmlContent, pdfStream, properties);
                }
            }

            Console.WriteLine("PDF created successfully: " + outputPdfPath);
        }
        catch (Exception ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

Imports System
Imports System.Net.Http
Imports System.IO
Imports iText.Html2pdf

Public Class Program
	Public Shared Async Function Main(ByVal args() As String) As System.Threading.Tasks.Task
		Dim url As String = "https://www.apple.com" ' Replace with your target URL
		Dim outputPdfPath As String = "output.pdf"

		Try
			' Download HTML content from the URL
			Using client As New HttpClient()
				Dim htmlContent As String = Await client.GetStringAsync(url)

				' Convert HTML to PDF
				Using pdfStream As New FileStream(outputPdfPath, FileMode.Create)
					Dim properties As New ConverterProperties()
					HtmlConverter.ConvertToPdf(htmlContent, pdfStream, properties)
				End Using
			End Using

			Console.WriteLine("PDF created successfully: " & outputPdfPath)
		Catch ex As Exception
			Console.WriteLine("Error: " & ex.Message)
		End Try
	End Function
End Class

PDF de salida

Como se ve aquí, el enfoque de iText7 para la conversión de URL a PDF es más manual y complejo. Primero, necesitamos descargar el contenido HTML de la URL, antes de seguir pasos similares como se ve en el ejemplo de HTML a PDF para renderizar nuestro contenido de URL en un documento PDF y guardarlo. Como puedes ver en la imagen de salida, iText7 no fue capaz de mantener gran parte del estilo y diseño original, a diferencia de IronPDF.

Firmas PDF

using System.Security.Cryptography.X509Certificates;
using iText.Kernel.Pdf;
using iText.Signatures;
using iText.Bouncycastle.Crypto;
using iText.Commons.Bouncycastle.Cert;
using iText.Commons.Bouncycastle.Crypto;
using Org.BouncyCastle.Pkcs;
using Org.BouncyCastle.Crypto;
using iText.Bouncycastle.X509;
using iText.Kernel.Crypto;
using System.IO;

public class Program
{
    static void Main(string[] args)
    {
        string inputPdf = "input.pdf";       // PDF to be signed
        string outputPdf = "signed_output.pdf";  // Signed PDF output
        string pfxFile = "IronSoftware.pfx";  // Path to your PFX certificate
        string password = "Passw0rd";   // Password for PFX file

        try
        {
            // Load your certificate
            Pkcs12Store ks = new Pkcs12StoreBuilder().Build();
            using (FileStream fs = new FileStream(pfxFile, FileMode.Open, FileAccess.Read))
            {
                ks.Load(fs, password.ToCharArray());
            }

            string alias = null;
            foreach (string al in ks.Aliases)
            {
                if (ks.IsKeyEntry(al))
                {
                    alias = al;
                    break;
                }
            }

            if (alias == null)
            {
                throw new Exception("Alias not found in the PFX file.");
            }

            ICipherParameters pk = ks.GetKey(alias).Key;
            X509CertificateEntry[] chain = ks.GetCertificateChain(alias);

            // Convert BouncyCastle certificates to iText certificates
            var itextCertChain = new IX509Certificate[chain.Length];
            for (int i = 0; i < chain.Length; i++)
            {
                itextCertChain[i] = new X509CertificateBC(chain[i].Certificate);
            }

            // Create output PDF with signed content
            using (PdfReader reader = new PdfReader(inputPdf))
            using (FileStream os = new FileStream(outputPdf, FileMode.Create, FileAccess.Write))
            {
                PdfSigner signer = new PdfSigner(reader, os, new StampingProperties().UseAppendMode());

                // Set up the external signature (private key + digest algorithm)
                IPrivateKey iTextPrivateKey = new PrivateKeyBC(pk);
                IExternalSignature pks = new PrivateKeySignature(iTextPrivateKey, DigestAlgorithms.SHA256);
                IExternalDigest digest = new BouncyCastleDigest();

                // Perform the signing (detached signature)
                signer.SignDetached(digest, pks, itextCertChain, null, null, null, 0, PdfSigner.CryptoStandard.CMS);
            }

            Console.WriteLine($"PDF digitally signed successfully: {outputPdf}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error signing PDF: {ex.Message}");
        }
    }
}

using System.Security.Cryptography.X509Certificates;
using iText.Kernel.Pdf;
using iText.Signatures;
using iText.Bouncycastle.Crypto;
using iText.Commons.Bouncycastle.Cert;
using iText.Commons.Bouncycastle.Crypto;
using Org.BouncyCastle.Pkcs;
using Org.BouncyCastle.Crypto;
using iText.Bouncycastle.X509;
using iText.Kernel.Crypto;
using System.IO;

public class Program
{
    static void Main(string[] args)
    {
        string inputPdf = "input.pdf";       // PDF to be signed
        string outputPdf = "signed_output.pdf";  // Signed PDF output
        string pfxFile = "IronSoftware.pfx";  // Path to your PFX certificate
        string password = "Passw0rd";   // Password for PFX file

        try
        {
            // Load your certificate
            Pkcs12Store ks = new Pkcs12StoreBuilder().Build();
            using (FileStream fs = new FileStream(pfxFile, FileMode.Open, FileAccess.Read))
            {
                ks.Load(fs, password.ToCharArray());
            }

            string alias = null;
            foreach (string al in ks.Aliases)
            {
                if (ks.IsKeyEntry(al))
                {
                    alias = al;
                    break;
                }
            }

            if (alias == null)
            {
                throw new Exception("Alias not found in the PFX file.");
            }

            ICipherParameters pk = ks.GetKey(alias).Key;
            X509CertificateEntry[] chain = ks.GetCertificateChain(alias);

            // Convert BouncyCastle certificates to iText certificates
            var itextCertChain = new IX509Certificate[chain.Length];
            for (int i = 0; i < chain.Length; i++)
            {
                itextCertChain[i] = new X509CertificateBC(chain[i].Certificate);
            }

            // Create output PDF with signed content
            using (PdfReader reader = new PdfReader(inputPdf))
            using (FileStream os = new FileStream(outputPdf, FileMode.Create, FileAccess.Write))
            {
                PdfSigner signer = new PdfSigner(reader, os, new StampingProperties().UseAppendMode());

                // Set up the external signature (private key + digest algorithm)
                IPrivateKey iTextPrivateKey = new PrivateKeyBC(pk);
                IExternalSignature pks = new PrivateKeySignature(iTextPrivateKey, DigestAlgorithms.SHA256);
                IExternalDigest digest = new BouncyCastleDigest();

                // Perform the signing (detached signature)
                signer.SignDetached(digest, pks, itextCertChain, null, null, null, 0, PdfSigner.CryptoStandard.CMS);
            }

            Console.WriteLine($"PDF digitally signed successfully: {outputPdf}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error signing PDF: {ex.Message}");
        }
    }
}

Imports System.Security.Cryptography.X509Certificates
Imports iText.Kernel.Pdf
Imports iText.Signatures
Imports iText.Bouncycastle.Crypto
Imports iText.Commons.Bouncycastle.Cert
Imports iText.Commons.Bouncycastle.Crypto
Imports Org.BouncyCastle.Pkcs
Imports Org.BouncyCastle.Crypto
Imports iText.Bouncycastle.X509
Imports iText.Kernel.Crypto
Imports System.IO

Public Class Program
	Shared Sub Main(ByVal args() As String)
		Dim inputPdf As String = "input.pdf" ' PDF to be signed
		Dim outputPdf As String = "signed_output.pdf" ' Signed PDF output
		Dim pfxFile As String = "IronSoftware.pfx" ' Path to your PFX certificate
		Dim password As String = "Passw0rd" ' Password for PFX file

		Try
			' Load your certificate
			Dim ks As Pkcs12Store = (New Pkcs12StoreBuilder()).Build()
			Using fs As New FileStream(pfxFile, FileMode.Open, FileAccess.Read)
				ks.Load(fs, password.ToCharArray())
			End Using

			Dim [alias] As String = Nothing
			For Each al As String In ks.Aliases
				If ks.IsKeyEntry(al) Then
					[alias] = al
					Exit For
				End If
			Next al

			If [alias] Is Nothing Then
				Throw New Exception("Alias not found in the PFX file.")
			End If

			Dim pk As ICipherParameters = ks.GetKey([alias]).Key
			Dim chain() As X509CertificateEntry = ks.GetCertificateChain([alias])

			' Convert BouncyCastle certificates to iText certificates
			Dim itextCertChain = New IX509Certificate(chain.Length - 1){}
			For i As Integer = 0 To chain.Length - 1
				itextCertChain(i) = New X509CertificateBC(chain(i).Certificate)
			Next i

			' Create output PDF with signed content
			Using reader As New PdfReader(inputPdf)
			Using os As New FileStream(outputPdf, FileMode.Create, FileAccess.Write)
				Dim signer As New PdfSigner(reader, os, (New StampingProperties()).UseAppendMode())

				' Set up the external signature (private key + digest algorithm)
				Dim iTextPrivateKey As IPrivateKey = New PrivateKeyBC(pk)
				Dim pks As IExternalSignature = New PrivateKeySignature(iTextPrivateKey, DigestAlgorithms.SHA256)
				Dim digest As IExternalDigest = New BouncyCastleDigest()

				' Perform the signing (detached signature)
				signer.SignDetached(digest, pks, itextCertChain, Nothing, Nothing, Nothing, 0, PdfSigner.CryptoStandard.CMS)
			End Using
			End Using

			Console.WriteLine($"PDF digitally signed successfully: {outputPdf}")
		Catch ex As Exception
			Console.WriteLine($"Error signing PDF: {ex.Message}")
		End Try
	End Sub
End Class

PDF de salida

Como puedes ver, aunque iText7 es capaz de firmar digitalmente documentos PDF, el proceso tiende a ser mucho más complejo que con IronPDF. Este código carga un certificado PFX y lo usa para firmar digitalmente un PDF. Extrae la clave privada y el certificado, configura el firmante y añade una firma separada al PDF, luego guarda el documento firmado.

Ventajas clave de IronPDF

IronPDF es reconocido por su facilidad de uso y optimización para alto rendimiento, ofreciendo una API más sencilla que simplifica tareas comunes como la conversión de HTML a PDF. Proporciona métodos de alto nivel que abstraen tareas complejas de procesamiento de PDF, lo que permite a los desarrolladores generar, editar y manipular PDFs con un mínimo de código. Para el procesamiento de documentos multihilos o a gran escala, IronPDF admite ejecución paralela.

• API fácil de usar – Métodos de alto nivel simplifican tareas comunes como la conversión de HTML a PDF.
• Requiere configuración mínima – Se integra fácilmente en proyectos .NET.
• Ejecución paralela incorporada – Optimizado para manejar generación y conversión masiva de PDFs.
• API simplificada – Requiere menos líneas de código para lograr resultados.

iText 7 - Potente pero Complejo

Por otro lado, iText 7 ofrece un nivel más detallado y granular de control, lo cual puede ser ventajoso para desarrolladores que requieren una extensa personalización. Proporciona una robusta API para trabajar con operaciones de bajo nivel de PDFs. Sin embargo, debido a su complejidad, iText 7 a menudo requiere más código para lograr resultados similares en comparación con IronPDF.

• Control granular de PDF – Ideal para aplicaciones empresariales que requieren cumplimiento estricto (por ejemplo, PDF/A, PDF/UA, firmas digitales).
• Altamente personalizable – Ofrece manipulación de PDF de bajo nivel para casos de uso avanzados.
• Curva de aprendizaje más pronunciada – Requiere más configuración y ajuste en comparación con IronPDF.
• Más intensivo en código – Las tareas comunes a menudo requieren implementaciones más largas.

Al seleccionar una biblioteca PDF para un proyecto .NET, las consideraciones de licencia y costo son críticas. Tanto IronPDF como iText 7 siguen diferentes modelos de licencias, y elegir el correcto depende de los requisitos de tu proyecto, el presupuesto y las necesidades de cumplimiento.

Licencia y costo de IronPDF

IronPDF sigue un modelo de licencia comercial, lo que significa que, aunque ofrece una prueba gratuita para licencia comercial y es gratis para desarrollo y evaluación, se requiere una licencia de pago para uso total en producción. La estructura de precios es transparente y depende de factores como la escala de uso, el número de desarrolladores y el tipo de proyecto.

Licencia de IronPDF:

• Modelo de licencia comercial (Sin restricciones de open-source).
• Precios sencillos basados en licencias por desarrollador o equipo.
• Sin costo extra por HTML-a-PDF, seguridad de PDF u otras características principales.
• Ideal para empresas que necesitan una solución de PDF sencilla y rentable.

Conclusión: IronPDF incluye todas las características principales en una sola licencia, lo que la hace una opción rentable para equipos y empresas.

Licencia y costo de iText7

iText7 opera bajo un modelo de doble licencia, que incluye:

1. AGPL (Licencia Pública General Affero de GNU) – Gratis para proyectos open-source, pero requiere que todo el proyecto que use iText7 sea open-source y compatible con AGPL. Esto significa que cualquier modificación o adición hecha al proyecto también debe compartirse públicamente.
2. Licencia Comercial – Requerida para cualquier software propietario o aplicaciones comerciales que no quieran divulgar su código fuente. La estructura de precios varía según el uso, nivel de soporte y escala de despliegue.

Para empresas que buscan integrar iText 7 en software propietario, una licencia comercial es obligatoria. El costo puede ser significativo, especialmente para soluciones de nivel empresarial, ya que se valora por desarrollador, pero ofrece acceso a soporte profesional y asegura el cumplimiento legal.

Por qué iText 7 puede ser más costoso:

• Precios por desarrollador – Cada desarrollador necesita una licencia separada, aumentando los costos totales para equipos.
• Características esenciales requieren complementos costosos:
  • pdfHTML (Pago) – Requerido para conversión de HTML a PDF.
  • pdfOCR (Pago) – Necesario para reconocimiento de texto de imágenes.
  • pdfCalligraph (Pago) – Mejora la renderización de texto y soporte de fuentes.
  • pdfRender (Pago) – Agrega conversión de PDF a imagen.
  • pdf2Data (Pago) – Extrae datos estructurados de PDFs.
• Los costos empresariales pueden aumentar rápidamente cuando se necesitan múltiples características y desarrolladores.

Conclusión: Si tu equipo requiere múltiples desarrolladores y características clave como HTML a PDF y OCR, iText 7 puede ser significativamente más caro que IronPDF, que proporciona estas características sin costos adicionales.

Proyectos Pequeños vs. Empresariales

Para proyectos pequeños a medianos que requieren una implementación rápida de funcionalidades PDF con mínima configuración, IronPDF es una elección convincente debido a su API fácil de usar y conjunto completo de características. Los proyectos de nivel empresarial que demandan una amplia personalización y adherencia a normas PDF específicas pueden beneficiarse de las capacidades avanzadas de iText7, sin embargo, IronPDF también demuestra ser un fuerte candidato para este nivel de trabajo debido a su alto rendimiento, opciones de licencia y usabilidad.

Uso Académico y Comercial

En entornos académicos o proyectos open-source, la licencia AGPL de iText 7 permite el uso gratuito, siempre que la licencia del proyecto sea compatible. Para aplicaciones comerciales, tanto IronPDF como iText 7 requieren la compra de una licencia comercial. Es aconsejable revisar los términos de licencia de cada biblioteca para asegurar el cumplimiento con los objetivos de tu proyecto.