Migrating from Veryfi to IronOCR

// Veryfi: financial data leaves your infrastructure on every call
var client = new VeryfiClient(clientId, clientSecret, username, apiKey); // 4 secrets
var bytes = File.ReadAllBytes("invoice-with-routing-number.pdf");
var response = await client.ProcessDocumentAsync(bytes); // bank details transmitted
var routingNumber = response.BankAccount?.RoutingNumber; // arrived via Veryfi cloud

' Veryfi: financial data leaves your infrastructure on every call
Dim client = New VeryfiClient(clientId, clientSecret, username, apiKey) ' 4 secrets
Dim bytes = File.ReadAllBytes("invoice-with-routing-number.pdf")
Dim response = Await client.ProcessDocumentAsync(bytes) ' bank details transmitted
Dim routingNumber = response.BankAccount?.RoutingNumber ' arrived via Veryfi cloud

// IronOCR: routing numbers never leave your server
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"; // 1 key
var ocr = new IronTesseract();
using var input = new OcrInput();
input.LoadPdf("invoice-with-routing-number.pdf"); // processed locally
var result = ocr.Read(input);
var routingNumber = Regex.Match(result.Text, @"Routing\s*#?\s*:?\s*(\d{9})").Groups[1].Value;

Imports IronOcr
Imports System.Text.RegularExpressions

' IronOCR: routing numbers never leave your server
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY" ' 1 key
Dim ocr As New IronTesseract()
Using input As New OcrInput()
    input.LoadPdf("invoice-with-routing-number.pdf") ' processed locally
    Dim result = ocr.Read(input)
    Dim routingNumber = Regex.Match(result.Text, "Routing\s*#?\s*:?\s*(\d{9})").Groups(1).Value
End Using

dotnet remove package Veryfi

// Before (Veryfi)
using Veryfi;
using Veryfi.Models;

// After (IronOCR)
using IronOcr;
using System.Text.RegularExpressions;

Imports IronOcr
Imports System.Text.RegularExpressions

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

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

using Veryfi;
using Microsoft.Extensions.Configuration;

public class ExpenseDocumentService
{
    private readonly VeryfiClient _client;

    // Four credentials injected — four secrets to manage, store, rotate
    public ExpenseDocumentService(IConfiguration config)
    {
        _client = new VeryfiClient(
            config["Veryfi:ClientId"],       // secret 1
            config["Veryfi:ClientSecret"],   // secret 2
            config["Veryfi:Username"],       // secret 3
            config["Veryfi:ApiKey"]          // secret 4
        );
    }

    public async Task<string> GetVendorNameAsync(string documentPath)
    {
        var bytes = File.ReadAllBytes(documentPath);
        // Document uploaded to Veryfi on this call
        var response = await _client.ProcessDocumentAsync(bytes);
        return response.Vendor?.Name;
    }

    public async Task<decimal?> GetTotalAsync(string documentPath)
    {
        var bytes = File.ReadAllBytes(documentPath);
        var response = await _client.ProcessDocumentAsync(bytes);
        return response.Total;
    }
}

Imports Veryfi
Imports Microsoft.Extensions.Configuration
Imports System.IO
Imports System.Threading.Tasks

Public Class ExpenseDocumentService
    Private ReadOnly _client As VeryfiClient

    ' Four credentials injected — four secrets to manage, store, rotate
    Public Sub New(config As IConfiguration)
        _client = New VeryfiClient(
            config("Veryfi:ClientId"),       ' secret 1
            config("Veryfi:ClientSecret"),   ' secret 2
            config("Veryfi:Username"),       ' secret 3
            config("Veryfi:ApiKey")          ' secret 4
        )
    End Sub

    Public Async Function GetVendorNameAsync(documentPath As String) As Task(Of String)
        Dim bytes = File.ReadAllBytes(documentPath)
        ' Document uploaded to Veryfi on this call
        Dim response = Await _client.ProcessDocumentAsync(bytes)
        Return response.Vendor?.Name
    End Function

    Public Async Function GetTotalAsync(documentPath As String) As Task(Of Decimal?)
        Dim bytes = File.ReadAllBytes(documentPath)
        Dim response = Await _client.ProcessDocumentAsync(bytes)
        Return response.Total
    End Function
