Leer datos de PDF en ASP.NET: Facturae, LOPDGDD y extracción de texto

¿Cómo se configura IronPDF en un proyecto ASP.NET Core ?

Comenzar es sencillo. Instale el paquete NuGet de IronPDF desde NuGet Package Manager Console o desde .NET CLI utilizando cualquiera de estos comandos:

Install-Package IronPdf
dotnet add package IronPdf

Install-Package IronPdf
dotnet add package IronPdf

Una vez instalado el paquete, agregue el espacio de nombres IronPDF en la parte superior de cualquier archivo que funcione con documentos PDF:

using IronPdf;

using IronPdf;

Imports IronPdf

Esa es toda la configuración necesaria para la mayoría de los proyectos. IronPDF no depende de procesos de renderizado externos ni de dependencias nativas adicionales en Windows. Para entornos Linux o Docker, consulte la documentación de IronPDF para obtener orientación específica de la plataforma.

Una licencia de prueba gratuita le permite probar el conjunto completo de funciones antes de comprometerse con el uso de producción. Puede obtener una licencia de prueba directamente desde el sitio de IronPDF y aplicarla en una sola línea de código antes de su primera operación de PDF.

¿Cómo extraer texto de un archivo PDF?

La extracción de texto es la tarea de lectura de PDF más común. IronPDF proporciona ExtractAllText para extraer todo el texto legible de un documento y ExtractTextFromPage para el acceso a nivel de página. Ambos métodos preservan el orden de lectura y manejan codificaciones de texto estándar, incluidas las codificaciones UTF-8 utilizadas en facturas Facturae y documentos PDF firmados con PAdES bajo el marco eIDAS.

// Load a PDF document from disk
var pdf = PdfDocument.FromFile("document.pdf");

// Extract all text from every page
string allText = pdf.ExtractAllText();

// Extract text from a specific page (zero-based index)
string pageOneText = pdf.ExtractTextFromPage(0);

Console.WriteLine(allText);

// Load a PDF document from disk
var pdf = PdfDocument.FromFile("document.pdf");

// Extract all text from every page
string allText = pdf.ExtractAllText();

// Extract text from a specific page (zero-based index)
string pageOneText = pdf.ExtractTextFromPage(0);

Console.WriteLine(allText);

Imports System

' Load a PDF document from disk
Dim pdf = PdfDocument.FromFile("document.pdf")

' Extract all text from every page
Dim allText As String = pdf.ExtractAllText()

' Extract text from a specific page (zero-based index)
Dim pageOneText As String = pdf.ExtractTextFromPage(0)

Console.WriteLine(allText)

ExtractAllText devuelve el contenido completo del texto como una sola cadena, conservando los saltos de línea. ExtractTextFromPage se dirige a una sola página utilizando un índice basado en cero, lo que resulta útil cuando sólo se necesita el contenido de una sección específica de un documento de varias páginas.

Para una mirada en profundidad a las opciones de extracción de texto e imágenes, la guía de extracción de texto de PDF cubre escenarios avanzados, incluida la extracción basada en regiones.

using IronPdf;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.IO;

[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    [HttpPost("extract-text")]
    public IActionResult ExtractText(IFormFile pdfFile)
    {
        if (pdfFile == null || pdfFile.Length == 0)
            return BadRequest("No PDF file uploaded.");

        using var stream = new MemoryStream();
        pdfFile.CopyTo(stream);

        var pdf = new PdfDocument(stream.ToArray());
        string extractedText = pdf.ExtractAllText();

        return Ok(new { text = extractedText });
    }
}

using IronPdf;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.IO;

[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    [HttpPost("extract-text")]
    public IActionResult ExtractText(IFormFile pdfFile)
    {
        if (pdfFile == null || pdfFile.Length == 0)
            return BadRequest("No PDF file uploaded.");

        using var stream = new MemoryStream();
        pdfFile.CopyTo(stream);

        var pdf = new PdfDocument(stream.ToArray());
        string extractedText = pdf.ExtractAllText();

        return Ok(new { text = extractedText });
    }
}

Imports IronPdf
Imports Microsoft.AspNetCore.Http
Imports Microsoft.AspNetCore.Mvc
Imports System.IO

