Le modèle de tarification par page de AWS Textret peut sembler peu coûteux à faible volume, mais les coûts se cumulent indéfiniment à l'échelle. Chaque document traité par votre application quitte votre réseau, se rend dans un centre de données Amazon, est traité par l'infrastructure Amazon, et la facture se cumule indéfiniment. Pour les équipes qui évaluent les options OCR en .NET, la question n'est pas seulement de savoir si Textract produit des résultats précis — c'est le cas — mais si le modèle de coût par page, la transmission obligatoire vers le cloud et l'architecture d'interrogation asynchrone pour les documents multipages correspondent aux besoins réels de votre application.

Comprendre AWS Textreat

AWS Textract est le service d'analyse de documents géré par Amazon, accessible via le SDK AWS for .NET grâce au package NuGet AWSSDK.Textract. Elle fonctionne comme une API cloud : votre application envoie des données de document à l'infrastructure d'Amazon et reçoit des résultats structurés. Ce service nécessite un compte AWS, des identifiants IAM avec les autorisations Textret et une connexion Internet pour chaque opération OCR.

Textract propose plusieurs modes d'analyse distincts, chacun ayant son propre prix :

• DetectDocumentText: Extraction de texte basique (voir tarification AWS Textract pour les taux par page actuels)
• AnalyzeDocument (Tables): Extraction de tables structurées à un taux par page supérieur à celui du texte basique
• AnalyzeDocument (Forms): Extraction de formulaires clé-valeur à un taux par page supérieur à celui de l'extraction de tables
• AnalyzeExpense : Analyse des factures et des reçus à 0,01 $ par page
• AnalyzeID : Extraction de documents d'identité à 0,025 $ par page
• StartDocumentTextDetection / StartDocumentAnalysis : API asynchrone requise pour tout PDF multipage, nécessitant un compartiment de transit S3, l'interrogation régulière des tâches et la pagination des résultats.

Le modèle de résultat utilise une liste plate d'objets Block avec des identifiants de relation qui doivent être parcourus pour reconstruire des tables, des formulaires ou tout autre résultat structuré. Une extraction simple de table nécessite l'itération des blocs BlockType.TABLE, la recherche des blocs enfants BlockType.CELL via les identifiants de relation RelationshipType.CHILD, puis la récupération des blocs BlockType.WORD pour le texte de chaque cellule. Ce modèle de graphe de relations gère des structures de documents complexes, mais il n'est pas léger.

Le pipeline S3-asynchrone

L'OCR sur une seule image via DetectDocumentTextAsync peut passer les octets du document directement dans la requête. Les PDF multi-pages ne peuvent pas. Tout fichier PDF nécessite le pipeline asynchrone complet :

// AWS Textract: PDF multipage 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: Toujours clean up S3
        await _s3Client.DeleteObjectAsync(_bucketName, key);
    }
}

// AWS Textract: PDF multipage 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: Toujours clean up S3
        await _s3Client.DeleteObjectAsync(_bucketName, key);
    }
}

C'est la mise en œuvre minimale viable pour un traitement PDF fiable — cinq phases distinctes, deux clients de service AWS, et une logique de nettoyage dans un bloc finally. La version de production complète avec une gestion des erreurs appropriée, une logique de nouvelle tentative de limitation du débit et une gestion des délais d'expiration s'exécute sur 150 à 300 lignes.

Comprendre IronOCR

IronOCR est une bibliothèque OCR .NET commerciale qui s'exécute entièrement sur votre infrastructure. Il intègre un moteur Tesseract 5 optimisé avec prétraitement automatique des images, prise en charge native du format PDF et une API synchrone qui produit des résultats directement sans appels de service externes ni étapes intermédiaires.

Caractéristiques clés de l'architecture IronOCR :

