Welche Tesseract OCR-Bibliothek sollten Sie wählen? Die drei besten Optionen im Vergleich für einen Entwickler

Verifizierung der Belegverarbeitung

Das VeryfiSDK stellt eine einzige primäre Methode zur Dokumentenverarbeitung bereit:

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

Rechnungen erhöhen die Sensibilität. Das gleiche ProcessDocumentAsync-Muster überträgt Dokumente, die häufig Bankkontonummern, Routing-Nummern, Lieferantensteuer-IDs und Zahlungsbedingungen enthalten:

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

Der Kontoauszug-Endpunkt ist der sensibelste. Der Aufruf von ProcessDocumentAsync mit categories: new[] { "bank_statements" } überträgt vollständige Kontonummern, Routing-Nummern, vollständige Transaktionshistorien, Anfangs- und Endguthaben sowie Überweisungsdetails an die Infrastruktur von Veryfi.

Detaillierter Funktionsvergleich

Veryfi-Ansatz

Jeder Veryfi-API-Aufruf überträgt Dokumentbytes über HTTPS an api.veryfi.com. Die aus diesen Dokumenten extrahierten Daten – Kontonummern, Bankleitzahlen, Transaktionshistorien, Steueridentifikationsnummern der Lieferanten, Zahlungskartendaten und Ausgabenmuster – werden von der Infrastruktur von Veryfiverarbeitet. Datenstandort, Aufbewahrungsrichtlinien, Unterauftragnehmerketten und Verfahren zur Reaktion auf Datenschutzverletzungen unterliegen den Bedingungen von Veryfi, nicht Ihren.

// Verarbeitung von Kontoauszügen — 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()
    };
}

// Verarbeitung von Kontoauszügen — 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

' Verarbeitung von Kontoauszügen — 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 ist nach SOC 2 Typ II, DSGVO und HIPAA (mit Business Associate Agreement) zertifiziert. Diese Zertifizierungen bestätigen, dass Veryfidie angegebenen Sicherheitspraktiken einhält. Das bedeutet nicht, dass Ihre Daten unter Ihrer Kontrolle bleiben, dass Sie die Datenspeicherung kontrollieren oder dass die Unterauftragnehmer von Veryfikeinen Zugriff haben. Für Organisationen, die unter CMMC Level 2+, ITAR, SOX oder GLBA fallen, führt die Hinzunahme von Veryfials Datenverarbeiter zu einem Compliance-Umfang, der eine rechtliche Prüfung und laufende Überwachung erfordert.

IronOCR-Ansatz

IronOCR verarbeitet Dokumente ohne Netzwerkübertragung. Die OCR-Engine läuft auf Ihrer Hardware. Kontoauszüge, Rechnungen mit Bankleitzahlen und Schecks mit Kontonummern verlassen niemals Ihren Server:

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

In Umgebungen mit hohem Compliance-Anspruch entfällt durch die lokale Verarbeitung der Prüfungsumfang durch Dritte vollständig. Kein BAA mit IronOCR. Keine Offenlegung von Unterauftragnehmerinformationen. Keine Fragen zum Datenstandort. Die Einrichtungsanleitung von IronTesseract enthält Informationen zur Bereitstellungskonfiguration unter Windows, Linux, Docker und in abgeschotteten Umgebungen.

Veryfi-Ansatz

Veryfi funktioniert innerhalb seines Wirkungsbereichs gut. Senden Sie ein Bild des Belegs ein, und die Antwort enthält Anbieter, Gesamtbetrag, Steuer, Zahlungsmethode und Einzelposten – von Ihrer Seite ist kein regulärer Ausdruck erforderlich. Der Geltungsbereich endet jedoch an der Grenze der Ausgaben- und Finanzdokumente. Die README-Datei dokumentiert dies direkt: Allgemeine Geschäftsdokumente, medizinische Aufzeichnungen, technische Zeichnungen, mehrsprachige Dokumente und benutzerdefinierte Formulararten außerhalb des trainierten Sets liefern schlechte Ergebnisse oder erfordern eine kostenpflichtige Schulung für ein benutzerdefiniertes Modell.

Reale Organisationen verarbeiten selten nur eine Dokumentenkategorie. Personalabteilungen bearbeiten die Einstellungsformulare für Mitarbeiter. Die Rechtsabteilung benötigt den Vertragstext. Die operativen Teams bearbeiten Versanddokumente und Logistikformulare. Jede Kategorie außerhalb des Anwendungsbereichs von Veryfierzwingt eine zweite Lösung im Lösungsstapel:

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

