Którą bibliotekę Tesseract OCR powinieneś wybrać? Porównanie trzech najlepszych opcji dla programistów

Przetwarzanie paragonów Veryfi

PakietVeryfiSDK udostępnia jedną podstawową metodę przetwarzania dokumentów:

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

Faktury zwiększają wrażliwość. Ten sam wzór ProcessDocumentAsync przesyła dokumenty, które często zawierają numery kont bankowych, numery routingu, identyfikatory podatkowe dostawców oraz warunki płatności:

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

    // Invoice uploaded toVeryfi— 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 toVeryfi— 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 toVeryfi— 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

Endpoint wyciągów bankowych jest najbardziej wrażliwy. Wywołanie ProcessDocumentAsync z categories: new[] { "bank_statements" } przesyła pełne numery kont, numery routingu, kompletną historię transakcji, otwarcia i zamknięcia sald oraz szczegóły przelewów na infrastrukturę Veryfi.

Szczegółowe porównanie funkcji

Podejście Veryfi

Każde wywołanie APIVeryfiprzesyła bajty dokumentu przez HTTPS do api.veryfi.com. Dane wyodrębnione z tych dokumentów — numery kont, numery rozliczeniowe, historie transakcji, numery identyfikacyjne dostawców, dane kart płatniczych oraz wzorce wydatków — są przetwarzane przez infrastrukturę Veryfi. Lokalizacja danych, zasady przechowywania, łańcuchy podwykonawców oraz procedury reagowania na naruszenia podlegają warunkom Veryfi, a nie Twoim.

// Przetwarzanie wyciągów bankowych — 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()
    };
}

// Przetwarzanie wyciągów bankowych — 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

' Przetwarzanie wyciągów bankowych — 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 posiada certyfikaty SOC 2 Type II, GDPR oraz HIPAA (wraz z umową o współpracy biznesowej). Certyfikaty te potwierdzają, że firmaVeryfiprzestrzega określonych przez siebie praktyk bezpieczeństwa. Nie oznacza to, że dane pozostają pod Twoją kontrolą, że kontrolujesz lokalizację danych ani że podwykonawcyVeryfinie mają do nich dostępu. W przypadku organizacji objętych wymogąmi CMMC poziomu 2+, ITAR, SOX lub GLBA dodanieVeryfijako podmiotu przetwarzającego dane wprowadza zakres zgodności, który wymaga przeglądu prawnego i stałego nadzoru.

Podejście IronOCR

IronOCR przetwarza dokumenty bez konieczności przesyłania danych przez sieć. Silnik OCR działa na Twoim sprzęcie. Wyciągi bankowe, faktury z numerami rozliczeniowymi i czeki z numerami kont nigdy nie opuszczają Twojego serwera:

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
        // Nie network calls — no external access
        using var input = new OcrInput();
        input.LoadPdf(pdfPath);

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

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

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

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

using IronOcr;
using System.Text.RegularExpressions;

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

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

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

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

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

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

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

Imports IronOcr
Imports System.Text.RegularExpressions

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

Public Class LocalFinancialDocumentProcessor
    Private ReadOnly _ocr As New IronTesseract()

    Public Function ProcessBankStatement(pdfPath As String) As BankStatementResult
        ' All processing on your infrastructure
        ' 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

W środowiskach o wysokich wymaganiach dotyczących zgodności lokalne przetwarzanie całkowicie eliminuje zakres audytu przeprowadzanego przez podmioty zewnętrzne. Brak BAA w przypadku IronOCR. Brak informacji o podwykonawcach. Brak pytań dotyczących lokalizacji danych. Zapoznaj się z przewodnikiem konfiguracji IronTesseract, aby uzyskać informacje na temat wdrażania w środowiskach Windows, Linux, Docker oraz w środowiskach odizolowanych.

Podejście Veryfi

Veryfi dobrze sprawdza się w swojej dziedzinie. Prześlij zdjęcie paragonu, a odpowiedź będzie zawierała nazwę sprzedawcy, sumę, podatek, metodę płatności i pozycje na paragonie — nie musisz używać wyrażeń regularnych. Jednak zakres kończy się na granicy dokumentów dotyczących wydatków i finansów. Dokument README bezpośrednio to potwierdza: ogólne dokumenty biznesowe, dokumentacja medyczna, rysunki techniczne, dokumenty wielojęzyczne oraz niestandardowe typy formularzy spoza zestawu szkoleniowego dają słabe wyniki lub wymagają płatnego szkolenia modelu niestandardowego.

