Migrating from Syncfusion OCR to IronOCR

// Syncfusion: tessdata path required — fails in any environment where this path is wrong
private const string TessDataPath = @"tessdata/";

using var document = new PdfLoadedDocument("scanned-invoice.pdf");
using var processor = new OCRProcessor(TessDataPath);  // throws if path does not resolve
processor.Settings.Language = Languages.English;
processor.PerformOCR(document);

var text = new StringBuilder();
foreach (PdfLoadedPage page in document.Pages)
    text.AppendLine(page.ExtractText());

Imports Syncfusion.Pdf
Imports Syncfusion.OCR
Imports System.Text

' Syncfusion: tessdata path required — fails in any environment where this path is wrong
Private Const TessDataPath As String = "tessdata/"

Using document As New PdfLoadedDocument("scanned-invoice.pdf")
    Using processor As New OCRProcessor(TessDataPath) ' throws if path does not resolve
        processor.Settings.Language = Languages.English
        processor.PerformOCR(document)

        Dim text As New StringBuilder()
        For Each page As PdfLoadedPage In document.Pages
            text.AppendLine(page.ExtractText())
        Next
    End Using
End Using

// IronOCR: no tessdata path, no path configuration, no folder to deploy
var text = new IronTesseract().Read("scanned-invoice.pdf").Text;

' IronOCR: no tessdata path, no path configuration, no folder to deploy
Dim text As String = New IronTesseract().Read("scanned-invoice.pdf").Text

dotnet remove package Syncfusion.PDF.OCR.Net.Core
dotnet remove package Syncfusion.Pdf.Net.Core
dotnet remove package Syncfusion.Compression.Net.Core

// Before (Syncfusion)
using Syncfusion.OCRProcessor;
using Syncfusion.Pdf;
using Syncfusion.Pdf.Parsing;

// After (IronOCR)
using IronOcr;

Imports IronOcr

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

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

using Syncfusion.OCRProcessor;
using Syncfusion.Pdf.Parsing;

public class DocumentOcrService
{
    // Path hardcoded — different on every deployment target
    private const string TessDataPath = @"tessdata/";

    private bool ValidateTessdataBeforeUse(string languageCode)
    {
        // Guard required because missing files cause runtime exceptions
        if (!Directory.Exists(TessDataPath))
            throw new InvalidOperationException(
                "tessdata directory not found. Download from github.com/tesseract-ocr/tessdata_best");

        string filePath = Path.Combine(TessDataPath, $"{languageCode}.traineddata");
        if (!File.Exists(filePath))
            throw new InvalidOperationException(
                $"{languageCode}.traineddata not found — file must be downloaded manually");

        return true;
    }

    public string ExtractText(string pdfPath, string languageCode = "eng")
    {
        ValidateTessdataBeforeUse(languageCode);  // defensive check before every call

        using var document = new PdfLoadedDocument(pdfPath);
        using var processor = new OCRProcessor(TessDataPath);
        processor.Settings.Language = Languages.English;
        processor.PerformOCR(document);

        var sb = new StringBuilder();
        foreach (PdfLoadedPage page in document.Pages)
            sb.AppendLine(page.ExtractText());

        return sb.ToString();
    }
}

Imports Syncfusion.OCRProcessor
Imports Syncfusion.Pdf.Parsing
Imports System.IO
Imports System.Text

Public Class DocumentOcrService
    ' Path hardcoded — different on every deployment target
    Private Const TessDataPath As String = "tessdata/"

    Private Function ValidateTessdataBeforeUse(languageCode As String) As Boolean
        ' Guard required because missing files cause runtime exceptions
        If Not Directory.Exists(TessDataPath) Then
            Throw New InvalidOperationException("tessdata directory not found. Download from github.com/tesseract-ocr/tessdata_best")
        End If

        Dim filePath As String = Path.Combine(TessDataPath, $"{languageCode}.traineddata")
        If Not File.Exists(filePath) Then
            Throw New InvalidOperationException($"{languageCode}.traineddata not found — file must be downloaded manually")
        End If

        Return True
    End Function

    Public Function ExtractText(pdfPath As String, Optional languageCode As String = "eng") As String
        ValidateTessdataBeforeUse(languageCode)  ' defensive check before every call

        Using document As New PdfLoadedDocument(pdfPath)
            Using processor As New OCRProcessor(TessDataPath)
                processor.Settings.Language = Languages.English
                processor.PerformOCR(document)

                Dim sb As New StringBuilder()
                For Each page As PdfLoadedPage In document.Pages
                    sb.AppendLine(page.ExtractText())
                Next

                Return sb.ToString()
            End Using
        End Using
    End Function
