Uma comparação entre IronOCR e Nanonets OCR

O Pipeline S3-Assíncrono

OCR de imagem única via DetectDocumentTextAsync pode passar bytes do documento diretamente na solicitação. PDFs de várias páginas não. Qualquer PDF requer o pipeline assíncrono completo:

// AWS Textract: PDF com várias 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: Sempre clean up S3
        await _s3Client.DeleteObjectAsync(_bucketName, key);
    }
}

// AWS Textract: PDF com várias 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: Sempre 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 TextractProcessor
    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: Always clean up S3
            Await _s3Client.DeleteObjectAsync(_bucketName, key)
        End Try
    End Function
End Class

Esta é a implementação mínima viável para um processamento confiável de PDF — cinco fases distintas, dois clientes de serviço AWS e lógica de limpeza em um bloco finally. A versão completa de produção, com tratamento de erros adequado, lógica de repetição com limite de taxa e gerenciamento de tempo limite, possui entre 150 e 300 linhas de código.

Comparação Detalhada de Recursos

Abordagem 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 a página de preços do AWS Textract para tarifas atuais por página. Diferentes recursos da API (detecção básica de texto, extração de tabelas, extração de formulários) têm taxas diferentes. Um documento contendo tabelas e campos de formulário incorreria em cobranças maiores do que a detecção básica de texto, e os custos cresceriam com o volume sem limite superior e sem maneira de pagar adiantado.

Em volumes altos de páginas, o custo total de três anos pode ser substancial, e o medidor continua a correr.

Abordagem IronOCR

// One license. Não 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. Não 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. Não per-page cost. Same code handles 1 page or 1,000,000.
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"

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

A licença $2,999 Professional cobre 10 desenvolvedores, projetos ilimitados e volume de página ilimitado. Após o primeiro ano, o custo contínuo por página processada é zero. Para equipes processando volumes de páginas significativos, a licença IronOCR se paga rapidamente em comparação aos custos crescentes por página na nuvem.

A página de licenciamento do IronOCR aborda detalhes dos níveis de licenciamento, opções de assinatura SaaS para cenários de cobrança baseada no uso e termos de redistribuição para OEMs.

Abordagem 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

A AWS oferece um Acordo de Parceiro ComercialHIPAApara entidades abrangidas, e as regiões GovCloud fornecem autorização FedRAMP High. Essas estruturas não alteram a arquitetura fundamental: os documentos saem da sua infraestrutura para cada operação. Para dados técnicos controlados pelo ITAR, isso não é uma nuance de conformidade — é uma proibição. Para cargas de trabalho CMMC Nível 3 com CUI (Informações Não Classificadas Controladas), a transmissão em nuvem requer autorizações específicas que a maioria dos contratados da área de defesa não possui. Para sistemas isolados da internet — redes de pesquisa, ambientes de controle industrial, instalações confidenciais — o Textract simplesmente não está disponível.

AWS Textract está disponível em seis regiões: us-east-1, us-west-2, eu-west-1, eu-west-2, ap-southeast-1 e ap-southeast-2. Organizações com requisitos de residência de dados fora dessas regiões não têm uma opção compatível.

Abordagem 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

Como o IronOCR é executado localmente, ele se integra naturalmente aos fluxos de trabalho da área da saúde que processam informações de saúde protegidas (PHI), aos sistemas de documentos jurídicos que lidam com comunicações privilegiadas, aos aplicativos financeiros que processam imagens de cartões de pagamento e aos sistemas de processamento de informações controladas não classificadas (CUI) de contratados da área de defesa. Não há processador externo para auditar, nenhum BAA para negociar, nenhuma restrição de residência de dados a cumprir. O âmbito de conformidade abrange a infraestrutura da sua própria organização.

Para equipes que implantam na infraestrutura da AWS, mas precisam de processamento local, o IronOCRé executado no AWS EC2 e no Lambda sem qualquer dependência do Textract — o processamento ocorre dentro dos limites da sua própria conta da AWS, em vez do serviço gerenciado da Amazon.

Abordagem 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

Isto não é um texto padrão que pode ser gerado e esquecido. Quando uma tarefa do Textract falha durante a execução, a limpeza do S3 ainda precisa ser realizada. Quando uma tarefa expira após 10 minutos, o solicitante precisa de uma mensagem de erro clara. Quando a rede cai durante a sondagem, a estratégia de repetição não deve criar tarefas duplicadas. Cada um desses modos de falha requer tratamento explícito — a estrutura mostrada acima é a implementação mínima responsável.

