Azure Computer Vision OCR vs IronOCR: .NET OCR

The Async Polling Pattern

The Read API's async requirement creates structural code consequences. Image analysis using AnalyzeAsync returns immediately but requires await; PDF processing through Form Recognizer requires WaitUntil.Completed to block until the operation finishes, or custom polling with UpdateStatusAsync for true async behavior. The result hierarchy then requires traversing blocks, lines, and words through nested loops:

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

PDF processing escalates the complexity further — a separate DocumentAnalysisClient with its own endpoint, AnalyzeDocumentAsync with WaitUntil.Completed, and a different result shape using result.Pages and page.Lines accessing .Content instead of .Text.

Detailed Feature Comparison

Azure Computer Vision Approach

Azure bills per transaction using tiered pricing based on volume. Consult the Azure Computer Vision pricing page for current rates. Each PDF page is one transaction. A 10-page PDF is 10 billable calls. A free tier of 5,000 transactions per month is available.

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

At moderate to high document volumes, the IronOCR perpetual license pays for itself quickly compared to ongoing Azure transaction costs, after which every additional document is savings.

IronOCR Approach

IronOCR's pricing model is a single number. Install the NuGet package, set the license key, and process any volume without a counter ticking:

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

No metering, no usage tracking, no budget alerts needed. Predictable costs from day one. See the reading text from images tutorial for a complete getting-started walkthrough.

Azure Computer Vision Approach

Even with regional endpoint selection and a signed Business Associate Agreement, the data flow is fixed:

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

An air-gapped network cannot reach the endpoint URL at all — Azure Computer Vision has no offline mode. For organizations running SCIFs, military installations, or isolated processing environments, the service is architecturally incompatible regardless of pricing.

IronOCR Approach

IronOCR processes documents within the calling process. There is no outbound connection:

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

The Docker deployment removes outbound network requirements entirely:

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
# No Azure endpoint, no API key, no outbound network rules needed
ENTRYPOINT ["dotnet", "YourApp.dll"]

For HIPAA-covered entities, ITAR compliance, or FedRAMP air-gapped scenarios, IronOCR eliminates the entire category of third-party data processor risk. See the Azure deployment guide for running IronOCR within Azure infrastructure while keeping documents local to the compute instance, and the Docker deployment guide for container configuration.

Azure Computer Vision Approach

Every Azure OCR call requires async/await. Production code adds retry logic for 429 rate-limit errors and 5xx service errors. A minimal production implementation looks like this:

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

This is not defensive over-engineering — it is the minimum required for any Azure API call in production. Rate limits, service outages, and transient errors are real conditions any Azure consumer will encounter.

IronOCR Approach

Local processing eliminates the network failure surface. The error handling scope narrows to file system and input validation:

// No 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);
}

// No 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);
}

Public Function ExtractText(imagePath As String) As String
    Dim result = New IronTesseract().Read(imagePath)
    Return result.Text
End Function

Public Function OneLineOcr(imagePath As String) As String
    Return New IronTesseract().Read(imagePath).Text
End Function

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

No RequestFailedException, no retry loops, no Task.WhenAll coordination for batch jobs. If you need async for integration with an async controller pipeline, Task.Run(() => ocr.Read(path)) wraps the synchronous call without structural changes to the OCR logic itself. The IronTesseract API reference covers the full synchronous interface. For workloads that genuinely need async patterns, IronOCR also provides a dedicated async OCR guide.

Azure Computer Vision Approach

The Azure setup sequence before writing any OCR code:

1. Create an Azure account if one does not exist.
2. Navigate to the Azure portal and create a Cognitive Services resource (or an Azure AI Services resource).
3. Select a pricing tier and region.
4. Copy the endpoint URL (format: https://your-resource.cognitiveservices.azure.com/).
5. Copy one of the two API keys.
6. Store both values securely — in environment variables, Azure Key Vault, or appsettings.json (non-production only).
7. Install Azure.AI.Vision.ImageAnalysis via NuGet.
8. Initialize ImageAnalysisClient with the endpoint and credential.

For PDF processing, repeat steps 2-8 for a Form Recognizer resource with a different NuGet package (Azure.AI.FormRecognizer) and a different client class (DocumentAnalysisClient).

The appsettings.json stores endpoint and key:

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

Rotating API keys, handling credential expiration, and managing endpoint URLs across environments (dev, staging, production) are ongoing operational tasks with no equivalent in local processing.

IronOCR Approach

The IronTesseract setup guide reduces setup to two steps:

dotnet add package IronOcr

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

The license key is a static string. It does not expire per request, does not require rotation, and does not call home for validation after activation. Deployment environments need no outbound firewall rules for OCR to function.

Compliance Requirements Block Cloud Processing

A healthcare ISV building a document management system starts on Azure Computer Vision because it is fast to integrate. Then the first enterprise customer arrives — a hospital system with a HIPAA security officer who asks two questions: "Where does our PHI go?" and "Can you show us the Business Associate Agreement covering that third party?" Azure has a BAA, but the answer to the first question — "Microsoft data centers" — triggers a lengthy security review, a request for Microsoft's audit reports, and a compliance timeline that delays the contract. Switching to IronOCR removes the question entirely. PHI never leaves the customer's environment. The compliance scope stays within the customer's own organization.

Volume Growth Makes Per-Transaction Pricing Untenable

An operations team launches an invoice processing pipeline at 5,000 documents per month — comfortably within Azure's free tier. As volume grows, per-transaction costs accumulate with every document processed. IronOCR Professional ($2,999) is a one-time purchase with no per-document fees. Teams that project even moderate volume growth reach break-even quickly, after which every additional document is savings.

Network Latency Affects Processing SLAs

A document processing service targets a 2-second end-to-end SLA. Azure Computer Vision adds 200-800ms of network latency for same-region calls and 500-2000ms for cross-region deployments — before the OCR computation itself. Under load, the 10 TPS rate limit on S1 forces queuing, which inflates latency further. IronOCR processes a single 300 DPI image in 100-400ms on commodity server hardware with no queue, no rate cap, and no network hop. The SLA becomes predictable because it depends only on hardware, not on Azure service health or network conditions.

Air-Gapped Infrastructure Requirements

Defense contractors, intelligence agencies, and critical infrastructure operators run workloads on networks with no internet connectivity by design. Azure Computer Vision is technically incompatible with these environments — the endpoint cannot be reached. Teams in these sectors need a library that deploys as a self-contained binary, operates without any outbound connection, and passes security reviews that explicitly prohibit cloud data transmission. IronOCR's Linux deployment and Docker support make it deployable in restricted environments without modification.

Simplifying Multi-Environment Deployment

A team managing dev, staging, and production environments for a SaaS application carries three Azure Cognitive Services resources, three sets of API keys, and three endpoint URLs — each requiring secure storage, rotation policies, and environment-specific configuration. Every deployment environment needs outbound network access to Azure. IronOCR reduces the per-environment configuration to one environment variable (IRONOCR_LICENSE), eliminates the network access requirement, and removes the operational overhead of credential management across environments.

Async to Synchronous Pattern

Azure Consumer code is async by necessity. IronOCR does not require async, but the transition is mechanical. Replace async Task<string> return types with string, remove await and async keywords, and delete the retry loop. If the calling method is an ASP.NET controller or service that must remain async, wrap the IronOCR call in 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

Confidence Scale Normalization

Azure Computer Vision returns word confidence as a float between 0 and 1. IronOCR returns confidence as a double on a 0-100 scale. Any code that thresholds on Azure confidence values needs adjustment:

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

The OcrResult API reference documents all result properties including the confidence scale. The confidence scores how-to guide covers threshold selection and per-element interpretation.

PDF Processing Service Consolidation

Azure splits image OCR and PDF OCR across two separate services with separate clients, NuGet packages, and endpoint configurations. Migrating means consolidating both paths into a single IronTesseract instance. The OcrInput.LoadPdf method accepts a file path, stream, or byte array, with an optional Password parameter for encrypted files — no second client required:

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

// Searchable PDF output — 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);

// Searchable PDF output — 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)

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

    ' Searchable PDF output — no manual construction
    pdfResult.SaveAsSearchablePdf("searchable-output.pdf")
End Using

The PDF input guide covers page range selection, stream input, and the native PDF rendering pipeline. For image inputs, see the image input guide.

Structured Data Extraction Without Form Recognizer

Teams using Form Recognizer's prebuilt models (invoices, receipts, identity documents) for field extraction need to replicate that extraction logic in IronOCR using region-based OCR with CropRectangle. The positional extraction is explicit rather than model-based:

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

The region-based OCR guide covers CropRectangle usage in detail. For invoice-specific workflows, the invoice OCR tutorial demonstrates the full extraction pattern.