Message icon
Skip to footer content
  1. IronOCR
  2. IronOCR Blog
  3. Compare to Other Components
  4. Tesseract vs. IronOCR for PDF
COMPARE TO OTHER COMPONENTS

Tesseract OCR vs. IronOCR: Extract PDF Text in C#

Kannaopat Udonpant
Kannapat Udonpant
Updated:

Tesseract OCR requires converting PDF pages to images before text extraction, while IronOCR reads PDF documents natively in .NET. For C# applications that process scanned documents at scale, this architectural difference determines setup complexity, code volume, and production reliability.

Extracting text from scanned PDF documents is a common requirement in C# and .NET 10 applications. Whether processing invoices, digitizing paper records, or automating data entry workflows, developers need reliable OCR solutions that convert PDF files into editable, searchable data efficiently. Tesseract OCR is a widely used open-source optical character recognition engine maintained by Google, but .NET developers regularly encounter friction when applying it to PDF content specifically.

This comparison examines how to use Tesseract and IronOCR for PDF-to-text conversion in C#, with code examples and practical guidance on selecting the right library for production systems.

What Is the Quick Decision for Tesseract vs. IronOCR?

Choose Tesseract when budget constraints require a free solution, your input is exclusively image files, and your team has capacity for the additional setup and dependency work.

Choose IronOCR when PDF documents and scanned files are your primary input, development speed matters, or you need cross-platform deployment to Azure, Docker, or Linux without dependency troubleshooting.

Criterion Tesseract IronOCR
Cost Free (Apache 2.0) Commercial license required
PDF input Requires image conversion Native support
Setup complexity High (multiple dependencies) Single NuGet package
Cross-platform Requires configuration Windows, macOS, Linux
Image preprocessing Manual Built-in filters
Production support Community only Commercial support

How Do These OCR Solutions Compare Feature-by-Feature?

Before exploring implementation details, here is a side-by-side comparison of key capabilities for text recognition from scanned PDF files:

Feature Tesseract IronOCR
Native PDF Input No (requires image conversion) Yes
Installation Multiple dependencies Single NuGet package
Password-Protected PDFs Not supported Supported
Image Preprocessing Manual (external tools) Built-in filters
Language Support 100+ languages 127+ languages
Licensing Apache 2.0 (Free) Commercial
.NET Integration Via wrapper library Native C# library
Image Formats PNG, JPEG, TIFF, BMP PNG, JPEG, TIFF, BMP, GIF, PDF
Output Options Plain text, hOCR, HTML Plain text, searchable PDF, hOCR

IronOCR provides more complete PDF handling capabilities, particularly for enterprise document management requiring searchable PDF generation and barcode recognition.

How Does Tesseract Handle PDF Files and Extract Text?

The Tesseract OCR engine does not natively support PDF document input. According to the official Tesseract documentation, developers must convert PDF pages to PNG or JPEG images before performing OCR. This process requires additional libraries such as Ghostscript or a dedicated PDF rendering library to convert each page, adding complexity and failure points to production pipelines.

Here is a simplified example of the standard Tesseract workflow for extracting text from a PDF in C#:

using Tesseract;

// Step 1: Convert PDF page to PNG (requires a separate PDF rendering library)
// This example assumes the scanned PDF has already been converted to an image
string imagePath = "document-scan.png";

// Step 2: Initialize Tesseract with the language data path
using var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default);

// Step 3: Load the image and run OCR
using var img = Pix.LoadFromFile(imagePath);
using var page = engine.Process(img);

// Step 4: Extract recognized text
string extractedText = page.GetText();
Console.WriteLine($"Confidence: {page.GetMeanConfidence()}");
Console.WriteLine(extractedText);

// Optional: retrieve word-level bounding boxes
using var iter = page.GetIterator();
iter.Begin();
do
{
    if (iter.TryGetBoundingBox(PageIteratorLevel.Word, out var bounds))
    {
        string word = iter.GetText(PageIteratorLevel.Word);
        Console.WriteLine($"Word: {word} at {bounds}");
    }
} while (iter.Next(PageIteratorLevel.Word));
using Tesseract;

// Step 1: Convert PDF page to PNG (requires a separate PDF rendering library)
// This example assumes the scanned PDF has already been converted to an image
string imagePath = "document-scan.png";