End Class

using IronOcr;
using System.Text.RegularExpressions;

public class ExpenseDocumentService
{
    private readonly IronTesseract _ocr;

    // One license key — set once at startup, not per-instance
    public ExpenseDocumentService()
    {
        _ocr = new IronTesseract();
    }

    public string GetVendorName(string documentPath)
    {
        // All processing local — document bytes never leave this server
        var result = _ocr.Read(documentPath);

        // Vendor is typically the first non-whitespace line on a receipt
        return result.Pages[0].Paragraphs
            .OrderBy(p => p.Y)
            .Select(p => p.Text.Trim())
            .FirstOrDefault(t => t.Length > 3);
    }

    public decimal? GetTotal(string documentPath)
    {
        var result = _ocr.Read(documentPath);
        var match = Regex.Match(result.Text,
            @"(?:Total|Grand Total|Amount Due):?\s*\$?\s*([\d,]+\.\d{2})",
            RegexOptions.IgnoreCase);
        return match.Success
            ? decimal.Parse(match.Groups[1].Value.Replace(",", ""))
            : (decimal?)null;
    }
}

Imports IronOcr
Imports System.Text.RegularExpressions

Public Class ExpenseDocumentService
    Private ReadOnly _ocr As IronTesseract

    ' One license key — set once at startup, not per-instance
    Public Sub New()
        _ocr = New IronTesseract()
    End Sub

    Public Function GetVendorName(documentPath As String) As String
        ' All processing local — document bytes never leave this server
        Dim result = _ocr.Read(documentPath)

        ' Vendor is typically the first non-whitespace line on a receipt
        Return result.Pages(0).Paragraphs _
            .OrderBy(Function(p) p.Y) _
            .Select(Function(p) p.Text.Trim()) _
            .FirstOrDefault(Function(t) t.Length > 3)
    End Function

    Public Function GetTotal(documentPath As String) As Decimal?
        Dim result = _ocr.Read(documentPath)
        Dim match = Regex.Match(result.Text, 
            "(?:Total|Grand Total|Amount Due):?\s*\$?\s*([\d,]+\.\d{2})", 
            RegexOptions.IgnoreCase)
        Return If(match.Success, 
            Decimal.Parse(match.Groups(1).Value.Replace(",", "")), 
            CType(Nothing, Decimal?))
    End Function
End Class

using Veryfi;

public class ReceiptFieldExtractor
{
    private readonly VeryfiClient _client;

    public ReceiptFieldExtractor(VeryfiClient client)
    {
        _client = client;
    }

    public async Task<(string Vendor, decimal? Total, decimal? Tax)>
        ExtractReceiptFieldsAsync(string imagePath)
    {
        var bytes = File.ReadAllBytes(imagePath);

        // Full document uploaded — Veryfi's ML returns structured fields
        var response = await _client.ProcessDocumentAsync(bytes);

        return (
            Vendor: response.Vendor?.Name,
            Total:  response.Total,
            Tax:    response.Tax
        );
    }
}

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

Public Class ReceiptFieldExtractor
    Private ReadOnly _client As VeryfiClient

    Public Sub New(client As VeryfiClient)
        _client = client
    End Sub

    Public Async Function ExtractReceiptFieldsAsync(imagePath As String) As Task(Of (Vendor As String, Total As Decimal?, Tax As Decimal?))
        Dim bytes = File.ReadAllBytes(imagePath)

        ' Full document uploaded — Veryfi's ML returns structured fields
        Dim response = Await _client.ProcessDocumentAsync(bytes)

        Return (Vendor:=response.Vendor?.Name, Total:=response.Total, Tax:=response.Tax)
    End Function
End Class

