Quelle bibliothèque OCR Tesseract devriez-vous choisir ? Une comparaison développeur des trois principales options

Traitement des reçus Veryfi

Le SDK Veryfiexpose une seule méthode principale pour le traitement des documents :

using Veryfi;

public class VeryfiReceiptService
{
    private readonly VeryfiClient _client;

    public VeryfiReceiptService(string clientId, string clientSecret,
                                string username, string apiKey)
    {
        // Four credentials required — four secrets to manage
        _client = new VeryfiClient(clientId, clientSecret, username, apiKey);
    }

    public async Task<ReceiptData> ProcessReceiptAsync(string imagePath)
    {
        // Receipt image leaves your infrastructure here

        var imageBytes = File.ReadAllBytes(imagePath);
        var base64Image = Convert.ToBase64String(imageBytes);

        var response = await _client.ProcessDocumentAsync(
            fileData: base64Image,
            fileName: Path.GetFileName(imagePath)
        );

        return new ReceiptData
        {
            VendorName   = response.Vendor?.Name,
            Total        = response.Total,
            Date         = response.Date,
            Tax          = response.Tax,
            PaymentType  = response.Payment?.Type,
            CardLastFour = response.Payment?.Last4,
            LineItems    = response.LineItems?.Select(li => new LineItem
            {
                Description = li.Description,
                Quantity    = li.Quantity,
                UnitPrice   = li.UnitPrice,
                Total       = li.Total
            }).ToList()
        };
    }
}

using Veryfi;

public class VeryfiReceiptService
{
    private readonly VeryfiClient _client;

    public VeryfiReceiptService(string clientId, string clientSecret,
                                string username, string apiKey)
    {
        // Four credentials required — four secrets to manage
        _client = new VeryfiClient(clientId, clientSecret, username, apiKey);
    }

    public async Task<ReceiptData> ProcessReceiptAsync(string imagePath)
    {
        // Receipt image leaves your infrastructure here

        var imageBytes = File.ReadAllBytes(imagePath);
        var base64Image = Convert.ToBase64String(imageBytes);

        var response = await _client.ProcessDocumentAsync(
            fileData: base64Image,
            fileName: Path.GetFileName(imagePath)
        );

        return new ReceiptData
        {
            VendorName   = response.Vendor?.Name,
            Total        = response.Total,
            Date         = response.Date,
            Tax          = response.Tax,
            PaymentType  = response.Payment?.Type,
            CardLastFour = response.Payment?.Last4,
            LineItems    = response.LineItems?.Select(li => new LineItem
            {
                Description = li.Description,
                Quantity    = li.Quantity,
                UnitPrice   = li.UnitPrice,
                Total       = li.Total
            }).ToList()
        };
    }
}

Imports Veryfi
Imports System.IO
Imports System.Threading.Tasks

Public Class VeryfiReceiptService
    Private ReadOnly _client As VeryfiClient

    Public Sub New(clientId As String, clientSecret As String, username As String, apiKey As String)
        ' Four credentials required — four secrets to manage
        _client = New VeryfiClient(clientId, clientSecret, username, apiKey)
    End Sub

    Public Async Function ProcessReceiptAsync(imagePath As String) As Task(Of ReceiptData)
        ' Receipt image leaves your infrastructure here

        Dim imageBytes = File.ReadAllBytes(imagePath)
        Dim base64Image = Convert.ToBase64String(imageBytes)

        Dim response = Await _client.ProcessDocumentAsync(
            fileData:=base64Image,
            fileName:=Path.GetFileName(imagePath)
        )

        Return New ReceiptData With {
            .VendorName = response.Vendor?.Name,
            .Total = response.Total,
            .Date = response.Date,
            .Tax = response.Tax,
            .PaymentType = response.Payment?.Type,
            .CardLastFour = response.Payment?.Last4,
            .LineItems = response.LineItems?.Select(Function(li) New LineItem With {
                .Description = li.Description,
                .Quantity = li.Quantity,
                .UnitPrice = li.UnitPrice,
                .Total = li.Total
            }).ToList()
        }
    End Function
End Class

Les factures accentuent la sensibilité du sujet. Le même modèle ProcessDocumentAsync transmet des documents contenant souvent des numéros de compte bancaire, des numéros de routage, des identifiants fiscaux des fournisseurs et des conditions de paiement :

public async Task<InvoiceData> ProcessInvoiceAsync(string pdfPath)
{
    var pdfBytes = File.ReadAllBytes(pdfPath);

    // Invoice uploaded to Veryfi— banking details included
    var response = await _client.ProcessDocumentAsync(
        fileData: pdfBytes,
        fileName: Path.GetFileName(pdfPath),
        categories: new[] { "invoices" }
    );

    return new InvoiceData
    {
        InvoiceNumber    = response.InvoiceNumber,
        VendorName       = response.Vendor?.Name,
        VendorTaxId      = response.Vendor?.TaxId,       // transmitted
        Total            = response.Total,
        DueDate          = response.DueDate,
        PaymentTerms     = response.PaymentTerms,
        BankAccountNumber = response.BankAccount?.AccountNumber, // transmitted
        BankRoutingNumber = response.BankAccount?.RoutingNumber  // transmitted
    };
}