// Step 2: Initialize Tesseract with the language data path
using var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default);

// Step 3: Load the image and run OCR
using var img = Pix.LoadFromFile(imagePath);
using var page = engine.Process(img);

// Step 4: Extract recognized text
string extractedText = page.GetText();
Console.WriteLine($"Confidence: {page.GetMeanConfidence()}");
Console.WriteLine(extractedText);

// Optional: retrieve word-level bounding boxes
using var iter = page.GetIterator();
iter.Begin();
do
{
    if (iter.TryGetBoundingBox(PageIteratorLevel.Word, out var bounds))
    {
        string word = iter.GetText(PageIteratorLevel.Word);
        Console.WriteLine($"Word: {word} at {bounds}");
    }
} while (iter.Next(PageIteratorLevel.Word));
$vbLabelText   $csharpLabel

This code demonstrates the standard Tesseract approach using the .NET wrapper available on NuGet. The engine initialization requires a path to the tessdata folder containing language data files, which must be downloaded separately from the tessdata repository. The img variable loads the input image in Leptonica's PIX format, an unmanaged C++ object that requires explicit disposal to prevent memory leaks. The page result performs the actual character recognition operation.

Why Does Tesseract Require Image Conversion First?

PDF viewer showing Invoice #1001 with $500 total, demonstrating document viewing capabilities for scanned PDF processing

Tesseract's architecture focuses purely on image processing rather than document handling. This design means developers must manage the PDF-to-image conversion pipeline themselves, introducing additional complexity when dealing with password-protected PDFs, multi-page documents, or mixed-content PDFs combining text layers and rasterized scans. The conversion quality directly affects OCR accuracy, making proper DPI settings and preprocessing critical for acceptable results.

How Do You Process Multiple PDF Pages with Tesseract?

For production environments, handling multi-page documents requires orchestration logic to convert each PDF page to an image, process it individually, and aggregate results across all pages:

using Tesseract;
using System.Text;

// Processing multiple PDF pages after prior PDF-to-image conversion
static string ProcessMultiPagePdf(string[] imagePaths)
{
    var results = new StringBuilder();
    using var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default);

    foreach (var imagePath in imagePaths)
    {
        using var img = Pix.LoadFromFile(imagePath);
        using var page = engine.Process(img);
        results.AppendLine($"Page confidence: {page.GetMeanConfidence():F2}");
        results.AppendLine(page.GetText());
        results.AppendLine("---");
    }

    return results.ToString();
}
using Tesseract;
using System.Text;

// Processing multiple PDF pages after prior PDF-to-image conversion
static string ProcessMultiPagePdf(string[] imagePaths)
{
    var results = new StringBuilder();
    using var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default);

    foreach (var imagePath in imagePaths)
    {
        using var img = Pix.LoadFromFile(imagePath);
        using var page = engine.Process(img);
        results.AppendLine($"Page confidence: {page.GetMeanConfidence():F2}");
        results.AppendLine(page.GetText());
        results.AppendLine("---");
    }

    return results.ToString();
}
$vbLabelText   $csharpLabel

Each PDF page must be individually converted to an image before this code can process it. The orchestration logic for that conversion (rendering pages at the correct DPI, writing temporary files, and cleaning them up) sits outside this function and requires a separate library. This multi-step pipeline introduces additional failure points and significantly increases the codebase size for what is conceptually a straightforward operation.

What Results Can You Expect from Basic Tesseract Processing?

Visual Studio Debug Console showing successful PDF text extraction with 'Invoice #1001' and 'Total: $500.00' from a .NET 9.0 application

The confidence scores returned by page.GetMeanConfidence() help validate extraction quality but require manual interpretation and custom threshold logic. Scanned documents with background noise, skew, or low resolution require preprocessing before OCR to achieve acceptable accuracy. Since Tesseract operates on images rather than PDFs directly, the quality of the intermediate image conversion step determines a significant portion of the final OCR accuracy, meaning bugs in the conversion pipeline manifest as OCR accuracy problems that can be difficult to isolate.

How Does IronOCR Process PDFs Directly in C#?

IronOCR provides native PDF support, eliminating the need to convert scanned documents to intermediate image formats. The library handles PDF rendering internally, simplifying the workflow for .NET 10 applications. This integrated approach proves particularly valuable for enterprise document processing where performance and reliability are critical requirements.

