¿Qué biblioteca de Tesseract OCR deberías elegir? Una comparación de desarrolladores entre las tres mejores opciones

Procesamiento de recibos Veryfi

El SDK de Muy fi expone un único método principal para el procesamiento de documentos:

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

Las facturas aumentan la sensibilidad. El mismo patrón de ProcessDocumentAsync transmite documentos que con frecuencia contienen números de cuenta bancaria, números de ruta, identificaciones tributarias de proveedores y términos de pago:

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

    // Invoice uploaded to Muy fi — banking details included
    var response = await _client.ProcessDocumentAsync(
        fileData: pdfBytes,
        fileName: Path.GetFileName(pdfPath),
        categories: new[] { "invoices" }
    );

    return new InvoiceData
    {
        InvoiceNumber    = response.InvoiceNumber,
        VendorName       = response.Vendor?.Name,
        VendorTaxId      = response.Vendor?.TaxId,       // transmitted
        Total            = response.Total,
        DueDate          = response.DueDate,
        PaymentTerms     = response.PaymentTerms,
        BankAccountNumber = response.BankAccount?.AccountNumber, // transmitted
        BankRoutingNumber = response.BankAccount?.RoutingNumber  // transmitted
    };
}

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

    // Invoice uploaded to Muy fi — banking details included
    var response = await _client.ProcessDocumentAsync(
        fileData: pdfBytes,
        fileName: Path.GetFileName(pdfPath),
        categories: new[] { "invoices" }
    );

    return new InvoiceData
    {
        InvoiceNumber    = response.InvoiceNumber,
        VendorName       = response.Vendor?.Name,
        VendorTaxId      = response.Vendor?.TaxId,       // transmitted
        Total            = response.Total,
        DueDate          = response.DueDate,
        PaymentTerms     = response.PaymentTerms,
        BankAccountNumber = response.BankAccount?.AccountNumber, // transmitted
        BankRoutingNumber = response.BankAccount?.RoutingNumber  // transmitted
    };
}

Imports System.IO
Imports System.Threading.Tasks

Public Async Function ProcessInvoiceAsync(pdfPath As String) As Task(Of InvoiceData)
    Dim pdfBytes = File.ReadAllBytes(pdfPath)

    ' Invoice uploaded to Muy fi — 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

El punto final del estado de cuenta bancario es el más sensible. Llamar a ProcessDocumentAsync con categories: new[] { "bank_statements" } transmite números de cuenta completos, números de ruta, historial de transacciones completo, saldos iniciales y finales, y detalles de transferencia bancaria a la infraestructura de Veryfi.

Comparación detallada de características

Enfoque Veryfi

Cada llamada de API de Muy fi transmite bytes de documento sobre HTTPS a api.veryfi.com. Los datos extraídos de esos documentos (números de cuenta, números de ruta, historiales de transacciones, números de identificación fiscal de proveedores, detalles de tarjetas de pago y patrones de gasto) son procesados ​​por la infraestructura de Veryfi. La residencia de datos, las políticas de retención, las cadenas de subprocesadores y los procedimientos de respuesta ante violaciones de seguridad se rigen por los términos de Veryfi, no por los suyos.

// Procesamiento de extractos bancarios — 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()
    };
}

// Procesamiento de extractos bancarios — 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

' Procesamiento de extractos bancarios — 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 posee las certificaciones SOC 2 Tipo II, GDPR y HIPAA (con Acuerdo de Asociado Comercial). Estas certificaciones confirman que Muy fi cumple con las prácticas de seguridad que ha declarado. Esto no significa que sus datos permanezcan bajo su control, que usted controle la residencia de los datos o que los subprocesadores de Muy fi no tengan acceso a ellos. Para las organizaciones que cumplen con los niveles 2 o superiores de CMMC, ITAR, SOX o GLBA, la incorporación de Muy fi como procesador de datos introduce un alcance de cumplimiento que requiere una revisión legal y una supervisión continua.

Enfoque de IronOCR

IronOCR procesa documentos sin transmisión de red. El motor OCR se ejecuta en su hardware. Los extractos bancarios, las facturas con números de ruta y los cheques con números de cuenta nunca salen de su servidor:

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

