Alternativas a Nanonets OCR para España: IronOCR con cumplimiento AEAT, Facturae y LOPDGDD

El canal S3-Async

El OCR de una sola imagen a través de DetectDocumentTextAsync puede pasar bytes de documento directamente en la solicitud. Los PDFs de varias páginas no pueden. Cualquier PDF requiere el proceso asíncrono completo:

// AWS Textract: PDF de varias páginas requires S3 + async job
public async Task<string> ProcessPdfAsync(string pdfPath)
{
    // Step 1: Upload to S3 — credentials for two services required
    var key = $"uploads/{Guid.NewGuid()}.pdf";
    using (var fileStream = File.OpenRead(pdfPath))
    {
        await _s3Client.PutObjectAsync(new PutObjectRequest
        {
            BucketName = _bucketName,
            Key = key,
            InputStream = fileStream
        });
    }

    try
    {
        // Step 2: Start async Textract job
        var startResponse = await _textractClient.StartDocumentTextDetectionAsync(
            new StartDocumentTextDetectionRequest
            {
                DocumentLocation = new DocumentLocation
                {
                    S3Object = new S3Object { Bucket = _bucketName, Name = key }
                }
            });

        var jobId = startResponse.JobId;

        // Step 3: Poll every 5 seconds until complete
        GetDocumentTextDetectionResponse getResponse;
        do
        {
            await Task.Delay(5000);
            getResponse = await _textractClient.GetDocumentTextDetectionAsync(
                new GetDocumentTextDetectionRequest { JobId = jobId });
        } while (getResponse.JobStatus == JobStatus.IN_PROGRESS);

        if (getResponse.JobStatus != JobStatus.SUCCEEDED)
            throw new Exception($"Textract job failed: {getResponse.StatusMessage}");

        // Step 4: Paginate through result blocks
        var allText = new StringBuilder();
        string nextToken = null;
        do
        {
            var pageResponse = await _textractClient.GetDocumentTextDetectionAsync(
                new GetDocumentTextDetectionRequest
                {
                    JobId = jobId,
                    NextToken = nextToken
                });

            foreach (var block in pageResponse.Blocks.Where(b => b.BlockType == BlockType.LINE))
                allText.AppendLine(block.Text);

            nextToken = pageResponse.NextToken;
        } while (nextToken != null);

        return allText.ToString();
    }
    finally
    {
        // Step 5: Siempre clean up S3
        await _s3Client.DeleteObjectAsync(_bucketName, key);
    }
}

// AWS Textract: PDF de varias páginas requires S3 + async job
public async Task<string> ProcessPdfAsync(string pdfPath)
{
    // Step 1: Upload to S3 — credentials for two services required
    var key = $"uploads/{Guid.NewGuid()}.pdf";
    using (var fileStream = File.OpenRead(pdfPath))
    {
        await _s3Client.PutObjectAsync(new PutObjectRequest
        {
            BucketName = _bucketName,
            Key = key,
            InputStream = fileStream
        });
    }

    try
    {
        // Step 2: Start async Textract job
        var startResponse = await _textractClient.StartDocumentTextDetectionAsync(
            new StartDocumentTextDetectionRequest
            {
                DocumentLocation = new DocumentLocation
                {
                    S3Object = new S3Object { Bucket = _bucketName, Name = key }
                }
            });

        var jobId = startResponse.JobId;

        // Step 3: Poll every 5 seconds until complete
        GetDocumentTextDetectionResponse getResponse;
        do
        {
            await Task.Delay(5000);
            getResponse = await _textractClient.GetDocumentTextDetectionAsync(
                new GetDocumentTextDetectionRequest { JobId = jobId });
        } while (getResponse.JobStatus == JobStatus.IN_PROGRESS);

        if (getResponse.JobStatus != JobStatus.SUCCEEDED)
            throw new Exception($"Textract job failed: {getResponse.StatusMessage}");

        // Step 4: Paginate through result blocks
        var allText = new StringBuilder();
        string nextToken = null;
        do
        {
            var pageResponse = await _textractClient.GetDocumentTextDetectionAsync(
                new GetDocumentTextDetectionRequest
                {
                    JobId = jobId,
                    NextToken = nextToken
                });

            foreach (var block in pageResponse.Blocks.Where(b => b.BlockType == BlockType.LINE))
                allText.AppendLine(block.Text);

            nextToken = pageResponse.NextToken;
        } while (nextToken != null);

        return allText.ToString();
    }
    finally
    {
        // Step 5: Siempre clean up S3
        await _s3Client.DeleteObjectAsync(_bucketName, key);
    }
}

Imports System
Imports System.IO
Imports System.Text
Imports System.Threading.Tasks
Imports Amazon.S3
Imports Amazon.Textract
Imports Amazon.Textract.Model