public async Task<InvoiceData> ProcessInvoiceAsync(string pdfPath)
{
    var pdfBytes = File.ReadAllBytes(pdfPath);

    // Invoice uploaded to Veryfi— banking details included
    var response = await _client.ProcessDocumentAsync(
        fileData: pdfBytes,
        fileName: Path.GetFileName(pdfPath),
        categories: new[] { "invoices" }
    );

    return new InvoiceData
    {
        InvoiceNumber    = response.InvoiceNumber,
        VendorName       = response.Vendor?.Name,
        VendorTaxId      = response.Vendor?.TaxId,       // transmitted
        Total            = response.Total,
        DueDate          = response.DueDate,
        PaymentTerms     = response.PaymentTerms,
        BankAccountNumber = response.BankAccount?.AccountNumber, // transmitted
        BankRoutingNumber = response.BankAccount?.RoutingNumber  // transmitted
    };
}

Imports System.IO
Imports System.Threading.Tasks

Public Async Function ProcessInvoiceAsync(pdfPath As String) As Task(Of InvoiceData)
    Dim pdfBytes = File.ReadAllBytes(pdfPath)

    ' Invoice uploaded to Veryfi— banking details included
    Dim response = Await _client.ProcessDocumentAsync(
        fileData:=pdfBytes,
        fileName:=Path.GetFileName(pdfPath),
        categories:=New String() {"invoices"}
    )

    Return New InvoiceData With {
        .InvoiceNumber = response.InvoiceNumber,
        .VendorName = response.Vendor?.Name,
        .VendorTaxId = response.Vendor?.TaxId,       ' transmitted
        .Total = response.Total,
        .DueDate = response.DueDate,
        .PaymentTerms = response.PaymentTerms,
        .BankAccountNumber = response.BankAccount?.AccountNumber, ' transmitted
        .BankRoutingNumber = response.BankAccount?.RoutingNumber  ' transmitted
    }
End Function

Le point de terminaison du relevé bancaire est le plus sensible. Appeler ProcessDocumentAsync avec categories: new[] { "bank_statements" } transmet les numéros de compte complets, les numéros de routage, l'historique complet des transactions, les soldes d'ouverture et de clôture, et les détails de transfert bancaire à l'infrastructure de Veryfi.

Comparaison détaillée des fonctionnalités

Approche Veryfi

Chaque appel d'API Veryfitransmet des octets de document via HTTPS vers api.veryfi.com. Les données extraites de ces documents (numéros de compte, numéros de routage, historiques de transactions, numéros d'identification fiscale des fournisseurs, détails des cartes de paiement et habitudes de dépenses) sont traitées par l'infrastructure de Veryfi. La résidence des données, les politiques de conservation, les chaînes de sous-traitants et les procédures de réponse aux violations de données sont toutes régies par les conditions de Veryfi, et non par les vôtres.

// Traitement des relevés bancaires — critical sensitivity
public async Task<BankStatementData> ProcessBankStatementAsync(string pdfPath)
{
    var pdfBytes = File.ReadAllBytes(pdfPath);

    // AT THIS POINT: full financial history leaves your infrastructure
    // Account numbers, transaction history, balances — all transmitted
    var response = await _client.ProcessDocumentAsync(
        fileData: pdfBytes,
        categories: new[] { "bank_statements" }
    );

    return new BankStatementData
    {
        AccountNumber  = response.AccountNumber,  // critical — transmitted
        RoutingNumber  = response.RoutingNumber,  // critical — transmitted
        OpeningBalance = response.OpeningBalance,
        ClosingBalance = response.ClosingBalance,
        Transactions   = response.Transactions?.Select(t => new Transaction
        {
            Date        = t.Date,
            Description = t.Description,
            Amount      = t.Amount,
            Balance     = t.RunningBalance
        }).ToList()
    };
}

// Traitement des relevés bancaires — critical sensitivity
public async Task<BankStatementData> ProcessBankStatementAsync(string pdfPath)
{
    var pdfBytes = File.ReadAllBytes(pdfPath);

    // AT THIS POINT: full financial history leaves your infrastructure
    // Account numbers, transaction history, balances — all transmitted
    var response = await _client.ProcessDocumentAsync(
        fileData: pdfBytes,
        categories: new[] { "bank_statements" }
    );

    return new BankStatementData
    {
        AccountNumber  = response.AccountNumber,  // critical — transmitted
        RoutingNumber  = response.RoutingNumber,  // critical — transmitted
        OpeningBalance = response.OpeningBalance,
        ClosingBalance = response.ClosingBalance,
        Transactions   = response.Transactions?.Select(t => new Transaction
        {
            Date        = t.Date,
            Description = t.Description,
            Amount      = t.Amount,
            Balance     = t.RunningBalance
        }).ToList()
    };
}

Imports System.IO
Imports System.Threading.Tasks

' Traitement des relevés bancaires — critical sensitivity
Public Async Function ProcessBankStatementAsync(pdfPath As String) As Task(Of BankStatementData)
    Dim pdfBytes = File.ReadAllBytes(pdfPath)

    ' AT THIS POINT: full financial history leaves your infrastructure
    ' Account numbers, transaction history, balances — all transmitted
    Dim response = Await _client.ProcessDocumentAsync(
        fileData:=pdfBytes,
        categories:=New String() {"bank_statements"}
    )

    Return New BankStatementData With {
        .AccountNumber = response.AccountNumber,  ' critical — transmitted
        .RoutingNumber = response.RoutingNumber,  ' critical — transmitted
        .OpeningBalance = response.OpeningBalance,
        .ClosingBalance = response.ClosingBalance,
        .Transactions = If(response.Transactions?.Select(Function(t) New Transaction With {
            .Date = t.Date,
            .Description = t.Description,
            .Amount = t.Amount,
            .Balance = t.RunningBalance
        }).ToList(), Nothing)
    }
End Function

