RapidOCR.NET vs IronOCR: .NET OCR Library

The 4-Model Configuration Overhead

Every RapidOCR.NET application begins with this initialization block, regardless of complexity:

// RapidOcrNet: 4 paths required — any missing file throws at runtime
var engine = new RapidOcrEngine(new RapidOcrOptions
{
    DetModelPath = "./models/det.onnx",      // ~3 MB download
    ClsModelPath = "./models/cls.onnx",      // ~1 MB download
    RecModelPath = "./models/rec_en.onnx",   // ~2–10 MB depending on language
    KeysPath     = "./models/en_keys.txt"    // ~100 KB character dictionary
});

// Text blocks returned — must be sorted and joined manually
var result = engine.Run(imagePath);
var text = string.Join("\n", result.TextBlocks
    .OrderBy(b => b.BoundingBox.Top)
    .ThenBy(b => b.BoundingBox.Left)
    .Select(b => b.Text));

// RapidOcrNet: 4 paths required — any missing file throws at runtime
var engine = new RapidOcrEngine(new RapidOcrOptions
{
    DetModelPath = "./models/det.onnx",      // ~3 MB download
    ClsModelPath = "./models/cls.onnx",      // ~1 MB download
    RecModelPath = "./models/rec_en.onnx",   // ~2–10 MB depending on language
    KeysPath     = "./models/en_keys.txt"    // ~100 KB character dictionary
});

// Text blocks returned — must be sorted and joined manually
var result = engine.Run(imagePath);
var text = string.Join("\n", result.TextBlocks
    .OrderBy(b => b.BoundingBox.Top)
    .ThenBy(b => b.BoundingBox.Left)
    .Select(b => b.Text));

Imports System.Linq

' RapidOcrNet: 4 paths required — any missing file throws at runtime
Dim engine = New RapidOcrEngine(New RapidOcrOptions With {
    .DetModelPath = "./models/det.onnx",      ' ~3 MB download
    .ClsModelPath = "./models/cls.onnx",      ' ~1 MB download
    .RecModelPath = "./models/rec_en.onnx",   ' ~2–10 MB depending on language
    .KeysPath = "./models/en_keys.txt"        ' ~100 KB character dictionary
})

' Text blocks returned — must be sorted and joined manually
Dim result = engine.Run(imagePath)
Dim text = String.Join(vbCrLf, result.TextBlocks _
    .OrderBy(Function(b) b.BoundingBox.Top) _
    .ThenBy(Function(b) b.BoundingBox.Left) _
    .Select(Function(b) b.Text))

Switching to Chinese OCR is not a configuration change — it is a file swap. The English recognition model (en_rec.onnx / en_keys.txt) and the Chinese recognition model (ch_rec.onnx / ch_keys.txt) are separate downloads. If a document contains both Chinese and Spanish text, there is no path forward: Spanish models do not exist in the RapidOCR model catalog at all.

The .csproj also requires explicit MSBuild entries to copy all four files on build:

<ItemGroup>
  <Content Include="models\**\*.*">
    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
  </Content>
</ItemGroup>

<ItemGroup>
  <Content Include="models\**\*.*">
    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
  </Content>
</ItemGroup>

Miss that step and the production deployment silently breaks at runtime when paths resolve to nothing.

Detailed Feature Comparison

RapidOCR.NET Approach

The model files are not bundled with the NuGet package. They live on GitHub release pages for the RapidOCR project and must be downloaded out-of-band, versioned manually, and deployed with your application. When the RapidOCR project releases updated models for better accuracy, you repeat the download sequence and replace files in your deployment.

In a CI/CD pipeline, model files must either be committed to the repository (adding 15–25 MB of binary data to Git history) or fetched during the build step with custom scripts. In a Docker container, each language's model set adds a dedicated COPY instruction and a non-trivial layer. In a Kubernetes deployment, model files typically end up in a mounted volume or baked into the image, both of which require policies for how updates propagate.

The validation logic in the source files makes the fragility concrete:

// RapidOcrNet: Runtime validation needed because any missing file crashes the engine
public static bool ValidateModelFiles()
{
    var requiredFiles = new[]
    {
        Path.Combine(ModelDirectory, "det.onnx"),
        Path.Combine(ModelDirectory, "cls.onnx"),
        Path.Combine(ModelDirectory, "rec_en.onnx"),
        Path.Combine(ModelDirectory, "en_keys.txt")
    };

    var missingFiles = requiredFiles.Where(f => !File.Exists(f)).ToList();

    if (missingFiles.Any())
    {
        Console.WriteLine("ERROR: Missing required model files:");
        foreach (var file in missingFiles)
            Console.WriteLine($"  - {file}");
        return false;
    }

    return true;
}

// RapidOcrNet: Runtime validation needed because any missing file crashes the engine
public static bool ValidateModelFiles()
{
    var requiredFiles = new[]
    {
        Path.Combine(ModelDirectory, "det.onnx"),
        Path.Combine(ModelDirectory, "cls.onnx"),
        Path.Combine(ModelDirectory, "rec_en.onnx"),
        Path.Combine(ModelDirectory, "en_keys.txt")
    };

    var missingFiles = requiredFiles.Where(f => !File.Exists(f)).ToList();

    if (missingFiles.Any())
    {
        Console.WriteLine("ERROR: Missing required model files:");
        foreach (var file in missingFiles)
            Console.WriteLine($"  - {file}");
        return false;
    }

    return true;
}

Imports System
Imports System.IO
Imports System.Linq

Public Class RapidOcrNet
    Public Shared Function ValidateModelFiles() As Boolean
        Dim requiredFiles = {
            Path.Combine(ModelDirectory, "det.onnx"),
            Path.Combine(ModelDirectory, "cls.onnx"),
            Path.Combine(ModelDirectory, "rec_en.onnx"),
            Path.Combine(ModelDirectory, "en_keys.txt")
        }

        Dim missingFiles = requiredFiles.Where(Function(f) Not File.Exists(f)).ToList()

        If missingFiles.Any() Then
            Console.WriteLine("ERROR: Missing required model files:")
            For Each file In missingFiles
                Console.WriteLine($"  - {file}")
            Next
            Return False
        End If

        Return True
    End Function
End Class

Production applications that use RapidOCR.NET routinely include startup validation like this because a missing model file does not produce a clear error at package install time — it produces a runtime crash when the engine first initializes. That failure surfaces in production, not development.

IronOCR Approach

There are no model files to manage. After dotnet add package IronOcr, the engine is ready:

// IronOCR: no model downloads, no path configuration, no validation boilerplate
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";
var text = new IronTesseract().Read("document.jpg").Text;

// IronOCR: no model downloads, no path configuration, no validation boilerplate
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";
var text = new IronTesseract().Read("document.jpg").Text;

' IronOCR: no model downloads, no path configuration, no validation boilerplate
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"
Dim text = New IronTesseract().Read("document.jpg").Text

The IronTesseract setup guide shows the complete installation path. Language packs that extend beyond English are NuGet packages — dotnet add package IronOcr.Languages.French — and the restore step handles everything, including in CI/CD pipelines that already restore NuGet dependencies. There are no .gitignore decisions about binary model files, no COPY layers in Dockerfiles, no startup validation scripts.

For teams that deploy to Docker, the IronOCR Docker guide covers the one required system dependency (libgdiplus on Debian/Ubuntu-based images) and nothing more.

RapidOCR.NET Approach

RapidOCR.NET's language coverage reflects its origin. PaddleOCR was built by Baidu to serve Chinese-language internet search. Its models are excellent for Chinese Simplified and Chinese Traditional. English support is included but was not the primary design target. Japanese and Korean have community-contributed models marked as experimental. Everything else — Spanish, French, German, Russian, Arabic, Hindi, Portuguese, and more than 100 other languages — has no available model.

Switching between supported languages requires downloading different model files:

// RapidOcrNet: English engine
var englishEngine = new RapidOcrEngine(new RapidOcrOptions
{
    DetModelPath = Path.Combine(modelPath, "det.onnx"),
    ClsModelPath = Path.Combine(modelPath, "cls.onnx"),
    RecModelPath = Path.Combine(modelPath, "en_rec.onnx"),   // English-specific
    KeysPath     = Path.Combine(modelPath, "en_keys.txt")    // English-specific
});