Public Class PdfProcessor
    Private _s3Client As IAmazonS3
    Private _textractClient As IAmazonTextract
    Private _bucketName As String

    Public Async Function ProcessPdfAsync(pdfPath As String) As Task(Of String)
        ' Step 1: Upload to S3 — credentials for two services required
        Dim key As String = $"uploads/{Guid.NewGuid()}.pdf"
        Using fileStream As FileStream = File.OpenRead(pdfPath)
            Await _s3Client.PutObjectAsync(New PutObjectRequest With {
                .BucketName = _bucketName,
                .Key = key,
                .InputStream = fileStream
            })
        End Using

        Try
            ' Step 2: Start async Textract job
            Dim startResponse = Await _textractClient.StartDocumentTextDetectionAsync(
                New StartDocumentTextDetectionRequest With {
                    .DocumentLocation = New DocumentLocation With {
                        .S3Object = New S3Object With {.Bucket = _bucketName, .Name = key}
                    }
                })

            Dim jobId As String = startResponse.JobId

            ' Step 3: Poll every 5 seconds until complete
            Dim getResponse As GetDocumentTextDetectionResponse
            Do
                Await Task.Delay(5000)
                getResponse = Await _textractClient.GetDocumentTextDetectionAsync(
                    New GetDocumentTextDetectionRequest With {.JobId = jobId})
            Loop While getResponse.JobStatus = JobStatus.IN_PROGRESS

            If getResponse.JobStatus <> JobStatus.SUCCEEDED Then
                Throw New Exception($"Textract job failed: {getResponse.StatusMessage}")
            End If

            ' Step 4: Paginate through result blocks
            Dim allText As New StringBuilder()
            Dim nextToken As String = Nothing
            Do
                Dim pageResponse = Await _textractClient.GetDocumentTextDetectionAsync(
                    New GetDocumentTextDetectionRequest With {
                        .JobId = jobId,
                        .NextToken = nextToken
                    })

                For Each block In pageResponse.Blocks.Where(Function(b) b.BlockType = BlockType.LINE)
                    allText.AppendLine(block.Text)
                Next

                nextToken = pageResponse.NextToken
            Loop While nextToken IsNot Nothing

            Return allText.ToString()
        Finally
            ' Step 5: Siempre clean up S3
            Await _s3Client.DeleteObjectAsync(_bucketName, key)
        End Try
    End Function
End Class

Esta es la implementación mínima viable para el procesamiento confiable de PDF — cinco fases distintas, dos clientes de servicio AWS, y lógica de limpieza en un bloque finally. La versión de producción completa, con el tratamiento adecuado de errores, la lógica de reintentos con límite de frecuencia y la gestión de tiempos de espera, tiene una extensión de entre 150 y 300 líneas.

Comparación detallada de características

Enfoque de AWS Textract

// Every call to this method costs money — per page, permanently
public async Task<string> DetectTextAsync(string imagePath)
{
    var imageBytes = File.ReadAllBytes(imagePath);  // Image leaves your network

    var request = new DetectDocumentTextRequest
    {
        Document = new Document
        {
            Bytes = new MemoryStream(imageBytes)
        }
    };

    var response = await _client.DetectDocumentTextAsync(request);  // per-page charge

    return string.Join("\n", response.Blocks
        .Where(b => b.BlockType == BlockType.LINE)
        .Select(b => b.Text));
}

// Every call to this method costs money — per page, permanently
public async Task<string> DetectTextAsync(string imagePath)
{
    var imageBytes = File.ReadAllBytes(imagePath);  // Image leaves your network

    var request = new DetectDocumentTextRequest
    {
        Document = new Document
        {
            Bytes = new MemoryStream(imageBytes)
        }
    };

    var response = await _client.DetectDocumentTextAsync(request);  // per-page charge

    return string.Join("\n", response.Blocks
        .Where(b => b.BlockType == BlockType.LINE)
        .Select(b => b.Text));
}

Imports System.IO
Imports System.Threading.Tasks

' Every call to this method costs money — per page, permanently
Public Async Function DetectTextAsync(imagePath As String) As Task(Of String)
    Dim imageBytes = File.ReadAllBytes(imagePath)  ' Image leaves your network

    Dim request = New DetectDocumentTextRequest With {
        .Document = New Document With {
            .Bytes = New MemoryStream(imageBytes)
        }
    }

    Dim response = Await _client.DetectDocumentTextAsync(request)  ' per-page charge

    Return String.Join(vbLf, response.Blocks _
        .Where(Function(b) b.BlockType = BlockType.LINE) _
        .Select(Function(b) b.Text))
End Function

Consulte la página de precios de AWS Textract para conocer las tarifas actuales por página. Las diferentes características del API (detección básica de texto, extracción de tablas, extracción de formularios) tienen diferentes tarifas. Un documento que contiene tablas y campos de formulario incurre en cargos más altos que la detección básica de texto, y los costos aumentan con el volumen sin límite superior y sin posibilidad de pagar por adelantado.

A volúmenes de página altos, los costos totales de tres años pueden ser sustanciales, y el contador sigue corriendo.

Enfoque de IronOCR

// One license. No per-page cost. Same code handles 1 page or 1,000,000.
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

var text = new IronTesseract().Read("document.jpg").Text;

// One license. No per-page cost. Same code handles 1 page or 1,000,000.
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

var text = new IronTesseract().Read("document.jpg").Text;

Imports IronOcr

' One license. No per-page cost. Same code handles 1 page or 1,000,000.
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"

Dim text As String = New IronTesseract().Read("document.jpg").Text

