Une comparaison entre IronOCR et Nanonets OCR

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

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

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

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

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

            Dim jobId = startResponse.JobId

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

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

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

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

                nextToken = pageResponse.NextToken
            Loop While nextToken IsNot Nothing

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

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.

Comparaison détaillée des fonctionnalités

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

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;

Imports IronOcr

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

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

La licence $2,999 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.

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

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

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.

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

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

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.

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

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

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.

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,999 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.

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

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

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

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

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.