• Traitement local uniquement : aucune donnée de document ne quitte la machine exécutant votre application
• Un seul package NuGet : dotnet add package IronOcr installe tout, y compris les binaires natifs
• Prétraitement automatique : le redressement, la réduction du bruit, l'amélioration du contraste, la binarisation et la mise à l'échelle de la résolution sont effectués automatiquement sur les entrées de mauvaise qualité.
• Prise en charge native des fichiers PDF : lit les PDF directement via le chemin d'accès ou le flux, sans transit S3 ni tâches asynchrones.
• Sécurité des threads : Une seule instance de IronTesseract gère les requêtes concurrentes à travers des threads sans contention
• Licences perpétuelles : $999 Lite / $1,499 Plus / $2,399 Professional / $4,799 Unlimited — un paiement, pas de frais par page, pas de mesure d'utilisation
• Plus de 125 modules linguistiques : installés sous forme de packages NuGet distincts, chargés localement, sans appel réseau

Comparaison des fonctionnalités

Comparaison détaillée des fonctionnalités

Coût à l'échelle

Le modèle de tarification par page est la contrainte structurelle déterminante d'AWS Textract. Des coûts qui semblent petits par page s'accumulent de manière significative dans un flux de travail documentaire réel.

Approche AWS Textreat

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

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

Consultez la page de tarification d'AWS Textract pour les taux par page actuels. Les différentes fonctionnalités de l'API (détection de texte basique, extraction de tables, extraction de formulaires) ont des tarifs différents. Un document contenant des tables et des champs de formulaire entraîne des coûts plus élevés que la détection de texte basique, et les coûts augmentent avec le volume sans limite supérieure et sans moyen de payer à l'avance.

À volumes élevés de pages, les coûts totaux sur trois ans peuvent être substantiels, et le compteur continue à tourner.

Approche d'IronOCR

// One license. Non 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. Non 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;

La licence $2,399 Professional couvre 10 développeurs, des projets illimités et un volume de pages illimité. Après la première année, les coûts récurrents liés au traitement des pages sont nuls. Pour les équipes traitant des volumes de pages importants, la licence IronOCR rentabilise rapidement par rapport aux frais par page continus dans le cloud.

La page de licence IronOCR détaille les différents niveaux de service, les options d'abonnement SaaS pour les scénarios de facturation basés sur l'utilisation et les conditions de redistribution OEM.

Souveraineté et conformité des données

L'architecture d'AWS Textreat rend une garantie impossible : que vos documents restent au sein de votre infrastructure. Chaque opération OCR transmet le contenu des documents aux serveurs d'Amazon.

Approche AWS Textreat

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

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

Public Class DocumentProcessor
    Private _client As AmazonTextractClient

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

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

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

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

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

AWS propose un accord de partenariat commercial HIPAApour les entités concernées, et les régions GovCloud offrent une autorisation FedRAMP de niveau élevé. Ces cadres ne modifient pas l'architecture fondamentale : les documents quittent votre infrastructure pour chaque opération. Pour les données techniques soumises à la réglementation ITAR, il ne s'agit pas d'une nuance de conformité, mais d'une interdiction. Pour les charges de travail CMMC de niveau 3 avec CUI, la transmission vers le cloud nécessite des autorisations spécifiques que la plupart des entreprises de défense ne possèdent pas. Pour les systèmes à isolation par air — réseaux de recherche, environnements de contrôle industriel, installations classifiées — Textract est tout simplement indisponible.

AWS Textract est disponible dans six régions : us-east-1, us-west-2, eu-west-1, eu-west-2, ap-southeast-1, et ap-southeast-2. Les organisations soumises à des exigences de résidence des données en dehors de ces régions n'ont aucune option conforme.

Approche d'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

' 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

Comme IronOCR s'exécute localement, il s'intègre naturellement aux flux de travail des établissements de santé traitant les informations de santé protégées, aux systèmes de documents juridiques gérant les communications confidentielles, aux applications financières traitant les images de cartes de paiement et aux pipelines des entreprises de défense traitant les informations non classifiées contrôlées. Il n'y a pas de sous-traitant externe à auditer, pas d'accord de partenariat commercial à négocier, pas de contrainte de résidence des données à respecter. Le périmètre de conformité correspond à l'infrastructure propre à votre organisation.

