¿Qué es la API de OCR.space?

OCR.space API es una solución de OCR utilizada por desarrolladores y empresas para extraer texto de imágenes y documentos. Es una de las diversas opciones de OCR evaluadas junto con IronOCR for .NET para el desarrollo de aplicaciones.

¿Cómo se compara IronOCR con la API de OCR.space para desarrolladores .NET?

IronOCR es una biblioteca de OCR .NET nativa de NuGet que utiliza IronTesseract como motor principal. En comparación con la API de OCR.space, ofrece una implantación más sencilla (sin instaladores SDK), precios de tarifa plana y una API de C# limpia sin interoperabilidad COM ni dependencias de la nube.

¿Es IronOCR más fácil de configurar que la API de OCR.space?

IronOCR se instala mediante un único paquete NuGet. No hay instaladores de SDK, archivos de licencia que copiar, componentes COM que registrar ni binarios de ejecución independientes que gestionar. Todo el motor de OCR está incluido en el paquete.

¿Qué diferencias de precisión existen entre la API de OCR.space y IronOCR?

IronOCR logra una alta precisión de reconocimiento para documentos comerciales estándar, facturas, recibos y formularios escaneados. Para documentos muy degradados o escrituras poco comunes, la precisión varía en función de la calidad de la fuente. IronOCR incluye filtros de preprocesamiento de imágenes para mejorar el reconocimiento en entradas de baja calidad.

¿Es IronOCR compatible con la extracción de texto en PDF?

Sí. IronOCR extrae texto tanto de PDF nativos como de imágenes PDF escaneadas en una sola llamada. También admite archivos TIFF de varias páginas, imágenes y secuencias. En el caso de los PDF escaneados, el OCR se aplica página a página con objetos de resultado por página.

¿En qué se diferencia la licencia API de OCR.space de la de IronOCR?

IronOCR utiliza una licencia perpetua de tarifa plana sin cargos por página o por escaneo. Las organizaciones que procesan grandes volúmenes de documentos pagan el mismo coste de licencia independientemente del volumen. Encontrará más información y precios por volumen en la página de licencias de IronOCR.

¿Qué idiomas admite IronOCR?

IronOCR es compatible con 127 idiomas a través de paquetes de idiomas NuGet independientes. Para añadir un idioma, basta con ejecutar el comando 'dotnet add package IronOcr.Languages.{Language}'. No es necesaria la colocación manual de archivos ni la configuración de rutas.

¿Cómo instalo IronOCR en un proyecto .NET ?

Instalación a través de NuGet: install-Package IronOcr' en la consola del gestor de paquetes o 'dotnet add package IronOcr' en la CLI. Los paquetes de idiomas adicionales se instalan del mismo modo. No se requiere ningún instalador nativo del SDK.

¿Es IronOCR adecuado para Docker y las implementaciones en contenedores, a diferencia de OCR.space?

Sí. IronOCR funciona en contenedores Docker a través de su paquete NuGet. La clave de licencia se establece mediante una variable de entorno. No se requieren archivos de licencia, rutas de SDK ni montajes de volumen para el propio motor de OCR.

¿Puedo probar IronOCR antes de comprarlo, en comparación con OCR.space?

Sí. El modo de prueba de IronOCR procesa documentos y devuelve resultados de OCR con una marca de agua superpuesta en la salida. Puede verificar la precisión en sus propios documentos antes de adquirir una licencia.

¿Admite IronOCR la lectura de códigos de barras junto con la extracción de texto?

IronOCR se centra en la extracción de texto y el reconocimiento óptico de caracteres. Para la lectura de códigos de barras, Iron Software ofrece IronBarcode como biblioteca complementaria. Ambas están disponibles por separado o como parte del paquete Iron Suite.

¿Es fácil migrar de OCR.space API a IronOCR?

La migración de OCR.space API a IronOCR suele implicar la sustitución de las secuencias de inicialización por la instanciación de IronTesseract, la eliminación de la gestión del ciclo de vida COM y la actualización de las llamadas a la API. La mayoría de las migraciones reducen significativamente la complejidad del código.

La Biblioteca OCR de C#

Explore IronOCR Prueba gratis

OCR en 1 línea de código

Ver Todos los Ejemplos de Código %s

using IronOcr;

string imageText = new IronTesseract().Read(@"images\image.png").Text;

using IronOcr;

string imageText = new IronTesseract().Read(@"images\image.png").Text;

PM >Install-Package IronOcr

Install-Package IronOcr

COMPARAR CON OTROS COMPONENTES

ABBYY FineReader vs Tesseract: Comparación de OCR

Kannapat Udonpant

Updated: 28 de junio de 2026

OCR.space no tiene paquete NuGet . Ese único hecho define cada decisión de integración que un desarrollador de .NET toma al elegirlo: escribes un HttpClient personalizado, codificas tus documentos en base64, realizas un POST a https://api.ocr.space/parse/image, analizas manualmente la respuesta JSON, capturas los HTTP 429s, implementas retrocesos exponenciales, construyes la contabilidad de límites de tasas y defines tus propios tipos de excepciones, todo antes de que un solo carácter de texto llegue a tu aplicación. Este artículo examina el coste real de ese desarrollo por cuenta propia en términos de código, tiempo y fiabilidad en producción, y lo compara directamente con IronOCR , una biblioteca nativa de .NET que se distribuye como un único paquete NuGet .

Comprender OCR.space

OCR.space es una API REST freemium que procesa imágenes y archivos PDF en servidores remotos operados por OCR.space. El servicio se centra en su plan gratuito: 25.000 solicitudes al mes sin necesidad de tarjeta de crédito, lo que resulta atractivo para los desarrolladores que experimentan con OCR o que crean proyectos personales. No existe ningún paquete NuGet , ni ningún SDK oficial de .NET , ni ninguna biblioteca cliente fuertemente tipada en ningún lenguaje. Cada integración .NET se construye a mano sobre HttpClient.

La realidad arquitectónica para los desarrolladores .NET :

Sin paquete NuGet : Cero soporte de primera clase .NET . Sin IntelliSense, sin modelos tipados, sin manejo de errores integrado.
Procesamiento exclusivamente en la nube: Todos los documentos salen de su infraestructura. No existe la opción de instalación local ni la posibilidad de implementación autogestionada.
Integración REST manual: Los desarrolladores codifican los archivos en base64, construyen FormUrlEncodedContent o MultipartFormDataContent, y analizan las respuestas JSON crudas.
Limitación de velocidad por parte del usuario: El nivel gratuito impone un límite de 60 solicitudes por minuto y un límite estricto de 500 solicitudes por día por IP. Las aplicaciones de producción deben implementar esta lógica por sí mismas.
Restricciones de tamaño de archivo: El plan gratuito rechaza archivos de más de 5 MB. Los archivos PDF de varias páginas suelen superar este límite.
Salida de PDF con marca de agua: La generación de PDF con capacidad de búsqueda en el plan gratuito incluye marcas de agua de OCR.space, lo que hace que la salida no sea utilizable para la entrega al cliente o el archivo de documentos.
Sin SLA: El nivel gratuito no incluye ningún compromiso de tiempo de actividad. Los planes de pago ofrecen límites más altos, pero las mismas limitaciones arquitectónicas.

Los desarrolladores de integración REST deben escribir

La documentación de OCR.space indica a los desarrolladores el punto final REST y les deja a ellos la tarea de construir todo lo demás. El cliente .NET mínimo viable —antes de considerar cualquier medida de seguridad para entornos de producción— tiene este aspecto:

// OCR.space: what you build before the first line of your actual application
public class OcrSpaceApiClient : IDisposable
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    private readonly SemaphoreSlim _rateLimiter;
    private const string ApiEndpoint = "https://api.ocr.space/parse/image";
    private const int MaxFileSizeFree = 5 * 1024 * 1024; // 5MB — hard limit on free tier
    private const int RateLimitPerMinute = 60;

    public OcrSpaceApiClient(string apiKey)
    {
        _apiKey = apiKey ?? throw new ArgumentNullException(nameof(apiKey));
        _httpClient = new HttpClient();
        _httpClient.Timeout = TimeSpan.FromSeconds(120);
        _rateLimiter = new SemaphoreSlim(RateLimitPerMinute, RateLimitPerMinute);
    }

    public async Task<OcrResult> ExtractTextFromFileAsync(
        string filePath,
        string language = "eng",
        CancellationToken cancellationToken = default)
    {
        if (!File.Exists(filePath))
            throw new FileNotFoundException("Image file not found", filePath);

        var fileInfo = new FileInfo(filePath);
        if (fileInfo.Length > MaxFileSizeFree)
        {
            throw new InvalidOperationException(
                $"File size {fileInfo.Length / 1024 / 1024}MB exceeds free tier limit of 5MB.");
        }

        await _rateLimiter.WaitAsync(cancellationToken);

        try
        {
            // Document leaves your infrastructure here
            byte[] imageBytes = await File.ReadAllBytesAsync(filePath, cancellationToken);
            string base64Image = Convert.ToBase64String(imageBytes);
            string mimeType = GetMimeType(filePath);

            var formContent = new FormUrlEncodedContent(new[]
            {
                new KeyValuePair<string, string>("apikey", _apiKey),
                new KeyValuePair<string, string>("base64Image", $"data:{mimeType};base64,{base64Image}"),
                new KeyValuePair<string, string>("language", language),
                new KeyValuePair<string, string>("isOverlayRequired", "false"),
                new KeyValuePair<string, string>("filetype", Path.GetExtension(filePath).TrimStart('.')),
                new KeyValuePair<string, string>("detectOrientation", "true"),
                new KeyValuePair<string, string>("scale", "true"),
                new KeyValuePair<string, string>("OCREngine", "2")
            });

            var response = await _httpClient.PostAsync(ApiEndpoint, formContent, cancellationToken);

            if (!response.IsSuccessStatusCode)
            {
                string errorBody = await response.Content.ReadAsStringAsync(cancellationToken);
                throw new OcrSpaceException(
                    $"OCR.space API returned {response.StatusCode}: {errorBody}",
                    (int)response.StatusCode);
            }

            string jsonResponse = await response.Content.ReadAsStringAsync(cancellationToken);
            return ParseOcrResponse(jsonResponse);
        }
        finally
        {
            _ = Task.Run(async () =>
            {
                await Task.Delay(60000 / RateLimitPerMinute);
                _rateLimiter.Release();
            });
        }
    }

    private OcrResult ParseOcrResponse(string jsonResponse)
    {
        using var doc = JsonDocument.Parse(jsonResponse);
        var root = doc.RootElement;

        if (root.TryGetProperty("IsErroredOnProcessing", out var isErrored) && isErrored.GetBoolean())
        {
            string errorMessage = "OCR processing failed";
            if (root.TryGetProperty("ErrorMessage", out var errorMessages))
            {
                // Parse the array of error strings manually
                var messages = new List<string>();
                if (errorMessages.ValueKind == JsonValueKind.Array)
                {
                    foreach (var msg in errorMessages.EnumerateArray())
                        messages.Add(msg.GetString() ?? "Unknown error");
                }
                errorMessage = string.Join("; ", messages);
            }
            throw new OcrSpaceException(errorMessage, 500);
        }

        var result = new OcrResult();

        if (root.TryGetProperty("ParsedResults", out var parsedResults))
        {
            foreach (var parsedResult in parsedResults.EnumerateArray())
            {
                if (parsedResult.TryGetProperty("ParsedText", out var parsedText))
                    result.ParsedText += parsedText.GetString();

                if (parsedResult.TryGetProperty("FileParseExitCode", out var exitCode))
                    result.ExitCodes.Add(exitCode.GetInt32());
            }
        }

        return result;
    }

    private string GetMimeType(string filePath) =>
        Path.GetExtension(filePath).ToLowerInvariant() switch
        {
            ".png"          => "image/png",
            ".jpg" or ".jpeg" => "image/jpeg",
            ".bmp"          => "image/bmp",
            ".tiff" or ".tif" => "image/tiff",
            ".pdf"          => "application/pdf",
            _               => "application/octet-stream"
        };

    public void Dispose()
    {
        _httpClient?.Dispose();
        _rateLimiter?.Dispose();
    }
}