using IronOcr;

// Initialize the OCR engine (built on optimized Tesseract 5)
var ocr = new IronTesseract();
ocr.Configuration.PageSegmentationMode = TesseractPageSegmentationMode.Auto;
ocr.Configuration.ReadBarCodes = true; // Detect barcodes and QR codes alongside text

// Load PDF directly - no image conversion required
using var input = new OcrInput();
input.LoadPdf("scanned-document.pdf", Password: "optional-password");

// Apply preprocessing for low-quality scans
input.DeNoise();              // Remove background noise from scanned paper
input.Deskew();               // Correct rotation from camera angle
input.EnhanceResolution(300); // Ensure adequate DPI for accurate recognition

// Extract text from all pages
OcrResult result = ocr.Read(input);

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

// Export results as a searchable PDF
result.SaveAsSearchablePdf("searchable-output.pdf");
using IronOcr;

// Initialize the OCR engine (built on optimized Tesseract 5)
var ocr = new IronTesseract();
ocr.Configuration.PageSegmentationMode = TesseractPageSegmentationMode.Auto;
ocr.Configuration.ReadBarCodes = true; // Detect barcodes and QR codes alongside text

// Load PDF directly - no image conversion required
using var input = new OcrInput();
input.LoadPdf("scanned-document.pdf", Password: "optional-password");

// Apply preprocessing for low-quality scans
input.DeNoise();              // Remove background noise from scanned paper
input.Deskew();               // Correct rotation from camera angle
input.EnhanceResolution(300); // Ensure adequate DPI for accurate recognition

// Extract text from all pages
OcrResult result = ocr.Read(input);

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

// Export results as a searchable PDF
result.SaveAsSearchablePdf("searchable-output.pdf");
$vbLabelText   $csharpLabel

The IronTesseract class wraps an optimized Tesseract 5 engine built specifically for .NET Core and .NET Framework environments. Unlike the standard .NET wrapper, this implementation manages memory automatically and includes performance optimizations tailored for .NET applications. The OcrInput class accepts PDF files directly via LoadPdf, rendering pages internally without requiring additional libraries to download or configure.

The DeNoise() and Deskew() methods apply built-in preprocessing filters that significantly improve accuracy on real-world scanned documents with noise, speckling, or rotation artifacts. The OcrResult object contains extracted text alongside confidence scores and character positions for post-processing validation. You can also export results as a searchable PDF with a single method call, which Tesseract cannot do without additional libraries.

For more granular control, you can target specific pages or document regions:

using IronOcr;
using System.Drawing;

var ocr = new IronTesseract();

// Restrict character recognition to digits and currency symbols for financial docs
ocr.Configuration = new TesseractConfiguration
{
    WhiteListCharacters = "0123456789.$,",
    PageSegmentationMode = TesseractPageSegmentationMode.SingleColumn
};

// Load only the first two pages from a financial report
using var input = new OcrInput();
input.LoadPdfPages("financial-report.pdf", new[] { 0, 1 });

// Target a specific crop region, such as an invoice total field
var cropRegion = new CropRectangle(x: 100, y: 500, width: 400, height: 200);
foreach (var page in input.Pages)
    page.AddCropRegion(cropRegion);

OcrResult result = ocr.Read(input);

foreach (var page in result.Pages)
{
    Console.WriteLine($"Page {page.PageNumber}:");
    foreach (var paragraph in page.Paragraphs)
        Console.WriteLine($"  ({paragraph.Confidence}%) {paragraph.Text}");
}
using IronOcr;
using System.Drawing;

var ocr = new IronTesseract();

// Restrict character recognition to digits and currency symbols for financial docs
ocr.Configuration = new TesseractConfiguration
{
    WhiteListCharacters = "0123456789.$,",
    PageSegmentationMode = TesseractPageSegmentationMode.SingleColumn
};

// Load only the first two pages from a financial report
using var input = new OcrInput();
input.LoadPdfPages("financial-report.pdf", new[] { 0, 1 });

// Target a specific crop region, such as an invoice total field
var cropRegion = new CropRectangle(x: 100, y: 500, width: 400, height: 200);
foreach (var page in input.Pages)
    page.AddCropRegion(cropRegion);

OcrResult result = ocr.Read(input);