using IronOcr;
using System.Text.RegularExpressions;

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

    public (string Vendor, decimal? Total, decimal? Tax)
        ExtractReceiptFields(string imagePath)
    {
        // Region 1: Header zone — vendor name typically in top 15% of receipt
        var headerRegion = new CropRectangle(0, 0, 800, 150);
        using var headerInput = new OcrInput();
        headerInput.LoadImage(imagePath, headerRegion);
        headerInput.Deskew();
        var headerResult = _ocr.Read(headerInput);

        // Region 2: Footer zone — totals typically in bottom 20% of receipt
        var footerRegion = new CropRectangle(0, 650, 800, 200);
        using var footerInput = new OcrInput();
        footerInput.LoadImage(imagePath, footerRegion);
        footerInput.DeNoise();
        var footerResult = _ocr.Read(footerInput);

        var vendor = headerResult.Pages[0].Paragraphs
            .OrderBy(p => p.Y)
            .Select(p => p.Text.Trim())
            .FirstOrDefault(t => t.Length > 3);

        var footerText = footerResult.Text;

        var totalMatch = Regex.Match(footerText,
            @"(?:Total|Grand Total):?\s*\$?\s*([\d,]+\.\d{2})",
            RegexOptions.IgnoreCase);

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

        return (
            Vendor: vendor,
            Total: totalMatch.Success
                ? decimal.Parse(totalMatch.Groups[1].Value.Replace(",", ""))
                : (decimal?)null,
            Tax: taxMatch.Success
                ? decimal.Parse(taxMatch.Groups[1].Value.Replace(",", ""))
                : (decimal?)null
        );
    }
}

Imports IronOcr
Imports System.Text.RegularExpressions

Public Class ReceiptFieldExtractor
    Private ReadOnly _ocr As New IronTesseract()

    Public Function ExtractReceiptFields(imagePath As String) As (Vendor As String, Total As Decimal?, Tax As Decimal?)
        ' Region 1: Header zone — vendor name typically in top 15% of receipt
        Dim headerRegion As New CropRectangle(0, 0, 800, 150)
        Using headerInput As New OcrInput()
            headerInput.LoadImage(imagePath, headerRegion)
            headerInput.Deskew()
            Dim headerResult = _ocr.Read(headerInput)

            ' Region 2: Footer zone — totals typically in bottom 20% of receipt
            Dim footerRegion As New CropRectangle(0, 650, 800, 200)
            Using footerInput As New OcrInput()
                footerInput.LoadImage(imagePath, footerRegion)
                footerInput.DeNoise()
                Dim footerResult = _ocr.Read(footerInput)

                Dim vendor = headerResult.Pages(0).Paragraphs _
                    .OrderBy(Function(p) p.Y) _
                    .Select(Function(p) p.Text.Trim()) _
                    .FirstOrDefault(Function(t) t.Length > 3)

                Dim footerText = footerResult.Text

                Dim totalMatch = Regex.Match(footerText, _
                    "(?:Total|Grand Total):?\s*\$?\s*([\d,]+\.\d{2})", _
                    RegexOptions.IgnoreCase)

                Dim taxMatch = Regex.Match(footerText, _
                    "(?:Tax|Sales Tax|VAT):?\s*\$?\s*([\d,]+\.\d{2})", _
                    RegexOptions.IgnoreCase)

                Return ( _
                    Vendor:=vendor, _
                    Total:=If(totalMatch.Success, Decimal.Parse(totalMatch.Groups(1).Value.Replace(",", "")), CType(Nothing, Decimal?)), _
                    Tax:=If(taxMatch.Success, Decimal.Parse(taxMatch.Groups(1).Value.Replace(",", "")), CType(Nothing, Decimal?)) _
                )
            End Using
        End Using
    End Function
End Class

using Veryfi;

public class ExpenseCategorizer
{
    private readonly VeryfiClient _client;

    public ExpenseCategorizer(VeryfiClient client)
    {
        _client = client;
    }

    public async Task<Dictionary<string, decimal>> CategorizeExpensesAsync(string receiptPath)
    {
        var bytes = File.ReadAllBytes(receiptPath);
        var response = await _client.ProcessDocumentAsync(bytes);

        var categories = new Dictionary<string, decimal>();

        // Line items arrive pre-parsed from Veryfi's ML pipeline
        foreach (var item in response.LineItems ?? Enumerable.Empty<dynamic>())
        {
            var category = response.Category ?? "Uncategorized";
            var amount   = (decimal)(item.Total ?? 0m);

            if (!categories.ContainsKey(category))
                categories[category] = 0m;

            categories[category] += amount;
        }

        return categories;
    }
}

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