Veryfi détient les certifications SOC 2 Type II, RGPD et HIPAA (avec accord de partenariat commercial). Ces certifications confirment que Veryfirespecte les pratiques de sécurité qu'elle a déclarées. Cela ne signifie pas que vos données restent sous votre contrôle, que vous contrôlez la résidence des données, ou que les sous-traitants de Veryfin'y ont aucun accès. Pour les organisations relevant des normes CMMC niveau 2+, ITAR, SOX ou GLBA, l'ajout de Veryfien tant que sous-traitant de données introduit un périmètre de conformité qui nécessite un examen juridique et une surveillance continue.

Approche d'IronOCR

IronOCR traite les documents sans aucune transmission réseau. Le moteur OCR s'exécute sur votre matériel. Les relevés bancaires, les factures avec numéros de routage et les chèques avec numéros de compte ne quittent jamais votre serveur :

using IronOcr;
using System.Text.RegularExpressions;

IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

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

    public BankStatementResult ProcessBankStatement(string pdfPath)
    {
        // All processing on your infrastructure
        // Non network calls — no external access
        using var input = new OcrInput();
        input.LoadPdf(pdfPath);

        var result = _ocr.Read(input);
        var text   = result.Text;

        // Account numbers stay on your server
        return new BankStatementResult
        {
            AccountNumber = ExtractAccountNumber(text),
            Balance       = ExtractBalance(text),
            RawText       = text,
            Confidence    = result.Confidence
        };
    }

    private string ExtractAccountNumber(string text)
    {
        var match = Regex.Match(text,
            @"Account\s*#?\s*:?\s*(\d{4,})",
            RegexOptions.IgnoreCase);
        return match.Success ? match.Groups[1].Value : null;
    }

    private decimal? ExtractBalance(string text)
    {
        var match = Regex.Match(text,
            @"Balance:?\s*\$?([\d,]+\.?\d*)",
            RegexOptions.IgnoreCase);
        if (match.Success && decimal.TryParse(
            match.Groups[1].Value.Replace(",", ""), out var bal))
            return bal;
        return null;
    }
}

using IronOcr;
using System.Text.RegularExpressions;

IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

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

    public BankStatementResult ProcessBankStatement(string pdfPath)
    {
        // All processing on your infrastructure
        // Non network calls — no external access
        using var input = new OcrInput();
        input.LoadPdf(pdfPath);

        var result = _ocr.Read(input);
        var text   = result.Text;

        // Account numbers stay on your server
        return new BankStatementResult
        {
            AccountNumber = ExtractAccountNumber(text),
            Balance       = ExtractBalance(text),
            RawText       = text,
            Confidence    = result.Confidence
        };
    }

    private string ExtractAccountNumber(string text)
    {
        var match = Regex.Match(text,
            @"Account\s*#?\s*:?\s*(\d{4,})",
            RegexOptions.IgnoreCase);
        return match.Success ? match.Groups[1].Value : null;
    }

    private decimal? ExtractBalance(string text)
    {
        var match = Regex.Match(text,
            @"Balance:?\s*\$?([\d,]+\.?\d*)",
            RegexOptions.IgnoreCase);
        if (match.Success && decimal.TryParse(
            match.Groups[1].Value.Replace(",", ""), out var bal))
            return bal;
        return null;
    }
}

Imports IronOcr
Imports System.Text.RegularExpressions

IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"

Public Class LocalFinancialDocumentProcessor
    Private ReadOnly _ocr As New IronTesseract()

    Public Function ProcessBankStatement(pdfPath As String) As BankStatementResult
        ' All processing on your infrastructure
        ' Non network calls — no external access
        Using input As New OcrInput()
            input.LoadPdf(pdfPath)

            Dim result = _ocr.Read(input)
            Dim text = result.Text

            ' Account numbers stay on your server
            Return New BankStatementResult With {
                .AccountNumber = ExtractAccountNumber(text),
                .Balance = ExtractBalance(text),
                .RawText = text,
                .Confidence = result.Confidence
            }
        End Using
    End Function

    Private Function ExtractAccountNumber(text As String) As String
        Dim match = Regex.Match(text,
                                "Account\s*#?\s*:?\s*(\d{4,})",
                                RegexOptions.IgnoreCase)
        Return If(match.Success, match.Groups(1).Value, Nothing)
    End Function

    Private Function ExtractBalance(text As String) As Decimal?
        Dim match = Regex.Match(text,
                                "Balance:?\s*\$?([\d,]+\.?\d*)",
                                RegexOptions.IgnoreCase)
        If match.Success AndAlso Decimal.TryParse(
            match.Groups(1).Value.Replace(",", ""), bal) Then
            Return bal
        End If
        Return Nothing
    End Function
End Class

Dans les environnements soumis à de fortes exigences de conformité, le traitement local élimine totalement le périmètre des audits tiers. Pas de BAA avec IronOCR. Aucune divulgation concernant les sous-traitants. Aucune question relative à la résidence des données. Consultez le guide d'installation d'IronTesseract pour la configuration du déploiement sur Windows, Linux, Docker et les environnements isolés.

Approche Veryfi

Veryfi fonctionne bien dans son domaine. Envoyez une image du reçu et la réponse contiendra le fournisseur, le total, la taxe, le mode de paiement et les lignes de paiement ; aucune expression régulière n'est requise de votre côté. Mais son champ d'application s'arrête à la frontière des dépenses et des documents financiers. Le fichier README le précise clairement : les documents commerciaux généraux, les dossiers médicaux, les dessins techniques, les documents multilingues et les types de formulaires personnalisés en dehors de l'ensemble d'entraînement produisent de mauvais résultats ou nécessitent une formation payante sur un modèle personnalisé.