La licencia Professional $2,999 cubre 10 desarrolladores, proyectos ilimitados y volumen de página ilimitado. Tras el primer año, el coste mensual por las páginas procesadas es cero. Para equipos que procesan volúmenes de página significativos, la licencia IronOCR se paga por sí misma rápidamente en comparación con los cargos continuos por página en la nube.

La página de licencias de IronOCR incluye detalles sobre los niveles de servicio, opciones de suscripción SaaS para escenarios de facturación basada en el uso y condiciones de redistribución para fabricantes de equipos originales (OEM).

Enfoque de AWS Textract

// This code sends PHI, legal documents, financial records — whatever is in
// the file — to Amazon Web Services infrastructure
public async Task<string> ProcessSensitiveDocumentAsync(string documentPath)
{
    var imageBytes = File.ReadAllBytes(documentPath);

    // Data crosses your security perimeter here
    var request = new DetectDocumentTextRequest
    {
        Document = new Document
        {
            Bytes = new MemoryStream(imageBytes)
        }
    };

    // Amazon processes it; you receive text back
    var response = await _client.DetectDocumentTextAsync(request);

    return string.Join("\n", response.Blocks
        .Where(b => b.BlockType == BlockType.LINE)
        .Select(b => b.Text));
}

// This code sends PHI, legal documents, financial records — whatever is in
// the file — to Amazon Web Services infrastructure
public async Task<string> ProcessSensitiveDocumentAsync(string documentPath)
{
    var imageBytes = File.ReadAllBytes(documentPath);

    // Data crosses your security perimeter here
    var request = new DetectDocumentTextRequest
    {
        Document = new Document
        {
            Bytes = new MemoryStream(imageBytes)
        }
    };

    // Amazon processes it; you receive text back
    var response = await _client.DetectDocumentTextAsync(request);

    return string.Join("\n", response.Blocks
        .Where(b => b.BlockType == BlockType.LINE)
        .Select(b => b.Text));
}

Imports System.IO
Imports System.Threading.Tasks
Imports Amazon.Textract
Imports Amazon.Textract.Model

Public Class DocumentProcessor
    Private _client As AmazonTextractClient

    Public Sub New(client As AmazonTextractClient)
        _client = client
    End Sub

    ' This code sends PHI, legal documents, financial records — whatever is in
    ' the file — to Amazon Web Services infrastructure
    Public Async Function ProcessSensitiveDocumentAsync(documentPath As String) As Task(Of String)
        Dim imageBytes = File.ReadAllBytes(documentPath)

        ' Data crosses your security perimeter here
        Dim request As New DetectDocumentTextRequest With {
            .Document = New Document With {
                .Bytes = New MemoryStream(imageBytes)
            }
        }

        ' Amazon processes it; you receive text back
        Dim response = Await _client.DetectDocumentTextAsync(request)

        Return String.Join(vbLf, response.Blocks _
            .Where(Function(b) b.BlockType = BlockType.LINE) _
            .Select(Function(b) b.Text))
    End Function
End Class

AWS ofrece un Acuerdo de socio comercial HIPAApara entidades cubiertas, y las regiones de GovCloud proporcionan la autorización FedRAMP High. Estos marcos no modifican la arquitectura fundamental: los documentos salen de su infraestructura para cada operación. En el caso de los datos técnicos sujetos a la normativa ITAR, no se trata de una sutileza de cumplimiento, sino de una prohibición. Para las cargas de trabajo de nivel 3 del CMMC con CUI, la transmisión en la nube requiere autorizaciones específicas que la mayoría de los contratistas de defensa no poseen. Para los sistemas aislados (redes de investigación, entornos de control industrial, instalaciones clasificadas), Textract simplemente no está disponible.

AWS Textract está disponible en seis regiones: us-east-1, us-west-2, eu-west-1, eu-west-2, ap-southeast-1 y ap-southeast-2. Las organizaciones con requisitos de residencia de datos fuera de estas regiones no disponen de ninguna opción que cumpla con la normativa.

Enfoque de IronOCR

// IronOCR: document bytes never leave this process
public string ProcessSensitiveDocument(string documentPath)
{
    // Processes entirely on local hardware — no network call
    var ocr = new IronTesseract();
    return ocr.Read(documentPath).Text;
}

// IronOCR: document bytes never leave this process
public string ProcessSensitiveDocument(string documentPath)
{
    // Processes entirely on local hardware — no network call
    var ocr = new IronTesseract();
    return ocr.Read(documentPath).Text;
}

' IronOCR: document bytes never leave this process
Public Function ProcessSensitiveDocument(documentPath As String) As String
    ' Processes entirely on local hardware — no network call
    Dim ocr As New IronTesseract()
    Return ocr.Read(documentPath).Text
End Function

Dado que IronOCR se ejecuta localmente, encaja de forma natural en los flujos de trabajo del sector sanitario que procesan información médica protegida (PHI), en los sistemas de documentos legales que gestionan comunicaciones privilegiadas, en las aplicaciones financieras que manejan imágenes de tarjetas de pago y en los procesos de los contratistas de defensa que procesan información controlada (CUI). No hay ningún procesador externo que auditar, ningún acuerdo de negocios (BAA) que negociar ni ninguna restricción de residencia de datos que cumplir. El ámbito de cumplimiento es la propia infraestructura de su organización.