Public Class ExpenseCategorizer
    Private ReadOnly _client As VeryfiClient

    Public Sub New(client As VeryfiClient)
        _client = client
    End Sub

    Public Async Function CategorizeExpensesAsync(receiptPath As String) As Task(Of Dictionary(Of String, Decimal))
        Dim bytes = File.ReadAllBytes(receiptPath)
        Dim response = Await _client.ProcessDocumentAsync(bytes)

        Dim categories As New Dictionary(Of String, Decimal)()

        ' Line items arrive pre-parsed from Veryfi's ML pipeline
        For Each item In If(response.LineItems, Enumerable.Empty(Of Object)())
            Dim category = If(response.Category, "Uncategorized")
            Dim amount = CType(If(item.Total, 0D), Decimal)

            If Not categories.ContainsKey(category) Then
                categories(category) = 0D
            End If

            categories(category) += amount
        Next

        Return categories
    End Function
End Class

using IronOcr;
using System.Text.RegularExpressions;

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

    // Keyword-based categorization — tune these for your expense policy
    private static readonly Dictionary<string, string[]> CategoryKeywords = new()
    {
        ["Meals & Entertainment"] = new[] { "restaurant", "cafe", "coffee", "lunch", "dinner", "food", "bar" },
        ["Travel"]                = new[] { "airline", "hotel", "uber", "lyft", "taxi", "parking", "gas", "fuel" },
        ["Office Supplies"]       = new[] { "staples", "office depot", "paper", "ink", "toner", "supplies" },
        ["Software & Subscriptions"] = new[] { "adobe", "microsoft", "github", "aws", "azure", "slack" }
    };

    public Dictionary<string, decimal> CategorizeExpenses(string receiptPath)
    {
        var result = _ocr.Read(receiptPath);

        // Use paragraph coordinates to isolate line items
        // Line items typically appear in the middle vertical band of the receipt
        var lineItemParagraphs = result.Pages[0].Paragraphs
            .Where(p => p.Y > 150 && p.Y < 650) // skip header/footer regions
            .OrderBy(p => p.Y)
            .ToList();

        var categories = new Dictionary<string, decimal>();
        var pricePattern = new Regex(@"\$?([\d,]+\.\d{2})$");
        var vendorText   = result.Text.ToLower();

        // Determine top-level category from vendor name
        var topCategory = "Uncategorized";
        foreach (var (cat, keywords) in CategoryKeywords)
        {
            if (keywords.Any(kw => vendorText.Contains(kw)))
            {
                topCategory = cat;
                break;
            }
        }

        // Extract individual line item amounts
        foreach (var para in lineItemParagraphs)
        {
            var priceMatch = pricePattern.Match(para.Text.Trim());
            if (!priceMatch.Success)
                continue;

            if (!decimal.TryParse(priceMatch.Groups[1].Value.Replace(",", ""), out var amount))
                continue;

            // Classify individual items where keywords appear in the description
            var itemCategory = topCategory;
            var descriptionText = para.Text.ToLower();
            foreach (var (cat, keywords) in CategoryKeywords)
            {
                if (keywords.Any(kw => descriptionText.Contains(kw)))
                {
                    itemCategory = cat;
                    break;
                }
            }

            if (!categories.ContainsKey(itemCategory))
                categories[itemCategory] = 0m;

            categories[itemCategory] += amount;
        }

        return categories;
    }
}

Imports IronOcr
Imports System.Text.RegularExpressions