End Class

using IronOcr;

public class DocumentOcrService
{
    // No tessdata path — no validation logic — no defensive checks
    public string ExtractText(string pdfPath)
    {
        return new IronTesseract().Read(pdfPath).Text;
    }
}

Imports IronOcr

Public Class DocumentOcrService
    ' No tessdata path — no validation logic — no defensive checks
    Public Function ExtractText(pdfPath As String) As String
        Return New IronTesseract().Read(pdfPath).Text
    End Function
End Class

using Syncfusion.OCRProcessor;
using Syncfusion.Pdf.Parsing;

public class SearchablePdfService
{
    private const string TessDataPath = @"tessdata/";

    public void ConvertToSearchable(string inputPdfPath, string outputPdfPath)
    {
        // Load document — mutable: PerformOCR modifies it in place
        using var document = new PdfLoadedDocument(inputPdfPath);
        using var processor = new OCRProcessor(TessDataPath);

        processor.Settings.Language = Languages.English;

        // Step 1: OCR modifies the document object
        processor.PerformOCR(document);

        // Step 2: Save the modified document to a separate output file
        using var outputStream = new FileStream(outputPdfPath, FileMode.Create, FileAccess.Write);
        document.Save(outputStream);
    }

    public byte[] ConvertToSearchableBytes(string inputPdfPath)
    {
        using var document = new PdfLoadedDocument(inputPdfPath);
        using var processor = new OCRProcessor(TessDataPath);

        processor.Settings.Language = Languages.English;
        processor.PerformOCR(document);

        using var outputStream = new MemoryStream();
        document.Save(outputStream);
        return outputStream.ToArray();
    }
}

Imports Syncfusion.OCRProcessor
Imports Syncfusion.Pdf.Parsing
Imports System.IO

Public Class SearchablePdfService
    Private Const TessDataPath As String = "tessdata/"

    Public Sub ConvertToSearchable(inputPdfPath As String, outputPdfPath As String)
        ' Load document — mutable: PerformOCR modifies it in place
        Using document As New PdfLoadedDocument(inputPdfPath)
            Using processor As New OCRProcessor(TessDataPath)
                processor.Settings.Language = Languages.English

                ' Step 1: OCR modifies the document object
                processor.PerformOCR(document)

                ' Step 2: Save the modified document to a separate output file
                Using outputStream As New FileStream(outputPdfPath, FileMode.Create, FileAccess.Write)
                    document.Save(outputStream)
                End Using
            End Using
        End Using
    End Sub

    Public Function ConvertToSearchableBytes(inputPdfPath As String) As Byte()
        Using document As New PdfLoadedDocument(inputPdfPath)
            Using processor As New OCRProcessor(TessDataPath)
                processor.Settings.Language = Languages.English
                processor.PerformOCR(document)

                Using outputStream As New MemoryStream()
                    document.Save(outputStream)
                    Return outputStream.ToArray()
                End Using
            End Using
        End Using
    End Function
End Class

using IronOcr;

public class SearchablePdfService
{
    public void ConvertToSearchable(string inputPdfPath, string outputPdfPath)
    {
        var result = new IronTesseract().Read(inputPdfPath);
        result.SaveAsSearchablePdf(outputPdfPath);
    }

    public byte[] ConvertToSearchableBytes(string inputPdfPath)
    {
        using var input = new OcrInput();
        input.LoadPdf(inputPdfPath);

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

        // SaveAsSearchablePdf also accepts a MemoryStream
        using var ms = new MemoryStream();
        result.SaveAsSearchablePdf(ms);
        return ms.ToArray();
    }
}

Imports IronOcr

Public Class SearchablePdfService
    Public Sub ConvertToSearchable(inputPdfPath As String, outputPdfPath As String)
        Dim result = New IronTesseract().Read(inputPdfPath)
        result.SaveAsSearchablePdf(outputPdfPath)
    End Sub

    Public Function ConvertToSearchableBytes(inputPdfPath As String) As Byte()
        Using input As New OcrInput()
            input.LoadPdf(inputPdfPath)

            Dim result = New IronTesseract().Read(input)

            ' SaveAsSearchablePdf also accepts a MemoryStream
            Using ms As New MemoryStream()
                result.SaveAsSearchablePdf(ms)
                Return ms.ToArray()
            End Using
        End Using
    End Function
End Class

using Syncfusion.OCRProcessor;
using Syncfusion.Pdf.Parsing;

public class StreamOcrService
{
    private const string TessDataPath = @"tessdata/";