En entornos con altos requisitos de cumplimiento normativo, el procesamiento local elimina por completo el alcance de las auditorías de terceros. No BAA con IronOCR. No se divulgan datos de subprocesadores. No se plantean preguntas sobre la residencia de los datos. Consulte la guía de configuración de IronTesseract para obtener información sobre la configuración de implementación en entornos Windows, Linux, Docker y entornos aislados de la red.

Enfoque Veryfi

Veryfi funciona bien dentro de su nicho. Envíe una imagen del recibo y la respuesta contendrá el proveedor, el total, los impuestos, el método de pago y los detalles de los artículos; no se requiere ninguna expresión regular por su parte. Pero el alcance termina en el límite de los gastos y los documentos financieros. El archivo README lo documenta directamente: los documentos comerciales generales, los historiales médicos, los dibujos técnicos, los documentos multilingües y los tipos de formularios personalizados que no pertenecen al conjunto entrenado producen resultados deficientes o requieren una capacitación de pago sobre modelos personalizados.

Las organizaciones reales rara vez procesan una sola categoría de documentos. Los departamentos de recursos humanos procesan los formularios de incorporación de empleados. Los equipos legales necesitan el texto del contrato. Los equipos de operaciones se encargan de los documentos de envío y los formularios de logística. Cada categoría que queda fuera del alcance de Muy fi obliga a incorporar una segunda solución a la pila:

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

Enfoque de IronOCR

IronOCR procesa cualquier tipo de documento. La lógica de extracción la escribes tú, lo que significa que maneja exactamente los campos que contienen tus documentos, y no la suposición de un modelo preentrenado sobre qué campos son comunes en todos los documentos de gastos. La misma instancia de IronTesseract procesa recibos, contratos, formularios médicos, documentos de envío y formularios internos personalizados:

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

Para los campos de facturas y recibos que siguen patrones consistentes, la extracción de datos estructurados de IronOCR proporciona posicionamiento a nivel de palabra que hace que la lógica de extracción sea precisa. La colección result.Lines, ordenada por posición Y, extrae de manera confiable los nombres de los proveedores de los encabezados de recibos. Los filtros de corrección de calidad de imagen gestionan los recibos arrugados, descoloridos o fotografiados que se generan en los flujos de trabajo de gastos reales.

Enfoque Veryfi

Veryfi cobra por documento. La tarifa depende del tipo de documento y el nivel de volumen — contacta a Muy fi para conocer los precios actuales. Los costos crecen en proporción directa al volumen sin techo a menos que negocies uno contractualmente, y no hay reducción en años posteriores independientemente de cuánto tiempo hayas sido cliente.

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

Los costos ocultos aumentan el total: la limitación de velocidad en HTTP 429 obliga a aplicar una lógica de reintento; Los cambios en la versión de la API requieren actualizaciones del SDK; La revisión de seguridad del acuerdo de procesamiento de datos añade tiempo legal; y se aplican cargos adicionales cuando el volumen estacional supera las estimaciones del plan.

Enfoque de IronOCR

La licencia de IronOCR es una compra única. La licencia Professional en $2,999 cubre a 10 desarrolladores, procesa documentos ilimitados por mes y no requiere renovación para continuar procesando. El segundo año no tiene ningún coste de procesamiento. El año 5 no tiene ningún coste de procesamiento.

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

La comparación de 3 años a altos volúmenes de documentos:IronOCR totaliza $2,999 más un estimado de 8–16 horas de tiempo de desarrollo para construir patrones de extracción, mientras que los costos de Muy fi se acumulan con cada documento procesado. El punto de equilibrio suele ocurrir dentro de los primeros meses de uso dependiendo del volumen.

Para los equipos que actualmente invierten en OCR en la nube, la página de licencias de IronOCR incluye detalles sobre los niveles y la opción de suscripción SaaS disponible para los equipos que prefieren la facturación anual.

Enfoque Veryfi

Todo el procesamiento de Muy fi es asíncrono porque está basado en la nube. El método ProcessDocumentAsync inicia una llamada HTTP, espera a que el pipeline de Muy fi complete y devuelve el resultado. La latencia total incluye la transmisión de red, el tiempo de espera en la infraestructura de Veryfi, la inferencia del modelo y la transmisión de la respuesta.

// Muy fi error 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)
    {
        // Muy fi infrastructure failure — your processing is down
        throw new Exception("Veryfi server error. Processing unavailable.", ex);
    }
}