Public Class ExpenseCategorizer
    Private ReadOnly _ocr As New IronTesseract()

    ' Keyword-based categorization — tune these for your expense policy
    Private Shared ReadOnly CategoryKeywords As New Dictionary(Of String, String()) From {
        {"Meals & Entertainment", New String() {"restaurant", "cafe", "coffee", "lunch", "dinner", "food", "bar"}},
        {"Travel", New String() {"airline", "hotel", "uber", "lyft", "taxi", "parking", "gas", "fuel"}},
        {"Office Supplies", New String() {"staples", "office depot", "paper", "ink", "toner", "supplies"}},
        {"Software & Subscriptions", New String() {"adobe", "microsoft", "github", "aws", "azure", "slack"}}
    }

    Public Function CategorizeExpenses(receiptPath As String) As Dictionary(Of String, Decimal)
        Dim result = _ocr.Read(receiptPath)

        ' Use paragraph coordinates to isolate line items
        ' Line items typically appear in the middle vertical band of the receipt
        Dim lineItemParagraphs = result.Pages(0).Paragraphs _
            .Where(Function(p) p.Y > 150 AndAlso p.Y < 650) _
            .OrderBy(Function(p) p.Y) _
            .ToList()

        Dim categories As New Dictionary(Of String, Decimal)()
        Dim pricePattern As New Regex("\$?([\d,]+\.\d{2})$")
        Dim vendorText = result.Text.ToLower()

        ' Determine top-level category from vendor name
        Dim topCategory = "Uncategorized"
        For Each kvp In CategoryKeywords
            Dim cat = kvp.Key
            Dim keywords = kvp.Value
            If keywords.Any(Function(kw) vendorText.Contains(kw)) Then
                topCategory = cat
                Exit For
            End If
        Next

        ' Extract individual line item amounts
        For Each para In lineItemParagraphs
            Dim priceMatch = pricePattern.Match(para.Text.Trim())
            If Not priceMatch.Success Then
                Continue For
            End If

            Dim amount As Decimal
            If Not Decimal.TryParse(priceMatch.Groups(1).Value.Replace(",", ""), amount) Then
                Continue For
            End If

            ' Classify individual items where keywords appear in the description
            Dim itemCategory = topCategory
            Dim descriptionText = para.Text.ToLower()
            For Each kvp In CategoryKeywords
                Dim cat = kvp.Key
                Dim keywords = kvp.Value
                If keywords.Any(Function(kw) descriptionText.Contains(kw)) Then
                    itemCategory = cat
                    Exit For
                End If
            Next

            If Not categories.ContainsKey(itemCategory) Then
                categories(itemCategory) = 0D
            End If

            categories(itemCategory) += amount
        Next

        Return categories
    End Function
End Class

using Veryfi;
using Microsoft.AspNetCore.Mvc;

// Veryfi webhook receiver — required for high-volume reliable processing
[ApiController]
[Route("webhooks")]
public class VeryfiWebhookController : ControllerBase
{
    private readonly IDocumentResultQueue _queue;

    public VeryfiWebhookController(IDocumentResultQueue queue)
    {
        _queue = queue;
    }

    [HttpPost("veryfi")]
    public IActionResult ReceiveWebhook([FromBody] VeryfiWebhookPayload payload,
                                        [FromHeader(Name = "X-Veryfi-Token")] string token)
    {
        // Validate webhook signature — prevents spoofed payloads
        if (!IsValidSignature(token, payload))
            return Unauthorized();

        // Enqueue result for async downstream consumption
        _queue.Enqueue(new DocumentResult
        {
            DocumentId = payload.Id,
            Vendor     = payload.Data?.Vendor?.Name,
            Total      = payload.Data?.Total
        });

        return Ok();
    }

    private bool IsValidSignature(string token, VeryfiWebhookPayload payload) =>
        // HMAC validation against webhook secret — infrastructure requirement
        token == ComputeHmac(payload, Environment.GetEnvironmentVariable("VERYFI_WEBHOOK_SECRET"));
}

// Document batch submission — fire and forget, results arrive via webhook
public class VeryfiDocumentBatchSubmitter
{
    private readonly VeryfiClient _client;

    public async Task SubmitBatchAsync(string[] documentPaths)
    {
        foreach (var path in documentPaths)
        {
            var bytes = File.ReadAllBytes(path);
            // Submit — result arrives asynchronously via webhook, not here
            await _client.ProcessDocumentAsync(bytes);
        }
    }
}

Imports Veryfi
Imports Microsoft.AspNetCore.Mvc