    public string ExtractFromStream(Stream pdfStream)
    {
        // Stream input works, but tessdata path constraint remains
        using var document = new PdfLoadedDocument(pdfStream);
        using var processor = new OCRProcessor(TessDataPath);

        processor.Settings.Language = Languages.English;
        processor.PerformOCR(document);

        var sb = new StringBuilder();
        foreach (PdfLoadedPage page in document.Pages)
            sb.AppendLine(page.ExtractText());

        return sb.ToString();
    }

    public async Task<string> ExtractFromStreamAsync(Stream pdfStream)
    {
        // No native async — must wrap in Task.Run
        return await Task.Run(() => ExtractFromStream(pdfStream));
    }
}

Imports Syncfusion.OCRProcessor
Imports Syncfusion.Pdf.Parsing
Imports System.IO
Imports System.Text
Imports System.Threading.Tasks

Public Class StreamOcrService
    Private Const TessDataPath As String = "tessdata/"

    Public Function ExtractFromStream(pdfStream As Stream) As String
        ' Stream input works, but tessdata path constraint remains
        Using document As New PdfLoadedDocument(pdfStream)
            Using processor As New OCRProcessor(TessDataPath)
                processor.Settings.Language = Languages.English
                processor.PerformOCR(document)

                Dim sb As New StringBuilder()
                For Each page As PdfLoadedPage In document.Pages
                    sb.AppendLine(page.ExtractText())
                Next

                Return sb.ToString()
            End Using
        End Using
    End Function

    Public Async Function ExtractFromStreamAsync(pdfStream As Stream) As Task(Of String)
        ' No native async — must wrap in Task.Run
        Return Await Task.Run(Function() ExtractFromStream(pdfStream))
    End Function
End Class

using IronOcr;

public class StreamOcrService
{
    public string ExtractFromStream(Stream pdfStream)
    {
        using var input = new OcrInput();
        input.LoadPdf(pdfStream);    // accepts Stream directly

        return new IronTesseract().Read(input).Text;
    }

    public async Task<string> ExtractFromStreamAsync(Stream pdfStream)
    {
        using var input = new OcrInput();
        input.LoadPdf(pdfStream);

        var ocr = new IronTesseract();
        var result = await ocr.ReadAsync(input);   // native async support
        return result.Text;
    }
}

Imports IronOcr

Public Class StreamOcrService
    Public Function ExtractFromStream(pdfStream As Stream) As String
        Using input As New OcrInput()
            input.LoadPdf(pdfStream) ' accepts Stream directly

            Return New IronTesseract().Read(input).Text
        End Using
    End Function

    Public Async Function ExtractFromStreamAsync(pdfStream As Stream) As Task(Of String)
        Using input As New OcrInput()
            input.LoadPdf(pdfStream)

            Dim ocr As New IronTesseract()
            Dim result = Await ocr.ReadAsync(input) ' native async support
            Return result.Text
        End Using
    End Function
End Class

using Syncfusion.OCRProcessor;
using Syncfusion.Pdf.Parsing;

public class StructuredExtractionService
{
    private const string TessDataPath = @"tessdata/";

    public Dictionary<int, string> ExtractPerPage(string pdfPath)
    {
        var pageTexts = new Dictionary<int, string>();

        using var document = new PdfLoadedDocument(pdfPath);
        using var processor = new OCRProcessor(TessDataPath);

        processor.Settings.Language = Languages.English;
        processor.PerformOCR(document);

        // Page-level is the finest granularity available
        int pageNum = 1;
        foreach (PdfLoadedPage page in document.Pages)
        {
            pageTexts[pageNum] = page.ExtractText();
            pageNum++;
        }

        return pageTexts;
        // No word coordinates, no paragraph boundaries, no per-token confidence
    }
}

Imports Syncfusion.OCRProcessor
Imports Syncfusion.Pdf.Parsing

Public Class StructuredExtractionService
    Private Const TessDataPath As String = "tessdata/"

    Public Function ExtractPerPage(pdfPath As String) As Dictionary(Of Integer, String)
        Dim pageTexts As New Dictionary(Of Integer, String)()

        Using document As New PdfLoadedDocument(pdfPath)
            Using processor As New OCRProcessor(TessDataPath)
                processor.Settings.Language = Languages.English
                processor.PerformOCR(document)

                ' Page-level is the finest granularity available
                Dim pageNum As Integer = 1
                For Each page As PdfLoadedPage In document.Pages
                    pageTexts(pageNum) = page.ExtractText()
                    pageNum += 1
                Next
            End Using
        End Using

        Return pageTexts
        ' No word coordinates, no paragraph boundaries, no per-token confidence
    End Function
End Class

using IronOcr;