// Custom models — no SDK means you define these yourself
public class OcrResult
{
    public string ParsedText { get; set; } = string.Empty;
    public List<string> Warnings { get; } = new();
    public List<int> ExitCodes { get; } = new();
}

public class OcrSpaceException : Exception
{
    public int StatusCode { get; }
    public OcrSpaceException(string message, int statusCode) : base(message)
        => StatusCode = statusCode;
}

// OCR.space: what you build before the first line of your actual application
public class OcrSpaceApiClient : IDisposable
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    private readonly SemaphoreSlim _rateLimiter;
    private const string ApiEndpoint = "https://api.ocr.space/parse/image";
    private const int MaxFileSizeFree = 5 * 1024 * 1024; // 5MB — hard limit on free tier
    private const int RateLimitPerMinute = 60;

    public OcrSpaceApiClient(string apiKey)
    {
        _apiKey = apiKey ?? throw new ArgumentNullException(nameof(apiKey));
        _httpClient = new HttpClient();
        _httpClient.Timeout = TimeSpan.FromSeconds(120);
        _rateLimiter = new SemaphoreSlim(RateLimitPerMinute, RateLimitPerMinute);
    }

    public async Task<OcrResult> ExtractTextFromFileAsync(
        string filePath,
        string language = "eng",
        CancellationToken cancellationToken = default)
    {
        if (!File.Exists(filePath))
            throw new FileNotFoundException("Image file not found", filePath);

        var fileInfo = new FileInfo(filePath);
        if (fileInfo.Length > MaxFileSizeFree)
        {
            throw new InvalidOperationException(
                $"File size {fileInfo.Length / 1024 / 1024}MB exceeds free tier limit of 5MB.");
        }

        await _rateLimiter.WaitAsync(cancellationToken);

        try
        {
            // Document leaves your infrastructure here
            byte[] imageBytes = await File.ReadAllBytesAsync(filePath, cancellationToken);
            string base64Image = Convert.ToBase64String(imageBytes);
            string mimeType = GetMimeType(filePath);

            var formContent = new FormUrlEncodedContent(new[]
            {
                new KeyValuePair<string, string>("apikey", _apiKey),
                new KeyValuePair<string, string>("base64Image", $"data:{mimeType};base64,{base64Image}"),
                new KeyValuePair<string, string>("language", language),
                new KeyValuePair<string, string>("isOverlayRequired", "false"),
                new KeyValuePair<string, string>("filetype", Path.GetExtension(filePath).TrimStart('.')),
                new KeyValuePair<string, string>("detectOrientation", "true"),
                new KeyValuePair<string, string>("scale", "true"),
                new KeyValuePair<string, string>("OCREngine", "2")
            });

            var response = await _httpClient.PostAsync(ApiEndpoint, formContent, cancellationToken);

            if (!response.IsSuccessStatusCode)
            {
                string errorBody = await response.Content.ReadAsStringAsync(cancellationToken);
                throw new OcrSpaceException(
                    $"OCR.space API returned {response.StatusCode}: {errorBody}",
                    (int)response.StatusCode);
            }

            string jsonResponse = await response.Content.ReadAsStringAsync(cancellationToken);
            return ParseOcrResponse(jsonResponse);
        }
        finally
        {
            _ = Task.Run(async () =>
            {
                await Task.Delay(60000 / RateLimitPerMinute);
                _rateLimiter.Release();
            });
        }
    }

    private OcrResult ParseOcrResponse(string jsonResponse)
    {
        using var doc = JsonDocument.Parse(jsonResponse);
        var root = doc.RootElement;

        if (root.TryGetProperty("IsErroredOnProcessing", out var isErrored) && isErrored.GetBoolean())
        {
            string errorMessage = "OCR processing failed";
            if (root.TryGetProperty("ErrorMessage", out var errorMessages))
            {
                // Parse the array of error strings manually
                var messages = new List<string>();
                if (errorMessages.ValueKind == JsonValueKind.Array)
                {
                    foreach (var msg in errorMessages.EnumerateArray())
                        messages.Add(msg.GetString() ?? "Unknown error");
                }
                errorMessage = string.Join("; ", messages);
            }
            throw new OcrSpaceException(errorMessage, 500);
        }

        var result = new OcrResult();

        if (root.TryGetProperty("ParsedResults", out var parsedResults))
        {
            foreach (var parsedResult in parsedResults.EnumerateArray())
            {
                if (parsedResult.TryGetProperty("ParsedText", out var parsedText))
                    result.ParsedText += parsedText.GetString();

                if (parsedResult.TryGetProperty("FileParseExitCode", out var exitCode))
                    result.ExitCodes.Add(exitCode.GetInt32());
            }
        }

        return result;
    }

    private string GetMimeType(string filePath) =>
        Path.GetExtension(filePath).ToLowerInvariant() switch
        {
            ".png"          => "image/png",
            ".jpg" or ".jpeg" => "image/jpeg",
            ".bmp"          => "image/bmp",
            ".tiff" or ".tif" => "image/tiff",
            ".pdf"          => "application/pdf",
            _               => "application/octet-stream"
        };

    public void Dispose()
    {
        _httpClient?.Dispose();
        _rateLimiter?.Dispose();
    }
}

// Custom models — no SDK means you define these yourself
public class OcrResult
{
    public string ParsedText { get; set; } = string.Empty;
    public List<string> Warnings { get; } = new();
    public List<int> ExitCodes { get; } = new();
}

public class OcrSpaceException : Exception
{
    public int StatusCode { get; }
    public OcrSpaceException(string message, int statusCode) : base(message)
        => StatusCode = statusCode;
}

Imports System
Imports System.Collections.Generic
Imports System.IO
Imports System.Net.Http
Imports System.Text.Json
Imports System.Threading
Imports System.Threading.Tasks

' OCR.space: what you build before the first line of your actual application
Public Class OcrSpaceApiClient
    Implements IDisposable

    Private ReadOnly _httpClient As HttpClient
    Private ReadOnly _apiKey As String
    Private ReadOnly _rateLimiter As SemaphoreSlim
    Private Const ApiEndpoint As String = "https://api.ocr.space/parse/image"
    Private Const MaxFileSizeFree As Integer = 5 * 1024 * 1024 ' 5MB — hard limit on free tier
    Private Const RateLimitPerMinute As Integer = 60

    Public Sub New(apiKey As String)
        _apiKey = If(apiKey, Throw New ArgumentNullException(NameOf(apiKey)))
        _httpClient = New HttpClient()
        _httpClient.Timeout = TimeSpan.FromSeconds(120)
        _rateLimiter = New SemaphoreSlim(RateLimitPerMinute, RateLimitPerMinute)
    End Sub

    Public Async Function ExtractTextFromFileAsync(filePath As String, Optional language As String = "eng", Optional cancellationToken As CancellationToken = Nothing) As Task(Of OcrResult)
        If Not File.Exists(filePath) Then
            Throw New FileNotFoundException("Image file not found", filePath)
        End If

        Dim fileInfo = New FileInfo(filePath)
        If fileInfo.Length > MaxFileSizeFree Then
            Throw New InvalidOperationException($"File size {fileInfo.Length \ 1024 \ 1024}MB exceeds free tier limit of 5MB.")
        End If

        Await _rateLimiter.WaitAsync(cancellationToken)

        Try
            ' Document leaves your infrastructure here
            Dim imageBytes As Byte() = Await File.ReadAllBytesAsync(filePath, cancellationToken)
            Dim base64Image As String = Convert.ToBase64String(imageBytes)
            Dim mimeType As String = GetMimeType(filePath)

            Dim formContent = New FormUrlEncodedContent(New KeyValuePair(Of String, String)() {
                New KeyValuePair(Of String, String)("apikey", _apiKey),
                New KeyValuePair(Of String, String)("base64Image", $"data:{mimeType};base64,{base64Image}"),
                New KeyValuePair(Of String, String)("language", language),
                New KeyValuePair(Of String, String)("isOverlayRequired", "false"),
                New KeyValuePair(Of String, String)("filetype", Path.GetExtension(filePath).TrimStart("."c)),
                New KeyValuePair(Of String, String)("detectOrientation", "true"),
                New KeyValuePair(Of String, String)("scale", "true"),
                New KeyValuePair(Of String, String)("OCREngine", "2")
            })

            Dim response = Await _httpClient.PostAsync(ApiEndpoint, formContent, cancellationToken)

            If Not response.IsSuccessStatusCode Then
                Dim errorBody = Await response.Content.ReadAsStringAsync(cancellationToken)
                Throw New OcrSpaceException($"OCR.space API returned {response.StatusCode}: {errorBody}", CInt(response.StatusCode))
            End If

            Dim jsonResponse = Await response.Content.ReadAsStringAsync(cancellationToken)
            Return ParseOcrResponse(jsonResponse)
        Finally
            _ = Task.Run(Async Function()
                             Await Task.Delay(60000 \ RateLimitPerMinute)
                             _rateLimiter.Release()
                         End Function)
        End Try
    End Function

    Private Function ParseOcrResponse(jsonResponse As String) As OcrResult
        Using doc = JsonDocument.Parse(jsonResponse)
            Dim root = doc.RootElement

            If root.TryGetProperty("IsErroredOnProcessing", ByRef isErrored) AndAlso isErrored.GetBoolean() Then
                Dim errorMessage As String = "OCR processing failed"
                If root.TryGetProperty("ErrorMessage", ByRef errorMessages) Then
                    ' Parse the array of error strings manually
                    Dim messages = New List(Of String)()
                    If errorMessages.ValueKind = JsonValueKind.Array Then
                        For Each msg In errorMessages.EnumerateArray()
                            messages.Add(msg.GetString() OrElse "Unknown error")
                        Next
                    End If
                    errorMessage = String.Join("; ", messages)
                End If
                Throw New OcrSpaceException(errorMessage, 500)
            End If

            Dim result = New OcrResult()

            If root.TryGetProperty("ParsedResults", ByRef parsedResults) Then
                For Each parsedResult In parsedResults.EnumerateArray()
                    If parsedResult.TryGetProperty("ParsedText", ByRef parsedText) Then
                        result.ParsedText &= parsedText.GetString()
                    End If

                    If parsedResult.TryGetProperty("FileParseExitCode", ByRef exitCode) Then
                        result.ExitCodes.Add(exitCode.GetInt32())
                    End If
                Next
            End If

            Return result
        End Using
    End Function

    Private Function GetMimeType(filePath As String) As String
        Return Path.GetExtension(filePath).ToLowerInvariant() Select Case
            Case ".png" : Return "image/png"
            Case ".jpg", ".jpeg" : Return "image/jpeg"
            Case ".bmp" : Return "image/bmp"
            Case ".tiff", ".tif" : Return "image/tiff"
            Case ".pdf" : Return "application/pdf"
            Case Else : Return "application/octet-stream"
        End Select
    End Function

    Public Sub Dispose() Implements IDisposable.Dispose
        _httpClient?.Dispose()
        _rateLimiter?.Dispose()
    End Sub