<ApiController>
<Route("api/[controller]")>
Public Class PdfController
    Inherits ControllerBase

    <HttpPost("extract-text")>
    Public Function ExtractText(pdfFile As IFormFile) As IActionResult
        If pdfFile Is Nothing OrElse pdfFile.Length = 0 Then
            Return BadRequest("No PDF file uploaded.")
        End If

        Using stream As New MemoryStream()
            pdfFile.CopyTo(stream)

            Dim pdf As New PdfDocument(stream.ToArray())
            Dim extractedText As String = pdf.ExtractAllText()

            Return Ok(New With {.text = extractedText})
        End Using
    End Function
End Class

¿Cómo leer datos de formularios PDF en ASP.NET Core?

Los formularios PDF, también llamados AcroForms , contienen campos interactivos que los usuarios completan. IronPDF expone los campos de formulario a través de la propiedad Form de PdfDocument, proporcionándole el nombre y el valor de cada campo del documento.

Cuando los formularios PDF recopilan datos personales de ciudadanos o clientes en España, el tratamiento de esos datos queda sujeto a la LOPDGDD (Ley Orgánica de Protección de Datos y Garantía de Derechos Digitales) y a la supervisión de la AEPD (Agencia Española de Protección de Datos). Antes de almacenar o procesar los valores extraídos de los formularios, asegúrese de contar con la base legitimadora adecuada (consentimiento, contrato, obligación legal) y de haber informado al usuario según los artículos 13 y 14 del RGPD con transposición española.

El siguiente punto final lee un formulario PDF cargado y devuelve todos los valores de campo como un diccionario JSON:

[HttpPost("extract-form")]
public IActionResult ExtractForm([FromForm] IFormFile pdfFile)
{
    if (pdfFile == null || pdfFile.Length == 0)
        return BadRequest("No PDF file uploaded.");

    using var stream = new MemoryStream();
    pdfFile.CopyTo(stream);

    var pdf = new PdfDocument(stream.ToArray());
    var formData = new Dictionary<string, string>();

    if (pdf.Form != null)
    {
        foreach (var field in pdf.Form)
        {
            formData[field.Name] = field.Value;
        }
    }

    return Ok(new { formFields = formData });
}

[HttpPost("extract-form")]
public IActionResult ExtractForm([FromForm] IFormFile pdfFile)
{
    if (pdfFile == null || pdfFile.Length == 0)
        return BadRequest("No PDF file uploaded.");

    using var stream = new MemoryStream();
    pdfFile.CopyTo(stream);

    var pdf = new PdfDocument(stream.ToArray());
    var formData = new Dictionary<string, string>();

    if (pdf.Form != null)
    {
        foreach (var field in pdf.Form)
        {
            formData[field.Name] = field.Value;
        }
    }

    return Ok(new { formFields = formData });
}

Imports Microsoft.AspNetCore.Mvc
Imports System.IO

<HttpPost("extract-form")>
Public Function ExtractForm(<FromForm> pdfFile As IFormFile) As IActionResult
    If pdfFile Is Nothing OrElse pdfFile.Length = 0 Then
        Return BadRequest("No PDF file uploaded.")
    End If

    Using stream As New MemoryStream()
        pdfFile.CopyTo(stream)

        Dim pdf = New PdfDocument(stream.ToArray())
        Dim formData As New Dictionary(Of String, String)()

        If pdf.Form IsNot Nothing Then
            For Each field In pdf.Form
                formData(field.Name) = field.Value
            Next
        End If

        Return Ok(New With {.formFields = formData})
    End Using
End Function

Cada campo de pdf.Form tiene una propiedad Name (el identificador de campo establecido en la herramienta de creación de PDF) y una propiedad Value (el texto o la selección que ha introducido el usuario). En esta colección aparecen cuadros de texto, casillas de verificación, botones de opción y menús desplegables.

La respuesta JSON facilita el reenvío de envíos de formularios a una base de datos, una API de terceros o una cola de mensajes sin ningún análisis adicional. Para los flujos de trabajo que implican la creación o edición de formularios PDF mediante programación, la guía de formularios PDF muestra cómo agregar campos y completar previamente valores.

¿Cómo extraer datos de una tabla de un PDF?

Las tablas en archivos PDF se almacenan como texto posicionado: no existe una estructura de datos de tabla nativa en el formato PDF. Por lo tanto, extraer datos tabulares significa extraer el texto sin procesar y luego aplicar lógica de análisis para reconstruir filas y columnas.