Les organisations réelles traitent rarement une seule catégorie de documents. Les services des ressources humaines traitent les formulaires d'intégration des employés. Les équipes juridiques ont besoin du texte du contrat. Les équipes opérationnelles gèrent les documents d'expédition et les formulaires logistiques. Chaque catégorie hors du champ d'application de Veryfiimpose l'ajout d'une seconde solution à la pile :

// Veryfi: works for invoices, fails for shipping manifests
var invoiceResponse = await _client.ProcessDocumentAsync(
    fileData: invoiceBytes,
    categories: new[] { "invoices" }
);

// For anything outside the supported list, you need a second tool
// Contracts: limited support
// Medical forms: not supported
// Shipping documents: not supported
// Custom forms: paid training required

// Veryfi: works for invoices, fails for shipping manifests
var invoiceResponse = await _client.ProcessDocumentAsync(
    fileData: invoiceBytes,
    categories: new[] { "invoices" }
);

// For anything outside the supported list, you need a second tool
// Contracts: limited support
// Medical forms: not supported
// Shipping documents: not supported
// Custom forms: paid training required

Imports System.Threading.Tasks

' Veryfi: works for invoices, fails for shipping manifests
Dim invoiceResponse = Await _client.ProcessDocumentAsync(
    fileData:=invoiceBytes,
    categories:=New String() {"invoices"}
)

' For anything outside the supported list, you need a second tool
' Contracts: limited support
' Medical forms: not supported
' Shipping documents: not supported
' Custom forms: paid training required

Approche d'IronOCR

IronOCR traite tout type de document. C'est vous qui écrivez la logique d'extraction, ce qui signifie qu'elle traite exactement les champs contenus dans vos documents, et non pas les suppositions d'un modèle pré-entraîné sur les champs communs à tous les documents de dépenses. La même instance IronTesseract traite les reçus, contrats, formulaires médicaux, documents d'expédition et formulaires internes personnalisés :

using IronOcr;

var ocr = new IronTesseract();

// Receipts
var receiptResult = ocr.Read("receipt.jpg");
var receiptTotal  = ExtractTotal(receiptResult.Text);

// Contracts — not in Veryfi's scope
using var contractInput = new OcrInput();
contractInput.LoadPdf("contract.pdf");
var contractResult = ocr.Read(contractInput);
var parties        = ExtractContractParties(contractResult.Text);

// Medical forms — requires HIPAA BAA with Veryfi; stays local with IronOCR
var medicalResult = ocr.Read("patient-intake-form.jpg");
var patientName   = medicalResult.Lines.FirstOrDefault()?.Text;

// Shipping documents
var shipResult    = ocr.Read("bill-of-lading.jpg");
var trackingNum   = ExtractPattern(shipResult.Text, @"Tracking\s*#?\s*:?\s*(\w+)");

using IronOcr;

var ocr = new IronTesseract();

// Receipts
var receiptResult = ocr.Read("receipt.jpg");
var receiptTotal  = ExtractTotal(receiptResult.Text);

// Contracts — not in Veryfi's scope
using var contractInput = new OcrInput();
contractInput.LoadPdf("contract.pdf");
var contractResult = ocr.Read(contractInput);
var parties        = ExtractContractParties(contractResult.Text);

// Medical forms — requires HIPAA BAA with Veryfi; stays local with IronOCR
var medicalResult = ocr.Read("patient-intake-form.jpg");
var patientName   = medicalResult.Lines.FirstOrDefault()?.Text;

// Shipping documents
var shipResult    = ocr.Read("bill-of-lading.jpg");
var trackingNum   = ExtractPattern(shipResult.Text, @"Tracking\s*#?\s*:?\s*(\w+)");

Imports IronOcr

Dim ocr As New IronTesseract()

' Receipts
Dim receiptResult = ocr.Read("receipt.jpg")
Dim receiptTotal = ExtractTotal(receiptResult.Text)

' Contracts — not in Veryfi's scope
Using contractInput As New OcrInput()
    contractInput.LoadPdf("contract.pdf")
    Dim contractResult = ocr.Read(contractInput)
    Dim parties = ExtractContractParties(contractResult.Text)
End Using

' Medical forms — requires HIPAA BAA with Veryfi; stays local with IronOCR
Dim medicalResult = ocr.Read("patient-intake-form.jpg")
Dim patientName = medicalResult.Lines.FirstOrDefault()?.Text

' Shipping documents
Dim shipResult = ocr.Read("bill-of-lading.jpg")
Dim trackingNum = ExtractPattern(shipResult.Text, "Tracking\s*#?\s*:?\s*(\w+)")

Pour les champs de facture et de reçu suivant des modèles cohérents, l'extraction de données structurées d'IronOCR fournit un positionnement au niveau des mots qui rend la logique d'extraction précise. La collection result.Lines, ordonnée par position Y, fait remonter de manière fiable les noms des fournisseurs à partir des en-têtes des reçus. Les filtres de correction de la qualité d'image traitent les reçus froissés, décolorés ou photographiés que produisent les flux de travail réels de gestion des dépenses.

Approche Veryfi

Veryfi facture par document. Le tarif dépend du type de document et du niveau de volume—contactez Veryfipour connaître les tarifs actuels. Les coûts augmentent en proportion directe du volume sans plafond, sauf si vous en négociez un contractuellement, et il n'y a aucune réduction les années suivantes, quel que soit le temps que vous ayez été client.

// This method call costs money — every time
// Costs accumulate with every document processed
var response = await _client.ProcessDocumentAsync(bytes);

// This method call costs money — every time
// Costs accumulate with every document processed
var response = await _client.ProcessDocumentAsync(bytes);