' Veryfi webhook receiver — required for high-volume reliable processing
<ApiController>
<Route("webhooks")>
Public Class VeryfiWebhookController
    Inherits ControllerBase

    Private ReadOnly _queue As IDocumentResultQueue

    Public Sub New(queue As IDocumentResultQueue)
        _queue = queue
    End Sub

    <HttpPost("veryfi")>
    Public Function ReceiveWebhook(<FromBody> payload As VeryfiWebhookPayload,
                                   <FromHeader(Name:="X-Veryfi-Token")> token As String) As IActionResult
        ' Validate webhook signature — prevents spoofed payloads
        If Not IsValidSignature(token, payload) Then
            Return Unauthorized()
        End If

        ' Enqueue result for async downstream consumption
        _queue.Enqueue(New DocumentResult With {
            .DocumentId = payload.Id,
            .Vendor = payload.Data?.Vendor?.Name,
            .Total = payload.Data?.Total
        })

        Return Ok()
    End Function

    Private Function IsValidSignature(token As String, payload As VeryfiWebhookPayload) As Boolean
        ' HMAC validation against webhook secret — infrastructure requirement
        Return token = ComputeHmac(payload, Environment.GetEnvironmentVariable("VERYFI_WEBHOOK_SECRET"))
    End Function
End Class

' Document batch submission — fire and forget, results arrive via webhook
Public Class VeryfiDocumentBatchSubmitter

    Private ReadOnly _client As VeryfiClient

    Public Async Function SubmitBatchAsync(documentPaths As String()) As Task
        For Each path In documentPaths
            Dim bytes = File.ReadAllBytes(path)
            ' Submit — result arrives asynchronously via webhook, not here
            Await _client.ProcessDocumentAsync(bytes)
        Next
    End Function
End Class

using IronOcr;
using System.Text.RegularExpressions;
using System.Collections.Concurrent;

// No webhook controller needed — results are synchronous and local
public class DocumentBatchProcessor
{
    // IronTesseract is thread-safe when one instance is created per thread
    public List<DocumentResult> ProcessBatch(string[] documentPaths)
    {
        var results = new ConcurrentBag<DocumentResult>();

        Parallel.ForEach(documentPaths, documentPath =>
        {
            // One IronTesseract per thread — thread-safe pattern
            var ocr    = new IronTesseract();
            var result = ocr.Read(documentPath);

            results.Add(new DocumentResult
            {
                FilePath   = documentPath,
                Vendor     = ExtractVendor(result),
                Total      = ExtractTotal(result.Text),
                Confidence = result.Confidence,
                // Result is available immediately — no queue, no webhook
                ProcessedAt = DateTime.UtcNow
            });
        });

        return results.OrderBy(r => r.FilePath).ToList();
    }

    private string ExtractVendor(OcrResult result)
    {
        // Vendor: first substantive paragraph ordered by vertical position
        return result.Pages[0].Paragraphs
            .OrderBy(p => p.Y)
            .Select(p => p.Text.Trim())
            .FirstOrDefault(t => !string.IsNullOrWhiteSpace(t) && t.Length > 3);
    }

    private decimal? ExtractTotal(string text)
    {
        var match = Regex.Match(text,
            @"(?:Total|Grand Total|Amount Due):?\s*\$?\s*([\d,]+\.\d{2})",
            RegexOptions.IgnoreCase);
        return match.Success
            ? decimal.Parse(match.Groups[1].Value.Replace(",", ""))
            : (decimal?)null;
    }
}

public class DocumentResult
{
    public string FilePath   { get; set; }
    public string Vendor     { get; set; }
    public decimal? Total    { get; set; }
    public double Confidence { get; set; }
    public DateTime ProcessedAt { get; set; }
}

Imports IronOcr
Imports System.Text.RegularExpressions
Imports System.Collections.Concurrent