Un escenario especialmente relevante en España es la extracción de datos de facturas en formato Facturae XML embebido en PDF/A-3, o de los valores de líneas de producto en facturas PDF generadas por software de facturación bajo VeriFactu. En estos casos, la extracción de texto estructurado puede alimentar directamente los sistemas de conciliación contable integrados con SAP o Microsoft Dynamics 365 Spain localization.

El ExtractAllText de IronPDF conserva los espacios en blanco y los caracteres de tabulación, lo que permite dividir líneas en columnas mediante programación. La siguiente acción del controlador demuestra este enfoque:

[HttpPost("extract-table")]
public IActionResult ExtractTable([FromForm] IFormFile pdfFile)
{
    if (pdfFile == null || pdfFile.Length == 0)
        return BadRequest("No PDF file uploaded.");

    using var memoryStream = new MemoryStream();
    pdfFile.CopyTo(memoryStream);

    var pdf = new PdfDocument(memoryStream.ToArray());
    string text = pdf.ExtractAllText();

    // Split into lines, then split each line into columns
    string[] lines = text.Split(
        new[] { '\r', '\n' },
        StringSplitOptions.RemoveEmptyEntries
    );

    var tableData = new List<string[]>();
    foreach (string line in lines)
    {
        string[] columns = line
            .Split('\t')
            .Where(c => !string.IsNullOrWhiteSpace(c))
            .ToArray();

        if (columns.Length > 0)
            tableData.Add(columns);
    }

    var table = tableData.Select(r => string.Join(" | ", r)).ToList();
    return Ok(new { Table = table });
}

[HttpPost("extract-table")]
public IActionResult ExtractTable([FromForm] IFormFile pdfFile)
{
    if (pdfFile == null || pdfFile.Length == 0)
        return BadRequest("No PDF file uploaded.");

    using var memoryStream = new MemoryStream();
    pdfFile.CopyTo(memoryStream);

    var pdf = new PdfDocument(memoryStream.ToArray());
    string text = pdf.ExtractAllText();

    // Split into lines, then split each line into columns
    string[] lines = text.Split(
        new[] { '\r', '\n' },
        StringSplitOptions.RemoveEmptyEntries
    );

    var tableData = new List<string[]>();
    foreach (string line in lines)
    {
        string[] columns = line
            .Split('\t')
            .Where(c => !string.IsNullOrWhiteSpace(c))
            .ToArray();

        if (columns.Length > 0)
            tableData.Add(columns);
    }

    var table = tableData.Select(r => string.Join(" | ", r)).ToList();
    return Ok(new { Table = table });
}

Imports Microsoft.AspNetCore.Mvc
Imports System.IO
Imports System.Linq

<HttpPost("extract-table")>
Public Function ExtractTable(<FromForm> pdfFile As IFormFile) As IActionResult
    If pdfFile Is Nothing OrElse pdfFile.Length = 0 Then
        Return BadRequest("No PDF file uploaded.")
    End If

    Using memoryStream As New MemoryStream()
        pdfFile.CopyTo(memoryStream)

        Dim pdf As New PdfDocument(memoryStream.ToArray())
        Dim text As String = pdf.ExtractAllText()

        ' Split into lines, then split each line into columns
        Dim lines As String() = text.Split(New Char() {ControlChars.Cr, ControlChars.Lf}, StringSplitOptions.RemoveEmptyEntries)

        Dim tableData As New List(Of String())()
        For Each line As String In lines
            Dim columns As String() = line.Split(ControlChars.Tab).Where(Function(c) Not String.IsNullOrWhiteSpace(c)).ToArray()

            If columns.Length > 0 Then
                tableData.Add(columns)
            End If
        Next

        Dim table = tableData.Select(Function(r) String.Join(" | ", r)).ToList()
        Return Ok(New With {.Table = table})
    End Using
End Function

Este enfoque funciona bien para archivos PDF cuyas tablas utilizan columnas consistentes separadas por tabulaciones. Para los documentos en los que las columnas están separadas por espacios variables, es posible que deba aplicar una heurística de espacio mínimo o inspeccionar las posiciones de los caracteres. La guía para fusionar o dividir archivos PDF es útil cuando necesita aislar páginas específicas que contienen tablas antes de la extracción.

using IronPdf;
using System.Text.RegularExpressions;