' This method call costs money — every time
' Costs accumulate with every document processed
Dim response = Await _client.ProcessDocumentAsync(bytes)

Les coûts cachés alourdissent le total : la limitation du débit au niveau du code HTTP 429 impose une logique de nouvelle tentative ; Les modifications de la version de l'API nécessitent des mises à jour du SDK ; L'examen de sécurité de l'accord de traitement des données ajoute du temps légal ; et des frais de dépassement apparaissent lorsque le volume saisonnier dépasse les estimations du plan.

Approche d'IronOCR

La licence IronOCR est un achat unique. La licence Professional à $2,999 couvre 10 développeurs, traite un nombre illimité de documents par mois, et ne nécessite pas de renouvellement pour continuer à traiter. La deuxième année ne coûte rien en frais de traitement. La cinquième année ne coûte rien en frais de traitement.

// Configure once at startup — no per-call cost
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

var ocr = new IronTesseract();

// This processes 50,000 documents/month at $0 marginal cost
foreach (var documentPath in documentBatch)
{
    var result = ocr.Read(documentPath);
    ProcessExtractedData(result.Text, result.Lines);
}

// Configure once at startup — no per-call cost
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

var ocr = new IronTesseract();

// This processes 50,000 documents/month at $0 marginal cost
foreach (var documentPath in documentBatch)
{
    var result = ocr.Read(documentPath);
    ProcessExtractedData(result.Text, result.Lines);
}

Imports IronOcr

' Configure once at startup — no per-call cost
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"

Dim ocr As New IronTesseract()

' This processes 50,000 documents/month at $0 marginal cost
For Each documentPath In documentBatch
    Dim result = ocr.Read(documentPath)
    ProcessExtractedData(result.Text, result.Lines)
Next

La comparaison sur 3 ans à des volumes élevés de documents : IronOCR totalise $2,999 plus un temps de développement estimé entre 8 et 16 heures pour construire des modèles d'extraction, tandis que les coûts Veryfis'accumulent avec chaque document traité. Le seuil de rentabilité se produit généralement au cours des premiers mois d'utilisation en fonction du volume.

Pour les équipes qui investissent actuellement dans la reconnaissance optique de caractères (OCR) dans le cloud, la page de licences IronOCR détaille les différents niveaux de service et l'option d'abonnement SaaS disponible pour les équipes qui préfèrent une facturation annuelle.

Approche Veryfi

Tout le traitement Veryfiest asynchrone car il est basé sur le cloud. La méthode ProcessDocumentAsync initie un appel HTTP, attend que la chaîne de traitement Veryfise termine, et renvoie le résultat. La latence totale comprend la transmission réseau, le temps d'attente sur l'infrastructure de Veryfi, l'inférence du modèle et la transmission de la réponse.

// Veryfierror categories reflect cloud dependencies
public async Task<ReceiptData> ProcessWithHandlingAsync(string path)
{
    try
    {
        var bytes    = File.ReadAllBytes(path);
        var response = await _client.ProcessDocumentAsync(bytes);
        return MapToReceiptData(response);
    }
    catch (VeryfiApiException ex) when (ex.StatusCode == 401)
    {
        // Credential failure — check all four credentials
        throw new Exception("Authentication failed. Verify clientId, clientSecret, username, apiKey.", ex);
    }
    catch (VeryfiApiException ex) when (ex.StatusCode == 402)
    {
        // Plan quota exceeded — processing halted until billing resolved
        throw new Exception("Quota exceeded. Check plan limits and billing.", ex);
    }
    catch (VeryfiApiException ex) when (ex.StatusCode == 429)
    {
        // Rate limited — requires exponential backoff implementation
        throw new Exception("Rate limit exceeded. Implement retry with backoff.", ex);
    }
    catch (VeryfiApiException ex) when (ex.StatusCode == 500)
    {
        // Veryfiinfrastructure failure — your processing is down
        throw new Exception("Veryfi server error. Processing unavailable.", ex);
    }
}

// Veryfierror categories reflect cloud dependencies
public async Task<ReceiptData> ProcessWithHandlingAsync(string path)
{
    try
    {
        var bytes    = File.ReadAllBytes(path);
        var response = await _client.ProcessDocumentAsync(bytes);
        return MapToReceiptData(response);
    }
    catch (VeryfiApiException ex) when (ex.StatusCode == 401)
    {
        // Credential failure — check all four credentials
        throw new Exception("Authentication failed. Verify clientId, clientSecret, username, apiKey.", ex);
    }
    catch (VeryfiApiException ex) when (ex.StatusCode == 402)
    {
        // Plan quota exceeded — processing halted until billing resolved
        throw new Exception("Quota exceeded. Check plan limits and billing.", ex);
    }
    catch (VeryfiApiException ex) when (ex.StatusCode == 429)
    {
        // Rate limited — requires exponential backoff implementation
        throw new Exception("Rate limit exceeded. Implement retry with backoff.", ex);
    }
    catch (VeryfiApiException ex) when (ex.StatusCode == 500)
    {
        // Veryfiinfrastructure failure — your processing is down
        throw new Exception("Veryfi server error. Processing unavailable.", ex);
    }
}

Imports System.IO
Imports System.Threading.Tasks