Pour les équipes déployant sur une infrastructure AWS mais nécessitant un traitement local, IronOCR fonctionne sur AWS EC2 et Lambda sans aucune dépendance à Textract — le traitement s'effectue au sein de votre propre compte AWS plutôt que via le service géré d'Amazon.

Interrogation asynchrone vs. traitement synchrone

La séparation architecturale entre les API synchrones (image unique) et asynchrones (PDF multipage) de Textract n'est pas un détail mineur de l'API. Cela détermine la manière dont les services sont construits, dont les erreurs sont gérées et la quantité de code que les responsables de la maintenance doivent lire et analyser.

Approche AWS Textreat

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

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

Il ne s'agit pas d'un code standard que l'on peut générer et oublier. Lorsqu'une tâche Textret échoue en cours d'exécution, le nettoyage S3 doit tout de même s'exécuter. Lorsqu'une tâche expire après 10 minutes, l'appelant a besoin d'un message d'erreur clair. En cas de coupure réseau pendant l'interrogation, la stratégie de nouvelle tentative ne doit pas créer de tâches en double. Chacun de ces modes de défaillance nécessite un traitement explicite — la structure présentée ci-dessus constitue l'implémentation minimale responsable.

Le traitement par lots ajoute une autre couche : la limite TPS par défaut de Textract est de 5 requêtes par seconde. Traiter 100 documents nécessite une limitation SemaphoreSlim, un minuteur de réapprovisionnement et une logique de reprise pour ProvisionedThroughputExceededException.

Approche d'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

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

Il n'y a pas de boucle d'interrogation, pas de suivi des identifiants de tâches, pas de compartiment S3, pas de pagination des résultats. Le même code permet de gérer un fichier JPEG et un PDF de 200 pages. Le traitement s'achève ou génère une exception — aucun état intermédiaire " en cours " à gérer. Pour le traitement par lots, IronOCR est thread-safe et une seule instance IronTesseract gère Parallel.ForEach sans verrous ou sémaphores.

Le guide d'installation d'IronTesseract couvre la configuration, et le guide d'entrée PDF documente la sélection de la plage de pages, les PDF protégés par mot de passe et l'entrée basée sur le flux pour les PDF récupérés à partir de bases de données ou de réponses HTTP.

Frais généraux de gestion des identifiants

Le lancement d'une opération OCR avec AWS Textret nécessite une configuration IAM avant le traitement d'une seule page.

Approche AWS Textreat

Avant d'appeler DetectDocumentTextAsync, un développeur doit :

1. Créez un compte AWS ou obtenez l'accès à un compte existant.
2. Créer un utilisateur ou un rôle IAM avec les autorisations textract:DetectDocumentText et textract:AnalyzeDocument
3. Générer et stocker en toute sécurité l'identifiant de clé d'accès et la clé d'accès secrète
4. Configurez la résolution des informations d'identification : variables d'environnement, fichier d'informations d'identification AWS ou profil d'instance EC2
5. Si vous traitez des PDF : créez un bucket S3, configurez la politique du bucket, ajoutez les autorisations s3:PutObject et s3:DeleteObject
6. Mettre en œuvre des politiques de rotation des identifiants pour respecter les normes de sécurité
7. Stockez les informations d'identification en toute sécurité dans chaque environnement de déploiement : secrets Docker, secrets Kubernetes, AWS Secrets Manager ou variables de pipeline 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

' 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

Lorsque les identifiants expirent, tournent ou sont mal configurés, chaque appel OCR échoue avec AmazonTextractException portant ErrorCode == "AccessDeniedException". Dans un système de production, cela signifie mettre en œuvre des blocs de gestion spécifiques pour les échecs d'authentification et surveiller les dérives des politiques IAM.