End Class

' Custom models — no SDK means you define these yourself
Public Class OcrResult
    Public Property ParsedText As String = String.Empty
    Public ReadOnly Property Warnings As New List(Of String)()
    Public ReadOnly Property ExitCodes As New List(Of Integer)()
End Class

Public Class OcrSpaceException
    Inherits Exception

    Public ReadOnly Property StatusCode As Integer

    Public Sub New(message As String, statusCode As Integer)
        MyBase.New(message)
        Me.StatusCode = statusCode
    End Sub
End Class

Imports System
Imports System.Collections.Generic
Imports System.IO
Imports System.Net.Http
Imports System.Text.Json
Imports System.Threading
Imports System.Threading.Tasks

' OCR.space: what you build before the first line of your actual application
Public Class OcrSpaceApiClient
    Implements IDisposable

    Private ReadOnly _httpClient As HttpClient
    Private ReadOnly _apiKey As String
    Private ReadOnly _rateLimiter As SemaphoreSlim
    Private Const ApiEndpoint As String = "https://api.ocr.space/parse/image"
    Private Const MaxFileSizeFree As Integer = 5 * 1024 * 1024 ' 5MB — hard limit on free tier
    Private Const RateLimitPerMinute As Integer = 60

    Public Sub New(apiKey As String)
        _apiKey = If(apiKey, Throw New ArgumentNullException(NameOf(apiKey)))
        _httpClient = New HttpClient()
        _httpClient.Timeout = TimeSpan.FromSeconds(120)
        _rateLimiter = New SemaphoreSlim(RateLimitPerMinute, RateLimitPerMinute)
    End Sub

    Public Async Function ExtractTextFromFileAsync(filePath As String, Optional language As String = "eng", Optional cancellationToken As CancellationToken = Nothing) As Task(Of OcrResult)
        If Not File.Exists(filePath) Then
            Throw New FileNotFoundException("Image file not found", filePath)
        End If

        Dim fileInfo = New FileInfo(filePath)
        If fileInfo.Length > MaxFileSizeFree Then
            Throw New InvalidOperationException($"File size {fileInfo.Length \ 1024 \ 1024}MB exceeds free tier limit of 5MB.")
        End If

        Await _rateLimiter.WaitAsync(cancellationToken)

        Try
            ' Document leaves your infrastructure here
            Dim imageBytes As Byte() = Await File.ReadAllBytesAsync(filePath, cancellationToken)
            Dim base64Image As String = Convert.ToBase64String(imageBytes)
            Dim mimeType As String = GetMimeType(filePath)

            Dim formContent = New FormUrlEncodedContent(New KeyValuePair(Of String, String)() {
                New KeyValuePair(Of String, String)("apikey", _apiKey),
                New KeyValuePair(Of String, String)("base64Image", $"data:{mimeType};base64,{base64Image}"),
                New KeyValuePair(Of String, String)("language", language),
                New KeyValuePair(Of String, String)("isOverlayRequired", "false"),
                New KeyValuePair(Of String, String)("filetype", Path.GetExtension(filePath).TrimStart("."c)),
                New KeyValuePair(Of String, String)("detectOrientation", "true"),
                New KeyValuePair(Of String, String)("scale", "true"),
                New KeyValuePair(Of String, String)("OCREngine", "2")
            })

            Dim response = Await _httpClient.PostAsync(ApiEndpoint, formContent, cancellationToken)

            If Not response.IsSuccessStatusCode Then
                Dim errorBody = Await response.Content.ReadAsStringAsync(cancellationToken)
                Throw New OcrSpaceException($"OCR.space API returned {response.StatusCode}: {errorBody}", CInt(response.StatusCode))
            End If

            Dim jsonResponse = Await response.Content.ReadAsStringAsync(cancellationToken)
            Return ParseOcrResponse(jsonResponse)
        Finally
            _ = Task.Run(Async Function()
                             Await Task.Delay(60000 \ RateLimitPerMinute)
                             _rateLimiter.Release()
                         End Function)
        End Try
    End Function

    Private Function ParseOcrResponse(jsonResponse As String) As OcrResult
        Using doc = JsonDocument.Parse(jsonResponse)
            Dim root = doc.RootElement

            If root.TryGetProperty("IsErroredOnProcessing", ByRef isErrored) AndAlso isErrored.GetBoolean() Then
                Dim errorMessage As String = "OCR processing failed"
                If root.TryGetProperty("ErrorMessage", ByRef errorMessages) Then
                    ' Parse the array of error strings manually
                    Dim messages = New List(Of String)()
                    If errorMessages.ValueKind = JsonValueKind.Array Then
                        For Each msg In errorMessages.EnumerateArray()
                            messages.Add(msg.GetString() OrElse "Unknown error")
                        Next
                    End If
                    errorMessage = String.Join("; ", messages)
                End If
                Throw New OcrSpaceException(errorMessage, 500)
            End If

            Dim result = New OcrResult()

            If root.TryGetProperty("ParsedResults", ByRef parsedResults) Then
                For Each parsedResult In parsedResults.EnumerateArray()
                    If parsedResult.TryGetProperty("ParsedText", ByRef parsedText) Then
                        result.ParsedText &= parsedText.GetString()
                    End If

                    If parsedResult.TryGetProperty("FileParseExitCode", ByRef exitCode) Then
                        result.ExitCodes.Add(exitCode.GetInt32())
                    End If
                Next
            End If

            Return result
        End Using
    End Function

    Private Function GetMimeType(filePath As String) As String
        Return Path.GetExtension(filePath).ToLowerInvariant() Select Case
            Case ".png" : Return "image/png"
            Case ".jpg", ".jpeg" : Return "image/jpeg"
            Case ".bmp" : Return "image/bmp"
            Case ".tiff", ".tif" : Return "image/tiff"
            Case ".pdf" : Return "application/pdf"
            Case Else : Return "application/octet-stream"
        End Select
    End Function

    Public Sub Dispose() Implements IDisposable.Dispose
        _httpClient?.Dispose()
        _rateLimiter?.Dispose()
    End Sub
End Class

' Custom models — no SDK means you define these yourself
Public Class OcrResult
    Public Property ParsedText As String = String.Empty
    Public ReadOnly Property Warnings As New List(Of String)()
    Public ReadOnly Property ExitCodes As New List(Of Integer)()
End Class

Public Class OcrSpaceException
    Inherits Exception

    Public ReadOnly Property StatusCode As Integer

    Public Sub New(message As String, statusCode As Integer)
        MyBase.New(message)
        Me.StatusCode = statusCode
    End Sub
End Class

Se trata de más de 90 líneas de código de infraestructura que existen antes del primer método de lógica de negocio. Cada integración de OCR.space incluye este código estándar (o algo equivalente), y cada equipo que lo escribe está resolviendo el mismo problema que OCR.space decidió no resolver por ellos.

Comprender IronOCR

IronOCR es una biblioteca OCR comercial para .NET, instalada a través del paquete NuGet IronOcr. Integra un motor Tesseract 5 optimizado con preprocesamiento automático, entrada nativa de PDF, salida de PDF con capacidad de búsqueda, más de 125 paquetes de idiomas y extracción estructurada de resultados, todo ello sin dependencia de la nube, claves API ni cargos por solicitud. Los documentos se procesan localmente en la infraestructura donde se ejecuta la aplicación .NET .

Características clave:

Paquete NuGet único: dotnet add package IronOcr es la instalación completa. No hay binarios nativos que gestionar, ni directorios tessdata, ni variables de entorno.
API fuertemente tipada: IronTesseract, OcrInput, OcrResult y CropRectangle son tipos .NET de primera clase con soporte completo de IntelliSense.
Preprocesamiento automático: Los filtros de corrección de inclinación, reducción de ruido, contraste, binarización y mejora de la resolución se aplican automáticamente o bajo demanda sin necesidad de bibliotecas externas.
Compatibilidad nativa con PDF: Tanto la lectura de archivos PDF escaneados como la generación de archivos PDF con capacidad de búsqueda están integradas. Sin límites de tamaño más allá de la memoria disponible.
Ejecución local: No se produce ninguna llamada de red durante el OCR. La biblioteca se ejecuta completamente dentro del mismo proceso. Los entornos aislados de la red funcionan sin necesidad de realizar cambios en la configuración.
Seguro para hilos: Múltiples instancias de IronTesseract se ejecutan concurrentemente sin bloqueo o gestión de contención.
Licenciamiento perpetuo: $999 Lite / $1,499 Plus / $2,399 Professional. No se aplican cargos por solicitud, independientemente del volumen.

Comparación de características

Característica	OCR.space	IronOCR
Paquete NuGet	Ninguno: solo API REST	`IronOcr` — soporte completo .NET
Lugar de procesamiento	Servidores en la nube de OCR.space	Local: su infraestructura
Nivel gratuito	25.000 solicitudes/mes (limitado)	Prueba disponible
Precios pagados	Contacta a OCR.space para conocer los precios actuales	$2,399 perpetuo de una sola vez
limitación de velocidad	60 solicitudes/min, 500/día (gratis)	None
Capacidad sin conexión	No	Sí, completamente aislado del aire.
Privacidad de datos	Documentos enviados a terceros	Los documentos permanecen en sus servidores.

