Veryfi sendet Ihre Bankkontonummern, Routing-Nummern, Transaktionsbeträge und Lieferantenbeziehungen an einen Drittanbieter-Cloud-Server jedes Mal, wenn Sie _client.ProcessDocumentAsync(bytes) aufrufen. Das ist die architektonische Realität, die die gesamte Veryfi-Evaluierung definiert: Bevor auch nur eine einzige Zeile strukturiertes JSON zurückkommt, haben Ihre Spesenabrechnungen – die einige der sensibelsten Finanzdaten Ihres Unternehmens enthalten – Ihre Infrastruktur bereits verlassen. Für viele Teams ist damit die Bewertung abgeschlossen.

Verifizierung verstehen

Veryfi ist eine cloudbasierte API zur Dokumentenanalyse, die speziell für Spesen- und Finanzdokumente entwickelt wurde. Das Kernversprechen des Produkts ist die strukturierte Ausgabe: Anstatt des rohen OCR-Textes, der nachgelagert analysiert werden muss, liefert ein Veryfi-API-Aufruf vorab extrahierte Felder – Lieferantenname, Gesamtbetrag, Einzelposten, Steuer, die letzten vier Ziffern der Zahlungskarte sowie bei Rechnungen Bankkontonummer und Bankleitzahl. Die Modelle sind mit großen Mengen an Finanzdokumenten vortrainiert und erreichen eine Genauigkeit von über 99 % in den unterstützten Dokumentenkategorien.

Die Architektur basiert auf reiner Cloud-Technologie. Jedes Dokument verlässt Ihre Anwendung, wird über HTTPS an die Server von Veryfigesendet, durchläuft deren KI/ML-Pipeline und wird als JSON zurückgesendet. Es gibt keine Option für die Bereitstellung vor Ort, keinen Air-Gap-Modus und keine Möglichkeit, ein Dokument zu verarbeiten, ohne es extern zu übertragen.

Wichtigste architektonische Merkmale:

• Nur-Cloud-Verarbeitung: Jedes Dokument wird zu api.veryfi.com hochgeladen, ohne lokalen Verarbeitungspfad
• Vier-Credential-Authentifizierung: VeryfiClient erfordert clientId, clientSecret, username und apiKey—vier Geheimnisse zum Verwalten, sicheren Speichern und Rotieren
• Pro-Dokument-Preisgestaltung: Kontaktieren Sie Veryfifür aktuelle Raten nach Dokumentart und Volumenstufe
• Nur-Async-API: ProcessDocumentAsync ist die primäre Methode; es gibt keinen synchronen Pfad
• Spezialisierter Dokumentenumfang: Quittungen, Rechnungen, Schecks, Kontoauszüge, Lohnsteuerbescheinigungen und Visitenkarten; Allgemeine Dokumente, Krankenakten, Verträge und technische Zeichnungen fallen nicht unter den Versicherungsschutz.
• Proprietäres JSON-Schema: Das Antwortformat von Veryfiist spezifisch für Veryfi; der Wechsel des Anbieters erfordert das Umschreiben der Extraktionslogik
• Ratenbegrenzung: Die Verarbeitung großer Datenmengen erfordert Backoff- und Wiederholungslogik zur Behandlung von HTTP-429-Antworten.

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

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

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.

##IronOCR verstehen

IronOCR ist eine kommerzielle, lokal installierte OCR-Bibliothek für .NET , die jedes Dokument lokal verarbeitet. Es verlassen keine Dokumentbytes Ihre Infrastruktur. Die Bibliothek kapselt eine optimierte Tesseract 5-Engine mit automatischer Vorverarbeitung, nativer PDF-Unterstützung und über 125 Sprachpaketen – alles wird als einzelnes NuGet Paket mit einer unbefristeten Lizenz geliefert.

Hauptmerkmale:

• On-Premise-Design: Die gesamte Verarbeitung findet auf Ihrer Hardware statt; Keine Netzwerkaufrufe für OCR
• Automatische Vorverarbeitung: Entzerren, Rauschen entfernen, Kontrast anpassen, Binarisieren und Auflösung verbessern werden automatisch ohne explizite Konfiguration angewendet.
• Native PDF-Eingabe: Scannen und digitale PDFs direkt über LoadPdf() lesen—keine separate PDF-Bibliothek erforderlich
• Unbefristete Lizenzierung: $999 Lite / $1,499 Plus / $2,399 Professional / $4,799 Unlimited—einmal zahlen, unbegrenzt Dokumente verarbeiten
• Strukturierter Ergebniszugriff: Wörter, Zeilen, Absätze und Seiten mit X/Y-Koordinaten und Konfidenzwerten pro Wort
• Thread-sicher und parallelisierbar: IronTesseract-Instanzen können über Threads hinweg verwendet werden, ohne zusätzliche Synchronisation
• Über 125 Sprachen: Installation als NuGet -Pakete, keine Verwaltung des Tessdata-Ordners erforderlich
• Plattformübergreifend: Windows, Linux, macOS, Docker, AWS, Azure – ein Paket deckt alle Ziele ab

Funktionsvergleich

Detaillierter Funktionsvergleich

Datenschutz für Finanzdokumente

Die von Veryfiverarbeiteten Finanzdokumente umfassen die sensibelsten Datenkategorien in jedem Unternehmen. Dies ist keine theoretische Überlegung – es ist eine konkrete architektonische Tatsache über die Funktionsweise des Produkts.

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

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

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.

Spezialisierter OCR vs. Generalistischer OCR

Veryfis enger Fokus auf Dokumente ist zugleich seine größte Stärke und seine bedeutendste Einschränkung. Die vortrainierten Modelle liefern wirklich schnelle, strukturierte Ergebnisse für die spezifischen Dokumenttypen, für die sie entwickelt wurden. Das Problem entsteht, sobald Ihre Organisation OCR außerhalb dieser Liste benötigt.

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

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

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.

Kosten pro Dokument in der Cloud im Vergleich zur Dauerlizenz

Der Kostenunterschied zwischen Veryfiund IronOCR erhöht sich mit jedem verarbeiteten Dokument. Das dokumentenbasierte Modell von Veryfibedeutet, dass die Kosten proportional zum Volumen steigen, ohne Obergrenze, es sei denn, eine solche wird vertraglich vereinbart.

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)

' 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,399 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

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

Webhook und asynchrone Verarbeitung vs. synchrone lokale Ergebnisse

Veryfi setzt bei seiner Cloud-Architektur ein ausschließlich asynchrones Verarbeitungsmodell voraus. Das Dokument wird an einen Remote-Server gesendet, dort von einer Pipeline verarbeitet und die Antwort trifft nach einem Netzwerk-Roundtrip ein. Für die Verarbeitung großer Datenmengen empfiehlt VeryfiBenachrichtigungen per Webhook anstelle von Polling.IronOCR arbeitet standardmäßig synchron, ohne Netzwerkabhängigkeit im Ablauf.

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

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

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.

API-Mapping-Referenz

Wenn Teams einen Wechsel von Veryfizu IronOCR erwägen

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

Gemeinsame Überlegungen zur Migration

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)

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

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

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.

Zusätzliche Funktionen von IronOCR

Über die Kernbereiche des Vergleichs hinaus bietet IronOCR Funktionen, die vollständig außerhalb des Leistungsumfangs von Veryfiliegen:

• Tabellenextraktion : Strukturiertes Einlesen von Tabellen aus Dokumenten mit Rasterlayout, anwendbar auf Kontoauszüge und Einzelrechnungen
• Handschrifterkennung : Verarbeitung handschriftlicher Notizen, Unterschriften und handschriftlicher Formularfelder, für die die vortrainierten Modelle von Veryfinicht ausgelegt sind.
• MICR-/Schecklesung : Dedizierte MICR-Zeilenextraktion für Scheckverarbeitungs-Workflows, wobei die Extraktion von Routing- und Kontonummern lokal erfolgt.
• hOCR-Export : Export der OCR-Ergebnisse als hOCR (HTML mit Positionsdaten) für nachgelagerte Dokumentenanalyse-Pipelines
• Fortschrittsverfolgung : Überwachen Sie den Verarbeitungsfortschritt von langlaufenden Batch-Jobs, ohne eine Remote-API abzufragen.
• Pass- und Ausweislesen : Extrahieren maschinenlesbarer Daten aus Pässen und Ausweisdokumenten für Onboarding- und KYC-Prozesse
• AWS- und Azure-Bereitstellung : Bereitstellung in der Cloud-Infrastruktur bei gleichzeitiger Dokumentenverarbeitung innerhalb Ihres eigenen Cloud-Kontos – kein externer SaaS-Datenverarbeiter wird Ihrem Compliance-Bereich hinzugefügt.