Approche d'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")

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

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

La clé de licence est une chaîne de caractères statique. Il n'expire pas en cours d'utilisation, ne nécessite pas de rotation et ne requiert aucune autorisation de gestion. Un conteneur Dockerqui traite des documents n'a pas besoin d'informations d'identification AWS injectées, d'un rôle IAM lié à un contexte d'exécution, ni d'un accès réseau à AWS STS pour l'actualisation des jetons.

La réduction complète de la surcharge des identifiants lors du passage de Textract à IronOCR : trois packages NuGet supprimés (AWSSDK.Textract, AWSSDK.S3, AWSSDK.Core), toutes les variables d'environnement AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY / AWS_DEFAULT_REGION supprimées, et les rôles IAM et les configurations de bucket S3 déclassés. Le guide d'entrée d'images et le guide d'entrée de flux couvrent toute la gamme des méthodes d'entrée qui remplacent les modèles de documents de tableaux d'octets et d'objets S3 de Textract.

Référence de mappage d'API

Quand les équipes envisagent de passer d'AWS Textreat à IronOCR

Quand la facture mensuelle devient une ligne budgétaire

Les équipes qui ont commencé à utiliser Textract avec un faible volume de données rencontrent souvent un problème précis : la facture AWS pour le traitement OCR apparaît lors d'une revue budgétaire trimestrielle et quelqu'un demande si ce coût est fixe. Ce n'est pas. À volumes élevés de pages, les coûts annuels de Textract peuvent être substantiels — consultez la page de tarification d'AWS Textract pour les tarifs actuels. La licence IronOCR Professional à $2,399 payée une fois se rentabilise rapidement à des volumes de pages modérés à élevés.

Lorsqu'une exigence de conformité bloque le traitement dans le cloud

Les organismes de santé qui mettent en œuvre des flux de travail de numérisation de documents découvrent fréquemment en cours de projet que les informations de santé protégées par la loi HIPAAne peuvent pas transiter par les services cloud sans un accord de partenariat commercial (BAA) et un examen juridique supplémentaire, ou que leur équipe de sécurité interdit totalement la transmission par le cloud. Les entreprises de défense qui manipulent des dessins techniques, des spécifications ou toute information non classifiée contrôlée (CUI) sont soumises aux contraintes ITARet CMMC qui excluent AWS Textret de toute possibilité. Les cabinets d'avocats traitant des communications confidentielles partagent des préoccupations similaires. Il ne s'agit pas de cas limites théoriques en matière de conformité ; ils apparaissent régulièrement dans les examens des achats, les audits de sécurité et les négociations contractuelles. IronOCR traite les données localement, la question de conformité pour les données documentaires se résume donc à savoir si votre propre infrastructure est concernée, et non si l'infrastructure d'Amazon l'est.

Lorsque la complexité du PDF asynchrone dépasse sa valeur

Le pipeline asynchrone S3 en cinq phases (téléchargement, démarrage de la tâche, interrogation, pagination des résultats, nettoyage) n'est pas techniquement difficile à mettre en œuvre. Il est difficile à entretenir, à tester et à utiliser. Chaque phase représente un point de défaillance. Les échecs de chargement S3 nécessitent une logique de nouvelle tentative. Les échecs des tâches Textreat nécessitent de distinguer les erreurs transitoires des erreurs permanentes. Les délais d'expiration des requêtes nécessitent une gestion des délais d'expiration distincte de l'annulation. La pagination des résultats nécessite l'accumulation d'informations sur plusieurs appels d'API. Les échecs de nettoyage S3 nécessitent un système d'alerte car les objets orphelins engendrent des coûts. Les équipes qui ont mis ce pipeline en production consacrent généralement plus de temps d'ingénierie continue à sa maintenance qu'à sa construction. L'équivalent IronOCR — input.LoadPdf(path) suivi de ocr.Read(input) — élimine toutes les cinq phases et leurs modes d'échec associés.