// RapidOcrNet: Chinese engine — different rec and keys files required
var chineseEngine = new RapidOcrEngine(new RapidOcrOptions
{
    DetModelPath = Path.Combine(modelPath, "det.onnx"),
    ClsModelPath = Path.Combine(modelPath, "cls.onnx"),
    RecModelPath = Path.Combine(modelPath, "ch_rec.onnx"),   // Different download
    KeysPath     = Path.Combine(modelPath, "ch_keys.txt")    // Different download
});

// Spanish? NotSupportedException — no model exists

// RapidOcrNet: English engine
var englishEngine = new RapidOcrEngine(new RapidOcrOptions
{
    DetModelPath = Path.Combine(modelPath, "det.onnx"),
    ClsModelPath = Path.Combine(modelPath, "cls.onnx"),
    RecModelPath = Path.Combine(modelPath, "en_rec.onnx"),   // English-specific
    KeysPath     = Path.Combine(modelPath, "en_keys.txt")    // English-specific
});

// RapidOcrNet: Chinese engine — different rec and keys files required
var chineseEngine = new RapidOcrEngine(new RapidOcrOptions
{
    DetModelPath = Path.Combine(modelPath, "det.onnx"),
    ClsModelPath = Path.Combine(modelPath, "cls.onnx"),
    RecModelPath = Path.Combine(modelPath, "ch_rec.onnx"),   // Different download
    KeysPath     = Path.Combine(modelPath, "ch_keys.txt")    // Different download
});

// Spanish? NotSupportedException — no model exists

Imports System.IO

' RapidOcrNet: English engine
Dim englishEngine = New RapidOcrEngine(New RapidOcrOptions With {
    .DetModelPath = Path.Combine(modelPath, "det.onnx"),
    .ClsModelPath = Path.Combine(modelPath, "cls.onnx"),
    .RecModelPath = Path.Combine(modelPath, "en_rec.onnx"),   ' English-specific
    .KeysPath = Path.Combine(modelPath, "en_keys.txt")        ' English-specific
})

' RapidOcrNet: Chinese engine — different rec and keys files required
Dim chineseEngine = New RapidOcrEngine(New RapidOcrOptions With {
    .DetModelPath = Path.Combine(modelPath, "det.onnx"),
    .ClsModelPath = Path.Combine(modelPath, "cls.onnx"),
    .RecModelPath = Path.Combine(modelPath, "ch_rec.onnx"),   ' Different download
    .KeysPath = Path.Combine(modelPath, "ch_keys.txt")        ' Different download
})

' Spanish? NotSupportedException — no model exists

An application that needs to process English, Chinese, and Spanish documents from the same queue has no viable path in RapidOCR.NET for the Spanish documents.

IronOCR Approach

IronOCR supports 125+ languages, each available as a NuGet language pack. Switching is an enum property assignment on the IronTesseract instance — no file downloads, no engine recreation:

// IronOCR: language switching is a property change, not a file swap
var ocr = new IronTesseract();

// English
ocr.Language = OcrLanguage.English;

// Chinese Simplified
ocr.Language = OcrLanguage.ChineseSimplified;

// Spanish — no model download needed
ocr.Language = OcrLanguage.Spanish;

// Arabic — just works
ocr.Language = OcrLanguage.Arabic;

// Russian — just works
ocr.Language = OcrLanguage.Russian;

var result = ocr.Read("document.jpg");

// IronOCR: language switching is a property change, not a file swap
var ocr = new IronTesseract();

// English
ocr.Language = OcrLanguage.English;

// Chinese Simplified
ocr.Language = OcrLanguage.ChineseSimplified;

// Spanish — no model download needed
ocr.Language = OcrLanguage.Spanish;

// Arabic — just works
ocr.Language = OcrLanguage.Arabic;

// Russian — just works
ocr.Language = OcrLanguage.Russian;

var result = ocr.Read("document.jpg");

Imports IronOcr

Dim ocr As New IronTesseract()

' English
ocr.Language = OcrLanguage.English

' Chinese Simplified
ocr.Language = OcrLanguage.ChineseSimplified

' Spanish — no model download needed
ocr.Language = OcrLanguage.Spanish