foreach (var page in result.Pages)
{
    Console.WriteLine($"Page {page.PageNumber}:");
    foreach (var paragraph in page.Paragraphs)
        Console.WriteLine($"  ({paragraph.Confidence}%) {paragraph.Text}");
}
$vbLabelText   $csharpLabel

The LoadPdfPages method accepts zero-based page indices, allowing selective processing of large documents without loading every page into memory. Region-based extraction is essential for structured documents like invoices and financial statements, where only specific fields require extraction. The character whitelist configuration prevents false positives when your document contains a known set of characters.

What Types of PDFs Can IronOCR Handle?

IronOCR handles scanned documents, native text PDFs, mixed content, and password-protected files. The library automatically detects whether a PDF contains extractable text or requires OCR processing, optimizing performance for each case without additional configuration. Stream-based input enables processing documents from memory without writing temporary files, which is particularly suitable for cloud deployments and environments with strict file system restrictions.

How Does IronOCR Handle Specialized Document Types?

IronOCR provides dedicated methods for specialized document types, using machine learning models optimized for each format:

using IronOcr;

var ocr = new IronTesseract();

// Extract text from a vehicle license plate
var licensePlateResult = ocr.ReadLicensePlate("car-photo.jpg");
Console.WriteLine($"License Plate: {licensePlateResult.Text}");

// Read passport MRZ fields from a scanned document
var passportResult = ocr.ReadPassport("passport-scan.pdf");
Console.WriteLine($"Number: {passportResult.PassportNumber}");
Console.WriteLine($"Name: {passportResult.GivenNames} {passportResult.Surname}");

// Process MICR cheques for banking workflows
var chequeResult = ocr.ReadMicrCheque("cheque-image.tiff");
Console.WriteLine($"Account: {chequeResult.AccountNumber}");
Console.WriteLine($"Routing: {chequeResult.RoutingNumber}");
using IronOcr;

var ocr = new IronTesseract();

// Extract text from a vehicle license plate
var licensePlateResult = ocr.ReadLicensePlate("car-photo.jpg");
Console.WriteLine($"License Plate: {licensePlateResult.Text}");

// Read passport MRZ fields from a scanned document
var passportResult = ocr.ReadPassport("passport-scan.pdf");
Console.WriteLine($"Number: {passportResult.PassportNumber}");
Console.WriteLine($"Name: {passportResult.GivenNames} {passportResult.Surname}");

// Process MICR cheques for banking workflows
var chequeResult = ocr.ReadMicrCheque("cheque-image.tiff");
Console.WriteLine($"Account: {chequeResult.AccountNumber}");
Console.WriteLine($"Routing: {chequeResult.RoutingNumber}");
$vbLabelText   $csharpLabel

These specialized methods use configurations and models optimized for each document type, providing better accuracy than configuring the general-purpose engine manually. License plate recognition handles various international formats. Passport reading extracts MRZ data automatically. MICR cheque processing handles banking documents without manual engine configuration. Achieving equivalent accuracy with Tesseract for these document types would require custom training data and model tuning.

What Are the Key Differences in Setup and Workflow?

Why Is Tesseract Installation More Complex?

Tesseract requires several components for a working .NET 10 setup: the OCR engine binaries, the Leptonica imaging library, Visual C++ redistributables on Windows, and language data files for each language to recognize. Developers must download tessdata files separately and configure the correct folder path before the library initializes successfully. Cross-platform deployment to Azure, Docker containers, or Linux servers frequently requires platform-specific configuration and dependency troubleshooting that is difficult to automate reliably.

The dependency complexity intensifies for Azure Functions or AWS Lambda deployments, where runtime environments impose strict limits on external binaries and memory allocation. Older CPUs without AVX instruction support produce SEHException errors at runtime, adding a diagnostic layer for incidents that are unrelated to application logic. The libgdiplus dependency creates additional challenges on non-Windows platforms.

How Does IronOCR Simplify Installation?

IronOCR reduces installation to a single NuGet package with no external binaries to manage:

Install-Package IronOcr
Install-Package IronOcr
SHELL

For specialized scanning or additional language support:

# Advanced scanning algorithms (optional)
Install-Package IronOcr.Extensions.AdvancedScan

# Language packs install as needed
Install-Package IronOcr.Languages.French
Install-Package IronOcr.Languages.Japanese
# Advanced scanning algorithms (optional)
Install-Package IronOcr.Extensions.AdvancedScan