IronOCR-Ansatz

IronOCR verarbeitet alle Dokumenttypen. Die Extraktionslogik müssen Sie selbst schreiben, das heißt, sie verarbeitet genau die Felder, die Ihre Dokumente enthalten – und nicht die Vermutung eines vorab trainierten Modells darüber, welche Felder in allen Spesenabrechnungen üblich sind. Die gleiche IronTesseract-Instanz verarbeitet Belege, Verträge, medizinische Formulare, Versanddokumente und benutzerdefinierte interne Formulare:

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

Für Rechnungs- und Belegfelder, die konsistente Muster aufweisen, bietet IronOCR's strukturierte Datenausgabe eine Wortpositionierung, die die Extraktionslogik präzise macht. Die result.Lines-Sammlung, nach Y-Position geordnet, zeigt zuverlässig Lieferantennamen aus Belegköpfen an. Die Filter zur Bildqualitätskorrektur kümmern sich um zerknitterte, verblasste oder fotografierte Belege, die bei realen Spesenabrechnungsprozessen entstehen.

Veryfi-Ansatz

Veryfi berechnet Gebühren pro Dokument. Der Preis ist abhängig von Dokumenttyp und Volumenstufe — kontaktieren Sie Veryfifür aktuelle Preisgestaltung. Die Kosten steigen proportional zum Volumen mit keiner Obergrenze, es sei denn, Sie verhandeln einen vertraglich, und es gibt keine Reduzierung in den folgenden Jahren, unabhängig davon, wie lange Sie Kunde sind.

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

Versteckte Kosten erhöhen die Gesamtkosten: Die Ratenbegrenzung bei HTTP 429 erzwingt eine Wiederholungslogik; Änderungen der API-Version erfordern SDK-Aktualisierungen; Die Sicherheitsprüfung der Datenverarbeitungsvereinbarung verlängert die Bearbeitungszeit; und es fallen Gebühren für die Überschreitung des saisonalen Datenvolumens an, wenn die geplanten Schätzungen überschritten werden.

IronOCR-Ansatz

Die Lizenzierung von IronOCR ist ein einmaliger Kauf. Die Professional-Lizenz bei $2,999 deckt 10 Entwickler ab, verarbeitet unbegrenzt Dokumente pro Monat und erfordert keine Erneuerung, um die Verarbeitung fortzusetzen. Im zweiten Jahr fallen keine Bearbeitungskosten an. Im fünften Jahr fallen keine Bearbeitungskosten an.

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

Der 3-Jahres-Vergleich bei hohem Dokumentvolumen:IronOCR summiert sich auf $2,999 plus geschätzte 8–16 Stunden Entwicklungszeit, um Extraktionsmuster zu erstellen, während die Veryfi-Kosten mit jedem verarbeiteten Dokument steigen. Der Break-Even-Punkt tritt normalerweise in den ersten Monaten der Nutzung je nach Volumen ein.

Für Teams, die derzeit in Cloud-OCR investieren, bietet die IronOCR -Lizenzseite detaillierte Informationen zu den Lizenzstufen und zur SaaS-Abonnementoption für Teams, die eine jährliche Abrechnung bevorzugen.

Veryfi-Ansatz

Die gesamte Verarbeitung bei Veryfierfolgt asynchron, da es cloudbasiert ist. Die ProcessDocumentAsync-Methode initiiert einen HTTP-Aufruf, wartet auf die Fertigstellung der Veryfi-Pipeline und gibt das Ergebnis zurück. Die Gesamtlatenz umfasst die Netzwerkübertragung, die Wartezeit in der Veryfi-Infrastruktur, die Modellinferenz und die Antwortübertragung.

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

Netzwerkausfälle unterbrechen die Verarbeitung. Infrastrukturstörungen bei Veryfiführen zum Ausfall der Verarbeitung. Ratenbegrenzungen stoppen die Verarbeitung. Jede dieser Abhängigkeiten ist extern und kann von Ihrer Anwendung nicht kontrolliert werden.

IronOCR-Ansatz

IronOCR arbeitet synchron und ist dabei völlig unabhängig vom Netzwerk. Das Ergebnis ist sofort nach Read() verfügbar, ohne Abfragen, ohne Webhook-Konfiguration und ohne Wiederholungslogik für Netzwerkausfälle.

using IronOcr;

var ocr = new IronTesseract();