public class FacturaEspanolaParser
{
    public DatosFactura ExtraerCamposFiscales(byte[] pdfBytes)
    {
        using var pdf = new PdfDocument(pdfBytes);
        string texto = pdf.ExtractAllText();

        // Extraer NIF/CIF (formato español: letra+7 dígitos+letra o 8 dígitos+letra)
        var nifEmisor = Regex.Match(texto, @"(?:NIF|CIF)[:\s]+([A-Z]\d{7}[A-Z0-9]|\d{8}[A-Z])");

        // Extraer número de factura
        var numFactura = Regex.Match(texto, @"(?:Factura|N[uú]mero)[:\s#]+(\d{4}-\d{4})");

        // Extraer total en EUR (formato español: 1.815,00 EUR)
        var totalEur = Regex.Match(texto, @"TOTAL[:\s]+(\d{1,3}(?:\.\d{3})*,\d{2})\s*EUR");

        // Extraer IBAN (formato ES: ES + 22 dígitos)
        var iban = Regex.Match(texto, @"ES\d{2}\s?\d{4}\s?\d{4}\s?\d{4}\s?\d{4}\s?\d{4}");

        // Verificar presencia de la leyenda VERI*FACTU (obligatoria bajo RD 1007/2023)
        bool tieneVeriFactu = texto.Contains("VERI*FACTU") || texto.Contains("VERIFACTU");

        return new DatosFactura
        {
            NifEmisor = nifEmisor.Success ? nifEmisor.Groups[1].Value : null,
            NumeroFactura = numFactura.Success ? numFactura.Groups[1].Value : null,
            TotalEur = totalEur.Success ? totalEur.Groups[1].Value : null,
            Iban = iban.Success ? iban.Value.Replace(" ", "") : null,
            CumpleVeriFactu = tieneVeriFactu
        };
    }
}

public record DatosFactura(
    string? NifEmisor,
    string? NumeroFactura,
    string? TotalEur,
    string? Iban,
    bool CumpleVeriFactu
);

using IronPdf;
using System.Text.RegularExpressions;

public class FacturaEspanolaParser
{
    public DatosFactura ExtraerCamposFiscales(byte[] pdfBytes)
    {
        using var pdf = new PdfDocument(pdfBytes);
        string texto = pdf.ExtractAllText();

        // Extraer NIF/CIF (formato español: letra+7 dígitos+letra o 8 dígitos+letra)
        var nifEmisor = Regex.Match(texto, @"(?:NIF|CIF)[:\s]+([A-Z]\d{7}[A-Z0-9]|\d{8}[A-Z])");

        // Extraer número de factura
        var numFactura = Regex.Match(texto, @"(?:Factura|N[uú]mero)[:\s#]+(\d{4}-\d{4})");

        // Extraer total en EUR (formato español: 1.815,00 EUR)
        var totalEur = Regex.Match(texto, @"TOTAL[:\s]+(\d{1,3}(?:\.\d{3})*,\d{2})\s*EUR");

        // Extraer IBAN (formato ES: ES + 22 dígitos)
        var iban = Regex.Match(texto, @"ES\d{2}\s?\d{4}\s?\d{4}\s?\d{4}\s?\d{4}\s?\d{4}");

        // Verificar presencia de la leyenda VERI*FACTU (obligatoria bajo RD 1007/2023)
        bool tieneVeriFactu = texto.Contains("VERI*FACTU") || texto.Contains("VERIFACTU");

        return new DatosFactura
        {
            NifEmisor = nifEmisor.Success ? nifEmisor.Groups[1].Value : null,
            NumeroFactura = numFactura.Success ? numFactura.Groups[1].Value : null,
            TotalEur = totalEur.Success ? totalEur.Groups[1].Value : null,
            Iban = iban.Success ? iban.Value.Replace(" ", "") : null,
            CumpleVeriFactu = tieneVeriFactu
        };
    }
}

public record DatosFactura(
    string? NifEmisor,
    string? NumeroFactura,
    string? TotalEur,
    string? Iban,
    bool CumpleVeriFactu
);

Imports IronPdf
Imports System.Text.RegularExpressions