' Veryfierror categories reflect cloud dependencies
Public Class Processor
    Private _client As VeryfiClient

    Public Async Function ProcessWithHandlingAsync(path As String) As Task(Of ReceiptData)
        Try
            Dim bytes = File.ReadAllBytes(path)
            Dim response = Await _client.ProcessDocumentAsync(bytes)
            Return MapToReceiptData(response)
        Catch ex As VeryfiApiException When ex.StatusCode = 401
            ' Credential failure — check all four credentials
            Throw New Exception("Authentication failed. Verify clientId, clientSecret, username, apiKey.", ex)
        Catch ex As VeryfiApiException When ex.StatusCode = 402
            ' Plan quota exceeded — processing halted until billing resolved
            Throw New Exception("Quota exceeded. Check plan limits and billing.", ex)
        Catch ex As VeryfiApiException When ex.StatusCode = 429
            ' Rate limited — requires exponential backoff implementation
            Throw New Exception("Rate limit exceeded. Implement retry with backoff.", ex)
        Catch ex As VeryfiApiException When ex.StatusCode = 500
            ' Veryfiinfrastructure failure — your processing is down
            Throw New Exception("Veryfi server error. Processing unavailable.", ex)
        End Try
    End Function

    Private Function MapToReceiptData(response As Object) As ReceiptData
        ' Implementation of mapping logic
    End Function
End Class

Public Class VeryfiClient
    Public Function ProcessDocumentAsync(bytes As Byte()) As Task(Of Object)
        ' Implementation of processing logic
    End Function
End Class

Public Class ReceiptData
    ' Implementation of ReceiptData class
End Class

Public Class VeryfiApiException
    Inherits Exception
    Public Property StatusCode As Integer
End Class

Les pannes de réseau interrompent le traitement. Les incidents d'infrastructure de Veryfiinterrompent le traitement. Les limites de débit interrompent le traitement. Chacune de ces dépendances est externe et votre application ne peut pas la contrôler.

Approche d'IronOCR

IronOCR traite les données de manière synchrone, sans aucune dépendance au réseau. Le résultat est disponible immédiatement après que Read() ne retourne, sans sondage, sans configuration de webhook et sans logique de réessayage pour les échecs de réseau.

using IronOcr;

var ocr = new IronTesseract();

// Synchronous — result immediately available
// Non network, no quota, no rate limits
var result = ocr.Read("receipt.jpg");

Console.WriteLine(result.Text);
Console.WriteLine($"Confidence: {result.Confidence}%");

// Word-level positioning for precise field extraction
foreach (var line in result.Lines)
{
    Console.WriteLine($"Y={line.Y}: {line.Text}");
}

using IronOcr;

var ocr = new IronTesseract();

// Synchronous — result immediately available
// Non network, no quota, no rate limits
var result = ocr.Read("receipt.jpg");

Console.WriteLine(result.Text);
Console.WriteLine($"Confidence: {result.Confidence}%");

// Word-level positioning for precise field extraction
foreach (var line in result.Lines)
{
    Console.WriteLine($"Y={line.Y}: {line.Text}");
}

Imports IronOcr

Dim ocr As New IronTesseract()

' Synchronous — result immediately available
' Non network, no quota, no rate limits
Dim result = ocr.Read("receipt.jpg")

Console.WriteLine(result.Text)
Console.WriteLine($"Confidence: {result.Confidence}%")

' Word-level positioning for precise field extraction
For Each line In result.Lines
    Console.WriteLine($"Y={line.Y}: {line.Text}")
Next

Pour les applications nécessitant un comportement asynchrone pour la réactivité de l'interface utilisateur, IronOCR prend également en charge l'OCR asynchrone via le wrapping Task.Run ou l'API asynchrone. La différence réside dans le fait que, dans IronOCR, l'asynchronisme est un modèle de concurrence, et non une exigence imposée par un appel distant. Une panne de réseau à 2 heures du matin n'interrompt pas votre traitement par lots.

Pour les flux de travail de numérisation de reçus, le tutoriel sur la numérisation de reçus et le guide OCR sur les factures couvrent l'implémentation complète des modèles d'extraction. Les scores de confiance fournissent des signaux de fiabilité par mot qui permettent de repérer les analyses de faible qualité avant de transmettre les données extraites à un système en aval.

La souveraineté des données devient non négociable

Le déclencheur le plus courant de l'évaluation IronOCR est un audit de conformité ou un examen juridique qui révèle que Veryfiest un sous-traitant de données pour des documents financiers sensibles. Une évaluation HIPAA révèle que les documents de dépenses contenant des informations de santé protégées nécessitent un accord de partenariat commercial avec Veryfiet un contrôle d'audit continu. Une évaluation CMMC de niveau 2 identifie la transmission de documents financiers via le cloud comme une faille potentielle. Une équipe juridique déconseille l'envoi de données relatives aux dépenses des clients à un tiers. Dans chaque scénario, la voie de la conformité consiste à éliminer la transmission de données externes, ce qui implique de remplacer Veryfipar une solution OCR sur site. Le modèle de traitement local d'IronOCR satisfait ces exigences par défaut : pas de BAA, pas de chaîne de sous-traitants, pas de périmètre d'audit tiers.

Les types de documents s'étendent au-delà des dépenses

Les organisations qui adoptent Veryfipour l'automatisation des dépenses découvrent souvent dans les 6 à 12 mois que les équipes adjacentes ont besoin de la reconnaissance optique de caractères (OCR) pour les documents qui ne font pas partie de l'ensemble de formation de Veryfi. Le service des ressources humaines a besoin que les formulaires d'intégration soient traités. Le texte du contrat a besoin d'être extrait. Les opérations nécessitent la saisie des données du connaissement. Chaque nouvelle catégorie de documents produit soit de mauvais résultats avec le terminal à usage général de Veryfi, soit nécessite une formation de modèle personnalisée payante, soit impose l'intégration d'une deuxième solution OCR dans l'infrastructure. Une seule licence IronOCR permet de gérer tout cela avec la même API. Le tutoriel sur la lecture de documents spécifiques aborde les stratégies d'extraction pour les mises en page de formulaires structurés.