' Arabic — just works
ocr.Language = OcrLanguage.Arabic

' Russian — just works
ocr.Language = OcrLanguage.Russian

Dim result = ocr.Read("document.jpg")

Mixed-language documents use AddSecondaryLanguage:

var ocr = new IronTesseract();
ocr.Language = OcrLanguage.ChineseSimplified;
ocr.AddSecondaryLanguage(OcrLanguage.English);
var result = ocr.Read("mixed-document.jpg");

var ocr = new IronTesseract();
ocr.Language = OcrLanguage.ChineseSimplified;
ocr.AddSecondaryLanguage(OcrLanguage.English);
var result = ocr.Read("mixed-document.jpg");

Imports IronOcr

Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.ChineseSimplified
ocr.AddSecondaryLanguage(OcrLanguage.English)
Dim result = ocr.Read("mixed-document.jpg")

The multiple languages how-to and the international languages example cover language pack installation and secondary language configuration in detail.

RapidOCR.NET Approach

RapidOCR.NET processes images. PDFs are not images. The library has no PDF rendering capability, no PDF writing capability, and no mechanism to produce searchable PDF output. Extracting text from a scanned PDF with RapidOCR.NET requires at least three separate components:

// RapidOcrNet: PDF processing requires external library + manual assembly
public async Task<string> ExtractTextFromPdf(string pdfPath)
{
    // Step 1: Requires PdfPig, Docotic, or similar external library
    var pageImages = await RenderPdfToImages(pdfPath);

    // Step 2: Initialize RapidOcr with 4 model files (must already be downloaded)
    using var engine = new RapidOcrEngine(new RapidOcrOptions
    {
        DetModelPath = "models/det.onnx",
        ClsModelPath = "models/cls.onnx",
        RecModelPath = "models/rec_en.onnx",
        KeysPath     = "models/en_keys.txt"
    });

    // Step 3: OCR each image individually
    var results = new List<string>();
    foreach (var pageImage in pageImages)
    {
        var result = engine.Run(pageImage);
        results.Add(string.Join("\n", result.TextBlocks.Select(b => b.Text)));
    }

    // Step 4: Combine manually — page structure not preserved
    return string.Join("\n\n", results);
}

// RapidOcrNet: PDF processing requires external library + manual assembly
public async Task<string> ExtractTextFromPdf(string pdfPath)
{
    // Step 1: Requires PdfPig, Docotic, or similar external library
    var pageImages = await RenderPdfToImages(pdfPath);

    // Step 2: Initialize RapidOcr with 4 model files (must already be downloaded)
    using var engine = new RapidOcrEngine(new RapidOcrOptions
    {
        DetModelPath = "models/det.onnx",
        ClsModelPath = "models/cls.onnx",
        RecModelPath = "models/rec_en.onnx",
        KeysPath     = "models/en_keys.txt"
    });

    // Step 3: OCR each image individually
    var results = new List<string>();
    foreach (var pageImage in pageImages)
    {
        var result = engine.Run(pageImage);
        results.Add(string.Join("\n", result.TextBlocks.Select(b => b.Text)));
    }

    // Step 4: Combine manually — page structure not preserved
    return string.Join("\n\n", results);
}

Imports System.Threading.Tasks
Imports System.Collections.Generic
Imports System.Linq

Public Class PdfTextExtractor
    ' RapidOcrNet: PDF processing requires external library + manual assembly
    Public Async Function ExtractTextFromPdf(pdfPath As String) As Task(Of String)
        ' Step 1: Requires PdfPig, Docotic, or similar external library
        Dim pageImages = Await RenderPdfToImages(pdfPath)

        ' Step 2: Initialize RapidOcr with 4 model files (must already be downloaded)
        Using engine As New RapidOcrEngine(New RapidOcrOptions With {
            .DetModelPath = "models/det.onnx",
            .ClsModelPath = "models/cls.onnx",
            .RecModelPath = "models/rec_en.onnx",
            .KeysPath = "models/en_keys.txt"
        })

            ' Step 3: OCR each image individually
            Dim results As New List(Of String)()
            For Each pageImage In pageImages
                Dim result = engine.Run(pageImage)
                results.Add(String.Join(vbLf, result.TextBlocks.Select(Function(b) b.Text)))
            Next

            ' Step 4: Combine manually — page structure not preserved
            Return String.Join(vbLf & vbLf, results)
        End Using
    End Function

    ' Placeholder for the RenderPdfToImages method
    Private Async Function RenderPdfToImages(pdfPath As String) As Task(Of List(Of Object))
        ' Implementation goes here
        Return New List(Of Object)()
    End Function