Public Class FacturaEspanolaParser
    Public Function ExtraerCamposFiscales(pdfBytes As Byte()) As DatosFactura
        Using pdf = New PdfDocument(pdfBytes)
            Dim texto As String = pdf.ExtractAllText()

            ' Extraer NIF/CIF (formato español: letra+7 dígitos+letra o 8 dígitos+letra)
            Dim nifEmisor = Regex.Match(texto, "(?:NIF|CIF)[:\s]+([A-Z]\d{7}[A-Z0-9]|\d{8}[A-Z])")

            ' Extraer número de factura
            Dim numFactura = Regex.Match(texto, "(?:Factura|N[uú]mero)[:\s#]+(\d{4}-\d{4})")

            ' Extraer total en EUR (formato español: 1.815,00 EUR)
            Dim totalEur = Regex.Match(texto, "TOTAL[:\s]+(\d{1,3}(?:\.\d{3})*,\d{2})\s*EUR")

            ' Extraer IBAN (formato ES: ES + 22 dígitos)
            Dim iban = Regex.Match(texto, "ES\d{2}\s?\d{4}\s?\d{4}\s?\d{4}\s?\d{4}\s?\d{4}")

            ' Verificar presencia de la leyenda VERI*FACTU (obligatoria bajo RD 1007/2023)
            Dim tieneVeriFactu As Boolean = texto.Contains("VERI*FACTU") OrElse texto.Contains("VERIFACTU")

            Return New DatosFactura(
                If(nifEmisor.Success, nifEmisor.Groups(1).Value, Nothing),
                If(numFactura.Success, numFactura.Groups(1).Value, Nothing),
                If(totalEur.Success, totalEur.Groups(1).Value, Nothing),
                If(iban.Success, iban.Value.Replace(" ", ""), Nothing),
                tieneVeriFactu
            )
        End Using
    End Function
End Class

Public Class DatosFactura
    Public Property NifEmisor As String
    Public Property NumeroFactura As String
    Public Property TotalEur As String
    Public Property Iban As String
    Public Property CumpleVeriFactu As Boolean

    Public Sub New(nifEmisor As String, numeroFactura As String, totalEur As String, iban As String, cumpleVeriFactu As Boolean)
        Me.NifEmisor = nifEmisor
        Me.NumeroFactura = numeroFactura
        Me.TotalEur = totalEur
        Me.Iban = iban
        Me.CumpleVeriFactu = cumpleVeriFactu
    End Sub
End Class

¿Cómo gestionar las cargas asincrónicas de archivos PDF?

Las aplicaciones ASP.NET Core de producción deben manejar las cargas de archivos de forma asincrónica para evitar bloquear el grupo de subprocesos. El método IFormFile.CopyToAsync combinado con async/await mantiene el controlador sin bloqueo:

[HttpPost("process-upload")]
public async Task<IActionResult> ProcessPdf([FromForm] IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("No PDF file uploaded.");

    using var ms = new MemoryStream();
    await file.CopyToAsync(ms);

    var pdf = new PdfDocument(ms.ToArray());
    string text = pdf.ExtractAllText();
    int pageCount = pdf.PageCount;

    return Ok(new
    {
        text,
        pages = pageCount
    });
}

[HttpPost("process-upload")]
public async Task<IActionResult> ProcessPdf([FromForm] IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("No PDF file uploaded.");

    using var ms = new MemoryStream();
    await file.CopyToAsync(ms);

    var pdf = new PdfDocument(ms.ToArray());
    string text = pdf.ExtractAllText();
    int pageCount = pdf.PageCount;

    return Ok(new
    {
        text,
        pages = pageCount
    });
}

Imports System.IO
Imports Microsoft.AspNetCore.Mvc

<HttpPost("process-upload")>
Public Async Function ProcessPdf(<FromForm> file As IFormFile) As Task(Of IActionResult)
    If file Is Nothing OrElse file.Length = 0 Then
        Return BadRequest("No PDF file uploaded.")
    End If

    Using ms As New MemoryStream()
        Await file.CopyToAsync(ms)

        Dim pdf As New PdfDocument(ms.ToArray())
        Dim text As String = pdf.ExtractAllText()
        Dim pageCount As Integer = pdf.PageCount

        Return Ok(New With {
            .text = text,
            .pages = pageCount
        })
    End Using
End Function

El constructor PdfDocument es síncrono, pero el paso de carga -a menudo la parte más lenta del proceso- se ejecuta de forma asíncrona. Este patrón escala bien bajo carga concurrente y es compatible con puntos finales de API mínimos, controladores de Razor Pages y servicios gRPC.

builder.Services.Configure<FormOptions>(options =>
{
    options.MultipartBodyLengthLimit = 100 * 1024 * 1024; // 100 MB
});