Lorsque les environnements de déploiement n'ont pas accès à Internet

Les conteneurs Dockerexécutés dans des segments de réseau isolés, les serveurs sur site sans accès Internet sortant, les environnements de recherche isolés du réseau et les systèmes industriels avec des contrôles réseau stricts ont tous une caractéristique commune : AWS Textret n'est pas disponible. IronOCR s'installe comme un package NuGet standard et fonctionne sans aucun appel réseau après son installation. Les équipes exécutant des applications .NET dans ces environnements ne disposent pas de l'option TextReact et ont besoin d'une bibliothèque qui traite les données localement. Le guide de déploiement Docker et le guide de déploiement Linux couvrent la configuration spécifique des environnements conteneurisés.

Quand la limitation du débit perturbe les flux de travail par lots

La limite TPS StartDocumentTextDetection par défaut est de 5 requêtes par seconde. Les appels synchrones DetectDocumentText sont également limités en taux. Les travaux par lots traitant des centaines ou des milliers de documents doivent mettre en œuvre une limitation SemaphoreSlim, un backoff exponentiel sur ProvisionedThroughputExceededException, et des minuteurs de réapprovisionnement. AWS prend en charge les demandes d'augmentation de limite de TPS, mais celles-ci nécessitent une justification, un examen et ne sont pas garanties. IronOCR traite les documents aussi vite que le permet le processeur local — un serveur à 32 cœurs traite 32 documents simultanément sans configuration de limitation de débit ni négociation de niveau de service.

Considérations courantes en matière de migration

Remplacement du graphe par blocs par des collections directes

Textract représente tous les résultats comme un List<Block> plat où les lignes, les mots, les cellules, les tables et les paires clé-valeur sont distingués par BlockType et reliés par des tableaux d'identifiants de relation. IronOCR fournit des collections typées directement.

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

' 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

Le guide des résultats structurés couvre result.Pages, result.Paragraphs, result.Lines, result.Words, et l'accès aux coordonnées pour construire un traitement de documents conscient de la disposition.

Remplacement du traitement PDF par étapes S3 par Direct LoadPdf

Tout code Textrect qui télécharge des fichiers sur S3 avant de démarrer une tâche de détection peut être remplacé par un chargement direct de PDF. Pas de zone de transit, pas de planification des chargements, pas de logique de nettoyage.

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

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

Ajout d'un prétraitement pour les documents ayant généré un faible niveau de confiance dans TextRect

Le prétraitement de Textract est interne et non configurable. Lorsqu'un document numérisé donne de mauvais résultats, les seules options sont de réessayer ou d'accepter un résultat peu fiable. IronOCR expose directement le pipeline de prétraitement.

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

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

Le guide de correction de la qualité de l'image et le tutoriel sur les filtres d'image documentent la pipeline complète de prétraitement et les combinaisons qui fonctionnent le mieux pour des types de documents spécifiques. Pour l'interprétation des scores de confiance et l'accès aux confiances par élément, le guide des scores de confiance couvre la propriété result.Confidence et les valeurs de confiance par mot.

Gestion du passage d'un modèle asynchrone à un modèle synchrone

Le code Textract existant est nécessairement async Task<t> à travers, car le SDK est uniquement asynchrone. Les opérations IronOCR sont synchrones. Pour un code d'application qui a déjà une chaîne d'appel asynchrone, enveloppez l'appel IronOCR dans Task.Run pour conserver la limite asynchrone.

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

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

Il s'agit d'un simple habillage pratique, et non d'une obligation. Pour le traitement côté serveur où le code appelant s'exécute déjà sur un thread d'arrière-plan, l'appel synchrone direct est préférable.

Fonctionnalités supplémentaires d'IronOCR

Au-delà des points de comparaison ci-dessus, IronOCR offre des fonctionnalités qui n'ont pas d'équivalent sur AWS Textrect :

