Veryfi przesyła numery kont bankowych, numery routingu, kwoty transakcji oraz relacje z dostawcami na zewnętrzny serwer w chmurze za każdym razem, gdy wywołujesz _client.ProcessDocumentAsync(bytes). Taka jest rzeczywistość architektoniczna, która definiuje całą ocenę Veryfi: zanim pojawi się choćby jedna linijka ustrukturyzowanego JSON-a, dokumenty wydatków — zawierające jedne z najbardziej wrażliwych danych finansowych w organizacji — opuściły już infrastrukturę. Dla wielu zespołów to koniec oceny.

Zrozumienie Veryfi

Veryfi to oparte na chmurze API do analizy dokumentów, stworzone wyłącznie z myślą o dokumentach finansowych i dotyczących wydatków. Główną zaletą produktu jest ustrukturyzowany wynik: zamiast surowego tekstu z OCR, który wymaga dalszego parsowania, wywołanie APIVeryfizwraca wstępnie wyodrębnione pola — nazwę dostawcy, sumę, pozycje, podatek, cztery ostatnie cyfry karty płatniczej, a w przypadku faktur — numer konta bankowego i numer rozliczeniowy. Modele są wstępnie trenowane na dużych zbiorach dokumentów finansowych i zapewniają ponad 99% dokładności w obsługiwanych kategoriach dokumentów.

Architektura jest w pełni oparta na chmurze. Każdy dokument opuszcza aplikację, przechodzi przez HTTPS do serwerów Veryfi, przechodzi przez ich potok AI/ML i wraca jako JSON. Nie ma opcji wdrożenia lokalnego, trybu air-gapped ani możliwości przetwarzania dokumentu bez przesyłania go na zewnątrz.

Kluczowe cechy architektury:

• Przetwarzanie tylko w chmurze: Każdy dokument jest przesyłany do api.veryfi.com bez lokalnej ścieżki przetwarzania
• Autoryzacja czteroskładnikowa: VeryfiClient wymaga clientId, clientSecret, username, i apiKey—cztery tajemnice do zarządzania, przechowywania w bezpieczny sposób i obracania
• Cena za dokument: Skontaktuj sie z Veryfi, aby uzyskac aktualne stawki wedlug typu dokumentu i poziomu wolumenu
• API tylko asynchroniczne: ProcessDocumentAsync jest główną metodą; nie ma synchronicznej sciezki
• Zakres dokumentów specjalistycznych: pokwitowania, faktury, czeki, wyciągi bankowe, formularze W-2 i wizytówki; dokumenty ogólne, dokumentacja medyczna, umowy i rysunki techniczne nie są objęte niezawodnym tłumaczeniem
• Własny schemat JSON: format odpowiedziVeryfijest specyficzny dla Veryfi; przelaczenie dostawcow wymaga przepisania logiki ekstrakcji
• Ograniczanie szybkości: Przetwarzanie dużych ilości danych wymaga logiki wycofania i ponownej próby w celu obsługi odpowiedzi HTTP 429

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

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

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.

Zrozumienie IronOCR

IronOCR to komercyjna biblioteka OCR dla platformy .NET, przeznaczona do instalacji lokalnej, która przetwarza każdy dokument lokalnie. Żadne bajty dokumentów nie opuszczają Twojej infrastruktury. Biblioteka zawiera zoptymalizowany silnik Tesseract 5 z automatycznym przetwarzaniem wstępnym, natywną obsługą plików PDF oraz ponad 125 pakietami językowymi — wszystko to dostarczane jest w postaci pojedynczego pakietu NuGet z Licencją wieczystą.

Kluczowe cechy:

• Zaprojektowany do pracy lokalnej: całe przetwarzanie odbywa się na Twoim sprzęcie; brak wywołań sieciowych dla OCR
• Automatyczne przetwarzanie wstępne: funkcje Deskew, DeNoise, Contrast, Binarize i EnhanceResolution są stosowane automatycznie bez konieczności wyraźnej konfiguracji
• Natywne wejście PDF: Czytaj skanowane i cyfrowe PDF-y bezpośrednio przez LoadPdf()—nie jest wymagana osobna biblioteka PDF
• Licencjonowanie wieczyste: $999 Lite / $1,499 Plus / $2,399 Professional / $4,799 Unlimited—zapłać raz, przetwarzaj nieograniczoną liczbę dokumentów
• Strukturalny dostęp do wyników: słowa, wiersze, akapity i strony z współrzędnymi X/Y oraz wynikami pewności dla poszczególnych słów
• Bezpieczne dla wątków i dające się zrównoleglić: Instancje IronTesseract mogą być używane między wątkami bez dodatkowej synchronizacji
• Ponad 125 języków: instalacja jako pakiety NuGet, nie wymaga zarządzania folderem tessdata
• Wielopłatformowość: Windows, Linux, macOS, Docker, AWS, Azure — jeden pakiet obejmuje wszystkie platformy docelowe

Porównanie funkcji

Szczegółowe porównanie funkcji

Ochrona danych w dokumentach finansowych

Dokumenty finansowe przetwarzane przezVeryfizawierają najbardziej wrażliwe kategorie danych w każdej organizacji. Nie jest to kwestia teoretyczna — jest to konkretny fakt architektoniczny dotyczący działania produktu.

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

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

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.

Specjalistyczny zakres vs. ogólny OCR

Wąska specjalizacjaVeryfiw zakresie dokumentów jest zarówno jego największą zaletą, jak i najpoważniejszym ograniczeniem. Wstępnie wytrenowane modele zapewniają naprawdę szybkie, uporządkowane wyniki dla konkretnych typów dokumentów, do których zostały stworzone. Problem pojawia się w momencie, gdy Twoja organizacja potrzebuje OCR spoza tej listy.

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

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

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.

Koszt w chmurze za dokument a Licencja wieczysta

Różnica w kosztach międzyVeryfia IronOCR kumuluje się wraz z każdą przetworzoną dokumentacją. Model rozliczeniowyVeryfioparty na liczbie dokumentów oznacza, że koszty rosną proporcjonalnie do ilości, bez górnego limitu, chyba że zostanie on uzgodniony w umowie.

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)

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

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

Webhook i przetwarzanie asynchroniczne a synchroniczne wyniki lokalne

Architektura chmuryVeryfinarzuca model przetwarzania wyłącznie asynchronicznego. Dokument trafia na zdalny serwer, jest przetwarzany przez zdalny potok, a odpowiedź przychodzi po przejściu przez sieć w obie strony. W przypadku przetwarzania partii o dużej objętości firmaVeryfizaleca powiadomienia oparte na webhookach zamiast odpytywania.IronOCR domyślnie przetwarza dane synchronicznie, bez zależności od sieci w pętli.

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

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

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.

Przewodnik po mapowaniu API

Kiedy zespoły rozważają przejście zVeryfina IronOCR

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

Typowe kwestie związane z migracją

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)

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

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

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.

Dodatkowe możliwości IronOCR

Poza podstawowymi obszarami porównawczymi IronOCR oferuje funkcje, które całkowicie wykraczają poza zakres Veryfi:

• Pobieranie tabel: odczyt tabel o ustalonej strukturze z dokumentów o układzie siatki, co ma zastosowanie w przypadku wyciągów bankowych i szczegółowych faktur
• Rozpoznawanie pisma ręcznego: przetwarzanie odręcznych notatek, podpisów i ręcznie wypełnionych pól formularzy, do których obsługi nie są przystosowane wstępnie wyszkolone modele Veryfi
• Odczyt MICR/czeków: Dedykowane wyodrębnianie linii MICR dla procesów przetwarzania czeków, z zachowaniem wyodrębniania numeru rozliczeniowego i numeru konta na miejscu
• Eksport hOCR: Eksportuj wyniki OCR jako hOCR (HTML z danymi pozycyjnymi) do dalszych procesów analizy dokumentów
• Śledzenie postępów: monitorowanie postępu przetwarzania długotrwałych zadań wsadowych bez odpytywania zdalnego API
• Odczytywanie paszportów i dokumentów tożsamości: Wyodrębnianie danych ze stref nadających się do odczytu maszynowego z paszportów i dokumentów tożsamości na potrzeby procesów wdrażania nowych klientów i weryfikacji tożsamości (KYC)
• Wdrożenie w AWS i Azure: Wdrażaj w infrastrukturze chmurowej, zachowując przetwarzanie dokumentów na własnym koncie w chmurze — bez dodawania zewnętrznego podmiotu przetwarzającego dane SaaS do zakresu zgodności