Comparación detallada de características

Característica	OCR.space	IronOCR
Integración
Paquete NuGet	None	Sí (`IronOcr`)
Modelos fuertemente tipados	Ninguno: análisis manual de JSON	Sí (`OcrResult`, `OcrInput`)
Soporte de IntelliSense	None	Completo
Tipos de excepción personalizados	Debes definirte a ti mismo	Incorporado en
Lógica de reintento	Debes construirte a ti mismo	Incorporado en
Tratamiento
Ubicación de procesamiento	Servidores en la nube	En proceso local
Se requiere conexión a Internet	Sí, cada llamada	No
Soporte aislado	No	Sí
límites de velocidad	Sí, todos los planes	None
límites de tamaño de archivo	5 MB (nivel gratuito)	Solo memoria
Capacidad OCR
OCR de imágenes	Sí	Sí
OCR de PDF	Sí (con limitaciones)	Sí (nativo, sin límite de tamaño)
Salida en PDF con capacidad de búsqueda	Con marca de agua en el nivel gratuito	Salida limpia, sin marcas de agua.
Preprocesamiento automático	Ninguno (solo del lado del servidor)	Corrección de inclinación, reducción de ruido, contraste, binarización, mejora de la resolución
Control de preprocesamiento manual	None	API de filtro completo
Soporte de idiomas	~25 idiomas	Más de 125 paquetes de idiomas NuGet
Documento multilingüe	Limitado	Sí, lenguas primarias y secundarias.
Salida estructurada (palabras/líneas/páginas)	No, solo texto plano	Sí — páginas, párrafos, líneas, palabras con coordenadas
Puntuaciones de confianza	No	Sí, por resultado y por palabra.
OCR basado en la región	No	Sí — `CropRectangle`
Lectura de BarCodes durante el OCR	No	Sí — `ReadBarCodes = true`
Despliegue
Docker	Requiere conexión a internet saliente.	Funcionamiento inmediato
Linux	Requiere conexión a internet saliente.	Totalmente compatible
Compatible con HIPAA	Riesgo: los documentos quedan fuera de su control.	Sí, sin transmisión externa.
Compatible con el RGPD	Riesgo: la transferencia de datos de la UE no está clara.	Sí, no se gestionan datos de terceros.
Precios
Modelo de precios	Suscripción mensual	Licencia perpetua única
Precio de entrada	Contacta a OCR.space para conocer los precios actuales	$999 de una sola vez
Coste por documento a gran escala	Sí	None
SLA	Ninguno (gratis), varía (de pago)	Acuerdo de nivel de Enterprise disponible

Profundidad del SDK frente a HTTP sin procesar: El coste de la integración

La diferencia entre OCR.space y un SDK nativo no es una cuestión de estilo. Se mide en horas de desarrollo, superficie de fallos y carga de mantenimiento en cada implementación.

Enfoque OCR.space

Cada desarrollador .NET que utiliza OCR.space escribe su propio cliente HTTP. La implementación más sencilla posible —extracción básica de texto sin lógica de reintento, sin soporte para procesamiento por lotes y sin preprocesamiento— sigue siendo de más de 50 líneas:

// OCR.space: minimum viable extraction — Más de 50 lines before business logic
public class OcrSpaceBasicExtraction
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;

    public OcrSpaceBasicExtraction(string apiKey)
    {
        _apiKey = apiKey;
        _httpClient = new HttpClient();
    }

    public async Task<string> ExtractText(string imagePath)
    {
        // Read file and encode — document leaves your infrastructure
        byte[] imageBytes = File.ReadAllBytes(imagePath);
        string base64 = Convert.ToBase64String(imageBytes);

        var content = new FormUrlEncodedContent(new[]
        {
            new KeyValuePair<string, string>("apikey", _apiKey),
            new KeyValuePair<string, string>("base64Image", $"data:image/png;base64,{base64}"),
            new KeyValuePair<string, string>("language", "eng")
        });

        // Send to cloud
        var response = await _httpClient.PostAsync(
            "https://api.ocr.space/parse/image", content);

        if (!response.IsSuccessStatusCode)
            throw new Exception($"API error: {response.StatusCode}");

        // Parse JSON manually — no typed models
        string json = await response.Content.ReadAsStringAsync();
        using var doc = JsonDocument.Parse(json);

        return doc.RootElement
            .GetProperty("ParsedResults")[0]
            .GetProperty("ParsedText")
            .GetString() ?? string.Empty;
    }
}

// OCR.space: minimum viable extraction — Más de 50 lines before business logic
public class OcrSpaceBasicExtraction
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;

    public OcrSpaceBasicExtraction(string apiKey)
    {
        _apiKey = apiKey;
        _httpClient = new HttpClient();
    }

    public async Task<string> ExtractText(string imagePath)
    {
        // Read file and encode — document leaves your infrastructure
        byte[] imageBytes = File.ReadAllBytes(imagePath);
        string base64 = Convert.ToBase64String(imageBytes);

        var content = new FormUrlEncodedContent(new[]
        {
            new KeyValuePair<string, string>("apikey", _apiKey),
            new KeyValuePair<string, string>("base64Image", $"data:image/png;base64,{base64}"),
            new KeyValuePair<string, string>("language", "eng")
        });

        // Send to cloud
        var response = await _httpClient.PostAsync(
            "https://api.ocr.space/parse/image", content);

        if (!response.IsSuccessStatusCode)
            throw new Exception($"API error: {response.StatusCode}");

        // Parse JSON manually — no typed models
        string json = await response.Content.ReadAsStringAsync();
        using var doc = JsonDocument.Parse(json);

        return doc.RootElement
            .GetProperty("ParsedResults")[0]
            .GetProperty("ParsedText")
            .GetString() ?? string.Empty;
    }
}

Si se añade el procesamiento por lotes, el número de líneas asciende a más de 80, ya que cada solicitud por lotes necesita una limitación de velocidad, una lógica de reintento por solicitud con retroceso exponencial y un manejo explícito para las respuestas HTTP 429. Si se añade el procesamiento de PDF, se agrega una comprobación del tamaño del archivo de 5 MB antes de cada llamada, ya que el nivel gratuito rechazará los archivos más grandes con un error en lugar de una advertencia.

Enfoque de IronOCR

La instalación de IronOCR desde NuGet reemplaza todo ese código de infraestructura con llamadas a métodos que ya existen:

// IronOCR: complete implementation
var result = new IronTesseract().Read("invoice.png");
Console.WriteLine(result.Text);

// IronOCR: complete implementation
var result = new IronTesseract().Read("invoice.png");
Console.WriteLine(result.Text);

net

net

La clase IronTesseract maneja la lectura de archivos, el preprocesamiento, la ejecución del motor y la construcción de resultados. No se requiere cliente HTTP. Sin codificación base64. Sin análisis JSON. Sin clave API. Sin limitador de velocidad. El tutorial sobre lectura de texto a partir de imágenes abarca diversas variaciones de entrada (rutas de archivo, matrices de bytes, flujos, mapas de bits) que siguen el mismo patrón de una sola llamada.

Los números de complejidad del código que aparecen en los archivos fuente no son hipotéticos:

Escenario	Líneas de espacio OCR	Líneas IronOCR
Extracción básica	Más de 50	3
Procesamiento de PDF	Más de 60	12
Procesamiento por lotes	Más de 80	15
Tratamiento de errores	Más de 70	15
Infraestructura completa del cliente	Más de 200	0 (NuGet lo proporciona)

Procesamiento por lotes y límites de velocidad

El problema del límite de solicitudes es donde la versión gratuita de OCR.space muestra sus deficiencias más evidentes en condiciones de producción reales.

Enfoque OCR.space

El procesamiento por lotes bajo OCR.space requiere construir y gestionar un SemaphoreSlim para mantenerse dentro de la restricción de 60 solicitudes por minuto, además de la lógica de reintento con retroceso exponencial para las respuestas HTTP 429 que llegan cuando la lógica de semáforo es imprecisa o cuando la infraestructura compartida comparte una dirección IP:

// OCR.space batch: Más de 80 lines of rate-limit plumbing before actual work
public class OcrSpaceBatchProcessing
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    private readonly SemaphoreSlim _rateLimiter;

    public OcrSpaceBatchProcessing(string apiKey)
    {
        _apiKey = apiKey;
        _httpClient = new HttpClient();
        _rateLimiter = new SemaphoreSlim(60, 60); // Free tier: 60/minute
    }

    public async Task<Dictionary<string, string>> ProcessBatch(string[] imagePaths)
    {
        var results = new Dictionary<string, string>();

        foreach (var imagePath in imagePaths)
        {
            await _rateLimiter.WaitAsync();

            try
            {
                string text = await ProcessWithRetry(imagePath);
                results[imagePath] = text;
            }
            finally
            {
                _ = Task.Run(async () =>
                {
                    await Task.Delay(1000); // 1 second spacing
                    _rateLimiter.Release();
                });
            }
        }

        return results;
    }

    private async Task<string> ProcessWithRetry(string imagePath, int maxRetries = 3)
    {
        for (int attempt = 0; attempt < maxRetries; attempt++)
        {
            try
            {
                byte[] imageBytes = File.ReadAllBytes(imagePath);
                string base64 = Convert.ToBase64String(imageBytes);

                var content = new FormUrlEncodedContent(new[]
                {
                    new KeyValuePair<string, string>("apikey", _apiKey),
                    new KeyValuePair<string, string>("base64Image", $"data:image/png;base64,{base64}"),
                    new KeyValuePair<string, string>("language", "eng")
                });

                var response = await _httpClient.PostAsync(
                    "https://api.ocr.space/parse/image", content);

                if (response.StatusCode == System.Net.HttpStatusCode.TooManyRequests)
                {
                    // Rate limited — exponential backoff
                    await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)));
                    continue;
                }

                response.EnsureSuccessStatusCode();

                string json = await response.Content.ReadAsStringAsync();
                using var doc = JsonDocument.Parse(json);

                return doc.RootElement
                    .GetProperty("ParsedResults")[0]
                    .GetProperty("ParsedText")
                    .GetString() ?? string.Empty;
            }
            catch (HttpRequestException) when (attempt < maxRetries - 1)
            {
                await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)));
            }
        }

        throw new Exception($"Failed to process {imagePath} after {maxRetries} attempts");
    }
}