Les coûts par document dépassent le seuil de rentabilité.

Les équipes traitant 25 000 documents ou plus par mois constatent généralement que la période de retour sur investissement IronOCR est inférieure à trois mois. À des volumes élevés de documents, la licence IronOCR Professional à $2,999 est généralement rentabilisée dès le premier mois d'une dépense équivalente chez Veryfi. Les équipes financières qui effectuent une analyse du coût total de possession en fonction de la tarification du cloud par document arrivent inévitablement à cette comparaison. L'effort de migration — la création de modèles d'extraction d'expressions régulières pour les champs spécifiques dont l'équipe a besoin — prend généralement de 8 à 24 heures en fonction de la complexité du document et du nombre de types de documents distincts dans le flux de travail.

Environnements hors ligne et déconnectés

Les organisations de services sur le terrain, les sites de travail à distance, les applications mobiles de saisie des dépenses et les environnements gouvernementaux isolés partagent une exigence commune : la reconnaissance optique de caractères (OCR) doit fonctionner sans Internet. De par son architecture, Veryfiest incapable de satisfaire cette exigence : chaque appel de traitement de document échoue sans connexion réseau. IronOCR fonctionne hors ligne par conception. Un technicien de terrain utilisant une application mobile de gestion des dépenses, une usine de fabrication dotée d'un réseau protégé par un pare-feu et un entrepreneur de la défense dans une zone SCIF peuvent tous exécuter IronOCR sans modification. Le guide de déploiement Docker et le guide de déploiement Linux couvrent les environnements conteneurisés où la sortie réseau est restreinte.

Dépendance vis-à-vis du fournisseur et dépendance au schéma

Le schéma de réponse JSON de Veryfiest propriétaire. Chaque ligne de code d'extraction qui lit le nom du fournisseur, le total, le numéro de routage ou les champs de ligne de commande est un code qui ne fonctionne qu'avec Veryfi. Passer à une API cloud concurrente ou à une solution sur site nécessite de réécrire toute la logique d'extraction. Les organisations qui négocient des contrats pluriannuels avec Veryfidécouvrent cette dépendance lorsque les prix changent ou que la feuille de route du produit évolue. La logique d'extraction IronOCR lit le texte brut à l'aide d'expressions régulières .NET standard — portable et non liée au schéma d'un fournisseur.

Remplacement de la sortie structurée par l'extraction de modèles

Veryfi renvoie des champs pré-analysés ; IronOCR renvoie le texte brut issu de la reconnaissance optique de caractères (OCR). Le travail de migration consiste à rédiger les modèles d'extraction que Veryfieffectuait dans son cloud. Pour les reçus et les factures ayant une mise en page uniforme, c'est simple :

using IronOcr;
using System.Text.RegularExpressions;

var ocr    = new IronTesseract();
var result = ocr.Read("receipt.jpg");
var text   = result.Text;

// Vendor: first non-empty line, ordered by Y position
var vendor = result.Lines
    .OrderBy(l => l.Y)
    .Select(l => l.Text.Trim())
    .FirstOrDefault(t => !string.IsNullOrWhiteSpace(t) && t.Length > 3);

// Total: pattern matching against common receipt labels
decimal? total = null;
foreach (var pattern in new[] {
    @"Total:?\s*\$?\s*([\d,]+\.?\d*)",
    @"Grand Total:?\s*\$?\s*([\d,]+\.?\d*)",
    @"Amount Due:?\s*\$?\s*([\d,]+\.?\d*)" })
{
    var match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);
    if (match.Success && decimal.TryParse(
        match.Groups[1].Value.Replace(",", ""), out var t))
    {
        total = t;
        break;
    }
}

// Tax
var taxMatch = Regex.Match(text,
    @"(?:Tax|Sales Tax|VAT):?\s*\$?\s*([\d,]+\.?\d*)",
    RegexOptions.IgnoreCase);

using IronOcr;
using System.Text.RegularExpressions;

var ocr    = new IronTesseract();
var result = ocr.Read("receipt.jpg");
var text   = result.Text;

// Vendor: first non-empty line, ordered by Y position
var vendor = result.Lines
    .OrderBy(l => l.Y)
    .Select(l => l.Text.Trim())
    .FirstOrDefault(t => !string.IsNullOrWhiteSpace(t) && t.Length > 3);

// Total: pattern matching against common receipt labels
decimal? total = null;
foreach (var pattern in new[] {
    @"Total:?\s*\$?\s*([\d,]+\.?\d*)",
    @"Grand Total:?\s*\$?\s*([\d,]+\.?\d*)",
    @"Amount Due:?\s*\$?\s*([\d,]+\.?\d*)" })
{
    var match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);
    if (match.Success && decimal.TryParse(
        match.Groups[1].Value.Replace(",", ""), out var t))
    {
        total = t;
        break;
    }
}

// Tax
var taxMatch = Regex.Match(text,
    @"(?:Tax|Sales Tax|VAT):?\s*\$?\s*([\d,]+\.?\d*)",
    RegexOptions.IgnoreCase);

Imports IronOcr
Imports System.Text.RegularExpressions

Dim ocr As New IronTesseract()
Dim result = ocr.Read("receipt.jpg")
Dim text = result.Text

' Vendor: first non-empty line, ordered by Y position
Dim vendor = result.Lines _
    .OrderBy(Function(l) l.Y) _
    .Select(Function(l) l.Text.Trim()) _
    .FirstOrDefault(Function(t) Not String.IsNullOrWhiteSpace(t) AndAlso t.Length > 3)