O processamento em lote adiciona outra camada: o limite padrão de TPS StartDocumentTextDetection do Textract é de 5 solicitações por segundo. Processar 100 documentos exige uma limitação de SemaphoreSlim, um temporizador de reabastecimento de taxa e lógica de repetição para ProvisionedThroughputExceededException.

Abordagem 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

Não há loop de polling, rastreamento de ID de tarefa, bucket S3 ou paginação de resultados. O mesmo código processa tanto um único arquivo JPEG quanto um PDF de 200 páginas. O processamento é concluído ou rejeitado — não há estado intermediário "em andamento" para gerenciar. Para processamento em lote, IronOCR é seguro para threads e uma única instância IronTesseract lida com Parallel.ForEach sem bloqueios ou semáforos.

O guia de configuração do IronTesseract aborda a configuração, e o guia de entrada de PDF documenta a seleção de intervalo de páginas, PDFs protegidos por senha e entrada baseada em fluxo para PDFs recuperados de bancos de dados ou respostas HTTP.

Abordagem AWS Textract

Antes de chamar DetectDocumentTextAsync, um desenvolvedor deve:

1. Crie uma conta da AWS ou obtenha acesso a uma conta existente.
2. Criar um usuário ou função IAM com permissões textract:DetectDocumentText e textract:AnalyzeDocument
3. Gere e armazene com segurança o ID da chave de acesso e a chave de acesso secreta.
4. Configure a resolução de credenciais — variáveis ​​de ambiente, arquivo de credenciais da AWS ou perfil de instância EC2.
5. Se estiver processando PDFs: criar um bucket S3, configurar a política do bucket, adicionar permissões s3:PutObject e s3:DeleteObject
6. Implementar políticas de rotação de credenciais para atender aos padrões de segurança.
7. Armazene as credenciais com segurança em cada ambiente de implantação — segredos do Docker, segredos do Kubernetes, AWS Secrets Manager ou variáveis ​​do pipeline 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

Quando as credenciais expiram, são giradas ou estão configuradas incorretamente, todas as chamadas OCR falham com AmazonTextractException carregando ErrorCode == "AccessDeniedException". Em um sistema de produção, isso significa implementar blocos de tratamento específicos para falhas de credenciais e monitorar desvios nas políticas de IAM.

Abordagem 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")

A chave de licença é uma sequência estática. Não expira durante a operação, não requer rotação e não possui permissões de gerenciamento. Um contêinerDockerque processa documentos não precisa de credenciais AWS injetadas, uma função IAM vinculada a um contexto de execução ou acesso à rede do AWS STS para atualização de token.

A redução completa de sobrecarga de credenciais ao mudar do Textract para IronOCR: três pacotes NuGet removidos (AWSSDK.Textract, AWSSDK.S3, AWSSDK.Core), todas as variáveis de ambiente AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY / AWS_DEFAULT_REGION removidas, e funções IAM e configurações de bucket S3 descomissionadas. O guia de entrada de imagem e o guia de entrada de fluxo abrangem toda a gama de métodos de entrada que substituem os modelos de documento de matriz de bytes e objeto S3 do Textract.

Quando a conta mensal se torna uma despesa do orçamento

As equipes que começaram a usar o Textract em baixo volume frequentemente se deparam com um momento específico: a fatura da AWS para processamento de OCR aparece em uma revisão orçamentária trimestral e alguém pergunta se esse custo é fixo. Não é. Em altos volumes de páginas, os custos anuais do Textract podem ser substanciais — consulte a página de preços do AWS Textract para tarifas atuais. A licença IronOCR Professional por $2,999 paga por si mesma rapidamente em volumes de páginas moderados a altos.

Quando um requisito de conformidade bloqueia o processamento em nuvem

Organizações de saúde que implementam fluxos de trabalho de digitalização de documentos frequentemente descobrem, no meio do projeto, que as informações de saúde protegidas pelaHIPAA(PHI-PHI) não podem ser transmitidas por serviços em nuvem sem um Acordo de Parceiro Comercial (BAA) e uma revisão jurídica adicional, ou que sua equipe de segurança proíbe completamente a transmissão para a nuvem. Os contratados da área de defesa que lidam com desenhos técnicos, especificações ou qualquer informação controlada não classificada (CUI) estão sujeitos a restrições doITARe do CMMC que excluem oAWS Textractde sua consideração. Escritórios de advocacia que processam comunicações confidenciais têm preocupações semelhantes. Esses não são casos extremos teóricos de conformidade — eles aparecem regularmente em revisões de compras, auditorias de segurança e negociações de contratos. O IronOCR processa os dados localmente, portanto, a questão de conformidade para dados de documentos se resume a saber se sua própria infraestrutura está dentro do escopo, e não se a infraestrutura da Amazon está.