Para los equipos que implementan en la infraestructura de AWS pero necesitan procesamiento local,IronOCRse ejecuta en AWS (EC2, Lambda) sin ninguna dependencia de Textract: el procesamiento se realiza dentro de los límites de su propia cuenta de AWS en lugar de en el servicio gestionado de Amazon.

Enfoque de AWS Textract

// Full production-grade async processor for Textract PDF handling
public class TextractAsyncProcessor
{
    private readonly AmazonTextractClient _textractClient;
    private readonly AmazonS3Client _s3Client;
    private readonly string _bucketName;
    private readonly TimeSpan _pollInterval = TimeSpan.FromSeconds(5);
    private readonly TimeSpan _maxWaitTime = TimeSpan.FromMinutes(10);

    public async Task<DocumentResult> ProcessDocumentAsync(
        string localFilePath,
        CancellationToken cancellationToken = default)
    {
        var s3Key = $"textract-uploads/{Guid.NewGuid()}{Path.GetExtension(localFilePath)}";

        try
        {
            // Phase 1: Upload to S3
            await UploadToS3Async(localFilePath, s3Key, cancellationToken);

            // Phase 2: Start Textract job
            var jobId = await StartTextractJobAsync(s3Key, cancellationToken);

            // Phase 3: Poll until complete (up to 10 minutes)
            var pollResult = await PollForCompletionAsync(jobId, cancellationToken);

            if (!pollResult.Success)
                throw new Exception($"Textract job failed: {pollResult.ErrorMessage}");

            // Phase 4: Retrieve paginated results
            return await GetAllResultsAsync(jobId, cancellationToken);
        }
        finally
        {
            // Phase 5: S3 cleanup — must succeed or storage costs accumulate
            await DeleteFromS3Async(s3Key, cancellationToken);
        }
    }

    private async Task<(bool Success, string ErrorMessage)> PollForCompletionAsync(
        string jobId, CancellationToken cancellationToken)
    {
        var startTime = DateTime.UtcNow;
        int pollCount = 0;

        while (DateTime.UtcNow - startTime < _maxWaitTime)
        {
            cancellationToken.ThrowIfCancellationRequested();

            var response = await _textractClient.GetDocumentTextDetectionAsync(
                new GetDocumentTextDetectionRequest { JobId = jobId }, cancellationToken);

            pollCount++;

            switch (response.JobStatus)
            {
                case JobStatus.SUCCEEDED: return (true, null);
                case JobStatus.FAILED: return (false, response.StatusMessage ?? "Unknown error");
                case JobStatus.IN_PROGRESS:
                    await Task.Delay(_pollInterval, cancellationToken);
                    break;
                default:
                    throw new Exception($"Unknown job status: {response.JobStatus}");
            }
        }

        return (false, "Job timed out");
    }
}

// Full production-grade async processor for Textract PDF handling
public class TextractAsyncProcessor
{
    private readonly AmazonTextractClient _textractClient;
    private readonly AmazonS3Client _s3Client;
    private readonly string _bucketName;
    private readonly TimeSpan _pollInterval = TimeSpan.FromSeconds(5);
    private readonly TimeSpan _maxWaitTime = TimeSpan.FromMinutes(10);

    public async Task<DocumentResult> ProcessDocumentAsync(
        string localFilePath,
        CancellationToken cancellationToken = default)
    {
        var s3Key = $"textract-uploads/{Guid.NewGuid()}{Path.GetExtension(localFilePath)}";

        try
        {
            // Phase 1: Upload to S3
            await UploadToS3Async(localFilePath, s3Key, cancellationToken);

            // Phase 2: Start Textract job
            var jobId = await StartTextractJobAsync(s3Key, cancellationToken);

            // Phase 3: Poll until complete (up to 10 minutes)
            var pollResult = await PollForCompletionAsync(jobId, cancellationToken);

            if (!pollResult.Success)
                throw new Exception($"Textract job failed: {pollResult.ErrorMessage}");

            // Phase 4: Retrieve paginated results
            return await GetAllResultsAsync(jobId, cancellationToken);
        }
        finally
        {
            // Phase 5: S3 cleanup — must succeed or storage costs accumulate
            await DeleteFromS3Async(s3Key, cancellationToken);
        }
    }

    private async Task<(bool Success, string ErrorMessage)> PollForCompletionAsync(
        string jobId, CancellationToken cancellationToken)
    {
        var startTime = DateTime.UtcNow;
        int pollCount = 0;

        while (DateTime.UtcNow - startTime < _maxWaitTime)
        {
            cancellationToken.ThrowIfCancellationRequested();

            var response = await _textractClient.GetDocumentTextDetectionAsync(
                new GetDocumentTextDetectionRequest { JobId = jobId }, cancellationToken);

            pollCount++;

            switch (response.JobStatus)
            {
                case JobStatus.SUCCEEDED: return (true, null);
                case JobStatus.FAILED: return (false, response.StatusMessage ?? "Unknown error");
                case JobStatus.IN_PROGRESS:
                    await Task.Delay(_pollInterval, cancellationToken);
                    break;
                default:
                    throw new Exception($"Unknown job status: {response.JobStatus}");
            }
        }

        return (false, "Job timed out");
    }
}