Prawdziwe organizacje rzadko przetwarzają tylko jedną kategorię dokumentów. Działy kadr przetwarzają formularze związane z wdrażaniem nowych pracowników. Zespoły prawne potrzebują tekstu umowy. Zespoły operacyjne zajmują się dokumentami wysyłkowymi i formularzami logistycznymi. Każda kategoria wykraczająca poza zakresVeryfiwymusza dodanie drugiego rozwiązania do stosu:

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

Podejście IronOCR

IronOCR przetwarza każdy typ dokumentu. Logikę ekstrakcji należy napisać samodzielnie, co oznacza, że obsługuje ona dokładnie te pola, które zawierają dokumenty — a nie opiera się na przypuszczeniach wstępnie wytrenowanego modelu dotyczących pól wspólnych dla wszystkich dokumentów wydatków. Ta sama instancja IronTesseract przetwarza paragony, umowy, formularze medyczne, dokumenty wysyłkowe oraz niestandardowe formularze wewnętrzne:

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

Dla pól faktur i paragonów, które mają jednolite wzorce, strukturalne wydobywanie danychIronOCR zapewnia pozycjonowanie na poziomie słów, co sprawia, że logika wydobycia jest precyzyjna. Kolekcja result.Lines, uporządkowana według pozycji Y, niezawodnie wyciąga nazwy dostawców z nagłówków paragonów. Filtry korekcji jakości obrazu radzą sobie z pogniecionymi, wyblakłymi lub sfotografowanymi paragonami, które powstają w rzeczywistych procesach rozliczania wydatków.

Podejście Veryfi

Veryfi pobiera opłaty za dokument. Stawka zalezy od typu dokumentu i poziomu wolumenu - skontaktuj sie zVeryfipo aktualne ceny. Koszty rosna wprost proporcjonalnie do wolumenu bez sufitu, chyba ze wynegocjujesz to umowowo, a nie ma obnizenia ceny w kolejnych latach, bez wzgledu na to, jak dlugo jestes klientem.

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

Ukryte koszty zwiększają całkowity koszt: ograniczenie szybkości przy kodzie HTTP 429 wymusza logikę ponownych prób; Zmiany wersji API wymagają aktualizacji SDK; Przegląd bezpieczeństwa umowy o przetwarzaniu danych wydłuża czas oczekiwania na odpowiedź prawną; a opłaty za przekroczenie limitu pojawiają się, gdy sezonowy wolumen przekracza szacunki zawarte w planie.

Podejście IronOCR

Licencja IronOCR jest jednorazowym zakupem. Licencja Professional na $2,999 obejmuje 10 deweloperów, przetwarza nieograniczoną liczbę dokumentów miesięcznie i nie wymaga odnawiania, aby kontynuować przetwarzanie. Rok 2 kosztuje 0 USD za przetworzenie. Rok 5 kosztuje 0 USD za przetworzenie.

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

Porównanie 3-letnie przy dużych ilościach dokumentów:IronOCR kosztuje łącznie $2,999 plus szacunkowo 8-16 godzin czasu deweloperskiego na budowę wzorców ekstrakcji, podczas gdy kosztyVeryfinarastają z każdym przetworzonym dokumentem. Punkt break-even zwykle wystepuje w ciagu kilku pierwszych miesiecy uzytkowania w zaleznosci od wolumenu.

Dla zespołów, które obecnie ponoszą koszty związane z chmurowym OCR, strona licencyjna IronOCR zawiera szczegółowe informacje na temat poziomów oraz opcję subskrypcji SaaS dostępną dla zespołów preferujących rozliczenia roczne.

Podejście Veryfi

Wszystkie operacjeVeryfisą asynchroniczne, ponieważ odbywają się w chmurze. Metoda ProcessDocumentAsync inicjuje wywołanie HTTP, czeka na ukończenie procesówVeryfii zwraca wynik. Całkowite opóźnienie obejmuje transmisję sieciową, czas oczekiwania w kolejce w infrastrukturze Veryfi, wnioskowanie modelu oraz transmisję odpowiedzi.

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

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
        ' Veryfi infrastructure failure — your processing is down
        Throw New Exception("Veryfi server error. Processing unavailable.", ex)
    End Try
End Function

Awarie sieci wstrzymują przetwarzanie. Incydenty związane z infrastrukturąVeryfiwstrzymują przetwarzanie. Limity szybkości zatrzymują przetwarzanie. Każda z nich stanowi zewnętrzną zależność, nad którą aplikacja nie ma kontroli.