' No webhook controller needed — results are synchronous and local
Public Class DocumentBatchProcessor

    ' IronTesseract is thread-safe when one instance is created per thread
    Public Function ProcessBatch(documentPaths As String()) As List(Of DocumentResult)
        Dim results = New ConcurrentBag(Of DocumentResult)()

        Parallel.ForEach(documentPaths, Sub(documentPath)
            ' One IronTesseract per thread — thread-safe pattern
            Dim ocr = New IronTesseract()
            Dim result = ocr.Read(documentPath)

            results.Add(New DocumentResult With {
                .FilePath = documentPath,
                .Vendor = ExtractVendor(result),
                .Total = ExtractTotal(result.Text),
                .Confidence = result.Confidence,
                ' Result is available immediately — no queue, no webhook
                .ProcessedAt = DateTime.UtcNow
            })
        End Sub)

        Return results.OrderBy(Function(r) r.FilePath).ToList()
    End Function

    Private Function ExtractVendor(result As OcrResult) As String
        ' Vendor: first substantive paragraph ordered by vertical position
        Return result.Pages(0).Paragraphs _
            .OrderBy(Function(p) p.Y) _
            .Select(Function(p) p.Text.Trim()) _
            .FirstOrDefault(Function(t) Not String.IsNullOrWhiteSpace(t) AndAlso t.Length > 3)
    End Function

    Private Function ExtractTotal(text As String) As Decimal?
        Dim match = Regex.Match(text,
            "(?:Total|Grand Total|Amount Due):?\s*\$?\s*([\d,]+\.\d{2})",
            RegexOptions.IgnoreCase)
        Return If(match.Success,
            Decimal.Parse(match.Groups(1).Value.Replace(",", "")),
            CType(Nothing, Decimal?))
    End Function
End Class

Public Class DocumentResult
    Public Property FilePath As String
    Public Property Vendor As String
    Public Property Total As Decimal?
    Public Property Confidence As Double
    Public Property ProcessedAt As DateTime
End Class

// Map each Veryfi field to a Regex extraction
private static readonly Dictionary<string, string> FieldPatterns = new()
{
    ["InvoiceNumber"] = @"Invoice\s*#?\s*:?\s*(\w+[-\w]*)",
    ["PurchaseOrder"]  = @"(?:PO|P\.O\.|Purchase Order)\s*#?\s*:?\s*(\w+)",
    ["DueDate"]        = @"Due\s*(?:Date)?:?\s*(\d{1,2}/\d{1,2}/\d{4})",
    ["PaymentTerms"]   = @"(?:Terms|Net)\s*:?\s*(\w+\s*\d+)"
};

public string ExtractField(string text, string fieldName)
{
    if (!FieldPatterns.TryGetValue(fieldName, out var pattern))
        return null;
    var match = Regex.Match(text, pattern, RegexOptions.IgnoreCase);
    return match.Success ? match.Groups[1].Value.Trim() : null;
}

Imports System.Text.RegularExpressions
Imports System.Collections.Generic

' Map each Veryfi field to a Regex extraction
Private Shared ReadOnly FieldPatterns As New Dictionary(Of String, String) From {
    {"InvoiceNumber", "Invoice\s*#?\s*:?\s*(\w+[-\w]*)"},
    {"PurchaseOrder", "(?:PO|P\.O\.|Purchase Order)\s*#?\s*:?\s*(\w+)"},
    {"DueDate", "Due\s*(?:Date)?:?\s*(\d{1,2}/\d{1,2}/\d{4})"},
    {"PaymentTerms", "(?:Terms|Net)\s*:?\s*(\w+\s*\d+)"}
}

Public Function ExtractField(text As String, fieldName As String) As String
    Dim pattern As String = Nothing
    If Not FieldPatterns.TryGetValue(fieldName, pattern) Then
        Return Nothing
    End If
    Dim match As Match = Regex.Match(text, pattern, RegexOptions.IgnoreCase)
    Return If(match.Success, match.Groups(1).Value.Trim(), Nothing)
End Function

// Preserve async signature during transition — no codebase-wide refactor needed
public async Task<string> GetVendorNameAsync(string documentPath)
{
    return await Task.Run(() =>
    {
        var result = _ocr.Read(documentPath);
        return result.Pages[0].Paragraphs
            .OrderBy(p => p.Y)
            .Select(p => p.Text.Trim())
            .FirstOrDefault(t => t.Length > 3);
    });
}

Imports System.Threading.Tasks
Imports System.Linq