End Class

This adds another NuGet dependency, another set of API surface area to learn, and memory pressure from holding page-rendered bitmaps in memory for large documents. Searchable PDF output — writing recognized text back as a hidden OCR layer over the original scan — is not achievable at any point in this pipeline.

IronOCR Approach

IronOCR reads PDFs natively. The same IronTesseract.Read() method accepts both image paths and PDF paths:

// IronOCR: direct PDF OCR — no conversion, no external library
var text = new IronTesseract().Read("scanned-document.pdf").Text;

// Password-protected PDF — one parameter
using var input = new OcrInput();
input.LoadPdf("encrypted.pdf", Password: "secret");
var result = new IronTesseract().Read(input);

// Searchable PDF — one method call on the result
var result = new IronTesseract().Read("scanned.pdf");
result.SaveAsSearchablePdf("searchable-output.pdf");

// IronOCR: direct PDF OCR — no conversion, no external library
var text = new IronTesseract().Read("scanned-document.pdf").Text;

// Password-protected PDF — one parameter
using var input = new OcrInput();
input.LoadPdf("encrypted.pdf", Password: "secret");
var result = new IronTesseract().Read(input);

// Searchable PDF — one method call on the result
var result = new IronTesseract().Read("scanned.pdf");
result.SaveAsSearchablePdf("searchable-output.pdf");

Imports IronOcr

' IronOCR: direct PDF OCR — no conversion, no external library
Dim text As String = New IronTesseract().Read("scanned-document.pdf").Text

' Password-protected PDF — one parameter
Using input As New OcrInput()
    input.LoadPdf("encrypted.pdf", Password:="secret")
    Dim result = New IronTesseract().Read(input)
End Using

' Searchable PDF — one method call on the result
Dim result2 = New IronTesseract().Read("scanned.pdf")
result2.SaveAsSearchablePdf("searchable-output.pdf")

The PDF input how-to covers page selection, password handling, and multi-page processing. The searchable PDF how-to demonstrates creating compliance-grade output that remains visually identical to the original scan while adding a full-text search layer. For teams building document archival pipelines, that output format is the end goal — and it requires zero additional dependencies beyond the IronOCR package itself.

RapidOCR.NET Approach

RapidOCR.NET is a newer project. Its GitHub repository has limited stars and contribution activity relative to established .NET OCR libraries. Stack Overflow has minimal coverage. When edge cases surface in production — unusual image orientations, specific character sets, ONNX Runtime version conflicts, GPU mode configuration — the primary resource is the GitHub issues tracker. There is no commercial support tier, no maintenance SLA, and no guaranteed response timeline.

The dependency chain introduces additional risk. RapidOCR.NET depends on the RapidOCR project's model releases. The RapidOCR project depends on PaddleOCR's model architecture. A breaking change at any layer of that chain requires the .NET wrapper maintainer to respond before users can update — and the wrapper is maintained by a single community developer with no organizational backing.

Deployment also surfaces ONNX Runtime versioning issues. The Microsoft.ML.OnnxRuntime package has had breaking changes between minor versions, and the native binaries that ship with it are platform-specific. A container image built on linux/amd64 cannot use the same ONNX Runtime binaries as one built on linux/arm64. Each deployment target requires validation.

IronOCR Approach

IronOCR has been in active commercial development for more than a decade. The library ships under a versioned API with documented breaking changes, regular releases aligned with .NET SDK releases, and email support included with every commercial license. Teams building production pipelines get a direct support path rather than a GitHub issues queue monitored by one developer in their spare time.

The single-package design eliminates the deployment validation loop entirely. The NuGet restore step is deterministic: the same package version produces the same working installation on Windows, Linux, and macOS without platform-specific native binary management. For AWS Lambda and Azure deployments, the function bundle contains only the published application — no model file sidecars, no volume mounts, no startup validation logic.