// Synchronous — result immediately available
//Neinnetwork, 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
//Neinnetwork, 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
' No 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

Für Anwendungen, die asynchrone Verhaltensweisen für die Benutzeroberflächenreaktionsfähigkeit benötigen, unterstützt IronOCR auch asynchrone OCR über Task.Run-Umhüllung oder die asynchrone API-Oberfläche. Der Unterschied besteht darin, dass Async in IronOCR ein Parallelitätsmuster ist, keine Anforderung, die durch einen Remote-Aufruf auferlegt wird. Ein Netzwerkausfall um 2 Uhr morgens unterbricht Ihre Stapelverarbeitung nicht.

Für Workflows zum Scannen von Belegen decken das Tutorial zum Scannen von Belegen und der Leitfaden zur OCR-Rechnungserkennung alle Implementierungen der Extraktionsmuster ab. Die Konfidenzwerte liefern wortbezogene Zuverlässigkeitssignale, die dabei helfen, Scans von geringer Qualität zu kennzeichnen, bevor die extrahierten Daten an ein nachgelagertes System weitergegeben werden.

Datensouveränität wird nicht verhandelbar

Der häufigste Auslöser für die Bewertung von IronOCR ist eine Compliance-Prüfung oder eine rechtliche Überprüfung, bei der Veryfials Datenverarbeiter für sensible Finanzdaten identifiziert wird. Eine HIPAA-Prüfung ergab, dass Spesenabrechnungen, die PHI enthalten, eine Vereinbarung zur Auftragsverarbeitung mit Veryfisowie eine laufende Prüfungsaufsicht erfordern. Eine CMMC-Level-2-Bewertung identifiziert über die Cloud übertragene Finanzdokumentation als potenzielle Sicherheitslücke. Ein Rechtsteam rät davon ab, Kostendaten von Mandantenfällen an Dritte weiterzugeben. In jedem Szenario liegt der Weg zur Einhaltung der Vorschriften in der Eliminierung der externen Datenübertragung – das heißt, Veryfidurch eine OCR-Lösung vor Ort zu ersetzen. Das lokale Verarbeitungsmodell von IronOCR erfüllt diese Anforderungen standardmäßig: keine BAA, keine Unterprozessorkette, kein Prüfumfang durch Dritte.

Dokumentarten gehen über Ausgaben hinaus

Organisationen, die Veryfizur Automatisierung ihrer Ausgaben einsetzen, stellen oft innerhalb von 6 bis 12 Monaten fest, dass angrenzende Teams eine OCR-Funktion für Dokumente benötigen, die nicht zum Trainingsdatensatz von Veryfigehören. Die Personalabteilung benötigt die Bearbeitung der Onboarding-Formulare. Der Text des Rechtsbedarfsvertrags wurde extrahiert. Für den Betrieb werden die Daten des Frachtbriefs benötigt. Jede neue Dokumentenkategorie führt entweder zu schlechten Ergebnissen mit dem universellen Endpunkt von Veryfi, erfordert kostenpflichtiges, kundenspezifisches Modelltraining oder zwingt zur Integration einer zweiten OCR-Lösung in die Infrastruktur. Eine einzige IronOCR Lizenz deckt all diese Funktionen mit derselben API ab. Das Tutorial zum Lesen dokumentspezifischer Daten behandelt Extraktionsstrategien für strukturierte Formularlayouts.

Die Kosten pro Dokument überschreiten die Schwelle für einen wirtschaftlichen Nutzen.

Teams, die 25.000 oder mehr Dokumente pro Monat verarbeiten, erreichen in der Regel eine Amortisationszeit von IronOCR von unter drei Monaten. Bei hohem Dokumentvolumen wird die IronOCR-Professional-Lizenz bei $2,999 typischerweise innerhalb des ersten Monats äquivalenten Veryfi-Aufwands finanziert. Finanzteams, die eine Analyse der Gesamtbetriebskosten auf Basis der Cloud-Preisgestaltung pro Dokument durchführen, gelangen unweigerlich zu diesem Vergleich. Der Migrationsaufwand – das Erstellen von Regex-Extraktionsmustern für die spezifischen Felder, die das Team benötigt – beträgt in der Regel 8 bis 24 Stunden, abhängig von der Komplexität des Dokuments und der Anzahl der verschiedenen Dokumenttypen im Workflow.

Offline- und nicht verbundene Umgebungen