Imports System
Imports System.IO
Imports System.Threading
Imports System.Threading.Tasks
Imports Amazon.Textract
Imports Amazon.S3
Imports Amazon.Textract.Model

' Full production-grade async processor for Textract PDF handling
Public Class TextractAsyncProcessor
    Private ReadOnly _textractClient As AmazonTextractClient
    Private ReadOnly _s3Client As AmazonS3Client
    Private ReadOnly _bucketName As String
    Private ReadOnly _pollInterval As TimeSpan = TimeSpan.FromSeconds(5)
    Private ReadOnly _maxWaitTime As TimeSpan = TimeSpan.FromMinutes(10)

    Public Async Function ProcessDocumentAsync(localFilePath As String, Optional cancellationToken As CancellationToken = Nothing) As Task(Of DocumentResult)
        Dim s3Key = $"textract-uploads/{Guid.NewGuid()}{Path.GetExtension(localFilePath)}"

        Try
            ' Phase 1: Upload to S3
            Await UploadToS3Async(localFilePath, s3Key, cancellationToken)

            ' Phase 2: Start Textract job
            Dim jobId = Await StartTextractJobAsync(s3Key, cancellationToken)

            ' Phase 3: Poll until complete (up to 10 minutes)
            Dim pollResult = Await PollForCompletionAsync(jobId, cancellationToken)

            If Not pollResult.Success Then
                Throw New Exception($"Textract job failed: {pollResult.ErrorMessage}")
            End If

            ' Phase 4: Retrieve paginated results
            Return Await GetAllResultsAsync(jobId, cancellationToken)
        Finally
            ' Phase 5: S3 cleanup — must succeed or storage costs accumulate
            Await DeleteFromS3Async(s3Key, cancellationToken)
        End Try
    End Function

    Private Async Function PollForCompletionAsync(jobId As String, cancellationToken As CancellationToken) As Task(Of (Success As Boolean, ErrorMessage As String))
        Dim startTime = DateTime.UtcNow
        Dim pollCount As Integer = 0

        While DateTime.UtcNow - startTime < _maxWaitTime
            cancellationToken.ThrowIfCancellationRequested()

            Dim response = Await _textractClient.GetDocumentTextDetectionAsync(New GetDocumentTextDetectionRequest With {.JobId = jobId}, cancellationToken)

            pollCount += 1

            Select Case response.JobStatus
                Case JobStatus.SUCCEEDED
                    Return (True, Nothing)
                Case JobStatus.FAILED
                    Return (False, If(response.StatusMessage, "Unknown error"))
                Case JobStatus.IN_PROGRESS
                    Await Task.Delay(_pollInterval, cancellationToken)
                Case Else
                    Throw New Exception($"Unknown job status: {response.JobStatus}")
            End Select
        End While

        Return (False, "Job timed out")
    End Function
End Class

No se trata de un texto estándar que se pueda generar y olvidar. Cuando un trabajo de Textract falla en medio de la ejecución, la limpieza de S3 debe seguir ejecutándose. Cuando un trabajo agota el tiempo de espera tras 10 minutos, el autor de la llamada necesita un error claro. Cuando se produce una caída de la red durante el sondeo, la estrategia de reintento no debe crear trabajos duplicados. Cada uno de estos modos de fallo requiere un tratamiento explícito; la estructura mostrada anteriormente es la implementación mínima responsable.

El procesamiento por lotes añade otra capa: el límite TPS por defecto de Textract StartDocumentTextDetection es de 5 solicitudes por segundo. Procesar 100 documentos requiere una limitación SemaphoreSlim, un temporizador de reposición de tasa, y lógica de reintento para ProvisionedThroughputExceededException.

Enfoque de IronOCR

// IronOCR: same synchronous API regardless of document type or size
public string ProcessDocument(string filePath)
{
    using var input = new OcrInput();

    if (Path.GetExtension(filePath).Equals(".pdf", StringComparison.OrdinalIgnoreCase))
        input.LoadPdf(filePath);
    else
        input.LoadImage(filePath);

    return new IronTesseract().Read(input).Text;
}

// IronOCR: same synchronous API regardless of document type or size
public string ProcessDocument(string filePath)
{
    using var input = new OcrInput();

    if (Path.GetExtension(filePath).Equals(".pdf", StringComparison.OrdinalIgnoreCase))
        input.LoadPdf(filePath);
    else
        input.LoadImage(filePath);

    return new IronTesseract().Read(input).Text;
}

Imports System.IO

' IronOCR: same synchronous API regardless of document type or size
Public Function ProcessDocument(filePath As String) As String
    Using input As New OcrInput()
        If Path.GetExtension(filePath).Equals(".pdf", StringComparison.OrdinalIgnoreCase) Then
            input.LoadPdf(filePath)
        Else
            input.LoadImage(filePath)
        End If

        Return New IronTesseract().Read(input).Text
    End Using
End Function

