IronOCR ou Iris OCR: qual solução de OCR as equipes de engenharia devem escolher?

O padrão de sondagem assíncrona

A exigência de assincronia da API Read cria consequências estruturais no código. A análise de imagem usando AnalyzeAsync retorna imediatamente, mas requer await; O processamento de PDF através do Form Recognizer requer WaitUntil.Completed para bloquear até que a operação termine, ou polling personalizado com UpdateStatusAsync para comportamento assíncrono real. A hierarquia resultante exige, então, percorrer blocos, linhas e palavras através de loops aninhados:

// Azure Computer Vision: image OCR
// Requires: Azure subscription + Cognitive Services resource + endpoint + API key
using Azure;
using Azure.AI.Vision.ImageAnalysis;

public class AzureOcrService
{
    private readonly ImageAnalysisClient _client;

    public AzureOcrService(string endpoint, string apiKey)
    {
        // Endpoint and key provisioned in Azure portal
        _client = new ImageAnalysisClient(
            new Uri(endpoint),
            new AzureKeyCredential(apiKey));
    }

    public async Task<string> ExtractTextAsync(string imagePath)
    {
        // Document is uploaded to Microsoft Azure
        using var stream = File.OpenRead(imagePath);
        var imageData = BinaryData.FromStream(stream);

        var result = await _client.AnalyzeAsync(
            imageData,
            VisualFeatures.Read);

        var text = new StringBuilder();
        foreach (var block in result.Value.Read.Blocks)
        {
            foreach (var line in block.Lines)
            {
                text.AppendLine(line.Text);
            }
        }

        return text.ToString();
    }
}

// Azure Computer Vision: image OCR
// Requires: Azure subscription + Cognitive Services resource + endpoint + API key
using Azure;
using Azure.AI.Vision.ImageAnalysis;

public class AzureOcrService
{
    private readonly ImageAnalysisClient _client;

    public AzureOcrService(string endpoint, string apiKey)
    {
        // Endpoint and key provisioned in Azure portal
        _client = new ImageAnalysisClient(
            new Uri(endpoint),
            new AzureKeyCredential(apiKey));
    }

    public async Task<string> ExtractTextAsync(string imagePath)
    {
        // Document is uploaded to Microsoft Azure
        using var stream = File.OpenRead(imagePath);
        var imageData = BinaryData.FromStream(stream);

        var result = await _client.AnalyzeAsync(
            imageData,
            VisualFeatures.Read);

        var text = new StringBuilder();
        foreach (var block in result.Value.Read.Blocks)
        {
            foreach (var line in block.Lines)
            {
                text.AppendLine(line.Text);
            }
        }

        return text.ToString();
    }
}

Imports Azure
Imports Azure.AI.Vision.ImageAnalysis
Imports System.IO
Imports System.Text
Imports System.Threading.Tasks

Public Class AzureOcrService
    Private ReadOnly _client As ImageAnalysisClient

    Public Sub New(endpoint As String, apiKey As String)
        ' Endpoint and key provisioned in Azure portal
        _client = New ImageAnalysisClient(
            New Uri(endpoint),
            New AzureKeyCredential(apiKey))
    End Sub

    Public Async Function ExtractTextAsync(imagePath As String) As Task(Of String)
        ' Document is uploaded to Microsoft Azure
        Using stream = File.OpenRead(imagePath)
            Dim imageData = BinaryData.FromStream(stream)

            Dim result = Await _client.AnalyzeAsync(
                imageData,
                VisualFeatures.Read)

            Dim text = New StringBuilder()
            For Each block In result.Value.Read.Blocks
                For Each line In block.Lines
                    text.AppendLine(line.Text)
                Next
            Next

            Return text.ToString()
        End Using
    End Function
End Class

O processamento de PDF eleva ainda mais a complexidade — um DocumentAnalysisClient separado com seu próprio endpoint, AnalyzeDocumentAsync com WaitUntil.Completed, e uma forma de resultado diferente usando result.Pages e page.Lines acessando .Content em vez de .Text.

Comparação Detalhada de Recursos

Abordagem de Visão Computacional do Azure

O Azure cobra por transação usando preços em camadas com base no volume. Consulte a página de preços do Azure Computer Vision para tarifas atuais. Cada página do PDF representa uma transação. Um PDF de 10 páginas equivale a 10 chamadas faturáveis. Está disponível uma camada gratuita de 5.000 transações por mês.

// Azure bills per transaction — costs grow with every document processed
// Free tier: 5,000 transactions/month
// Volume tiers apply at higher usage levels
// (Every PDF page multiplies the bill)