// Muy fi error 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)
    {
        // Muy fi infrastructure failure — your processing is down
        throw new Exception("Veryfi server error. Processing unavailable.", ex);
    }
}

Imports System.IO
Imports System.Threading.Tasks

Public Class Example
    ' Muy fi error categories reflect cloud dependencies
    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
            ' Muy fi infrastructure failure — your processing is down
            Throw New Exception("Veryfi server error. Processing unavailable.", ex)
        End Try
    End Function
End Class

Las interrupciones en la red detienen el procesamiento. Los incidentes en la infraestructura de Muy fi detienen el procesamiento. Los límites de velocidad detienen el procesamiento. Cada una de ellas es una dependencia externa que su aplicación no puede controlar.

Enfoque de IronOCR

IronOCR se procesa de forma síncrona sin depender de la red. El resultado está disponible inmediatamente después de que Read() regresa, sin necesidad de sondeo, configuración de webhook ni lógica de reintento para fallos de red.

using IronOcr;

var ocr = new IronTesseract();

// Synchronous — result immediately available
// No 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
// No 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
' No network, no quota, no rate limits
Dim result = ocr.Read("receipt.jpg")

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

' Word-level positioning for precise field extraction
For Each line In result.Lines
    Console.WriteLine($"Y={line.Y}: {line.Text}")
Next

Para aplicaciones que necesitan comportamiento asíncrono por la capacidad de respuesta de la IU,IronOCR también soporta OCR asíncrono a través del envoltorio Task.Run o la superficie del API asíncrono. La diferencia radica en que en IronOCR, la asincronía es un patrón de concurrencia, no un requisito impuesto por una llamada remota. Una interrupción de la red a las 2 de la madrugada no detiene su proceso por lotes.

Para los flujos de trabajo de escaneo de recibos, el tutorial de escaneo de recibos y la guía de OCR de facturas cubren la implementación completa de patrones de extracción. Los índices de confianza proporcionan señales de fiabilidad por palabra que ayudan a detectar escaneos de baja calidad antes de enviar los datos extraídos a un sistema posterior.

La soberanía de los datos se convierte en algo innegociable.

El motivo más común para evaluar IronOCR es una auditoría de cumplimiento o una revisión legal que revela a Muy fi como procesador de datos para registros financieros confidenciales. Una evaluación de HIPAA determina que los documentos de gastos que contienen información de salud protegida (PHI) requieren un Acuerdo de Asociado Comercial con Muy fi y una supervisión de auditoría continua. Una evaluación CMMC de nivel 2 identifica los documentos financieros transmitidos a través de la nube como una posible deficiencia. Un equipo legal desaconseja enviar datos de gastos de clientes a terceros. En cada caso, el camino hacia el cumplimiento normativo consiste en eliminar la transmisión externa de datos, lo que implica sustituir Muy fi por un sistema OCR local. El modelo de procesamiento local de IronOCR cumple con estos requisitos por defecto: sin BAA, sin cadena de subprocesadores, sin alcance de auditoría de terceros.

Los tipos de documentos van más allá de los gastos.

Las organizaciones que adoptan Muy fi para la automatización de gastos suelen descubrir, en un plazo de 6 a 12 meses, que los equipos adyacentes necesitan OCR para documentos que no forman parte del conjunto de datos de entrenamiento de Veryfi. El departamento de Recursos Humanos necesita que se procesen los formularios de incorporación. Se ha extraído el texto del contrato de necesidades legales. El departamento de operaciones necesita tener registrados los datos del conocimiento de embarque. Cada nueva categoría de documento produce resultados deficientes en el punto final de uso general de Veryfi, requiere un entrenamiento de modelo personalizado de pago o fuerza la incorporación de una segunda solución OCR a la infraestructura. Una única licencia de IronOCR gestiona todas estas funciones con la misma API. El tutorial sobre la lectura de documentos específicos abarca estrategias de extracción para diseños de formularios estructurados.

Los costos por documento superan el umbral del caso de negocio.