The low-quality scan example and image quality correction how-to cover the preprocessing scenarios that commonly require custom code in ONNX-based pipelines — skewed scans, noisy backgrounds, low-contrast documents — without any code beyond selecting the appropriate filter methods.

When Model File Management Becomes a Deployment Bottleneck

Teams that started with RapidOCR.NET for a prototype typically hit the model file management wall when they attempt to productionize. The four model files must be versioned, tracked, copied on build, included in CI artifacts, deployed to staging, and deployed to production — separately from the NuGet dependency graph. On a small team, that operational overhead is absorbed once and forgotten. On a team maintaining multiple services, multiple environments, and multiple CI pipelines, the custom scripting around model file distribution accumulates into a meaningful maintenance cost. When a teammate asks "why do we have this models/ folder in the repo and what happens if I delete it?" and the answer requires a five-minute explanation, that is usually when the evaluation begins. IronOCR eliminates the entire model management surface: nothing to download separately, nothing to copy in CI, nothing to validate at startup.

When a Document Arrives in an Unsupported Language

The language coverage gap is a hard stop, not a configuration problem. If an organization receives German contracts, French invoices, Russian purchase orders, or Arabic correspondence, RapidOCR.NET provides no path for those documents — not "limited accuracy," but no model, no result. Teams that initially chose RapidOCR.NET for a CJK-focused use case discover this boundary the first time they need to process a document outside that set. IronOCR's language features cover 125+ languages installable through NuGet, so the scope of what the OCR pipeline can handle expands without touching application code — just add the language pack and change an enum property.

When the Application Needs PDF Input or Output

A significant category of business document OCR involves PDFs: scanned contracts, archived invoices, faxed forms converted to PDF by multifunction printers. RapidOCR.NET cannot read any of them without a separate PDF rendering library, custom conversion code, and memory management for page-sized bitmaps. Teams building document ingestion pipelines quickly find that the RapidOCR.NET stack requires at least two libraries — one for PDF rendering, one for OCR — each with their own upgrade cycles and compatibility surfaces. IronOCR handles both in a single package. The ability to also produce searchable PDFs, turning a scanned archive into a searchable index, is entirely out of scope for RapidOCR.NET and is a single method call with IronOCR. Teams building document management applications with compliance requirements often cite searchable PDF output as the deciding capability.

When Production Incidents Surface Without a Support Path

Community projects run on contributor availability. When a RapidOCR.NET production deployment encounters a novel edge case — a specific ONNX Runtime version conflict, a model inference failure on an unusual image format, a memory leak under sustained load — the support path is a GitHub issue and waiting. For teams with SLA obligations or business-critical document processing pipelines, that is not a viable incident response model. IronOCR's commercial license includes direct email support, giving teams an actual contact point when something breaks on a Friday night before a Monday deadline.

When the Project Outgrows the Prototype Assumptions

RapidOCR.NET is a reasonable choice for an experimental proof-of-concept: free, no license to negotiate, quick to install beyond the model setup. When that proof-of-concept becomes a production feature, the constraints that were acceptable in a lab — no PDF support, narrow language coverage, manual model management, no commercial support — become blockers. The migration path from RapidOCR.NET to IronOCR is mechanical: remove the packages, delete the models directory, remove the MSBuild copy rules, replace the engine initialization block with a single zero-argument OCR engine constructor, and unlock PDF input, 125-language coverage, automatic preprocessing, and searchable output simultaneously.

Replacing Engine Initialization

The most direct code change is replacing the RapidOcrEngine initialization block with an IronTesseract instantiation. The four-path configuration object disappears entirely:

// Before: RapidOcrNet — engine needs all 4 paths populated
var engine = new RapidOcrEngine(new RapidOcrOptions
{
    DetModelPath = "models/det.onnx",
    ClsModelPath = "models/cls.onnx",
    RecModelPath = "models/rec_en.onnx",
    KeysPath     = "models/en_keys.txt"
});
var result = engine.Run(imagePath);
var text = string.Join("\n", result.TextBlocks
    .OrderBy(b => b.BoundingBox.Top)
    .Select(b => b.Text));