// Azure bills per transaction — costs grow with every document processed
// Free tier: 5,000 transactions/month
// Volume tiers apply at higher usage levels
// (Every PDF page multiplies the bill)

' Azure bills per transaction — costs grow with every document processed
' Free tier: 5,000 transactions/month
' Volume tiers apply at higher usage levels
' (Every PDF page multiplies the bill)

Em volumes moderados a altos de documentos, a licença perpétua do IronOCR se paga rapidamente em comparação com os custos contínuos de transações do Azure, após o qual cada documento adicional é economia.

Abordagem IronOCR

O modelo de preços do IronOCR é um número único. Instale o pacote NuGet , defina a chave de licença e processe qualquer volume sem que o contador seja acionado:

// Install: dotnet add package IronOcr
// License: one-time, perpetual

IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

var ocr = new IronTesseract();

// Process 1 document or 1 million — same cost
foreach (var path in documentPaths)
{
    var result = ocr.Read(path);
    Console.WriteLine($"Processed: {path}");
}

// Multi-page PDFs — no per-page billing
foreach (var path in pdfPaths)
{
    // 1 page or 100 pages, still no extra cost
    var result = ocr.Read(path);
    Console.WriteLine($"{path}: {result.Pages.Length} pages processed");
}

// Install: dotnet add package IronOcr
// License: one-time, perpetual

IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

var ocr = new IronTesseract();

// Process 1 document or 1 million — same cost
foreach (var path in documentPaths)
{
    var result = ocr.Read(path);
    Console.WriteLine($"Processed: {path}");
}

// Multi-page PDFs — no per-page billing
foreach (var path in pdfPaths)
{
    // 1 page or 100 pages, still no extra cost
    var result = ocr.Read(path);
    Console.WriteLine($"{path}: {result.Pages.Length} pages processed");
}

' Install: dotnet add package IronOcr
' License: one-time, perpetual

IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")

Dim ocr As New IronTesseract()

' Process 1 document or 1 million — same cost
For Each path In documentPaths
    Dim result = ocr.Read(path)
    Console.WriteLine($"Processed: {path}")
Next

' Multi-page PDFs — no per-page billing
For Each path In pdfPaths
    ' 1 page or 100 pages, still no extra cost
    Dim result = ocr.Read(path)
    Console.WriteLine($"{path}: {result.Pages.Length} pages processed")
Next

Sem necessidade de medição, rastreamento de consumo ou alertas de orçamento. Custos previsíveis desde o primeiro dia. Consulte o tutorial de leitura de texto em imagens para obter um passo a passo completo de introdução.

Abordagem de Visão Computacional do Azure

Mesmo com a seleção de endpoints regionais e um Acordo de Parceiro Comercial assinado, o fluxo de dados é fixo:

// Azure: data flow for every OCR call
// 1. Your application reads the file
// 2. File is serialized to BinaryData
// 3. HTTPS transmission to Azure data center
// 4. Microsoft infrastructure processes the document
// 5. Result returned over HTTPS
// 6. You parse the result

using var stream = File.OpenRead(imagePath);
var imageData = BinaryData.FromStream(stream);  // Document in memory

// This call transmits your document to Azure
var result = await _client.AnalyzeAsync(
    imageData,           // Document leaves your network here
    VisualFeatures.Read);

// Azure: data flow for every OCR call
// 1. Your application reads the file
// 2. File is serialized to BinaryData
// 3. HTTPS transmission to Azure data center
// 4. Microsoft infrastructure processes the document
// 5. Result returned over HTTPS
// 6. You parse the result

using var stream = File.OpenRead(imagePath);
var imageData = BinaryData.FromStream(stream);  // Document in memory

// This call transmits your document to Azure
var result = await _client.AnalyzeAsync(
    imageData,           // Document leaves your network here
    VisualFeatures.Read);

Imports System.IO
Imports Azure.AI.FormRecognizer.DocumentAnalysis

' Azure: data flow for every OCR call
' 1. Your application reads the file
' 2. File is serialized to BinaryData
' 3. HTTPS transmission to Azure data center
' 4. Microsoft infrastructure processes the document
' 5. Result returned over HTTPS
' 6. You parse the result

Using stream As FileStream = File.OpenRead(imagePath)
    Dim imageData As BinaryData = BinaryData.FromStream(stream) ' Document in memory

    ' This call transmits your document to Azure
    Dim result = Await _client.AnalyzeAsync(
        imageData,           ' Document leaves your network here
        VisualFeatures.Read)