public class StructuredExtractionService
{
    public void ExtractWithStructure(string pdfPath)
    {
        var result = new IronTesseract().Read(pdfPath);

        Console.WriteLine($"Overall confidence: {result.Confidence}%");

        foreach (var page in result.Pages)
        {
            Console.WriteLine($"Page {page.PageNumber}: {page.Words.Length} words");

            foreach (var paragraph in page.Paragraphs)
            {
                Console.WriteLine($"  Paragraph at ({paragraph.X}, {paragraph.Y}):");
                Console.WriteLine($"  {paragraph.Text}");
            }
        }
    }

    public IEnumerable<string> ExtractHighConfidenceWords(string pdfPath, int minConfidence = 80)
    {
        var result = new IronTesseract().Read(pdfPath);

        // Per-word confidence filtering — not possible with Syncfusion's page-level model
        return result.Pages
            .SelectMany(p => p.Words)
            .Where(w => w.Confidence >= minConfidence)
            .Select(w => w.Text);
    }
}

Imports IronOcr

Public Class StructuredExtractionService
    Public Sub ExtractWithStructure(pdfPath As String)
        Dim result = New IronTesseract().Read(pdfPath)

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

        For Each page In result.Pages
            Console.WriteLine($"Page {page.PageNumber}: {page.Words.Length} words")

            For Each paragraph In page.Paragraphs
                Console.WriteLine($"  Paragraph at ({paragraph.X}, {paragraph.Y}):")
                Console.WriteLine($"  {paragraph.Text}")
            Next
        Next
    End Sub

    Public Function ExtractHighConfidenceWords(pdfPath As String, Optional minConfidence As Integer = 80) As IEnumerable(Of String)
        Dim result = New IronTesseract().Read(pdfPath)

        ' Per-word confidence filtering — not possible with Syncfusion's page-level model
        Return result.Pages _
            .SelectMany(Function(p) p.Words) _
            .Where(Function(w) w.Confidence >= minConfidence) _
            .Select(Function(w) w.Text)
    End Function
End Class

using Syncfusion.OCRProcessor;
using Syncfusion.Pdf.Parsing;

public class BatchOcrService
{
    private const string TessDataPath = @"tessdata/";

    public Dictionary<string, string> ProcessBatch(IEnumerable<string> pdfPaths)
    {
        var results = new Dictionary<string, string>();

        // Sequential processing — OCRProcessor thread safety not guaranteed
        foreach (var path in pdfPaths)
        {
            using var document = new PdfLoadedDocument(path);
            using var processor = new OCRProcessor(TessDataPath);

            processor.Settings.Language = Languages.English;
            processor.PerformOCR(document);

            var sb = new StringBuilder();
            foreach (PdfLoadedPage page in document.Pages)
                sb.AppendLine(page.ExtractText());

            results[path] = sb.ToString();
        }

        return results;
    }
}

Imports Syncfusion.OCRProcessor
Imports Syncfusion.Pdf.Parsing
Imports System.Collections.Generic
Imports System.Text

Public Class BatchOcrService
    Private Const TessDataPath As String = "tessdata/"

    Public Function ProcessBatch(pdfPaths As IEnumerable(Of String)) As Dictionary(Of String, String)
        Dim results As New Dictionary(Of String, String)()

        ' Sequential processing — OCRProcessor thread safety not guaranteed
        For Each path In pdfPaths
            Using document As New PdfLoadedDocument(path)
                Using processor As New OCRProcessor(TessDataPath)
                    processor.Settings.Language = Languages.English
                    processor.PerformOCR(document)

                    Dim sb As New StringBuilder()
                    For Each page As PdfLoadedPage In document.Pages
                        sb.AppendLine(page.ExtractText())
                    Next

                    results(path) = sb.ToString()
                End Using
            End Using
        Next

        Return results
    End Function
End Class

using IronOcr;

public class BatchOcrService
{
    public Dictionary<string, string> ProcessBatch(IEnumerable<string> pdfPaths)
    {
        var results = new ConcurrentDictionary<string, string>();

        // Parallel processing — IronTesseract is safe per-thread
        Parallel.ForEach(pdfPaths, pdfPath =>
        {
            var ocr = new IronTesseract();   // one instance per thread
            var text = ocr.Read(pdfPath).Text;
            results[pdfPath] = text;
        });

        return new Dictionary<string, string>(results);
    }
}

Imports IronOcr
Imports System.Collections.Concurrent
Imports System.Collections.Generic
Imports System.Threading.Tasks