Zgodność z platformą .NET i gotowość na przyszłość

IronOCR jest przeznaczony dla platform .NET 8, .NET 9 i nadchodzącej .NET 10, a także dla .NET Standard 2.0+ w celu zapewnienia kompatybilności z starszymi wersjami. Działa na systemach Windows x64/x86, Linux x64, macOS i ARM64 — obejmując wszystkie nowoczesne środowiska wdrożeniowe .NET, w tym kontenery Docker, Azure App Service, AWS Lambda oraz lokalne serwery Linux. Model wdrażania w postaci pojedynczego pakietu oznacza brak natywnego zarządzania plikami binarnymi w różnych środowiskach; to samo odwołanie NuGet jest poprawnie rozpoznawane na każdej obsługiwanej platformie. SDKVeryfidla języka C# jest przeznaczone dla platformy .NET Standard i działa jako opakowanie klienta HTTP, co oznacza, że jego "kompatybilność" wynika przede wszystkim ze stosu HTTP, a nie z głębokości silnika OCR — jest to istotna różnica, gdy w grę wchodzą ograniczenia platformy lub sieci.

Wnioski

Veryfi szybko rozwiązuje konkretny problem: przesyłanie dokumentu wydatków i otrzymywanie ustrukturyzowanych pól JSON bez konieczności pisania logiki parsującej. W przypadku automatyzacji wydatków na małą skalę w środowiskach, w których dopuszczalna jest transmisja danych w chmurze, propozycja ta ma rzeczywistą wartość. Trudności pojawiają się, gdy wolumen przekracza poziom, przy którym koszty w przeliczeniu na dokument przewyższają koszt Licencji wieczystej w ciągu kilku tygodni, gdy typy dokumentów wykraczają poza kategorie, na któreVeryfizostało przeszkolone, gdy wymogi zgodności sprawiają, że przetwarzanie dokumentów finansowych przez podmioty zewnętrzne staje się niepraktyczne lub gdy aplikacja po prostu musi działać bez dostępu do Internetu.

Model uwierzytelniania oparty na czterech poświadczeniach, API obsługujące wyłącznie operacje asynchroniczne, ograniczanie szybkości, błędy płatności HTTP 402, które wstrzymują przetwarzanie wsadowe, oraz zastrzeżony schemat JSON, który wiąże całą logikę ekstrakcji z jednym dostawcą — nie są to kwestie dotyczące tylko skrajnych przypadków. Są to codzienne realia operacyjne dla zespołów korzystających zVeryfiw środowisku produkcyjnym na dużą skalę.

IronOCR wymaga napisania wzorców ekstrakcji, któreVeryfiobsługuje automatycznie. To są rzeczywiste koszty rozwoju: należy spodziewać się, że stworzenie ekstrakcji wyrażeniami regularnymi dla paragonów i faktur zajmie od 8 do 24 godzin, w zależności od różnorodności dokumentów. Ale ta inwestycja jest jednorazowa. Powstały kod działa na Twojej infrastrukturze, przetwarza dowolny typ dokumentu, działa w trybie offline i nie generuje żadnych kosztów za dokument. Wyciągi bankowe, numery rozliczeniowe, numery kont i historie transakcji nigdy nie opuszczają Twojego serwera.

Dla zespołów z branży usług finansowych, opieki zdrowotnej, kontraktów obronnych lub usług prawnych — czyli każdej dziedziny, w której wysyłanie dokumentów dotyczących wydatków do chmury zewnętrznej wiąże się z kwestią zgodności z przepisami — rozwiązanie IronOCR całkowicie eliminuje tę kwestię. Dla zespołów, które obecnie wydają 5 000–20 000 dolarów miesięcznie na Veryfi, kalkulacja jest prosta. Dla zespołów, które potrzebują uniwersalnego OCR wykraczającego poza dokumenty rozliczeniowe, wybór jest oczywisty: specjalista od chmury lub lokalna biblioteka ogólnego przeznaczenia nie są równoważnymi narzędziami, a jednorazowy koszt licencji tej drugiej zapewnia nieograniczoną elastyczność, której ta pierwsza nie może zapewnić przy żadnej cenie za dokument.