No hay bucle de sondeo, ni seguimiento de ID de trabajo, ni bucket de S3, ni paginación de resultados. El mismo código gestiona tanto un único archivo JPEG como un PDF de 200 páginas. El procesamiento se completa o genera un error; no hay un estado intermedio de "en curso" que gestionar. Para el procesamiento por lotes, IronOCR es seguro para hilos y una sola instancia IronTesseract maneja Parallel.ForEach sin bloqueos o semáforos.

La guía de instalación de IronTesseract cubre la configuración, y la guía de entrada de PDF documenta la selección de rangos de páginas, los PDF protegidos con contraseña y la entrada basada en flujos para PDF recuperados de bases de datos o respuestas HTTP.

Enfoque de AWS Textract

Antes de llamar a DetectDocumentTextAsync, un desarrollador debe:

1. Crea una cuenta de AWS u obtén acceso a una ya existente
2. Crear un usuario o rol IAM con permisos textract:DetectDocumentText y textract:AnalyzeDocument
3. Generar y almacenar de forma segura el ID de la clave de acceso y la clave de acceso secreta
4. Configurar la resolución de credenciales: variables de entorno, archivo de credenciales de AWS o perfil de instancia de EC2
5. Si se procesan PDFs: crear un bucket S3, configurar la política del bucket, añadir permisos s3:PutObject y s3:DeleteObject
6. Implementar políticas de rotación de credenciales para cumplir con los estándares de seguridad
7. Almacene las credenciales de forma segura en cada entorno de implementación: secretos de Docker, secretos de Kubernetes, AWS Secrets Manager o variables del canal de CI/CD

// Every environment needs these configured before this constructor succeeds
public TextractOcrService()
{
    // Reads credentials from environment, ~/.aws/credentials, or IAM role
    _client = new AmazonTextractClient(Amazon.RegionEndpoint.USEast1);
}

// Every environment needs these configured before this constructor succeeds
public TextractOcrService()
{
    // Reads credentials from environment, ~/.aws/credentials, or IAM role
    _client = new AmazonTextractClient(Amazon.RegionEndpoint.USEast1);
}

' Every environment needs these configured before this constructor succeeds
Public Sub New()
    ' Reads credentials from environment, ~/.aws/credentials, or IAM role
    _client = New AmazonTextractClient(Amazon.RegionEndpoint.USEast1)
End Sub

Cuando las credenciales expiran, rotan o están mal configuradas, cada llamada de OCR falla con AmazonTextractException portando ErrorCode == "AccessDeniedException". En un sistema de producción, esto implica implementar bloques catch específicos para los errores de credenciales y supervisar las desviaciones de las políticas de IAM.

Enfoque de IronOCR

// One-time setup at application startup
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

// Or from environment — recommended for deployments
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

// One-time setup at application startup
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

// Or from environment — recommended for deployments
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

' One-time setup at application startup
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"

' Or from environment — recommended for deployments
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")

La clave de licencia es una cadena estática. No caduca durante su funcionamiento, no requiere rotación y no conlleva permisos que gestionar. Un contenedor Dockerque procesa documentos no necesita credenciales de AWS inyectadas, un rol de IAM vinculado a un contexto de ejecución ni acceso de red a AWS STS para la actualización de tokens.

La reducción total de sobrecarga de credenciales al cambiar de Textract a IronOCR: se han eliminado tres paquetes NuGet (AWSSDK.Textract, AWSSDK.S3, AWSSDK.Core), se han eliminado todas las variables de entorno AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY / AWS_DEFAULT_REGION, y se han desmantelado las configuraciones de roles IAM y buckets S3. La guía de entrada de imágenes y la guía de entrada de flujos cubren toda la gama de métodos de entrada que sustituyen a los modelos de documentos de matriz de bytes y objetos S3 de Textract.

Cuando la factura mensual se convierte en una partida presupuestaria

Los equipos que empezaron a utilizar Textract con un volumen reducido suelen encontrarse con una situación concreta: la factura de AWS por el procesamiento OCR aparece en la revisión trimestral del presupuesto y alguien pregunta si este coste es fijo. No lo es. En volúmenes altos de páginas, los costos anuales de Textract pueden ser sustanciales — consulte la página de precios de AWS Textract para tarifas actuales. La licencia Professional de IronOCR en $2,999 un solo pago se paga rápidamente con volúmenes de páginas moderados a altos.

Cuando un requisito de cumplimiento bloquea el procesamiento en la nube

Las organizaciones sanitarias que implementan flujos de trabajo de digitalización de documentos suelen descubrir a mitad del proyecto que la información médica protegida (PHI) según la HIPAAno puede circular a través de servicios en la nube sin un acuerdo de negocios (BAA) y una revisión legal adicional, o que su equipo de seguridad prohíbe por completo la transmisión a la nube. Los contratistas de defensa que manejan planos técnicos, especificaciones o cualquier información clasificada (CUI) se enfrentan a restricciones de ITARy CMMC que excluyen a Texto de AWS de su consideración. Los bufetes de abogados que procesan comunicaciones privilegiadas tienen preocupaciones similares. No se trata de casos extremos teóricos de cumplimiento normativo, sino que aparecen con frecuencia en revisiones de adquisiciones, auditorías de seguridad y negociaciones contractuales.IronOCR procesa los datos localmente, por lo que la cuestión del cumplimiento normativo en relación con los datos de los documentos se reduce a si su propia infraestructura está incluida en el ámbito de aplicación, y no a si la infraestructura de Amazon lo está.