' Total: pattern matching against common receipt labels
Dim total As Decimal? = Nothing
For Each pattern In {
    "Total:?\s*\$?\s*([\d,]+\.?\d*)",
    "Grand Total:?\s*\$?\s*([\d,]+\.?\d*)",
    "Amount Due:?\s*\$?\s*([\d,]+\.?\d*)"
}
    Dim match = Regex.Match(text, pattern, RegexOptions.IgnoreCase)
    If match.Success AndAlso Decimal.TryParse(match.Groups(1).Value.Replace(",", ""), total) Then
        Exit For
    End If
Next

' Tax
Dim taxMatch = Regex.Match(text,
    "(?:Tax|Sales Tax|VAT):?\s*\$?\s*([\d,]+\.?\d*)",
    RegexOptions.IgnoreCase)

Pour les reçus présentant une mise en page inhabituelle ou une impression délavée, les filtres de prétraitement d'IronOCR améliorent la précision brute avant les opérations d'extraction. Consultez le guide de correction de la qualité d'image et le guide de correction des couleurs d'image pour obtenir des informations sur la qualité réelle des numérisations de reçus.

Gestion de la transition asynchrone-synchrone

L'intégralité de l'API de Veryfiest asynchrone. Le chemin principal d'IronOCR est synchrone. Les signatures des méthodes asynchrones existantes dans le code de l'application peuvent être préservées en les encapsulant :

// Preserve async signature during transition
public async Task<ReceiptResult> ProcessReceiptAsync(string path)
{
    // Run IronOCR on a background thread
    return await Task.Run(() =>
    {
        var result = _ocr.Read(path);
        return new ReceiptResult
        {
            Vendor = result.Lines.FirstOrDefault()?.Text,
            Total  = ExtractTotal(result.Text),
            Date   = ExtractDate(result.Text)
        };
    });
}

// Preserve async signature during transition
public async Task<ReceiptResult> ProcessReceiptAsync(string path)
{
    // Run IronOCR on a background thread
    return await Task.Run(() =>
    {
        var result = _ocr.Read(path);
        return new ReceiptResult
        {
            Vendor = result.Lines.FirstOrDefault()?.Text,
            Total  = ExtractTotal(result.Text),
            Date   = ExtractDate(result.Text)
        };
    });
}

Imports System.Threading.Tasks

Public Async Function ProcessReceiptAsync(path As String) As Task(Of ReceiptResult)
    ' Run IronOCR on a background thread
    Return Await Task.Run(Function()
                              Dim result = _ocr.Read(path)
                              Return New ReceiptResult With {
                                  .Vendor = result.Lines.FirstOrDefault()?.Text,
                                  .Total = ExtractTotal(result.Text),
                                  .Date = ExtractDate(result.Text)
                              }
                          End Function)
End Function

Pour les scénarios à haut débit, IronOCR est sécurisé pour les threads et plusieurs instances IronTesseract peuvent traiter des documents en parallèle sans synchronisation. Le guide d'optimisation de la vitesse aborde les modèles de réutilisation des instances et les stratégies de chargement par lots qui minimisent le temps de traitement à grande échelle.

Nettoyage des identifiants

Veryfi requiert quatre identifiants : ClientId, ClientSecret, Username et ApiKey. Les quatre éléments doivent être supprimés des fichiers de configuration, des variables d'environnement, des coffres de clés et des pipelines CI/CD après la migration. IronOCR nécessite une seule chaîne de clé de licence. La liste de vérification de la migration : retirez tous les quatre secrets Veryfide chaque environnement, ajoutez une seule variable d'environnement IRONOCR_LICENSE, et mettez à jour les pipelines de déploiement pour supprimer l'injection de crédentiels Veryfi.

Traitement PDF des factures

Veryfi accepte des octets PDF via ProcessDocumentAsync. IronOCR traite les PDFs nativement via OcrInput.LoadPdf() :

// Multi-page invoice PDF — all pages processed locally
using var input = new OcrInput();
input.LoadPdf("invoice.pdf");

var result       = new IronTesseract().Read(input);
var invoiceText  = result.Text;
var invoiceNumber = Regex.Match(invoiceText,
    @"Invoice\s*#?\s*:?\s*(\w+[-\w]*)",
    RegexOptions.IgnoreCase).Groups[1].Value;

// Multi-page invoice PDF — all pages processed locally
using var input = new OcrInput();
input.LoadPdf("invoice.pdf");

var result       = new IronTesseract().Read(input);
var invoiceText  = result.Text;
var invoiceNumber = Regex.Match(invoiceText,
    @"Invoice\s*#?\s*:?\s*(\w+[-\w]*)",
    RegexOptions.IgnoreCase).Groups[1].Value;

Imports System.Text.RegularExpressions
Imports IronOcr

' Multi-page invoice PDF — all pages processed locally
Dim input As New OcrInput()
input.LoadPdf("invoice.pdf")

Dim result = New IronTesseract().Read(input)
Dim invoiceText As String = result.Text
Dim invoiceNumber As String = Regex.Match(invoiceText, _
    "Invoice\s*#?\s*:?\s*(\w+[-\w]*)", _
    RegexOptions.IgnoreCase).Groups(1).Value

Pour les workflows de facturation qui produisent des archives PDF interrogeables, la méthode SaveAsSearchablePdf() d'IronOCR génère une sortie compatible PDF/A à partir d'une entrée numérisée—une capacité que l'API cloud de Veryfine fournit pas. Consultez le guide des PDFs interrogeables pour les détails de mise en œuvre.