// After: IronOCR — no configuration required
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";
var text = new IronTesseract().Read(imagePath).Text;

// Before: RapidOcrNet — engine needs all 4 paths populated
var engine = new RapidOcrEngine(new RapidOcrOptions
{
    DetModelPath = "models/det.onnx",
    ClsModelPath = "models/cls.onnx",
    RecModelPath = "models/rec_en.onnx",
    KeysPath     = "models/en_keys.txt"
});
var result = engine.Run(imagePath);
var text = string.Join("\n", result.TextBlocks
    .OrderBy(b => b.BoundingBox.Top)
    .Select(b => b.Text));

// After: IronOCR — no configuration required
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";
var text = new IronTesseract().Read(imagePath).Text;

Imports System.Linq

' Before: RapidOcrNet — engine needs all 4 paths populated
Dim engine As New RapidOcrEngine(New RapidOcrOptions With {
    .DetModelPath = "models/det.onnx",
    .ClsModelPath = "models/cls.onnx",
    .RecModelPath = "models/rec_en.onnx",
    .KeysPath = "models/en_keys.txt"
})
Dim result = engine.Run(imagePath)
Dim text = String.Join(vbCrLf, result.TextBlocks _
    .OrderBy(Function(b) b.BoundingBox.Top) _
    .Select(Function(b) b.Text))

' After: IronOCR — no configuration required
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"
Dim text = New IronTesseract().Read(imagePath).Text

The result.TextBlocks collection with its manual OrderBy and Select chain collapses to result.Text. For applications that need the bounding-box data that TextBlocks provided, result.Words exposes the same per-word coordinates and confidence values through a structured API documented in the read results how-to.

Removing Model File Infrastructure

After replacing the code, delete the models/ directory, remove the MSBuild <Content> entries that copied model files on build, and remove any startup validation logic that checked for missing files. These are not needed — IronOCR ships its data internally. In CI/CD pipelines, remove any steps that fetched or cached model files. The image input how-to covers input handling patterns for the common file path, stream, and byte array scenarios that existing RapidOCR.NET code likely uses.

Handling Low-Quality Images

RapidOCR.NET's ONNX models apply internal preprocessing during inference, but the library exposes no preprocessing API to the caller. If existing code applies image manipulation before passing to engine.Run(), that code was written against a separate image library. IronOCR exposes a preprocessing API directly on OcrInput:

using var input = new OcrInput();
input.LoadImage("low-quality-scan.jpg");
input.Deskew();           // Correct skewed scans
input.DeNoise();          // Remove scanner noise
input.Contrast();         // Enhance contrast
input.Binarize();         // Convert to black/white
input.EnhanceResolution(300);

var result = new IronTesseract().Read(input);
Console.WriteLine($"Confidence: {result.Confidence}%");

using var input = new OcrInput();
input.LoadImage("low-quality-scan.jpg");
input.Deskew();           // Correct skewed scans
input.DeNoise();          // Remove scanner noise
input.Contrast();         // Enhance contrast
input.Binarize();         // Convert to black/white
input.EnhanceResolution(300);

var result = new IronTesseract().Read(input);
Console.WriteLine($"Confidence: {result.Confidence}%");

Imports IronOcr

Using input As New OcrInput()
    input.LoadImage("low-quality-scan.jpg")
    input.Deskew()           ' Correct skewed scans
    input.DeNoise()          ' Remove scanner noise
    input.Contrast()         ' Enhance contrast
    input.Binarize()         ' Convert to black/white
    input.EnhanceResolution(300)

    Dim result = New IronTesseract().Read(input)
    Console.WriteLine($"Confidence: {result.Confidence}%")
End Using

The image orientation correction how-to and DPI settings how-to cover the two preprocessing concerns that most commonly affect accuracy on scanned documents. Confidence scores are available on result.Confidence and per-word via result.Words[i].Confidence.

Adding PDF Support

Any code that performed PDF-to-image conversion before calling engine.Run() can be deleted outright. IronTesseract.Read() accepts a PDF path directly. Remove the PDF rendering library dependency along with the conversion pipeline code — this is a net reduction in dependencies, not an addition.