Los equipos que procesan 25.000 documentos o más al mes suelen encontrar que el periodo de amortización de IronOCR es inferior a tres meses. A altos volúmenes de documentos, la licencia Professional de IronOCR en $2,999 se paga típicamente dentro del primer mes de gasto equivalente en Veryfi. Los equipos financieros que realizan análisis del coste total de propiedad sobre los precios de la nube por documento inevitablemente llegan a esta comparación. El proceso de migración —que consiste en crear patrones de extracción de expresiones regulares para los campos específicos que necesita el equipo— suele durar entre 8 y 24 horas, dependiendo de la complejidad del documento y del número de tipos de documentos distintos en el flujo de trabajo.

Entornos sin conexión y desconectados

Las organizaciones de servicios de campo, los lugares de trabajo remotos, las aplicaciones móviles de captura de gastos y los entornos gubernamentales aislados de la red comparten un requisito común: el OCR debe funcionar sin conexión a Internet. Muy fi es arquitectónicamente incapaz de satisfacer este requisito: cualquier llamada de procesamiento de documentos falla sin una conexión de red.IronOCR procesa los datos sin conexión a internet por diseño. Un técnico de campo que utiliza una aplicación móvil para el control de gastos, una planta de fabricación con una red protegida por un cortafuegos y un contratista de defensa en una instalación de información clasificada (SCIF) pueden ejecutar IronOCR sin modificaciones. La guía de implementación de Docker y la guía de implementación de Linux cubren entornos de contenedores donde la salida de red está restringida.

Dependencia del proveedor y del esquema

El esquema de respuesta JSON de Muy fi es propietario. Cada línea de código de extracción que lee el nombre del proveedor, el total, el número de ruta o los campos de la línea de artículo es código que solo funciona con Veryfi. Cambiar a una API en la nube de la competencia, o a una solución local, requiere reescribir toda la lógica de extracción. Las organizaciones que negocian contratos plurianuales con Muy fi descubren esta dependencia cuando cambian los precios o se modifica la hoja de ruta del producto. La lógica de extracción de IronOCR lee el texto sin formato utilizando expresiones regulares estándar de .NET : es portátil y no está vinculada al esquema de ningún proveedor.

Sustitución de la salida estructurada por la extracción de patrones

Veryfi devuelve campos preanalizados;IronOCR devuelve el texto OCR sin procesar. El trabajo de migración consiste en escribir los patrones de extracción que Muy fi utilizaba en su nube. Para recibos y facturas con diseños uniformes, esto es sencillo:

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)

Para recibos con diseños inusuales o impresión borrosa, los filtros de preprocesamiento de IronOCR mejoran la precisión de los datos brutos antes de que se ejecute la extracción. Consulte la guía de corrección de calidad de imagen y la guía de corrección de color de imagen para obtener información sobre cómo gestionar la calidad de escaneo de recibos reales.

Cómo gestionar la transición de asíncrono a síncrono

Toda la interfaz API de Muy fi es asíncrona. La ruta principal de IronOCR es síncrona. Las firmas de métodos asíncronos existentes en el código de la aplicación se pueden conservar mediante el encapsulado:

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

Para escenarios de alto rendimiento,IronOCR es seguro para hilos y varias instancias de IronTesseract pueden procesar documentos en paralelo sin sincronización. La guía de optimización de velocidad abarca patrones de reutilización de instancias y estrategias de carga por lotes que minimizan el tiempo de procesamiento a gran escala.

Limpieza de credenciales

Veryfi requiere cuatro credenciales: ClientId, ClientSecret, Username y ApiKey. Los cuatro elementos deben eliminarse de los archivos de configuración, las variables de entorno, los almacenes de claves y las canalizaciones de CI/CD después de la migración.IronOCR requiere una única clave de licencia. La lista de verificación de migración: elimine los cuatro secretos de Muy fi de cada entorno, añada una única variable de entorno IRONOCR_LICENSE y actualice las pipelines de despliegue para eliminar la inyección de credenciales de Veryfi.

Procesamiento de PDF para facturas

Veryfi acepta bytes de PDF a través de ProcessDocumentAsync.IronOCR procesa PDFs de manera nativa a través de 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

Para flujos de trabajo de facturación que producen archivos PDF archivables buscables, el método SaveAsSearchablePdf() de IronOCR genera salida compatible con PDF/A a partir de entrada escaneada, una capacidad que la API en la nube de Muy fi no proporciona. Consulte la guía de PDF buscable para detalles de implementación.