Außendienstorganisationen, entfernte Arbeitsorte, mobile Spesenabrechnungs-Apps und abgeschottete Regierungsumgebungen haben eine gemeinsame Anforderung: OCR muss ohne Internet funktionieren. Veryfiist architektonisch nicht in der Lage, diese Anforderung zu erfüllen – jeder Aufruf zur Dokumentenverarbeitung schlägt ohne Netzwerkverbindung fehl.IronOCR verarbeitet Prozesse standardmäßig offline. Ein Außendiensttechniker, der eine mobile Spesenabrechnungs-App nutzt, ein Produktionsbetrieb mit einem durch eine Firewall geschützten Netzwerk und ein Rüstungsunternehmen in einem SCIF können IronOCR alle ohne Modifikationen ausführen. Der Docker-Bereitstellungsleitfaden und der Linux-Bereitstellungsleitfaden behandeln containerisierte Umgebungen, in denen der Netzwerkaustritt eingeschränkt ist.

Anbieterbindung und Schemaabhängigkeit

Das JSON-Antwortschema von Veryfiist proprietär. Jede Zeile des Extraktionscodes, die Lieferantenname, Gesamtbetrag, Bankleitzahl oder Positionsfelder ausliest, ist Code, der nur mit Veryfifunktioniert. Der Wechsel zu einer konkurrierenden Cloud-API oder zu einer On-Premise-Lösung erfordert das Umschreiben der gesamten Extraktionslogik. Organisationen, die mehrjährige Verträge mit Veryfiaushandeln, entdecken diese Abhängigkeit, wenn sich die Preise ändern oder die Produktstrategie angepasst wird. Die IronOCR Extraktionslogik liest Rohdaten mithilfe von Standard .NET -Regex – portabel und nicht an das Schema eines bestimmten Anbieters gebunden.

Ersetzen der strukturierten Ausgabe durch Mustererkennung

Veryfi gibt vorab analysierte Felder zurück;IronOCR gibt den unformatierten OCR-Text zurück. Die Migrationsarbeit besteht darin, die Extraktionsmuster zu schreiben, die Veryfiin ihrer Cloud verwendet hat. Bei Quittungen und Rechnungen mit einheitlichem Layout ist dies unkompliziert:

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)

Bei Belegen mit ungewöhnlichem Layout oder verblasstem Druck verbessern die Vorverarbeitungsfilter von IronOCR die Rohgenauigkeit vor der Datenextraktion. Hinweise zur Bearbeitung von Belegscans in der Praxis finden Sie im Leitfaden zur Bildqualitätskorrektur und im Leitfaden zur Bildfarbkorrektur .

Umgang mit dem Übergang von asynchron zu synchron

Die gesamte API-Oberfläche von Veryfiist asynchron. Der primäre Pfad von IronOCR ist synchron. Vorhandene Signaturen asynchroner Methoden im Anwendungscode können durch Umschließen beibehalten werden:

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

Für Szenarien mit hohem Durchsatz ist IronOCR thread-sicher und mehrere IronTesseract-Instanzen können Dokumente ohne Synchronisation parallel verarbeiten. Der Leitfaden zur Geschwindigkeitsoptimierung umfasst Instanzwiederverwendungsmuster und Strategien für das Stapelladen, die die Verarbeitungszeit bei großem Umfang minimieren.

Bereinigung der Anmeldeinformationen

Veryfi erfordert vier Zugangsdaten: ClientId, ClientSecret, Username und ApiKey. Alle vier müssen nach der Migration aus Konfigurationsdateien, Umgebungsvariablen, Schlüsseltresoren und CI/CD-Pipelines entfernt werden.IronOCR benötigt einen einzigen Lizenzschlüssel. Die Migrations-Checkliste: Entfernen Sie alle vier Veryfi-Geheimnisse aus jeder Umgebung, fügen Sie eine einzige IRONOCR_LICENSE-Umgebungsvariable hinzu und aktualisieren Sie die Bereitstellungspipelines, um die Veryfi-Anmeldeinformationen zu entfernen.

PDF-Verarbeitung für Rechnungen

Veryfi akzeptiert PDF-Bytes über ProcessDocumentAsync.IronOCR verarbeitet PDFs nativ durch 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

Für Rechnungs-Workflows, die durchsuchbare PDF-Archive erzeugen, erzeugt IronOCR's SaveAsSearchablePdf()-Methode PDF/A-kompatible Ausgaben aus gescanntem Input—eine Fähigkeit, die die Veryfi-Cloud-API nicht bietet. Siehe den Leitfaden für durchsuchbare PDF für Implementierungsdetails.