Cuando la complejidad del PDF asíncrono supera su valor

El proceso S3-async de cinco fases —carga, inicio del trabajo, sondeo, paginación de resultados, limpieza— no es técnicamente difícil de implementar. Es difícil de mantener, probar y operar. Cada fase es un punto de fallo. Los errores de carga en S3 requieren una lógica de reintento. Los fallos en las tareas de Textract requieren distinguir entre errores transitorios y permanentes. Los tiempos de espera de las consultas requieren un manejo de los tiempos de espera independiente de la cancelación. La paginación de resultados requiere acumular el estado a lo largo de múltiples llamadas a la API. Los fallos en la limpieza de S3 requieren una alerta, ya que los objetos huérfanos acumulan costes. Los equipos que han implementado este sistema en producción suelen dedicar más tiempo de ingeniería a su mantenimiento que el que invirtieron en su desarrollo. El equivalente de IronOCR— input.LoadPdf(path) seguido de ocr.Read(input) — elimina todas las cinco fases y sus modos de falla asociados.

Cuando los entornos de implementación carecen de acceso a Internet

Los contenedores Dockerque se ejecutan en segmentos de red aislados, los servidores locales sin conexión a Internet saliente, los entornos de investigación aislados físicamente y los sistemas industriales con estrictos controles de red comparten una característica: Texto de AWS no está disponible.IronOCR se instala como un paquete NuGet estándar y funciona sin necesidad de realizar llamadas de red después de la instalación. Los equipos que ejecutan aplicaciones .NET en estos entornos no tienen la opción Textract y necesitan una biblioteca que procese localmente. La guía de implementación de Docker y la guía de implementación de Linux cubren la configuración específica para entornos de contenedores.

Cuando la limitación de velocidad interrumpe los flujos de trabajo por lotes

El límite TPS por defecto StartDocumentTextDetection es de 5 solicitudes por segundo. Las llamadas sincrónicas DetectDocumentText también están limitadas por tasa. Los trabajos por lotes que procesan cientos o miles de documentos deben implementar limitación SemaphoreSlim, retroceso exponencial en ProvisionedThroughputExceededException, y temporizadores de reposición de tasa. AWS admite las solicitudes de aumento del límite de TPS, pero requieren justificación, revisión y no están garantizadas.IronOCR procesa las tareas tan rápido como lo permite la CPU local: un servidor de 32 núcleos procesa 32 documentos simultáneamente sin configuración de limitación de velocidad ni negociación del nivel de servicio.

Sustitución del gráfico de bloques por colecciones directas

Textract representa todos los resultados como una List<Block> plana donde líneas, palabras, celdas, tablas y pares clave-valor se distinguen por BlockType y se enlazan por matrices de IDs de relación.IronOCR proporciona colecciones de texto directamente escritas.

// Textract: filter flat block list by type
var lines = response.Blocks.Where(b => b.BlockType == BlockType.LINE);
var words = response.Blocks.Where(b => b.BlockType == BlockType.WORD);

// IronOCR: direct access to typed collections
var result = ocr.Read(imagePath);
var lines = result.Lines;   // IEnumerable<OcrResult.OcrResultLine>
var words = result.Words;   // IEnumerable<OcrResult.OcrResultWord>
foreach (var word in result.Words)
    Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) confidence {word.Confidence}%");

// Textract: filter flat block list by type
var lines = response.Blocks.Where(b => b.BlockType == BlockType.LINE);
var words = response.Blocks.Where(b => b.BlockType == BlockType.WORD);

// IronOCR: direct access to typed collections
var result = ocr.Read(imagePath);
var lines = result.Lines;   // IEnumerable<OcrResult.OcrResultLine>
var words = result.Words;   // IEnumerable<OcrResult.OcrResultWord>
foreach (var word in result.Words)
    Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) confidence {word.Confidence}%");

' Textract: filter flat block list by type
Dim lines = response.Blocks.Where(Function(b) b.BlockType = BlockType.LINE)
Dim words = response.Blocks.Where(Function(b) b.BlockType = BlockType.WORD)

' IronOCR: direct access to typed collections
Dim result = ocr.Read(imagePath)
Dim lines = result.Lines   ' IEnumerable(Of OcrResult.OcrResultLine)
Dim words = result.Words   ' IEnumerable(Of OcrResult.OcrResultWord)
For Each word In result.Words
    Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) confidence {word.Confidence}%")
Next

La guía de resultados estructurados cubre result.Pages, result.Paragraphs, result.Lines, result.Words y el acceso a coordenadas para construir procesamiento de documentos consciente del diseño.

Sustitución del procesamiento de PDF por etapas S3 con Direct LoadPdf

Cualquier código de Textract que se cargue en S3 antes de iniciar una tarea de detección puede sustituirse por una carga directa de PDF. Sin área de preparación, sin sincronización de carga, sin lógica de limpieza.