.NET-Kompatibilität und Zukunftsfähigkeit

IronOCR zielt auf .NET 8, .NET 9 und das kommende .NET 10 sowie auf .NET Standard 2.0+ ab, um die Kompatibilität mit älteren Versionen zu gewährleisten. Es läuft unter Windows x64/x86, Linux x64, macOS und ARM64 – und deckt damit alle modernen .NET -Bereitstellungsziele ab, einschließlich Docker-Container, Azure App Service, AWS Lambda und lokale Linux-Server. Das Einzelpaket-Bereitstellungsmodell bedeutet, dass keine native Binärverwaltung über verschiedene Umgebungen hinweg erfolgt; Derselbe NuGet -Verweis wird auf jeder unterstützten Plattform korrekt aufgelöst. Das C# SDK von Veryfizielt auf .NET Standard ab und fungiert als HTTP-Client-Wrapper, was bedeutet, dass seine "Kompatibilität" in erster Linie eine Funktion des HTTP-Stacks und nicht der OCR-Engine-Tiefe ist - ein Unterschied, der wichtig wird, wenn Plattformbeschränkungen oder Netzwerkbeschränkungen eine Rolle spielen.

Abschluss

Veryfi löst schnell ein spezifisches Problem: Ein Spesenbeleg einreichen und strukturierte JSON-Felder empfangen, ohne dass eine Parsing-Logik geschrieben werden muss. Für die Automatisierung kleiner Ausgaben in Umgebungen, in denen die Datenübertragung über die Cloud akzeptabel ist, hat dieser Vorschlag einen echten Wert. Die Reibungspunkte entstehen, wenn das Volumen so stark ansteigt, dass die Kosten pro Dokument innerhalb weniger Wochen die Kosten einer Dauerlizenz übersteigen, wenn die Dokumenttypen über die von Veryfiabgedeckten Kategorien hinausgehen, wenn Compliance-Anforderungen die Verarbeitung von Finanzdokumenten durch Dritte unpraktisch machen oder wenn die Anwendung einfach ohne Internetzugang funktionieren muss.

Das Vier-Anmeldeinformations-Authentifizierungsmodell, die ausschließlich asynchrone API, die Ratenbegrenzung, die HTTP-402-Zahlungsfehler, die die Stapelverarbeitung stoppen, und das proprietäre JSON-Schema, das die gesamte Extraktionslogik an einen einzigen Anbieter koppelt – das sind keine Randfälle. Für Teams, die Veryfiim Produktionsbetrieb in großem Umfang einsetzen, gehören sie zum täglichen Arbeitsalltag.

IronOCR erfordert das Schreiben von Extraktionsmustern, die Veryfiautomatisch verarbeitet. Das sind reale Entwicklungskosten: Rechnen Sie mit 8 bis 24 Stunden für die Erstellung der Regex-Extraktion für Belege und Rechnungen, abhängig von der Dokumentenart. Diese Investition wird jedoch nur einmal getätigt. Der resultierende Code läuft auf Ihrer Infrastruktur, verarbeitet beliebige Dokumenttypen, funktioniert offline und verursacht keine Kosten pro Dokument. Kontoauszüge, Bankleitzahlen, Kontonummern und Transaktionshistorien verlassen niemals Ihren Server.

Für Teams in den Bereichen Finanzdienstleistungen, Gesundheitswesen, Rüstungsaufträge oder Rechtsdienstleistungen – also in allen Bereichen, in denen das Senden von Spesenabrechnungen an eine Drittanbieter-Cloud eine Frage der Compliance ist – entfällt diese Diskussion mit IronOCR vollständig. Für Teams, die derzeit monatlich 5.000 bis 20.000 US-Dollar für Veryfiausgeben, ist die Rechnung einfach. Für Teams, die über Spesenabrechnungen hinaus eine allgemeine OCR-Lösung benötigen, ist die Wahl klar: Ein Cloud-Spezialist oder eine lokale allgemeine Bibliothek sind keine gleichwertigen Werkzeuge, und die einmaligen Lizenzkosten der letzteren bieten eine unbegrenzte Flexibilität, die der erstere zu keinem Preis pro Dokument bieten kann.