// OCR.space batch: Más de 80 lines of rate-limit plumbing before actual work
public class OcrSpaceBatchProcessing
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    private readonly SemaphoreSlim _rateLimiter;

    public OcrSpaceBatchProcessing(string apiKey)
    {
        _apiKey = apiKey;
        _httpClient = new HttpClient();
        _rateLimiter = new SemaphoreSlim(60, 60); // Free tier: 60/minute
    }

    public async Task<Dictionary<string, string>> ProcessBatch(string[] imagePaths)
    {
        var results = new Dictionary<string, string>();

        foreach (var imagePath in imagePaths)
        {
            await _rateLimiter.WaitAsync();

            try
            {
                string text = await ProcessWithRetry(imagePath);
                results[imagePath] = text;
            }
            finally
            {
                _ = Task.Run(async () =>
                {
                    await Task.Delay(1000); // 1 second spacing
                    _rateLimiter.Release();
                });
            }
        }

        return results;
    }

    private async Task<string> ProcessWithRetry(string imagePath, int maxRetries = 3)
    {
        for (int attempt = 0; attempt < maxRetries; attempt++)
        {
            try
            {
                byte[] imageBytes = File.ReadAllBytes(imagePath);
                string base64 = Convert.ToBase64String(imageBytes);

                var content = new FormUrlEncodedContent(new[]
                {
                    new KeyValuePair<string, string>("apikey", _apiKey),
                    new KeyValuePair<string, string>("base64Image", $"data:image/png;base64,{base64}"),
                    new KeyValuePair<string, string>("language", "eng")
                });

                var response = await _httpClient.PostAsync(
                    "https://api.ocr.space/parse/image", content);

                if (response.StatusCode == System.Net.HttpStatusCode.TooManyRequests)
                {
                    // Rate limited — exponential backoff
                    await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)));
                    continue;
                }

                response.EnsureSuccessStatusCode();

                string json = await response.Content.ReadAsStringAsync();
                using var doc = JsonDocument.Parse(json);

                return doc.RootElement
                    .GetProperty("ParsedResults")[0]
                    .GetProperty("ParsedText")
                    .GetString() ?? string.Empty;
            }
            catch (HttpRequestException) when (attempt < maxRetries - 1)
            {
                await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)));
            }
        }

        throw new Exception($"Failed to process {imagePath} after {maxRetries} attempts");
    }
}

El límite de 500 solicitudes diarias en el nivel gratuito restringe aún más esta posibilidad. Una aplicación que procese 600 documentos en un solo día fallará a mitad del proceso, sin que se produzca una prórroga automática hasta el siguiente día natural.

Enfoque de IronOCR

IronOCR no tiene límites de uso. El procesamiento por lotes es un bucle:

//IronOCR batch: 8 lines, no rate limits, no retries needed
public Dictionary<string, string> ProcessBatch(string[] imagePaths)
{
    var results = new Dictionary<string, string>();
    var ocr = new IronTesseract();

    foreach (var imagePath in imagePaths)
    {
        // No rate limits, no retries, no cloud dependency
        var result = ocr.Read(imagePath);
        results[imagePath] = result.Text;
    }

    return results;
}

//IronOCR batch: 8 lines, no rate limits, no retries needed
public Dictionary<string, string> ProcessBatch(string[] imagePaths)
{
    var results = new Dictionary<string, string>();
    var ocr = new IronTesseract();

    foreach (var imagePath in imagePaths)
    {
        // No rate limits, no retries, no cloud dependency
        var result = ocr.Read(imagePath);
        results[imagePath] = result.Text;
    }

    return results;
}

Reutilizar la instancia IronTesseract a través del lote evita la sobrecarga de inicialización repetida del motor. La velocidad de procesamiento está limitada por la CPU local y la E/S del disco, no por la política de limitación de una API remota. El ejemplo de multihilo muestra cómo paralelizar entre núcleos cuando el rendimiento es importante.

Procesamiento de PDF

La compatibilidad con archivos PDF ilustra la segunda brecha estructural importante.

Enfoque OCR.space

OCR.space acepta la carga de archivos PDF en los planes de pago y parcialmente en el plan gratuito, pero el límite de tamaño de archivo de 5 MB en las cuentas gratuitas excluye a la mayoría de los documentos de varias páginas. La salida PDF con capacidad de búsqueda de la versión gratuita incluye una marca de agua. La implementación requiere la extracción de resultados por página y una comprobación explícita del tamaño del archivo antes de cada solicitud:

// OCR.space PDF: size check required, watermarks on free tier
public async Task<List<string>> ExtractTextFromPdf(string pdfPath)
{
    var pageTexts = new List<string>();

    // Reject before wasting a request quota entry
    var fileInfo = new FileInfo(pdfPath);
    if (fileInfo.Length > 5 * 1024 * 1024)
        throw new InvalidOperationException("File exceeds 5MB free tier limit. Upgrade or split PDF.");

    byte[] pdfBytes = File.ReadAllBytes(pdfPath);
    string base64 = Convert.ToBase64String(pdfBytes);

    var content = new FormUrlEncodedContent(new[]
    {
        new KeyValuePair<string, string>("apikey", _apiKey),
        new KeyValuePair<string, string>("base64Image", $"data:application/pdf;base64,{base64}"),
        new KeyValuePair<string, string>("language", "eng"),
        new KeyValuePair<string, string>("filetype", "PDF"),
        new KeyValuePair<string, string>("isCreateSearchablePdf", "false") // Watermarked on free tier
    });

    var response = await _httpClient.PostAsync("https://api.ocr.space/parse/image", content);

    if (!response.IsSuccessStatusCode)
        throw new Exception($"API error: {response.StatusCode}");

    string json = await response.Content.ReadAsStringAsync();
    using var doc = JsonDocument.Parse(json);

    if (doc.RootElement.TryGetProperty("ParsedResults", out var results))
    {
        foreach (var result in results.EnumerateArray())
        {
            if (result.TryGetProperty("ParsedText", out var text))
                pageTexts.Add(text.GetString() ?? string.Empty);
        }
    }

    return pageTexts;
}

// OCR.space PDF: size check required, watermarks on free tier
public async Task<List<string>> ExtractTextFromPdf(string pdfPath)
{
    var pageTexts = new List<string>();

    // Reject before wasting a request quota entry
    var fileInfo = new FileInfo(pdfPath);
    if (fileInfo.Length > 5 * 1024 * 1024)
        throw new InvalidOperationException("File exceeds 5MB free tier limit. Upgrade or split PDF.");

    byte[] pdfBytes = File.ReadAllBytes(pdfPath);
    string base64 = Convert.ToBase64String(pdfBytes);

    var content = new FormUrlEncodedContent(new[]
    {
        new KeyValuePair<string, string>("apikey", _apiKey),
        new KeyValuePair<string, string>("base64Image", $"data:application/pdf;base64,{base64}"),
        new KeyValuePair<string, string>("language", "eng"),
        new KeyValuePair<string, string>("filetype", "PDF"),
        new KeyValuePair<string, string>("isCreateSearchablePdf", "false") // Watermarked on free tier
    });

    var response = await _httpClient.PostAsync("https://api.ocr.space/parse/image", content);

    if (!response.IsSuccessStatusCode)
        throw new Exception($"API error: {response.StatusCode}");

    string json = await response.Content.ReadAsStringAsync();
    using var doc = JsonDocument.Parse(json);

    if (doc.RootElement.TryGetProperty("ParsedResults", out var results))
    {
        foreach (var result in results.EnumerateArray())
        {
            if (result.TryGetProperty("ParsedText", out var text))
                pageTexts.Add(text.GetString() ?? string.Empty);
        }
    }

    return pageTexts;
}

Imports System.IO
Imports System.Net.Http
Imports System.Text.Json
Imports System.Threading.Tasks

Public Class OCRSpaceClient
    Private ReadOnly _apiKey As String
    Private ReadOnly _httpClient As HttpClient

    Public Sub New(apiKey As String, httpClient As HttpClient)
        _apiKey = apiKey
        _httpClient = httpClient
    End Sub

    Public Async Function ExtractTextFromPdf(pdfPath As String) As Task(Of List(Of String))
        Dim pageTexts As New List(Of String)()

        ' Reject before wasting a request quota entry
        Dim fileInfo As New FileInfo(pdfPath)
        If fileInfo.Length > 5 * 1024 * 1024 Then
            Throw New InvalidOperationException("File exceeds 5MB free tier limit. Upgrade or split PDF.")
        End If

        Dim pdfBytes As Byte() = File.ReadAllBytes(pdfPath)
        Dim base64 As String = Convert.ToBase64String(pdfBytes)

        Dim content As New FormUrlEncodedContent(New KeyValuePair(Of String, String)() {
            New KeyValuePair(Of String, String)("apikey", _apiKey),
            New KeyValuePair(Of String, String)("base64Image", $"data:application/pdf;base64,{base64}"),
            New KeyValuePair(Of String, String)("language", "eng"),
            New KeyValuePair(Of String, String)("filetype", "PDF"),
            New KeyValuePair(Of String, String)("isCreateSearchablePdf", "false") ' Watermarked on free tier
        })

        Dim response As HttpResponseMessage = Await _httpClient.PostAsync("https://api.ocr.space/parse/image", content)

        If Not response.IsSuccessStatusCode Then
            Throw New Exception($"API error: {response.StatusCode}")
        End If

        Dim json As String = Await response.Content.ReadAsStringAsync()
        Using doc As JsonDocument = JsonDocument.Parse(json)
            If doc.RootElement.TryGetProperty("ParsedResults", results) Then
                For Each result In results.EnumerateArray()
                    If result.TryGetProperty("ParsedText", text) Then
                        pageTexts.Add(If(text.GetString(), String.Empty))
                    End If
                Next
            End If
        End Using

        Return pageTexts
    End Function
End Class

Imports System.IO
Imports System.Net.Http
Imports System.Text.Json
Imports System.Threading.Tasks