builder.Services.Configure<FormOptions>(options =>
{
    options.MultipartBodyLengthLimit = 100 * 1024 * 1024; // 100 MB
});

Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.AspNetCore.Http

builder.Services.Configure(Of FormOptions)(Sub(options)
    options.MultipartBodyLengthLimit = 100 * 1024 * 1024 ' 100 MB
End Sub)

builder.WebHost.ConfigureKestrel(options =>
{
    options.Limits.MaxRequestBodySize = 100 * 1024 * 1024;
});

builder.WebHost.ConfigureKestrel(options =>
{
    options.Limits.MaxRequestBodySize = 100 * 1024 * 1024;
});

builder.WebHost.ConfigureKestrel(Sub(options)
    options.Limits.MaxRequestBodySize = 100 * 1024 * 1024
End Sub)

¿Cómo convertir contenido PDF extraído a otros formatos?

Una vez que tenga datos de texto o formulario, puede canalizarlos a cualquier proceso posterior que requiera su aplicación: escrituras en bases de datos, indexación de búsqueda, generación de informes o llamadas API. IronPDF también admite la conversión en la otra dirección: renderizar HTML a PDF.

Para los casos en los que desee mostrar contenido extraído visualmente, puede renderizar el PDF original como imágenes utilizando la guía de conversión de PDF a imagen . Esto es útil para las funciones de vista previa de documentos donde desea mostrar miniaturas de páginas sin cargar el PDF completo en el navegador.

Si necesita proteger los documentos de salida antes de entregarlos a los usuarios, IronPDF admite firmas digitales compatibles con el estándar PAdES bajo eIDAS y marcas de agua como pasos de posprocesamiento. Agregar encabezados y pies de página (que se explica en la guía de encabezados y pies de página ) es igualmente sencillo.

¿Cuáles son los siguientes pasos después de configurar la extracción de datos PDF?

Ahora tiene patrones de trabajo para extracción de texto, lectura de datos de formularios, análisis de tablas y cargas asincrónicas. A continuación se presentan algunas direcciones que puede explorar a continuación en función de los requisitos de su aplicación.

Para los ISV españoles de software de facturación, la extracción de texto es el primer paso de un flujo de trabajo que puede incluir la validación de la leyenda VERI*FACTU en facturas visualizadas, la verificación del enlace QR de la AEAT (Factura verificable en la sede electrónica de la AEAT) o la conciliación de datos con el sistema SII (Suministro Inmediato de Información) de la AEAT. IronPDF facilita estos flujos sin las restricciones de la licencia AGPL de iText, que puede comprometer la distribución de software propietario.

Si necesita generar informes en PDF junto con su flujo de trabajo de extracción, la descripción general de las características de IronPDF cubre la representación de HTML a PDF, las superposiciones de sellos y la manipulación de páginas. Para las aplicaciones que fusionan informes de múltiples fuentes, la guía de fusión o división de PDF explica cómo combinar y dividir documentos.

Para una entrega segura de documentos, las firmas digitales le permiten certificar los PDF con firmas PAdES antes de enviarlos a los clientes bajo el marco eIDAS. Las marcas de agua personalizadas agregan marca visual o etiquetas de borrador a los documentos generados.

Si su proyecto extrae datos de PDF escaneados (imágenes en lugar de texto que permita búsquedas), necesitará un paso de OCR antes de llamar a ExtractAllText. IronOCR de Iron Software se integra con IronPDF para gestionar flujos de trabajo de documentos escaneados, con soporte de idioma español incluyendo caracteres acentuados (á, é, í, ó, ú, ñ) y texto en catalán o euskera.

IronPDF está disponible bajo opciones de licencia flexibles para desarrolladores individuales y equipos. Comience con una prueba gratuita para probar todas las funciones sin restricciones. La documentación completa incluye referencia de API, guías de inicio y notas de implementación para entornos de Windows, Linux, Docker y la nube.

La lectura de datos de archivos PDF en ASP.NET Core ya no requiere código de análisis de bajo nivel ni dependencias pesadas. Con IronPDF, la ruta desde el archivo cargado hasta el contenido extraído es un puñado de líneas que se adaptan naturalmente a cualquier controlador o capa de servicio, cumpliendo al mismo tiempo los requisitos de la LOPDGDD y los flujos de trabajo de facturación electrónica bajo la normativa española.