# Language packs install as needed
Install-Package IronOcr.Languages.French
Install-Package IronOcr.Languages.Japanese
SHELL

NuGet Package Manager Console showing successful IronOCR installation with automatic dependency resolution completing in approximately 20 seconds

All required components are bundled within the package. Language packs install with the same simplicity as the main library, with no manual tessdata folder management required. IronOCR supports .NET Framework 4.6.2+, .NET Core, and .NET 5–10 across Windows, macOS, and Linux by default.

For production services, here is a complete async processing example with progress tracking and cancellation support:

using IronOcr;

async Task<OcrResult> ProcessPdfAsync(string pdfPath)
{
    var ocr = new IronTesseract();

    // Report progress to the caller for user feedback in batch workflows
    ocr.OcrProgress += (sender, e) =>
        Console.WriteLine($"Page {e.PagesComplete}/{e.TotalPages}: {e.ProgressPercent}%");

    using var input = new OcrInput();

    // Use a lower DPI for very large files to reduce memory pressure
    if (new System.IO.FileInfo(pdfPath).Length > 100_000_000)
        input.TargetDPI = 150;

    input.LoadPdf(pdfPath);
    input.DeNoise();
    input.Deskew();

    // Cancel automatically after 5 minutes to prevent resource exhaustion
    using var cts = new System.Threading.CancellationTokenSource(TimeSpan.FromMinutes(5));
    return await ocr.ReadAsync(input, cts.Token);
}
using IronOcr;

async Task<OcrResult> ProcessPdfAsync(string pdfPath)
{
    var ocr = new IronTesseract();

    // Report progress to the caller for user feedback in batch workflows
    ocr.OcrProgress += (sender, e) =>
        Console.WriteLine($"Page {e.PagesComplete}/{e.TotalPages}: {e.ProgressPercent}%");

    using var input = new OcrInput();

    // Use a lower DPI for very large files to reduce memory pressure
    if (new System.IO.FileInfo(pdfPath).Length > 100_000_000)
        input.TargetDPI = 150;

    input.LoadPdf(pdfPath);
    input.DeNoise();
    input.Deskew();

    // Cancel automatically after 5 minutes to prevent resource exhaustion
    using var cts = new System.Threading.CancellationTokenSource(TimeSpan.FromMinutes(5));
    return await ocr.ReadAsync(input, cts.Token);
}
$vbLabelText   $csharpLabel

This pattern demonstrates IronOCR's async processing support with built-in progress reporting and cancellation. The CancellationTokenSource prevents resource exhaustion when processing unexpectedly large documents, and the progress event provides real-time feedback for batch workflows that need to report status to end users.

What Are the Licensing Differences Between Tesseract and IronOCR?

The licensing model is the most fundamental distinction between the two libraries and directly influences total cost of ownership and long-term maintenance burden.

What Does Tesseract's Open-Source License Mean in Practice?

Tesseract is released under the Apache 2.0 license, permitting free use in both open-source and commercial applications without royalties. The cost of Tesseract is not zero, however, when you account for the developer time required for initial setup, PDF-to-image conversion pipeline development, dependency management across deployment targets, and ongoing maintenance as environments change. For image-only OCR workflows where the setup overhead is manageable, Tesseract represents a genuine cost-effective starting point.

What Does IronOCR's Commercial License Include?

IronOCR requires a commercial license for production deployment. Licensing tiers cover individual developers, small teams, and enterprise redistribution scenarios with royalty-free options. A free trial is available for evaluation without a credit card. The commercial license includes access to technical support, regular updates, and security patches, reducing the ongoing maintenance cost over the application's lifetime. For teams processing high volumes of PDF documents under production SLAs, the license cost is frequently offset by the reduction in developer time spent on infrastructure setup and production incident investigation.

Which OCR Library Should You Choose for .NET Applications?

The decision between Tesseract and IronOCR depends on your project's input formats, deployment targets, and team resources.

Choose Tesseract when:

  • Budget constraints require a fully free, open-source solution
  • Your input consists exclusively of image files, not PDF documents
  • Your team has C++ interop experience and capacity for dependency management
  • Custom OCR engine training or specialized dictionary support is required
  • Project timelines permit the additional setup and troubleshooting work