Public Class BatchOcrService
    Public Function ProcessBatch(pdfPaths As IEnumerable(Of String)) As Dictionary(Of String, String)
        Dim results As New ConcurrentDictionary(Of String, String)()

        ' Parallel processing — IronTesseract is safe per-thread
        Parallel.ForEach(pdfPaths, Sub(pdfPath)
                                       Dim ocr As New IronTesseract() ' one instance per thread
                                       Dim text As String = ocr.Read(pdfPath).Text
                                       results(pdfPath) = text
                                   End Sub)

        Return New Dictionary(Of String, String)(results)
    End Function
End Class

// Delete these entirely — they have no equivalent in IronOCR
// private const string TessDataPath = @"tessdata/";
// private bool ValidateTessdata() { ... }

// The only error handling needed after migration:
try
{
    return new IronTesseract().Read(pdfPath).Text;
}
catch (FileNotFoundException)
{
    throw new ArgumentException($"PDF file not found: {pdfPath}");
}

Imports System.IO

' The only error handling needed after migration:
Try
    Return New IronTesseract().Read(pdfPath).Text
Catch ex As FileNotFoundException
    Throw New ArgumentException($"PDF file not found: {pdfPath}")
End Try

# Languages install as NuGet packages — no manual file management
dotnet add package IronOcr.Languages.French
dotnet add package IronOcr.Languages.German
dotnet add package IronOcr.Languages.ChineseSimplified

// Language configuration after migration
var ocr = new IronTesseract();
ocr.Language = OcrLanguage.French;
ocr.AddSecondaryLanguage(OcrLanguage.German);
var result = ocr.Read("multilingual-report.pdf");

Imports IronTesseract

' Language configuration after migration
Dim ocr As New IronTesseract()
ocr.Language = OcrLanguage.French
ocr.AddSecondaryLanguage(OcrLanguage.German)
Dim result = ocr.Read("multilingual-report.pdf")

// Verify the searchable PDF contains the expected text
var result = new IronTesseract().Read("scanned.pdf");
result.SaveAsSearchablePdf("output-searchable.pdf");

// Validation: confirm text layer is present and readable
var verificationText = new IronTesseract().Read("output-searchable.pdf").Text;
Assert.True(verificationText.Contains("expected content"));

Imports IronOcr

' Verify the searchable PDF contains the expected text
Dim result = New IronTesseract().Read("scanned.pdf")
result.SaveAsSearchablePdf("output-searchable.pdf")

' Validation: confirm text layer is present and readable
Dim verificationText = New IronTesseract().Read("output-searchable.pdf").Text
Assert.True(verificationText.Contains("expected content"))

// Replace split PerformOCR / ExtractText pattern
public OcrResult ProcessDocument(string pdfPath)
{
    // One call, immutable result, all data available
    return new IronTesseract().Read(pdfPath);
}

// Callers decide what they need from the result
var result = service.ProcessDocument("contract.pdf");
var fullText = result.Text;
var confidence = result.Confidence;
result.SaveAsSearchablePdf("contract-searchable.pdf");

Imports IronTesseract

Public Class Service
    ' Replace split PerformOCR / ExtractText pattern
    Public Function ProcessDocument(pdfPath As String) As OcrResult
        ' One call, immutable result, all data available
        Return New IronTesseract().Read(pdfPath)
    End Function
End Class

' Callers decide what they need from the result
Dim service As New Service()
Dim result As OcrResult = service.ProcessDocument("contract.pdf")
Dim fullText As String = result.Text
Dim confidence As Double = result.Confidence
result.SaveAsSearchablePdf("contract-searchable.pdf")

// Remove (causes compile error after package removal)
// Syncfusion.Licensing.SyncfusionLicenseProvider.RegisterLicense("SYNCFUSION-KEY");

// Add at application startup
IronOcr.License.LicenseKey = "YOUR-IRONOCR-KEY";

' Remove (causes compile error after package removal)
' Syncfusion.Licensing.SyncfusionLicenseProvider.RegisterLicense("SYNCFUSION-KEY")

' Add at application startup
IronOcr.License.LicenseKey = "YOUR-IRONOCR-KEY"

# Find all Syncfusion namespace imports
grep -r "using Syncfusion" --include="*.cs" .

# Find OCRProcessor usage
grep -r "OCRProcessor\|PerformOCR\|PdfLoadedDocument\|ExtractText" --include="*.cs" .

# Find tessdata path references
grep -r "TessDataPath\|tessdata\|traineddata" --include="*.cs" .

# Find Syncfusion license registration
grep -r "SyncfusionLicenseProvider\|RegisterLicense" --include="*.cs" .

# Find csproj tessdata copy rules
grep -r "tessdata\|traineddata" --include="*.csproj" .

# Find Dockerfile tessdata layers
grep -r "tessdata" Dockerfile* docker-compose*.yml .