Podejście IronOCR

IronOCR działa synchronicznie, bez żadnej zależności od sieci. Wynik jest dostępny natychmiast po zwróceniu Read(), bez potrzeby sondowania, konfiguracji webhooka czy logiki ponawiania w przypadku awarii sieci.

using IronOcr;

var ocr = new IronTesseract();

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

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

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

using IronOcr;

var ocr = new IronTesseract();

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

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

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

Imports IronOcr

Dim ocr As New IronTesseract()

' Synchronous — result immediately available
' Nie 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

Dla aplikacji, które potrzebują asynchronicznego działania dla reaktywności interfejsu użytkownika,IronOCR obsługuje również asynchroniczny OCR za pośrednictwem opakowania Task.Run lub asynchronicznej powierzchni API. Różnica polega na tym, że async w IronOCR jest wzorcem współbieżności, a nie wymogiem narzuconym przez wywołanie zdalne. Awaria sieci o 2 w nocy nie zatrzymuje procesu wsadowego.

W przypadku procesów skanowania paragonów samouczek dotyczący skanowania paragonów oraz przewodnik po OCR faktur obejmują pełne implementacje wzorców wyodrębniania. Wskaźniki pewności dostarczają sygnałów wiarygodności dla poszczególnych WORD-ów, które pomagają zidentyfikować skanowanie niskiej jakości przed przekazaniem wyodrębnionych danych do systemu końcowego.

Suwerenność danych staje się kwestią niepodlegającą negocjacjom

Najczęstszym powodem oceny IronOCR jest audyt zgodności lub przegląd prawny, w wyniku którego firmaVeryfizostaje wskazana jako podmiot przetwarzający wrażliwe dane finansowe. Ocena HIPAA wykazała, że dokumenty dotyczące wydatków zawierające dane medyczne (PHI) wymagają zawarcia umowy o współpracy biznesowej zVeryfioraz stałego nadzoru audytowego. Ocena CMMC poziomu 2 wskazuje dokumenty finansowe przesyłane w chmurze jako potencjalną lukę. Zespół prawny odradza wysyłanie danych dotyczących wydatków związanych ze sprawami klientów do stron trzecich. W każdym scenariuszu drogą do zgodności jest wyeliminowanie zewnętrznej transmisji danych — co oznacza zastąpienieVeryfilokalnym OCR. Model przetwarzania lokalnego IronOCR domyślnie spełnia te wymagania: brak umowy BAA, brak łańcucha podwykonawców, brak zakresu audytu przez stronę trzecią.

Rodzaje dokumentów wykraczają poza koszty

Organizacje, które wdrażająVeryfido automatyzacji rozliczania wydatków, często w ciągu 6–12 miesięcy odkrywają, że sąsiednie zespoły potrzebują OCR do dokumentów spoza zestawu szkoleniowego Veryfi. Dział kadr potrzebuje przetworzonych formularzy wdrożeniowych. Wymagane jest wyodrębnienie tekstu umowy. Dział operacyjny potrzebuje danych z listów przewozowych. Każda nowa kategoria dokumentów albo daje słabe wyniki z punktu końcowego ogólnego przeznaczenia Veryfi, albo wymaga płatnego szkolenia modelu niestandardowego, albo wymusza wprowadzenie do infrastruktury drugiego rozwiązania OCR. Pojedyncza licencja IronOCR obsługuje wszystkie te funkcje za pomocą tego samego interfejsu API. Samouczek dotyczący czytania konkretnych dokumentów obejmuje strategie pozyskiwania danych z ustrukturyzowanych układów formularzy.

Koszty na dokument przekraczają próg opłacalności

Zespoły przetwarzające 25 000 lub więcej dokumentów miesięcznie zazwyczaj osiągają zwrot z inwestycji w IronOCR w ciągu mniej niż trzech miesięcy. Przy dużych wolumenach dokumentów, Licencja Professional IronOCR na $2,999 jest zwykle opłacana w ciągu pierwszego miesiąca ekwiwalentnych wydatków na Veryfi. Zespoły finansowe przeprowadzające analizę całkowitego kosztu posiadania w oparciu o ceny usług chmurowych naliczane za dokument nieuchronnie dochodzą do tego porównania. Praca związana z migracją — tworzenie wzorców ekstrakcji regex dla konkretnych pól potrzebnych zespołowi — zajmuje zazwyczaj od 8 do 24 godzin, w zależności od złożoności dokumentów i liczby różnych typów dokumentów w przepływie pracy.

Środowiska offline i bez połączenia z internetem