Public Class OCRSpaceClient
    Private ReadOnly _apiKey As String
    Private ReadOnly _httpClient As HttpClient

    Public Sub New(apiKey As String, httpClient As HttpClient)
        _apiKey = apiKey
        _httpClient = httpClient
    End Sub

    Public Async Function ExtractTextFromPdf(pdfPath As String) As Task(Of List(Of String))
        Dim pageTexts As New List(Of String)()

        ' Reject before wasting a request quota entry
        Dim fileInfo As New FileInfo(pdfPath)
        If fileInfo.Length > 5 * 1024 * 1024 Then
            Throw New InvalidOperationException("File exceeds 5MB free tier limit. Upgrade or split PDF.")
        End If

        Dim pdfBytes As Byte() = File.ReadAllBytes(pdfPath)
        Dim base64 As String = Convert.ToBase64String(pdfBytes)

        Dim content As New FormUrlEncodedContent(New KeyValuePair(Of String, String)() {
            New KeyValuePair(Of String, String)("apikey", _apiKey),
            New KeyValuePair(Of String, String)("base64Image", $"data:application/pdf;base64,{base64}"),
            New KeyValuePair(Of String, String)("language", "eng"),
            New KeyValuePair(Of String, String)("filetype", "PDF"),
            New KeyValuePair(Of String, String)("isCreateSearchablePdf", "false") ' Watermarked on free tier
        })

        Dim response As HttpResponseMessage = Await _httpClient.PostAsync("https://api.ocr.space/parse/image", content)

        If Not response.IsSuccessStatusCode Then
            Throw New Exception($"API error: {response.StatusCode}")
        End If

        Dim json As String = Await response.Content.ReadAsStringAsync()
        Using doc As JsonDocument = JsonDocument.Parse(json)
            If doc.RootElement.TryGetProperty("ParsedResults", results) Then
                For Each result In results.EnumerateArray()
                    If result.TryGetProperty("ParsedText", text) Then
                        pageTexts.Add(If(text.GetString(), String.Empty))
                    End If
                Next
            End If
        End Using

        Return pageTexts
    End Function
End Class

Enfoque de IronOCR

IronOCR lee archivos PDF de forma nativa. El límite es la memoria disponible, no un umbral arbitrario de tamaño de archivo. La salida PDF con capacidad de búsqueda produce archivos limpios sin marcas de agua, en cualquier nivel de licencia:

//IronOCR PDF: native support, no size limit, no watermarks
public List<string> ExtractTextFromPdf(string pdfPath)
{
    var pageTexts = new List<string>();

    using var input = new OcrInput();
    input.LoadPdf(pdfPath); // No 5MB ceiling

    var result = new IronTesseract().Read(input);

    foreach (var page in result.Pages)
        pageTexts.Add(page.Text);

    return pageTexts;
}

// Generate searchable PDF — no watermarks
public void CreateSearchablePdf(string inputPath, string outputPath)
{
    var result = new IronTesseract().Read(inputPath);
    result.SaveAsSearchablePdf(outputPath);
}

//IronOCR PDF: native support, no size limit, no watermarks
public List<string> ExtractTextFromPdf(string pdfPath)
{
    var pageTexts = new List<string>();

    using var input = new OcrInput();
    input.LoadPdf(pdfPath); // No 5MB ceiling

    var result = new IronTesseract().Read(input);

    foreach (var page in result.Pages)
        pageTexts.Add(page.Text);

    return pageTexts;
}

// Generate searchable PDF — no watermarks
public void CreateSearchablePdf(string inputPath, string outputPath)
{
    var result = new IronTesseract().Read(inputPath);
    result.SaveAsSearchablePdf(outputPath);
}

Los PDF protegidos por contraseña son un solo parámetro: input.LoadPdf("encrypted.pdf", Password: "secret"). La guía práctica de OCR en formato PDF cubre en detalle la selección del rango de páginas y el manejo de contraseñas. Para obtener patrones de generación de PDF con capacidad de búsqueda, consulte la guía práctica sobre cómo crear PDF con capacidad de búsqueda .

Manejo de errores

OCR.space entrega errores a través de dos canales separados: códigos de estado HTTP y un indicador JSON IsErroredOnProcessing. El código de producción debe verificar ambos, analizar el array de errores JSON cuando IsErroredOnProcessing es verdadero e inspeccionar los valores FileParseExitCode por página para fallas parciales. Nada de esto está tipado; todo es análisis de cadenas desde JsonDocument:

// OCR.space: two error layers, all string-based
public async Task<string> SafeExtract(HttpClient client, string apiKey, string imagePath)
{
    try
    {
        byte[] imageBytes = File.ReadAllBytes(imagePath);
        string base64 = Convert.ToBase64String(imageBytes);

        var content = new FormUrlEncodedContent(new[]
        {
            new KeyValuePair<string, string>("apikey", apiKey),
            new KeyValuePair<string, string>("base64Image", $"data:image/png;base64,{base64}")
        });

        var response = await client.PostAsync("https://api.ocr.space/parse/image", content);

        if (!response.IsSuccessStatusCode)
        {
            switch (response.StatusCode)
            {
                case System.Net.HttpStatusCode.Unauthorized:
                    throw new Exception("Invalid API key");
                case System.Net.HttpStatusCode.TooManyRequests:
                    throw new Exception("Rate limit exceeded — wait and retry");
                case System.Net.HttpStatusCode.PaymentRequired:
                    throw new Exception("Quota exceeded — upgrade plan");
                default:
                    throw new Exception($"API error: {response.StatusCode}");
            }
        }

        // Second error layer: JSON-level failures
        string json = await response.Content.ReadAsStringAsync();
        using var doc = JsonDocument.Parse(json);

        if (doc.RootElement.TryGetProperty("IsErroredOnProcessing", out var isError)
            && isError.GetBoolean())
        {
            var messages = new List<string>();
            if (doc.RootElement.TryGetProperty("ErrorMessage", out var errors))
            {
                foreach (var e in errors.EnumerateArray())
                    messages.Add(e.GetString() ?? "Unknown error");
            }
            throw new Exception(string.Join("; ", messages));
        }

        // Third layer: per-page exit codes
        if (doc.RootElement.TryGetProperty("ParsedResults", out var results))
        {
            foreach (var result in results.EnumerateArray())
            {
                if (result.TryGetProperty("FileParseExitCode", out var exitCode)
                    && exitCode.GetInt32() != 1)
                    throw new Exception($"Page parse failed: exit code {exitCode.GetInt32()}");
            }
        }

        return doc.RootElement
            .GetProperty("ParsedResults")[0]
            .GetProperty("ParsedText")
            .GetString() ?? string.Empty;
    }
    catch (JsonException ex)
    {
        throw new Exception($"Invalid API response: {ex.Message}");
    }
    catch (HttpRequestException ex)
    {
        throw new Exception($"Network error: {ex.Message}");
    }
}

// OCR.space: two error layers, all string-based
public async Task<string> SafeExtract(HttpClient client, string apiKey, string imagePath)
{
    try
    {
        byte[] imageBytes = File.ReadAllBytes(imagePath);
        string base64 = Convert.ToBase64String(imageBytes);

        var content = new FormUrlEncodedContent(new[]
        {
            new KeyValuePair<string, string>("apikey", apiKey),
            new KeyValuePair<string, string>("base64Image", $"data:image/png;base64,{base64}")
        });

        var response = await client.PostAsync("https://api.ocr.space/parse/image", content);

        if (!response.IsSuccessStatusCode)
        {
            switch (response.StatusCode)
            {
                case System.Net.HttpStatusCode.Unauthorized:
                    throw new Exception("Invalid API key");
                case System.Net.HttpStatusCode.TooManyRequests:
                    throw new Exception("Rate limit exceeded — wait and retry");
                case System.Net.HttpStatusCode.PaymentRequired:
                    throw new Exception("Quota exceeded — upgrade plan");
                default:
                    throw new Exception($"API error: {response.StatusCode}");
            }
        }

        // Second error layer: JSON-level failures
        string json = await response.Content.ReadAsStringAsync();
        using var doc = JsonDocument.Parse(json);

        if (doc.RootElement.TryGetProperty("IsErroredOnProcessing", out var isError)
            && isError.GetBoolean())
        {
            var messages = new List<string>();
            if (doc.RootElement.TryGetProperty("ErrorMessage", out var errors))
            {
                foreach (var e in errors.EnumerateArray())
                    messages.Add(e.GetString() ?? "Unknown error");
            }
            throw new Exception(string.Join("; ", messages));
        }

        // Third layer: per-page exit codes
        if (doc.RootElement.TryGetProperty("ParsedResults", out var results))
        {
            foreach (var result in results.EnumerateArray())
            {
                if (result.TryGetProperty("FileParseExitCode", out var exitCode)
                    && exitCode.GetInt32() != 1)
                    throw new Exception($"Page parse failed: exit code {exitCode.GetInt32()}");
            }
        }

        return doc.RootElement
            .GetProperty("ParsedResults")[0]
            .GetProperty("ParsedText")
            .GetString() ?? string.Empty;
    }
    catch (JsonException ex)
    {
        throw new Exception($"Invalid API response: {ex.Message}");
    }
    catch (HttpRequestException ex)
    {
        throw new Exception($"Network error: {ex.Message}");
    }
}

Imports System
Imports System.Collections.Generic
Imports System.IO
Imports System.Net.Http
Imports System.Text.Json
Imports System.Threading.Tasks

Public Class OCRSpace
    Public Async Function SafeExtract(client As HttpClient, apiKey As String, imagePath As String) As Task(Of String)
        Try
            Dim imageBytes As Byte() = File.ReadAllBytes(imagePath)
            Dim base64 As String = Convert.ToBase64String(imageBytes)

            Dim content As New FormUrlEncodedContent(New KeyValuePair(Of String, String)() {
                New KeyValuePair(Of String, String)("apikey", apiKey),
                New KeyValuePair(Of String, String)("base64Image", $"data:image/png;base64,{base64}")
            })

            Dim response As HttpResponseMessage = Await client.PostAsync("https://api.ocr.space/parse/image", content)

            If Not response.IsSuccessStatusCode Then
                Select Case response.StatusCode
                    Case System.Net.HttpStatusCode.Unauthorized
                        Throw New Exception("Invalid API key")
                    Case System.Net.HttpStatusCode.TooManyRequests
                        Throw New Exception("Rate limit exceeded — wait and retry")
                    Case System.Net.HttpStatusCode.PaymentRequired
                        Throw New Exception("Quota exceeded — upgrade plan")
                    Case Else
                        Throw New Exception($"API error: {response.StatusCode}")
                End Select
            End If

            ' Second error layer: JSON-level failures
            Dim json As String = Await response.Content.ReadAsStringAsync()
            Using doc As JsonDocument = JsonDocument.Parse(json)
                If doc.RootElement.TryGetProperty("IsErroredOnProcessing", ByRef isError) AndAlso isError.GetBoolean() Then
                    Dim messages As New List(Of String)()
                    If doc.RootElement.TryGetProperty("ErrorMessage", ByRef errors) Then
                        For Each e In errors.EnumerateArray()
                            messages.Add(e.GetString() ?? "Unknown error")
                        Next
                    End If
                    Throw New Exception(String.Join("; ", messages))
                End If

                ' Third layer: per-page exit codes
                If doc.RootElement.TryGetProperty("ParsedResults", ByRef results) Then
                    For Each result In results.EnumerateArray()
                        If result.TryGetProperty("FileParseExitCode", ByRef exitCode) AndAlso exitCode.GetInt32() <> 1 Then
                            Throw New Exception($"Page parse failed: exit code {exitCode.GetInt32()}")
                        End If
                    Next
                End If

                Return doc.RootElement _
                    .GetProperty("ParsedResults")(0) _
                    .GetProperty("ParsedText") _
                    .GetString() ?? String.Empty
            End Using
        Catch ex As JsonException
            Throw New Exception($"Invalid API response: {ex.Message}")
        Catch ex As HttpRequestException
            Throw New Exception($"Network error: {ex.Message}")
        End Try
    End Function