Public Async Function GetVendorNameAsync(documentPath As String) As Task(Of String)
    Return Await Task.Run(Function()
                              Dim result = _ocr.Read(documentPath)
                              Return result.Pages(0).Paragraphs _
                                  .OrderBy(Function(p) p.Y) _
                                  .Select(Function(p) p.Text.Trim()) _
                                  .FirstOrDefault(Function(t) t.Length > 3)
                          End Function)
End Function

# Find all Veryfi credential references
grep -r "Veryfi:ClientId\|Veryfi:ClientSecret\|Veryfi:Username\|Veryfi:ApiKey" \
    --include="*.json" --include="*.yml" --include="*.yaml" --include="*.env" .

// Load from environment at startup
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE_KEY")
    ?? throw new InvalidOperationException("IRONOCR_LICENSE_KEY not set");

' Load from environment at startup
IronOcr.License.LicenseKey = If(Environment.GetEnvironmentVariable("IRONOCR_LICENSE_KEY"), Throw New InvalidOperationException("IRONOCR_LICENSE_KEY not set"))

using var input = new OcrInput();
input.LoadImage("receipt-phone-photo.jpg");
input.Deskew();        // correct rotation from angled phone capture
input.DeNoise();       // remove compression artifacts
input.Contrast();      // improve faded thermal print
input.Sharpen();       // recover edge detail

var result = _ocr.Read(input);

Imports System

Using input As New OcrInput()
    input.LoadImage("receipt-phone-photo.jpg")
    input.Deskew()        ' correct rotation from angled phone capture
    input.DeNoise()       ' remove compression artifacts
    input.Contrast()      ' improve faded thermal print
    input.Sharpen()       ' recover edge detail

    Dim result = _ocr.Read(input)
End Using

// One IronTesseract per thread — do not share instances across threads
Parallel.ForEach(
    documentPaths,
    new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount },
    path =>
    {
        var ocr    = new IronTesseract();
        var result = ocr.Read(path);
        SaveResult(path, result.Text, result.Confidence);
    });

Imports System
Imports System.Threading.Tasks

' One IronTesseract per thread — do not share instances across threads
Parallel.ForEach(
    documentPaths,
    New ParallelOptions With {.MaxDegreeOfParallelism = Environment.ProcessorCount},
    Sub(path)
        Dim ocr As New IronTesseract()
        Dim result = ocr.Read(path)
        SaveResult(path, result.Text, result.Confidence)
    End Sub)

// Extraction logic that is fully portable and unit-testable
[Fact]
public void ExtractsRoutingNumberFromInvoiceText()
{
    const string sampleText = "Routing Number: 021000021\nAccount: 1234567890";
    var match = Regex.Match(sampleText, @"Routing\s*(?:Number)?:?\s*(\d{9})",
                            RegexOptions.IgnoreCase);
    Assert.True(match.Success);
    Assert.Equal("021000021", match.Groups[1].Value);
}

Imports System.Text.RegularExpressions
Imports Xunit

' Extraction logic that is fully portable and unit-testable
Public Class InvoiceTests
    <Fact>
    Public Sub ExtractsRoutingNumberFromInvoiceText()
        Const sampleText As String = "Routing Number: 021000021" & vbLf & "Account: 1234567890"
        Dim match = Regex.Match(sampleText, "Routing\s*(?:Number)?:?\s*(\d{9})", RegexOptions.IgnoreCase)
        Assert.True(match.Success)
        Assert.Equal("021000021", match.Groups(1).Value)
    End Sub
End Class

# Find all Veryfi using statements
grep -rn "using Veryfi" --include="*.cs" .

# Find all VeryfiClient instantiations
grep -rn "VeryfiClient\|ProcessDocumentAsync" --include="*.cs" .

# Find all Veryfi response field accesses
grep -rn "response\.Vendor\|response\.Total\|response\.LineItems\|response\.BankAccount" --include="*.cs" .

# Find all credential configuration references
grep -r "Veryfi:ClientId\|Veryfi:ClientSecret\|Veryfi:Username\|Veryfi:ApiKey" \
    --include="*.json" --include="*.yml" --include="*.yaml" --include="*.env" .

# Find all webhook-related code
grep -rn "VeryfiWebhook\|X-Veryfi-Token\|webhook" --include="*.cs" .