End Using

Uma rede isolada da internet não consegue alcançar o URL do ponto de extremidade — o Visão Computacional do Azure não possui modo offline. Para organizações que operam SCIFs, instalações militares ou ambientes de processamento isolados, o serviço é arquiteturalmente incompatível, independentemente do preço.

Abordagem IronOCR

O IronOCR processa documentos durante o processo de chamada. Não existe conexão de saída:

// IronOCR: data never leaves your infrastructure
using IronOcr;

public class OnPremiseOcrService
{
    private readonly IronTesseract _ocr = new IronTesseract();

    public string ExtractText(string imagePath)
    {
        // Runs entirely in-process
        // Não network call, no serialization to external endpoint
        var result = _ocr.Read(imagePath);
        return result.Text;
    }

    public string ExtractFromPdf(string pdfPath)
    {
        // PDF processed entirely on-premise, native support
        using var input = new OcrInput();
        input.LoadPdf(pdfPath);
        return _ocr.Read(input).Text;
    }

    public string ExtractFromEncryptedPdf(string pdfPath, string password)
    {
        // Encrypted PDFs also stay local
        using var input = new OcrInput();
        input.LoadPdf(pdfPath, Password: password);
        return _ocr.Read(input).Text;
    }
}

// IronOCR: data never leaves your infrastructure
using IronOcr;

public class OnPremiseOcrService
{
    private readonly IronTesseract _ocr = new IronTesseract();

    public string ExtractText(string imagePath)
    {
        // Runs entirely in-process
        // Não network call, no serialization to external endpoint
        var result = _ocr.Read(imagePath);
        return result.Text;
    }

    public string ExtractFromPdf(string pdfPath)
    {
        // PDF processed entirely on-premise, native support
        using var input = new OcrInput();
        input.LoadPdf(pdfPath);
        return _ocr.Read(input).Text;
    }

    public string ExtractFromEncryptedPdf(string pdfPath, string password)
    {
        // Encrypted PDFs also stay local
        using var input = new OcrInput();
        input.LoadPdf(pdfPath, Password: password);
        return _ocr.Read(input).Text;
    }
}

Imports IronOcr

Public Class OnPremiseOcrService
    Private ReadOnly _ocr As New IronTesseract()

    Public Function ExtractText(imagePath As String) As String
        ' Runs entirely in-process
        ' Não network call, no serialization to external endpoint
        Dim result = _ocr.Read(imagePath)
        Return result.Text
    End Function

    Public Function ExtractFromPdf(pdfPath As String) As String
        ' PDF processed entirely on-premise, native support
        Using input As New OcrInput()
            input.LoadPdf(pdfPath)
            Return _ocr.Read(input).Text
        End Using
    End Function

    Public Function ExtractFromEncryptedPdf(pdfPath As String, password As String) As String
        ' Encrypted PDFs also stay local
        Using input As New OcrInput()
            input.LoadPdf(pdfPath, Password:=password)
            Return _ocr.Read(input).Text
        End Using
    End Function
End Class

A implementação do Docker elimina completamente os requisitos de rede de saída:

FROM mcr.microsoft.com/dotnet/aspnet:8.0
RUN apt-get update && apt-get install -y libgdiplus
WORKDIR /app
COPY --from=build /app/publish .
ENV IRONOCR_LICENSE=your-key
# Não Azure endpoint, no API key, no outbound network rules needed
ENTRYPOINT ["dotnet", "YourApp.dll"]

Para entidades abrangidas pela HIPAA, conformidade com o ITAR ou cenários isolados da rede FedRAMP, o IronOCR elimina toda a categoria de risco de processadores de dados terceirizados. Consulte o guia de implantação do Azure para executar o IronOCR na infraestrutura do Azure, mantendo os documentos locais na instância de computação, e o guia de implantação do Docker para configuração do contêiner.

Abordagem de Visão Computacional do Azure

Cada chamada OCR do Azure requer await. O código de produção adiciona lógica de repetição para erros de limite de taxa 429 e erros de serviço 5xx. Uma implementação mínima para produção teria a seguinte aparência:

public async Task<string> RobustExtractAsync(string imagePath)
{
    const int maxRetries = 3;
    int attempt = 0;

    while (attempt < maxRetries)
    {
        try
        {
            using var stream = File.OpenRead(imagePath);
            var imageData = BinaryData.FromStream(stream);

            var result = await _client.AnalyzeAsync(
                imageData,
                VisualFeatures.Read);

            return string.Join("\n",
                result.Value.Read.Blocks
                    .SelectMany(b => b.Lines)
                    .Select(l => l.Text));
        }
        catch (RequestFailedException ex) when (ex.Status == 429)
        {
            // Rate limited — Azure caps S1 at 10 TPS
            attempt++;
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)));
        }
        catch (RequestFailedException ex) when (ex.Status >= 500)
        {
            // Azure service error
            attempt++;
            await Task.Delay(TimeSpan.FromSeconds(1));
        }
        catch (RequestFailedException ex)
        {
            // Client error — bad credential, invalid endpoint
            throw new Exception($"Azure OCR failed: {ex.Message}", ex);
        }
    }

    throw new Exception("Max retries exceeded for Azure OCR");
}

public async Task<string> RobustExtractAsync(string imagePath)
{
    const int maxRetries = 3;
    int attempt = 0;

    while (attempt < maxRetries)
    {
        try
        {
            using var stream = File.OpenRead(imagePath);
            var imageData = BinaryData.FromStream(stream);

            var result = await _client.AnalyzeAsync(
                imageData,
                VisualFeatures.Read);

            return string.Join("\n",
                result.Value.Read.Blocks
                    .SelectMany(b => b.Lines)
                    .Select(l => l.Text));
        }
        catch (RequestFailedException ex) when (ex.Status == 429)
        {
            // Rate limited — Azure caps S1 at 10 TPS
            attempt++;
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)));
        }
        catch (RequestFailedException ex) when (ex.Status >= 500)
        {
            // Azure service error
            attempt++;
            await Task.Delay(TimeSpan.FromSeconds(1));
        }
        catch (RequestFailedException ex)
        {
            // Client error — bad credential, invalid endpoint
            throw new Exception($"Azure OCR failed: {ex.Message}", ex);
        }
    }

    throw new Exception("Max retries exceeded for Azure OCR");
}

Imports System.IO
Imports System.Threading.Tasks

Public Async Function RobustExtractAsync(imagePath As String) As Task(Of String)
    Const maxRetries As Integer = 3
    Dim attempt As Integer = 0

    While attempt < maxRetries
        Try
            Using stream = File.OpenRead(imagePath)
                Dim imageData = BinaryData.FromStream(stream)

                Dim result = Await _client.AnalyzeAsync(
                    imageData,
                    VisualFeatures.Read)

                Return String.Join(vbCrLf,
                    result.Value.Read.Blocks _
                        .SelectMany(Function(b) b.Lines) _
                        .Select(Function(l) l.Text))
            End Using
        Catch ex As RequestFailedException When ex.Status = 429
            ' Rate limited — Azure caps S1 at 10 TPS
            attempt += 1
            Await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)))
        Catch ex As RequestFailedException When ex.Status >= 500
            ' Azure service error
            attempt += 1
            Await Task.Delay(TimeSpan.FromSeconds(1))
        Catch ex As RequestFailedException
            ' Client error — bad credential, invalid endpoint
            Throw New Exception($"Azure OCR failed: {ex.Message}", ex)
        End Try
    End While

    Throw New Exception("Max retries exceeded for Azure OCR")
End Function

Isso não é excesso de engenharia defensiva — é o mínimo exigido para qualquer chamada de API do Azure em produção. Limites de taxa, interrupções de serviço e erros transitórios são situações reais que qualquer consumidor do Azure encontrará.

Abordagem IronOCR

O processamento local elimina a superfície de falha da rede. O escopo do tratamento de erros se restringe ao sistema de arquivos e à validação de entrada:

// Não async required — local processing returns synchronously
public string ExtractText(string imagePath)
{
    var result = new IronTesseract().Read(imagePath);
    return result.Text;
}

// One line for simple cases
public string OneLineOcr(string imagePath)
{
    return new IronTesseract().Read(imagePath).Text;
}

// Confidence-aware extraction
public (string Text, double Confidence) ExtractWithConfidence(string imagePath)
{
    var result = new IronTesseract().Read(imagePath);
    return (result.Text, result.Confidence);
}

// Não async required — local processing returns synchronously
public string ExtractText(string imagePath)
{
    var result = new IronTesseract().Read(imagePath);
    return result.Text;
}

// One line for simple cases
public string OneLineOcr(string imagePath)
{
    return new IronTesseract().Read(imagePath).Text;
}

// Confidence-aware extraction
public (string Text, double Confidence) ExtractWithConfidence(string imagePath)
{
    var result = new IronTesseract().Read(imagePath);
    return (result.Text, result.Confidence);
}

Imports IronTesseract