End Class

Imports System
Imports System.Collections.Generic
Imports System.IO
Imports System.Net.Http
Imports System.Text.Json
Imports System.Threading.Tasks

Public Class OCRSpace
    Public Async Function SafeExtract(client As HttpClient, apiKey As String, imagePath As String) As Task(Of String)
        Try
            Dim imageBytes As Byte() = File.ReadAllBytes(imagePath)
            Dim base64 As String = Convert.ToBase64String(imageBytes)

            Dim content As New FormUrlEncodedContent(New KeyValuePair(Of String, String)() {
                New KeyValuePair(Of String, String)("apikey", apiKey),
                New KeyValuePair(Of String, String)("base64Image", $"data:image/png;base64,{base64}")
            })

            Dim response As HttpResponseMessage = Await client.PostAsync("https://api.ocr.space/parse/image", content)

            If Not response.IsSuccessStatusCode Then
                Select Case response.StatusCode
                    Case System.Net.HttpStatusCode.Unauthorized
                        Throw New Exception("Invalid API key")
                    Case System.Net.HttpStatusCode.TooManyRequests
                        Throw New Exception("Rate limit exceeded — wait and retry")
                    Case System.Net.HttpStatusCode.PaymentRequired
                        Throw New Exception("Quota exceeded — upgrade plan")
                    Case Else
                        Throw New Exception($"API error: {response.StatusCode}")
                End Select
            End If

            ' Second error layer: JSON-level failures
            Dim json As String = Await response.Content.ReadAsStringAsync()
            Using doc As JsonDocument = JsonDocument.Parse(json)
                If doc.RootElement.TryGetProperty("IsErroredOnProcessing", ByRef isError) AndAlso isError.GetBoolean() Then
                    Dim messages As New List(Of String)()
                    If doc.RootElement.TryGetProperty("ErrorMessage", ByRef errors) Then
                        For Each e In errors.EnumerateArray()
                            messages.Add(e.GetString() ?? "Unknown error")
                        Next
                    End If
                    Throw New Exception(String.Join("; ", messages))
                End If

                ' Third layer: per-page exit codes
                If doc.RootElement.TryGetProperty("ParsedResults", ByRef results) Then
                    For Each result In results.EnumerateArray()
                        If result.TryGetProperty("FileParseExitCode", ByRef exitCode) AndAlso exitCode.GetInt32() <> 1 Then
                            Throw New Exception($"Page parse failed: exit code {exitCode.GetInt32()}")
                        End If
                    Next
                End If

                Return doc.RootElement _
                    .GetProperty("ParsedResults")(0) _
                    .GetProperty("ParsedText") _
                    .GetString() ?? String.Empty
            End Using
        Catch ex As JsonException
            Throw New Exception($"Invalid API response: {ex.Message}")
        Catch ex As HttpRequestException
            Throw New Exception($"Network error: {ex.Message}")
        End Try
    End Function
End Class

IronOCR genera excepciones estándar de .NET con mensajes claros. Sin análisis JSON, sin cambio de código de estado HTTP, sin extracción de errores por capas:

// IronOCR: standard .NET exceptions
public string SafeExtract(string imagePath)
{
    try
    {
        var result = new IronTesseract().Read(imagePath);
        return result.Text;
    }
    catch (FileNotFoundException)
    {
        throw; // File not found — straightforward
    }
    catch (Exception ex) when (ex.Message.Contains("corrupt"))
    {
        throw new Exception($"Image file is corrupt: {imagePath}");
    }
    // No JSON errors. No HTTP errors. No rate limit errors.
}

// IronOCR: standard .NET exceptions
public string SafeExtract(string imagePath)
{
    try
    {
        var result = new IronTesseract().Read(imagePath);
        return result.Text;
    }
    catch (FileNotFoundException)
    {
        throw; // File not found — straightforward
    }
    catch (Exception ex) when (ex.Message.Contains("corrupt"))
    {
        throw new Exception($"Image file is corrupt: {imagePath}");
    }
    // No JSON errors. No HTTP errors. No rate limit errors.
}

Imports IronOcr

Public Function SafeExtract(imagePath As String) As String
    Try
        Dim result = New IronTesseract().Read(imagePath)
        Return result.Text
    Catch ex As FileNotFoundException
        Throw ' File not found — straightforward
    Catch ex As Exception When ex.Message.Contains("corrupt")
        Throw New Exception($"Image file is corrupt: {imagePath}")
    End Try
    ' No JSON errors. No HTTP errors. No rate limit errors.
End Function

Imports IronOcr

Public Function SafeExtract(imagePath As String) As String
    Try
        Dim result = New IronTesseract().Read(imagePath)
        Return result.Text
    Catch ex As FileNotFoundException
        Throw ' File not found — straightforward
    Catch ex As Exception When ex.Message.Contains("corrupt")
        Throw New Exception($"Image file is corrupt: {imagePath}")
    End Try
    ' No JSON errors. No HTTP errors. No rate limit errors.
End Function

La referencia API de IronTesseract y la referencia API de OcrResult documentan la estructura de resultados tipados, incluyendo la propiedad Confidence para evaluar la calidad de la extracción.

Referencia de mapeo de API

Concepto de OCR.space	Equivalente a IronOCR
`POST https://api.ocr.space/parse/image`	`new IronTesseract().Read(path)`
`FormUrlEncodedContent` / `MultipartFormDataContent`	`OcrInput`
Parámetro `base64Image`	`input.LoadImage(path)` o `input.LoadImage(bytes)`
Parámetro `language`	`ocr.Language = OcrLanguage.English`
Parámetro `OCREngine`	Motor gestionado internamente
Parámetro `isOverlayRequired`	`result.Words` / `result.Lines` (siempre disponible)
Parámetro `isCreateSearchablePdf`	`result.SaveAsSearchablePdf(outputPath)`
Parámetro `filetype=PDF`	`input.LoadPdf(path)`
`ParsedResults[0].ParsedText`	`result.Text`
`ParsedResults[n]` (por página)	`result.Pages[n].Text`
Indicador JSON `IsErroredOnProcessing`	Excepción estándar de .NET
Indicador por página `FileParseExitCode`	Excepción estándar de .NET
`ProcessingTimeInMilliseconds`	Implícito: no se necesita análisis adicional
HTTP 429 / límite de velocidad	No aplicable — sin límites de tarifa
POCO personalizado `OcrResult` (definido por el usuario)	`IronOcr.OcrResult` (proporcionado por NuGet)
Personalizado `OcrSpaceException` (definido por el usuario)	Tipos de excepciones estándar de .NET
Limitador de tasa `SemaphoreSlim` (construido por el usuario)	No es necesario
Clave API en cada solicitud	`IronOcr.License.LicenseKey` (una vez al inicio)

Cuando los equipos consideran migrar de OCR.space a IronOCR

Alcanzar el nivel gratuito durante las pruebas de carga

El límite de 500 solicitudes por día por IP de OCR.space es una restricción estricta, no una recomendación informal. Los equipos descubren esto durante las pruebas de carga o las implementaciones de prueba en las que varios desarrolladores comparten una dirección IP de oficina. Una canalización CI/CD compartida que ejecuta pruebas de integración contra OCR.space agotará la cuota diaria antes de que finalice la jornada laboral. En ese momento, la aplicación falla no porque el código sea incorrecto, sino porque un contador de terceros alcanzó un umbral arbitrario. El paso al procesamiento local elimina por completo esta categoría de fallos, ya que no hay cuota que agotar porque el procesamiento se ejecuta dentro del mismo proceso.

Revisiones de cumplimiento y clasificación de datos

Las revisiones de seguridad que clasifican los documentos como información de identificación personal (PII), información de salud protegida (PHI) o información financieramente sensible crean un problema binario para OCR.space: el servicio no tiene una ruta de implementación local. No existe ningún equivalente documentado al Acuerdo de Asociado Comercial (BAA, por sus siglas en inglés) para los escenarios de HIPAA, ninguna estructura de Acuerdo de Procesamiento de Datos que regule claramente las transferencias de datos de la UE bajo el RGPD, y ningún mecanismo técnico para evitar la transmisión de documentos incluso con controles contractuales implementados. Los equipos que reciben notificaciones de incumplimiento normativo relacionadas con el procesamiento de documentos transmitidos a través de la nube necesitan una solución local.IronOCR cumple este requisito por diseño: los documentos nunca salen del servidor de la aplicación. La página de licencias documenta la estructura de la licencia perpetua, lo que también simplifica la documentación de cumplimiento al eliminar la revisión del proveedor de la nube del alcance.

Carga de mantenimiento del código de integración

Las integraciones de OCR.space acumulan deuda técnica en proporción a sus requisitos de funcionalidades. El cliente HTTP inicial es manejable. Luego, el equipo agrega la lógica de reintento. Luego, añaden un seguimiento del límite de velocidad por IP porque varios servicios comparten una dirección. Luego agregan un paso de prevalidación del tamaño del archivo. Después descubren que la estructura de error JSON difiere entre las respuestas del Motor 1 y el Motor 2 y agregan una bifurcación. Seis meses después, la integración de OCR.space consta de 400 líneas de código de infraestructura que todo nuevo miembro del equipo debe comprender antes de tocar cualquier cosa relacionada con OCR. Cuando ese equipo evalúa el costo de mantenimiento frente a una $999 licencia de IronOCR de una sola vez, la aritmética es simple.

Requisitos de salida estructurados

OCR.space devuelve texto plano y nada más. La respuesta no incluye coordenadas de palabras, límites de línea, segmentación de párrafos ni puntuaciones de confianza por palabra. Las aplicaciones que necesitan extraer campos específicos de las facturas (nombre del proveedor en una región conocida, importe total en la esquina inferior derecha) no tienen una base estructurada sobre la que construir a partir de la salida de OCR.space.IronOCR expone la jerarquía completa del documento con coordenadas y valores de confianza en cada nivel de granularidad: páginas, párrafos, líneas y palabras individuales. El procesamiento basado en regiones permite seleccionar zonas específicas del documento sin necesidad de procesar posteriormente toda la página. La guía sobre cómo leer los resultados y la guía de OCR basada en regiones cubren estos patrones en detalle.

Crecimiento del volumen más allá del nivel gratuito