Choose IronOCR when:

  • PDF files and scanned documents are a primary input format
  • Development speed and minimal boilerplate are priorities
  • Cross-platform deployment to cloud environments, Docker, or Linux is required
  • Built-in preprocessing filters would improve accuracy on real-world scans
  • Commercial support and regular updates provide production value
  • Password-protected PDFs or multi-language documents are required
  • You need to generate searchable PDF output from scanned documents

Both libraries use Tesseract's OCR engine as their recognition core. IronOCR extends it with native .NET integration, automatic memory management, built-in preprocessing, and direct PDF support, addressing the common pain points that emerge when building OCR pipelines in production .NET applications. The architectural difference becomes most apparent at scale: a Tesseract-based pipeline requires managing a multi-library dependency stack, while an IronOCR pipeline resolves to a single NuGet package.

What Are My Next Steps?

Start a free IronOCR trial to evaluate PDF text extraction with your own documents. For deeper coverage of specific scenarios, explore the PDF input guide, image preprocessing filters, and searchable PDF export documentation. Review IronOCR licensing options for production deployment planning.

Please noteGoogle is a registered trademark of its respective owner. This site is not affiliated with, endorsed by, or sponsored by Google. All product names, logos, and brands are property of their respective owners. Comparisons are for informational purposes only and reflect publicly available information at the time of writing.

Frequently Asked Questions

Can Tesseract OCR read PDF files directly in C#?

No. Tesseract does not support PDF input natively. Developers must convert each PDF page to an image format such as PNG or JPEG using a separate library before passing it to the Tesseract engine.

How does IronOCR handle PDF files in .NET?

IronOCR accepts PDF files directly through the LoadPdf method on OcrInput. The library renders pages internally, removing the need for a separate PDF-to-image conversion step. Password-protected PDFs are also supported.

Why do developers choose IronOCR over Tesseract for .NET applications?

IronOCR eliminates the PDF-to-image conversion pipeline that Tesseract requires, installs as a single NuGet package with no external dependencies, and includes built-in preprocessing filters. These differences reduce code complexity and setup time for production .NET applications.

What preprocessing options does IronOCR provide for scanned documents?

IronOCR provides built-in methods including DeNoise() to remove background noise, Deskew() to correct rotation artifacts, and EnhanceResolution() to improve DPI before recognition. These filters apply directly to OcrInput without requiring external image processing libraries.

Can IronOCR process specific pages or regions of a PDF?

Yes. Use LoadPdfPages with an array of zero-based page indices to process only selected pages. Use CropRectangle with AddCropRegion on individual pages to target specific document areas such as invoice fields or header sections.

Is IronOCR free to use?

IronOCR requires a commercial license for production deployment. A free trial is available for evaluation. Tesseract is free under the Apache 2.0 license, though it requires developer time for setup, PDF conversion pipelines, and ongoing dependency maintenance.

Does IronOCR support searchable PDF output?

Yes. After running OCR, call result.SaveAsSearchablePdf() on the OcrResult object to export the recognized text embedded in a searchable PDF. Tesseract requires additional libraries to achieve the same output.

What specialized document types can IronOCR recognize?

IronOCR provides dedicated methods for license plates (ReadLicensePlate), passport MRZ fields (ReadPassport), and MICR bank cheques (ReadMicrCheque). These use models optimized for each document type.

Does IronOCR work on Linux, macOS, and Docker?

Yes. IronOCR supports Windows, macOS, and Linux by default and deploys to Azure, Docker, and AWS without the platform-specific dependency configuration that Tesseract requires on non-Windows environments.

Is IronOCR compatible with .NET 10?

Yes. IronOCR supports .NET 10, .NET 9, .NET 8, .NET Framework 4.6.2, and earlier versions. No special configuration is required to use IronOCR in a .NET 10 application.

Kannaopat Udonpant
Kannapat Udonpant
  Chat with engineering team now
Software Engineer
Before becoming a Software Engineer, Kannapat completed a Environmental Resources PhD from Hokkaido University in Japan. While pursuing his degree, Kannapat also became a member of the Vehicle Robotics Laboratory, which is part of the Department of Bioproduction Engineering. In 2022, he leveraged his C# skills to join Iron Software's engineering ...
Read More

Related Articles

30-day trial → Full product. No limits. No card. Start Free Trial