Public Class OcrProcessor
    ' Não async required — local processing returns synchronously
    Public Function ExtractText(imagePath As String) As String
        Dim result = New IronTesseract().Read(imagePath)
        Return result.Text
    End Function

    ' One line for simple cases
    Public Function OneLineOcr(imagePath As String) As String
        Return New IronTesseract().Read(imagePath).Text
    End Function

    ' Confidence-aware extraction
    Public Function ExtractWithConfidence(imagePath As String) As (Text As String, Confidence As Double)
        Dim result = New IronTesseract().Read(imagePath)
        Return (result.Text, result.Confidence)
    End Function
End Class

No RequestFailedException, sem loops de tente novamente, sem coordenação Task.WhenAll para trabalhos em lote. Se você precisar de assíncrono para integração com um pipeline de controlador assíncrono, Task.Run(() => ocr.Read(path)) envolve a chamada síncrona sem alterações estruturais à lógica do OCR em si. A referência da API do IronTesseract abrange toda a interface síncrona. Para cargas de trabalho que realmente precisam de padrões assíncronos, o IronOCR também fornece um guia de OCR assíncrono dedicado.

Abordagem de Visão Computacional do Azure

Sequência de configuração do Azure antes de escrever qualquer código OCR:

1. Crie uma conta do Azure, caso ainda não possua uma.
2. Acesse o portal do Azure e crie um recurso dos Serviços Cognitivos (ou um recurso dos Serviços de IA do Azure).
3. Selecione um nível de preço e uma região.
4. Copie o URL do endpoint (formato: https://your-resource.cognitiveservices.azure.com/).
5. Copie uma das duas chaves de API.
6. Armazene ambos os valores de maneira segura — em variáveis de ambiente, Azure Key Vault, ou appsettings.json (somente não-produção).
7. Instale Azure.AI.Vision.ImageAnalysis via NuGet.
8. Inicialize ImageAnalysisClient com o endpoint e a credencial.

Para o processamento de PDF, repita os passos 2-8 para um recurso Form Recognizer com um pacote NuGet diferente (Azure.AI.FormRecognizer) e uma classe de cliente diferente (DocumentAnalysisClient).

O appsettings.json armazena endpoint e chave:

{
  "Azure": {
    "ComputerVision": {
      "Endpoint": "https://your-resource.cognitiveservices.azure.com/",
      "ApiKey": "your-api-key"
    }
  }
}

A rotação de chaves de API, o gerenciamento da expiração de credenciais e a administração de URLs de endpoints em diferentes ambientes (desenvolvimento, teste e produção) são tarefas operacionais contínuas sem equivalente no processamento local.

Abordagem IronOCR

O guia de configuração do IronTesseract reduz a configuração a duas etapas:

dotnet add package IronOcr

// Set once at application startup — environment variable recommended
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

// Then use immediately — no endpoint, no credential rotation, no portal setup
var text = new IronTesseract().Read("document.jpg").Text;

// Set once at application startup — environment variable recommended
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

// Then use immediately — no endpoint, no credential rotation, no portal setup
var text = new IronTesseract().Read("document.jpg").Text;

Imports System

' Set once at application startup — environment variable recommended
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")

' Then use immediately — no endpoint, no credential rotation, no portal setup
Dim text As String = (New IronTesseract()).Read("document.jpg").Text

A chave de licença é uma sequência estática. Não expira por solicitação, não requer rotação e não envia dados para validação após a ativação. Os ambientes de implantação não precisam de regras de firewall de saída para que o OCR funcione.

Requisitos de conformidade Bloqueiam o processamento em nuvem

Uma empresa de software independente (ISV) da área da saúde que está desenvolvendo um sistema de gerenciamento de documentos começa usando o Visão Computacional do Azure porque ele permite uma integração rápida. Então chega o primeiro cliente Enterprise — um sistema hospitalar com um responsável pela segurança HIPAA que faz duas perguntas: "Para onde vão nossas informações de saúde protegidas?" e "Vocês podem nos mostrar o Acordo de Parceiro Comercial (BAA) que cobre esse terceiro?". O Azure possui um BAA, mas a resposta à primeira pergunta — "data centers da Microsoft" — desencadeia uma longa revisão de segurança, uma solicitação de relatórios de auditoria da Microsoft e um cronograma de conformidade que atrasa o contrato. A mudança para o IronOCR remove a pergunta por completo. As informações de saúde protegidas (PHI) nunca saem do ambiente do cliente. O âmbito da conformidade permanece restrito à própria organização do cliente.

O crescimento do volume torna a precificação por transação insustentável.

Uma equipe de operações inicia um pipeline de processamento de faturas com capacidade para 5.000 documentos por mês — confortavelmente dentro do nível gratuito do Azure. À medida que o volume cresce, os custos por transação se acumulam com cada documento processado.IronOCR Professional ($2,999) é uma compra única sem taxas por documento. Equipes que projetam um crescimento de volume, mesmo que moderado, atingem o ponto de equilíbrio rapidamente, após o qual cada documento adicional representa economia.

A latência da rede afeta os SLAs de processamento.

Um serviço de processamento de documentos tem como meta um SLA de ponta a ponta de 2 segundos. O Visão Computacional do Azure adiciona de 200 a 800 ms de latência de rede para chamadas na mesma região e de 500 a 2000 ms para implantações entre regiões diferentes — antes mesmo do cálculo do OCR. Sob carga, o limite de taxa de 10 TPS no S1 força o enfileiramento, o que aumenta ainda mais a latência. O IronOCR processa uma única imagem de 300 DPI em 100 a 400 ms em hardware de servidor comum, sem filas, sem limite de taxa e sem saltos de rede. O SLA torna-se previsível porque depende apenas do hardware, e não da integridade do serviço Azure ou das condições da rede.

Requisitos de infraestrutura isolada da internet

Empresas contratadas pela área de defesa, agências de inteligência e operadores de infraestrutura crítica executam cargas de trabalho em redes que, por projeto, não possuem conectividade com a internet. O Visão Computacional do Azure é tecnicamente incompatível com esses ambientes — o ponto de extremidade não pode ser alcançado. As equipes nesses setores precisam de uma biblioteca que seja implantada como um binário independente, opere sem qualquer conexão de saída e passe por revisões de segurança que proíbam explicitamente a transmissão de dados para a nuvem. A implementação do IronOCR em Linux e o suporte ao Docker permitem que ele seja implantado em ambientes restritos sem modificações.

Simplificando a implantação em múltiplos ambientes

Uma equipe que gerencia ambientes de desenvolvimento, teste e produção para um aplicativo SaaS possui três recursos do Azure Cognitive Services, três conjuntos de chaves de API e três URLs de endpoint — cada um exigindo armazenamento seguro, políticas de rotação e configuração específica do ambiente. Todo ambiente de implantação precisa de acesso de rede de saída para o Azure.IronOCR reduz a configuração por ambiente para uma variável de ambiente (IRONOCR_LICENSE), elimina o requisito de acesso à rede e remove o overhead operacional do gerenciamento de credenciais entre ambientes.

Padrão Assíncrono para Síncrono

O código do consumidor Azure é async por necessidade. O IronOCR não requer modo assíncrono, mas a transição é mecânica. Substitua os tipos de retorno async Task<string> por string, remova palavras-chave await e async e exclua o loop de tentativa. Se o método de chamada for um controlador ASP.NET ou serviço que deve permanecer assíncrono, envolva a chamada IronOCR em Task.Run:

// Before: Azure async chain
public async Task<string> ReadTextAsync(string imagePath)
{
    using var stream = File.OpenRead(imagePath);
    var data = BinaryData.FromStream(stream);
    var result = await _client.AnalyzeAsync(data, VisualFeatures.Read);
    return string.Join("\n", result.Value.Read.Blocks
        .SelectMany(b => b.Lines)
        .Select(l => l.Text));
}

// After:IronOCR synchronous
public string ReadText(string imagePath)
{
    return new IronTesseract().Read(imagePath).Text;
}

// If async signature must be preserved for interface compatibility
public Task<string> ReadTextAsync(string imagePath)
{
    return Task.Run(() => new IronTesseract().Read(imagePath).Text);
}

// Before: Azure async chain
public async Task<string> ReadTextAsync(string imagePath)
{
    using var stream = File.OpenRead(imagePath);
    var data = BinaryData.FromStream(stream);
    var result = await _client.AnalyzeAsync(data, VisualFeatures.Read);
    return string.Join("\n", result.Value.Read.Blocks
        .SelectMany(b => b.Lines)
        .Select(l => l.Text));
}

// After:IronOCR synchronous
public string ReadText(string imagePath)
{
    return new IronTesseract().Read(imagePath).Text;
}

// If async signature must be preserved for interface compatibility
public Task<string> ReadTextAsync(string imagePath)
{
    return Task.Run(() => new IronTesseract().Read(imagePath).Text);
}

Imports System.IO
Imports System.Threading.Tasks
Imports System.Linq

' Before: Azure async chain
Public Async Function ReadTextAsync(imagePath As String) As Task(Of String)
    Using stream = File.OpenRead(imagePath)
        Dim data = BinaryData.FromStream(stream)
        Dim result = Await _client.AnalyzeAsync(data, VisualFeatures.Read)
        Return String.Join(vbLf, result.Value.Read.Blocks _
            .SelectMany(Function(b) b.Lines) _
            .Select(Function(l) l.Text))
    End Using
End Function

' After: IronOCR synchronous
Public Function ReadText(imagePath As String) As String
    Return New IronTesseract().Read(imagePath).Text
End Function

' If async signature must be preserved for interface compatibility
Public Function ReadTextAsync(imagePath As String) As Task(Of String)
    Return Task.Run(Function() New IronTesseract().Read(imagePath).Text)
End Function

Normalização da Escala de Confiança

Azure Computer Vision retorna confiança em palavras como um float entre 0 e 1.IronOCR retorna confiança como um double em uma escala de 0-100. Qualquer código que utilize limites para valores de confiança do Azure precisa ser ajustado:

// Azure: confidence is 0.0 - 1.0
foreach (var word in line.Words)
{
    if (word.Confidence > 0.85f) { /* high confidence */ }
}

// IronOCR: confidence is 0 - 100
var result = new IronTesseract().Read(imagePath);
foreach (var word in result.Words)
{
    if (word.Confidence > 85.0) { /* equivalent threshold */ }
}
Console.WriteLine($"Overall: {result.Confidence}%");

// Azure: confidence is 0.0 - 1.0
foreach (var word in line.Words)
{
    if (word.Confidence > 0.85f) { /* high confidence */ }
}

// IronOCR: confidence is 0 - 100
var result = new IronTesseract().Read(imagePath);
foreach (var word in result.Words)
{
    if (word.Confidence > 85.0) { /* equivalent threshold */ }
}
Console.WriteLine($"Overall: {result.Confidence}%");

Imports IronOcr

' Azure: confidence is 0.0 - 1.0
For Each word In line.Words
    If word.Confidence > 0.85F Then
        ' high confidence
    End If
Next

' IronOCR: confidence is 0 - 100
Dim result = New IronTesseract().Read(imagePath)
For Each word In result.Words
    If word.Confidence > 85.0 Then
        ' equivalent threshold
    End If
Next
Console.WriteLine($"Overall: {result.Confidence}%")

A documentação de referência da API OcrResult contém todas as propriedades dos resultados, incluindo a escala de confiança. O guia prático sobre índices de confiança aborda a seleção de limiares e a interpretação de cada elemento.

Consolidação do serviço de processamento de PDF

O Azure divide o OCR de imagens e o OCR de PDFs em dois serviços separados, com clientes, pacotes NuGet e configurações de endpoint distintos. Migrar significa consolidar ambos os caminhos em uma única instância IronTesseract. O método OcrInput.LoadPdf aceita um caminho de arquivo, stream, ou matriz de bytes, com um parâmetro Password opcional para arquivos criptografados — nenhum segundo cliente é necessário:

// Before: Two separate Azure clients for images vs PDFs
// Image: ImageAnalysisClient + AnalyzeAsync
// PDF:   DocumentAnalysisClient + AnalyzeDocumentAsync(WaitUntil.Completed, ...)

// After: One IronTesseract instance handles both
var ocr = new IronTesseract();

// Image
var imageResult = ocr.Read("document.jpg");

// PDF (same client, same Read method)
using var pdfInput = new OcrInput();
pdfInput.LoadPdf("document.pdf");
var pdfResult = ocr.Read(pdfInput);

// Password-protected PDF
using var encInput = new OcrInput();
encInput.LoadPdf("secured.pdf", Password: "secret");
var encResult = ocr.Read(encInput);

// Saída em PDF pesquisável — no manual construction
pdfResult.SaveAsSearchablePdf("searchable-output.pdf");

// Before: Two separate Azure clients for images vs PDFs
// Image: ImageAnalysisClient + AnalyzeAsync
// PDF:   DocumentAnalysisClient + AnalyzeDocumentAsync(WaitUntil.Completed, ...)

// After: One IronTesseract instance handles both
var ocr = new IronTesseract();

// Image
var imageResult = ocr.Read("document.jpg");

// PDF (same client, same Read method)
using var pdfInput = new OcrInput();
pdfInput.LoadPdf("document.pdf");
var pdfResult = ocr.Read(pdfInput);

// Password-protected PDF
using var encInput = new OcrInput();
encInput.LoadPdf("secured.pdf", Password: "secret");
var encResult = ocr.Read(encInput);

// Saída em PDF pesquisável — no manual construction
pdfResult.SaveAsSearchablePdf("searchable-output.pdf");

Imports IronOcr

' Before: Two separate Azure clients for images vs PDFs
' Image: ImageAnalysisClient + AnalyzeAsync
' PDF:   DocumentAnalysisClient + AnalyzeDocumentAsync(WaitUntil.Completed, ...)

' After: One IronTesseract instance handles both
Dim ocr As New IronTesseract()

' Image
Dim imageResult = ocr.Read("document.jpg")

' PDF (same client, same Read method)
Using pdfInput As New OcrInput()
    pdfInput.LoadPdf("document.pdf")
    Dim pdfResult = ocr.Read(pdfInput)

    ' Saída em PDF pesquisável — no manual construction
    pdfResult.SaveAsSearchablePdf("searchable-output.pdf")
End Using

' Password-protected PDF
Using encInput As New OcrInput()
    encInput.LoadPdf("secured.pdf", Password:="secret")
    Dim encResult = ocr.Read(encInput)
End Using

O guia de entrada de PDF aborda a seleção de intervalo de páginas, a entrada de fluxo e o pipeline de renderização de PDF nativo. Para entradas de imagem, consulte o guia de entrada de imagem .

Extração de dados estruturados sem reconhecimento de formulários

Equipes usando os modelos predefinidos do Form Recognizer (faturas, recibos, documentos de identidade) para extração de campo precisam replicar essa lógica de extração no IronOCR usando OCR baseado em região com CropRectangle. A extração posicional é explícita, e não baseada em modelo:

// Form Recognizer extracted named fields automatically
// IronOCR: define extraction zones for known document layouts
var ocr = new IronTesseract();

// Define regions matching the document template
var vendorZone   = new CropRectangle(0,   0,   300, 100);
var invoiceDate  = new CropRectangle(400, 0,   200, 50);
var totalAmount  = new CropRectangle(400, 500, 200, 100);

string vendor, date, total;

using (var input = new OcrInput())
{
    input.LoadImage("invoice.jpg", vendorZone);
    vendor = ocr.Read(input).Text.Trim();
}

using (var input = new OcrInput())
{
    input.LoadImage("invoice.jpg", invoiceDate);
    date = ocr.Read(input).Text.Trim();
}

using (var input = new OcrInput())
{
    input.LoadImage("invoice.jpg", totalAmount);
    total = ocr.Read(input).Text.Trim();
}

// Form Recognizer extracted named fields automatically
// IronOCR: define extraction zones for known document layouts
var ocr = new IronTesseract();

// Define regions matching the document template
var vendorZone   = new CropRectangle(0,   0,   300, 100);
var invoiceDate  = new CropRectangle(400, 0,   200, 50);
var totalAmount  = new CropRectangle(400, 500, 200, 100);

string vendor, date, total;

using (var input = new OcrInput())
{
    input.LoadImage("invoice.jpg", vendorZone);
    vendor = ocr.Read(input).Text.Trim();
}

using (var input = new OcrInput())
{
    input.LoadImage("invoice.jpg", invoiceDate);
    date = ocr.Read(input).Text.Trim();
}

using (var input = new OcrInput())
{
    input.LoadImage("invoice.jpg", totalAmount);
    total = ocr.Read(input).Text.Trim();
}

Imports IronOcr

' Form Recognizer extracted named fields automatically
' IronOCR: define extraction zones for known document layouts
Dim ocr As New IronTesseract()

' Define regions matching the document template
Dim vendorZone As New CropRectangle(0, 0, 300, 100)
Dim invoiceDate As New CropRectangle(400, 0, 200, 50)
Dim totalAmount As New CropRectangle(400, 500, 200, 100)

Dim vendor As String
Dim [date] As String
Dim total As String

Using input As New OcrInput()
    input.LoadImage("invoice.jpg", vendorZone)
    vendor = ocr.Read(input).Text.Trim()
End Using

Using input As New OcrInput()
    input.LoadImage("invoice.jpg", invoiceDate)
    [date] = ocr.Read(input).Text.Trim()
End Using

Using input As New OcrInput()
    input.LoadImage("invoice.jpg", totalAmount)
    total = ocr.Read(input).Text.Trim()
End Using

O guia de OCR baseado em região cobre o uso do CropRectangle em detalhe. Para fluxos de trabalho específicos de faturas, o tutorial de OCR para faturas demonstra o padrão de extração completo.