Organizacje świadczące usługi w terenie, zdalne miejsca pracy, mobilne aplikacje do rejestrowania wydatków oraz środowiska odizolowane rządowe mają wspólny wymóg: OCR musi działać bez internetu.Veryfinie jest w stanie spełnić tego wymogu ze względu na swoją architekturę — każde wywołanie przetwarzania dokumentu kończy się niepowodzeniem bez połączenia sieciowego.IronOCR z założenia działa w trybie offline. Technik terenowy korzystający z mobilnej aplikacji do rozliczania wydatków, zakład produkcyjny z siecią chronioną zaporą ogniową oraz wykonawca z branży obronnej w SCIF mogą korzystać z IronOCR bez żadnych modyfikacji. Przewodnik wdrażania Docker oraz przewodnik wdrażania Linux obejmują środowiska kontenerowe, w których ruch wychodzący z sieci jest ograniczony.

Zależność od dostawcy i zależność od schematu

Schemat odpowiedzi JSON firmyVeryfijest zastrzeżony. Każda linia kodu do wyodrębniania, która odczytuje nazwę dostawcy, sumę, numer rozliczeniowy lub pola pozycji, to kod, który działa wyłącznie z Veryfi. Przejście na konkurencyjny interfejs API w chmurze lub na rozwiązanie lokalne wymaga przepisania całej logiki ekstrakcji. Organizacje, które negocjują wieloletnie umowy z Veryfi, odkrywają tę zależność, gdy zmieniają się ceny lub plan rozwoju produktu. Logika ekstrakcji IronOCR odczytuje surowy tekst przy użyciu standardowego wyrażenia regularnego .NET — przenośnego, niezwiązanego ze schematem żadnego dostawcy.

Zastąpienie wyników ustrukturyzowanych ekstrakcją wzorców

Veryfi zwraca wstępnie przeanalizowane pola;IronOCR zwraca surowy tekst OCR. Praca związana z migracją polega na napisaniu wzorców ekstrakcji, które firmaVeryfirealizowała w swojej chmurze. W przypadku paragonów i faktur o spójnym układzie jest to proste:

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)

W przypadku paragonów o nietypowym układzie lub wyblakłym nadruku filtry przetwarzania wstępnego IronOCR poprawiają dokładność danych surowych przed rozpoczęciem ekstrakcji. Zapoznaj się z przewodnikiem po korekcji jakości obrazu oraz przewodnikiem po korekcji kolorów obrazu, aby dowiedzieć się, jak radzić sobie z rzeczywistą jakością skanów paragonów.

Obsługa przejścia z trybu asynchronicznego do synchronicznego

Cała powierzchnia APIVeryfijest asynchroniczna. Główna ścieżka IronOCR jest synchroniczna. Istniejące sygnatury metod asynchronicznych w kodzie aplikacji można zachować poprzez opakowanie:

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

Dla scenariuszy wysokiej przepustowości,IronOCR jest bezpieczny dla wątków, a wiele instancji IronTesseract może przetwarzać dokumenty równolegle bez synchronizacji. Przewodnik po optymalizacji szybkości obejmuje wzorce ponownego wykorzystania instancji oraz strategie ładowania partiami, które minimalizują czas przetwarzania na dużą skalę.

Czyszczenie danych uwierzytelniających

Veryfi wymaga czterech danych identyfikacyjnych: ClientId, ClientSecret, Username, i ApiKey. Wszystkie cztery elementy muszą zostać usunięte z plików konfiguracyjnych, zmiennych środowiskowych, magazynów kluczy oraz potoków CI/CD po migracji.IronOCR wymaga pojedynczego ciągu klucza licencyjnego. Lista kontrolna migracji: usuń wszystkie cztery tajemniceVeryfiz każdego środowiska, dodaj jedną zmienną środowiskową IRONOCR_LICENSE i zaktualizuj kanały wdrożenia, aby usunąć wprowadzanie danych identyfikacyjnych Veryfi.

Przetwarzanie plików PDF dla faktur

Veryfi akceptuje bajty PDF przez ProcessDocumentAsync.IronOCR przetwarza natywnie pliki PDF przez 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

Dla przepływów faktur, które tworzą przeszukiwalne archiwa PDF, metoda SaveAsSearchablePdf()IronOCR generuje wyjście zgodne z PDF/A z zeskanowanego wejścia—coś, czego chmurowe APIVeryfinie oferuje. Zobacz przewodnik po przeszukiwalnych plikach PDF dla szczegółów implementacyjnych.