• Lecture de code-barres pendant l'OCR : Définissez ocr.Configuration.ReadBarCodes = true et les codes-barres dans le document sont extraits avec le texte en un seul passage — pas d'étape distincte de balayage de code-barres requise
• Suivi de la progression des tâches longues : abonnez-vous aux événements de progression pour le traitement multipage sans interroger un service externe.
• Traitement des documents numérisés : Flux de traitement optimisé pour les flux de numérisation bureautiques classiques, y compris les numérisations recto verso et les pages à orientation mixte.
• Extraction simultanée multilingue : Combinez les packs de langue au moment de la lecture — OcrLanguage.French + OcrLanguage.German — sans changement de niveau d'API
• Lecture des passeports et cartes d'identité : Processus dédié aux zones lisibles par machine sur les documents d'identité, extrayant les champs structurés sans définition manuelle des régions

Compatibilité .NET et préparation à l'avenir

IronOCR cible .NET 8 et .NET 9, avec une compatibilité active pour les projets .NET Standard 2.0 et .NET Framework 4.6.2 à 4.8. La bibliothèque fournit des binaires natifs pour Windows x64, Windows x86, Linuxx64 et macOS via un seul package NuGet — sans changement d'identificateur d'exécution ni références de package spécifiques à la plateforme. Le package AWSSDK.Textract d'AWS Textract prend en charge les mêmes cibles modernes .NET, mais le modèle de déploiement porte l'arbre de dépendances complet du SDK AWS, l'infrastructure d'identifiants IAM et les contraintes architecturales documentées tout au long de cet article. IronOCR maintient un développement actif avec des versions régulières suivant les mises à jour du moteur Tesseract 5 et les avancées du runtime .NET , y compris la compatibilité avec .NET 10 lors de sa sortie.

Conclusion

AWS Textract et IronOCR résolvent le même problème — l'extraction de texte à partir de documents dans des applications .NET — avec des hypothèses architecturales fondamentalement incompatibles. Textract part du principe que les documents peuvent quitter votre réseau, que les coûts des services cloud augmentent linéairement avec le volume et que les PDF multipages justifient un pipeline asynchrone en cinq phases avec une zone de transit S3. IronOCR part du principe que les documents restent sur le lieu de traitement, que les coûts de licence sont indépendants du volume et que le traitement des PDF nécessite les mêmes trois lignes de code que le traitement d'images.

L'arithmétique des coûts est la ligne de partage la plus claire. À faible volume, les frais par page de Textract sont gérables. Au fur et à mesure que le volume augmente, les coûts annuels se cumulent de manière significative. À des volumes de pages élevés avec extraction de table, les coûts Textract sur plusieurs années peuvent largement dépasser même la licence Unlimited d'IronOCR à $4,799. La mathématique de départ reste : le modèle par page s'additionne rapidement, et ne s'arrête jamais.

La souveraineté des données est la deuxième contrainte structurelle. Pour les charges de travail liées aux soins de santé, au droit, à la finance et au gouvernement, la question du lieu de traitement des documents n'est pas une préférence, mais une obligation de conformité. IronOCR traite les données localement par conception, et non par configuration. Il n'existe pas de " mode local " à activer ; Le traitement local est le seul mode disponible. La réponse en matière de conformité est donc simple : vos documents restent dans votre infrastructure car il n'y a nulle part ailleurs où ils pourraient aller.

Pour les équipes évaluant la reconnaissance optique de caractères (OCR) à grande échelle ou opérant dans des environnements où les données documentaires ne peuvent pas quitter l'infrastructure interne, la documentation d'IronOCR fournit la référence API complète, des guides de déploiement pour Docker, AWS, Azuret Linux, ainsi que des tutoriels couvrant toute la gamme des cas d'utilisation de l'OCR, de la lecture d'images de base à la génération de PDF consultables et à l'extraction multilingue.