Con 25.000 solicitudes al mes, el plan gratuito resulta funcional para escenarios de bajo volumen. Más allá de eso, se aplican niveles pagados: contacte con OCR.space para obtener los precios actuales. Esos costos se multiplican con el tiempo hasta que la comparación se realiza contra una $999 licencia perpetua sin cargos por solicitud. Los equipos que prevén un crecimiento del volumen de documentos superior a 25.000 al mes tienen una justificación económica clara para el procesamiento local.

Consideraciones comunes sobre la migración

Reemplazar el cliente HTTP con una llamada a método.

La migración de OCR.space a IronOCR es arquitectónicamente sencilla porque ambas plataformas devuelven texto a partir de documentos. El cliente HTTP, el analizador JSON, el limitador de velocidad y los tipos de excepciones personalizadas desaparecen. Lo que los reemplaza es un único paquete NuGet y llamadas a métodos. El antes y el después en el límite de servicio:

// Before: OCR.space service (simplified — actual implementation is Más de 200 lines)
public class OcrSpaceService : IDisposable
{
    private readonly HttpClient _client = new();
    private readonly string _apiKey;

    public OcrSpaceService(string apiKey) => _apiKey = apiKey;

    public async Task<string> ProcessDocument(string path)
    {
        byte[] bytes = File.ReadAllBytes(path);
        string base64 = Convert.ToBase64String(bytes);

        var content = new FormUrlEncodedContent(new[]
        {
            new KeyValuePair<string, string>("apikey", _apiKey),
            new KeyValuePair<string, string>("base64Image", $"data:image/png;base64,{base64}")
        });

        var response = await _client.PostAsync("https://api.ocr.space/parse/image", content);
        response.EnsureSuccessStatusCode();

        string json = await response.Content.ReadAsStringAsync();
        using var doc = JsonDocument.Parse(json);
        return doc.RootElement.GetProperty("ParsedResults")[0].GetProperty("ParsedText").GetString()!;
    }

    public void Dispose() => _client.Dispose();
}

// After:IronOCR service — no HttpClient, no JSON, no API key
public class IronOcrService
{
    private readonly IronTesseract _ocr = new();

    public string ProcessDocument(string path)
    {
        return _ocr.Read(path).Text;
    }
    // No Dispose — no external connections to close
}

// Before: OCR.space service (simplified — actual implementation is Más de 200 lines)
public class OcrSpaceService : IDisposable
{
    private readonly HttpClient _client = new();
    private readonly string _apiKey;

    public OcrSpaceService(string apiKey) => _apiKey = apiKey;

    public async Task<string> ProcessDocument(string path)
    {
        byte[] bytes = File.ReadAllBytes(path);
        string base64 = Convert.ToBase64String(bytes);

        var content = new FormUrlEncodedContent(new[]
        {
            new KeyValuePair<string, string>("apikey", _apiKey),
            new KeyValuePair<string, string>("base64Image", $"data:image/png;base64,{base64}")
        });

        var response = await _client.PostAsync("https://api.ocr.space/parse/image", content);
        response.EnsureSuccessStatusCode();

        string json = await response.Content.ReadAsStringAsync();
        using var doc = JsonDocument.Parse(json);
        return doc.RootElement.GetProperty("ParsedResults")[0].GetProperty("ParsedText").GetString()!;
    }

    public void Dispose() => _client.Dispose();
}

// After:IronOCR service — no HttpClient, no JSON, no API key
public class IronOcrService
{
    private readonly IronTesseract _ocr = new();

    public string ProcessDocument(string path)
    {
        return _ocr.Read(path).Text;
    }
    // No Dispose — no external connections to close
}

La implementación de IDisposable desaparece porque no hay HttpClient que gestionar.

Eliminación de clave API

OCR.space requiere una clave API en cada solicitud HTTP. Dicha clave debe almacenarse de forma segura, rotarse cuando se exponga y excluirse del control de versiones.IronOCR utiliza una clave de licencia que se establece una sola vez al iniciar la aplicación, normalmente a partir de una variable de entorno o un sistema de configuración:

// At application startup — once, not per request
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

// At application startup — once, not per request
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

' At application startup — once, not per request
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")

' At application startup — once, not per request
IronOcr.License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE")

Tras la migración, el proceso de rotación de claves API, la configuración de la gestión de secretos y la lógica de inyección de clave por solicitud dejan de ser necesarios.

Preprocesamiento después de la migración

OCR.space aplica un procesamiento en el servidor antes de devolver los resultados, pero los desarrolladores no tienen control sobre lo que dicho procesamiento incluye o no incluye.IronOCR expone métodos de preprocesamiento explícitos. Si la calidad del documento es un problema (escaneos distorsionados, fotocopias de bajo contraste, salida de fax con ruido), el proceso de preprocesamiento consta de tres a cinco llamadas a métodos:

using var input = new OcrInput();
input.LoadImage("low-quality-scan.jpg");
input.Deskew();
input.DeNoise();
input.Contrast();
input.Binarize();
input.EnhanceResolution(300);
var result = new IronTesseract().Read(input);

using var input = new OcrInput();
input.LoadImage("low-quality-scan.jpg");
input.Deskew();
input.DeNoise();
input.Contrast();
input.Binarize();
input.EnhanceResolution(300);
var result = new IronTesseract().Read(input);

Imports IronOcr

Using input As New OcrInput()
    input.LoadImage("low-quality-scan.jpg")
    input.Deskew()
    input.DeNoise()
    input.Contrast()
    input.Binarize()
    input.EnhanceResolution(300)
    Dim result = New IronTesseract().Read(input)
End Using

Imports IronOcr

Using input As New OcrInput()
    input.LoadImage("low-quality-scan.jpg")
    input.Deskew()
    input.DeNoise()
    input.Contrast()
    input.Binarize()
    input.EnhanceResolution(300)
    Dim result = New IronTesseract().Read(input)
End Using

La guía de corrección de la calidad de imagen y la guía de corrección del color de la imagen documentan todos los filtros disponibles con ejemplos que muestran las diferencias de precisión antes y después de la aplicación.

Asíncrono vs. Síncrono

Las llamadas a OCR.space son inherentemente asíncronas porque implican viajes de ida y vuelta HTTP. Las llamadas a IronOCR son síncronas por defecto, lo que simplifica el código en contextos que no son web. Para escenarios de ASP.NET y servidores que requieren ejecución sin bloqueo,IronOCR soporta operación asincrónica a través de Task.Run envuelto o API asincrónica directa. La guía de OCR asíncrono cubre los patrones. Eliminar await de un método de servicio que previamente esperaba una llamada a la nube simplifica la pila de llamadas en contextos donde async fue adoptado solo porque OCR.space lo requería.

Funcionalidades adicionales de IronOCR

Funcionalidades no cubiertas en las secciones anteriores, cada una de las cuales representa una funcionalidad sin equivalente en OCR.space:

exportación hOCR: result.SaveAsHocrFile("output.hocr") produce salida hOCR conforme a estándares para procesos de documentación posteriores.
Seguimiento del progreso : Suscríbase a los eventos de progreso para operaciones por lotes de varias páginas de larga duración, lo que permite mostrar barras de progreso y cálculos de tiempo estimado de finalización en las aplicaciones de interfaz de usuario.
Extracción de tablas : Los datos de tablas estructuradas son accesibles a través del modelo de resultados, lo que permite casos de uso como la extracción de partidas de facturas que requieren alineación de columnas.
Lectura especializada de documentos: Las zonas MRZ de pasaportes, las placas de matrícula, las líneas de cheques MICR y el reconocimiento de escritura a mano son capacidades diseñadas específicamente accesibles a través del mismo API IronTesseract.

Compatibilidad con .NET y preparación para el futuro

IronOCR está dirigido a .NET 6, .NET 7, .NET 8 y .NET 9, con soporte activo para cada versión LTS y STS. La biblioteca se ejecuta en Windows x64, Windows x86, Linuxx64, macOS, Docker, AWS Lambda y Azure App Service, todo ello desde el mismo paquete NuGet y sin necesidad de configuración específica para cada plataforma. OCR.space requiere HTTPS saliente desde todos los entornos de implementación, lo que excluye las redes aisladas, los proxies corporativos restrictivos y la infraestructura donde el tráfico saliente a las API de terceros está bloqueado por políticas.IronOCR no tiene requisitos de red en tiempo de ejecución; Se ejecuta completamente dentro del mismo proceso. A medida que .NET 10 se acerca a su lanzamiento a finales de 2026, el historial de IronOCR en el mantenimiento de la compatibilidad entre las principales versiones de .NET proporciona continuidad sin necesidad de cambios en la integración.

Conclusión

OCR.space ocupa un nicho real y útil: desarrolladores que necesitan crear un prototipo de una función OCR durante un fin de semana, estudiantes que exploran conceptos de extracción de texto o herramientas personales de bajo volumen (menos de 25.000 documentos al mes) sin requisitos de cumplimiento normativo. Para ese público, la versión gratuita ofrece un valor real.

El problema es que los desarrolladores de .NET normalmente no crean prototipos para el fin de semana. Crean sistemas de facturación, procesadores de historiales médicos, sistemas de archivo de documentos y aplicaciones empresariales que deben cumplir con las normativas. En esos casos, la ausencia del paquete NuGet de OCR.space no es un inconveniente, sino una incompatibilidad estructural. Cada hora dedicada a construir el cliente HTTP, el limitador de velocidad, el analizador JSON y la infraestructura de reintentos es una hora que no se dedica a los requisitos reales de la aplicación. Ese coste se incurre inicialmente, pero el coste de mantenimiento continúa durante toda la vida útil de la integración.

IronOCR aborda el modo de fallo específico que define cada integración de OCR.space: la ausencia de un SDK real. Un solo paquete NuGet , una sola llamada a un método, sin necesidad de protocolos HTTP, sin límites de velocidad, sin documentos transmitidos a servidores externos. El precio de entrada $999 es un costo único; los costos de suscripción recurrentes de OCR.space lo excederán con el tiempo, especialmente a medida que el volumen crezca. Para los equipos con requisitos de cumplimiento, el procesamiento local es la única opción independientemente del costo.

En última instancia, la comparación se reduce a una sola pregunta: ¿la aplicación requiere OCR como una dependencia REST externa o como una función de biblioteca? Para las aplicaciones .NET de producción, la respuesta es casi siempre la segunda opción.

Por favor nota: OCR.space y Tesseract son marcas registradas de sus respectivos propietarios. Este sitio no está afiliado, respaldado ni patrocinado por Google ni OCR.space. Todos los nombres de producto, logotipos y marcas son propiedad de sus respectivos dueños. Las comparaciones son solo para fines informativos y reflejan información públicamente disponible en el momento de la redacción.