Quando a complexidade do PDF assíncrono excede seu valor

O pipeline assíncrono do S3 de cinco fases — upload, início da tarefa, polling, paginação dos resultados, limpeza — não é tecnicamente difícil de implementar. É difícil de manter, testar e operar. Cada fase é um ponto de falha. Falhas no envio de arquivos para o S3 exigem lógica de repetição. As falhas nos trabalhos do Textract exigem a distinção entre erros transitórios e permanentes. Os tempos limite de sondagem exigem um tratamento de tempo limite separado do cancelamento. A paginação de resultados requer o acúmulo de estado ao longo de múltiplas chamadas de API. Falhas na limpeza do S3 exigem alertas porque objetos órfãos acumulam custos. As equipes que implementaram esse pipeline em produção normalmente gastam mais tempo de engenharia contínua em sua manutenção do que gastaram em sua construção. O equivalente IronOCR— input.LoadPdf(path) seguido por ocr.Read(input) — elimina todas as cinco fases e seus modos de falha associados.

Quando os ambientes de implantação não têm acesso à Internet

ContêineresDockerexecutados em segmentos de rede isolados, servidores locais sem acesso à internet, ambientes de pesquisa isolados da internet e sistemas industriais com controles de rede rigorosos compartilham uma característica: oAWS Textractnão está disponível. O IronOCR é instalado como um pacote NuGet padrão e funciona sem qualquer chamada de rede após a instalação. As equipes que executam aplicativos .NET nesses ambientes não têm a opção do Textract e precisam de uma biblioteca que processe os dados localmente. O guia de implantação do Docker e o guia de implantação do Linux abordam a configuração específica para ambientes conteinerizados.

Quando a limitação de taxa interrompe os fluxos de trabalho em lote

O limite padrão de TPS StartDocumentTextDetection é de 5 solicitações por segundo. Chamadas síncronas DetectDocumentText também têm limite de taxa. Os trabalhos em lote que processam centenas ou milhares de documentos devem implementar limitação SemaphoreSlim, recuo exponencial em ProvisionedThroughputExceededException, e temporizadores de reabastecimento de taxa. A AWS aceita solicitações de aumento de limite de TPS, mas elas exigem justificativa, análise e não são garantidas. O IronOCR processa os dados na velocidade máxima permitida pela CPU local — um servidor de 32 núcleos processa 32 documentos simultaneamente, sem necessidade de configuração de limitação de capacidade ou negociação de nível de serviço.

Substituindo o grafo de blocos por coleções diretas

Textract representa todos os resultados como um List<Block> plano onde linhas, palavras, células, tabelas e pares chave-valor são distinguidos por BlockType e vinculados por matrizes de ID de relacionamento. O IronOCR fornece coleções digitadas diretamente.

// 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

O guia de resultados estruturados cobre result.Pages, result.Paragraphs, result.Lines, result.Words e acesso a coordenadas para construção de processamento de documentos consciente do layout.

Substituindo o processamento de PDF em estágios S3 pelo carregamento direto de PDF.

Qualquer código Textract que faça upload para o S3 antes de iniciar uma tarefa de detecção pode ser substituído por um carregamento direto de PDF. Sem ambiente de preparação (staging bucket), sem agendamento de uploads, sem lógica de limpeza.

// 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

Adicionando pré-processamento para documentos que produziram baixa confiança no Textract

O pré-processamento do Textract é interno e não configurável. Quando um documento digitalizado produz resultados insatisfatórios, as únicas opções são tentar novamente ou aceitar um resultado com baixa confiabilidade. O IronOCR expõe diretamente o pipeline de pré-processamento.

// 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}%")

O guia de correção de qualidade de imagem e o tutorial de filtros de imagem documentam o pipeline completo de pré-processamento e combinações que funcionam melhor para tipos de documentos específicos. Para interpretação de pontuação de confiança e acesso de confiança por elemento, o guia de pontuações de confiança cobre a propriedade result.Confidence e valores de confiança por palavra.

Lidando com a mudança de padrão de assíncrono para síncrono

O código existente do Textract é necessariamente async Task<t> por todo o SDK porque é apenas assíncrono. As operações do IronOCR são síncronas. Para código de aplicativo que já possui uma cadeia de chamadas assíncronas, envolva a chamada IronOCR em Task.Run para manter o limite assíncrono.

// 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

Esta é uma embalagem para facilitar o uso, não um requisito. Para processamento no lado do servidor, onde o código de chamada já está em uma thread em segundo plano, a chamada síncrona direta é preferível.