// Textract: upload to S3 → start job → poll → paginate → cleanup (50+ lines)
//IronOCR equivalent:
public string ProcessPdf(string pdfPath)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadPdf(pdfPath);
    return ocr.Read(input).Text;
}

// Specific page ranges (no Textract equivalent without async job per range)
public string ProcessPdfPages(string pdfPath, int startPage, int endPage)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadPdfPages(pdfPath, startPage, endPage);
    return ocr.Read(input).Text;
}

// Textract: upload to S3 → start job → poll → paginate → cleanup (50+ lines)
//IronOCR equivalent:
public string ProcessPdf(string pdfPath)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadPdf(pdfPath);
    return ocr.Read(input).Text;
}

// Specific page ranges (no Textract equivalent without async job per range)
public string ProcessPdfPages(string pdfPath, int startPage, int endPage)
{
    var ocr = new IronTesseract();
    using var input = new OcrInput();
    input.LoadPdfPages(pdfPath, startPage, endPage);
    return ocr.Read(input).Text;
}

Imports IronOcr

Public Class PdfProcessor
    ' Textract: upload to S3 → start job → poll → paginate → cleanup (50+ lines)
    ' IronOCR equivalent:
    Public Function ProcessPdf(pdfPath As String) As String
        Dim ocr As New IronTesseract()
        Using input As New OcrInput()
            input.LoadPdf(pdfPath)
            Return ocr.Read(input).Text
        End Using
    End Function

    ' Specific page ranges (no Textract equivalent without async job per range)
    Public Function ProcessPdfPages(pdfPath As String, startPage As Integer, endPage As Integer) As String
        Dim ocr As New IronTesseract()
        Using input As New OcrInput()
            input.LoadPdfPages(pdfPath, startPage, endPage)
            Return ocr.Read(input).Text
        End Using
    End Function
End Class

Agregar preprocesamiento para documentos que produjeron baja confianza en Textract

El preprocesamiento de Textract es interno y no configurable. Cuando un documento escaneado produce resultados deficientes, las únicas opciones son volver a intentarlo o aceptar un resultado con baja fiabilidad.IronOCR expone directamente el proceso de preprocesamiento.

// For documents that returned low-confidence results from Textract
using var input = new OcrInput();
input.LoadImage("low-quality-scan.jpg");

input.Deskew();              // Fix rotation from scanner misalignment
input.DeNoise();             // Remove scanner noise artifacts
input.Contrast();            // Boost faint text
input.EnhanceResolution(300); // Scale to optimal OCR resolution

var result = new IronTesseract().Read(input);
Console.WriteLine($"Confidence: {result.Confidence}%");

// For documents that returned low-confidence results from Textract
using var input = new OcrInput();
input.LoadImage("low-quality-scan.jpg");

input.Deskew();              // Fix rotation from scanner misalignment
input.DeNoise();             // Remove scanner noise artifacts
input.Contrast();            // Boost faint text
input.EnhanceResolution(300); // Scale to optimal OCR resolution

var result = new IronTesseract().Read(input);
Console.WriteLine($"Confidence: {result.Confidence}%");

Imports IronOcr

Dim input As New OcrInput()
input.LoadImage("low-quality-scan.jpg")

input.Deskew()              ' Fix rotation from scanner misalignment
input.DeNoise()             ' Remove scanner noise artifacts
input.Contrast()            ' Boost faint text
input.EnhanceResolution(300) ' Scale to optimal OCR resolution

Dim result = New IronTesseract().Read(input)
Console.WriteLine($"Confidence: {result.Confidence}%")

La guía de corrección de calidad de imagen y tutorial de filtros de imagen documentan toda la tubería de preprocesamiento y las combinaciones que funcionan mejor para tipos de documentos específicos. Para la interpretación de puntajes de confianza y el acceso a la confianza por elemento, la guía de puntuaciones de confianza cubre la propiedad result.Confidence y los valores de confianza por palabra.

Cómo gestionar el cambio de patrón de asíncrono a síncrono

El código existente de Textract es necesariamente async Task<t> durante todo el proceso porque el SDK es solo asincrónico. Las operaciones de IronOCR son síncronas. Para el código de la aplicación que ya tiene una cadena de llamadas asincrónica, envuelva la llamada IronOCR en Task.Run para mantener el límite asincrónico.

// Preserves async call site for minimal refactoring
public async Task<string> ExtractTextAsync(string path)
{
    return await Task.Run(() => new IronTesseract().Read(path).Text);
}

// Preserves async call site for minimal refactoring
public async Task<string> ExtractTextAsync(string path)
{
    return await Task.Run(() => new IronTesseract().Read(path).Text);
}

Imports System.Threading.Tasks

' Preserves async call site for minimal refactoring
Public Async Function ExtractTextAsync(path As String) As Task(Of String)
    Return Await Task.Run(Function() New IronTesseract().Read(path).Text)
End Function

Se trata de un envoltorio práctico, no de un requisito. Para el procesamiento del lado del servidor, donde el código que realiza la llamada ya se encuentra en un hilo en segundo plano, se prefiere la llamada síncrona directa.