Scanbot SDK vs IronBarcode: C# Barcode Library Comparison

The Camera Pipeline Architecture

Scanbot's architecture requires initialization at app startup followed by a camera-driven scanning call. There is no overload of BarcodeScanner.Open() that accepts a file path or stream; the method signature requires a BarcodeScannerConfiguration because the entire operation is camera-driven:

// In MauiProgram.cs or App.xaml.cs — initialization required before any scan
ScanbotSDK.Initialize(new ScanbotSDKConfiguration
{
    LicenseKey = "YOUR-SCANBOT-LICENSE-KEY",
    EnableLogging = false
});

// Configure accepted formats and camera appearance
var configuration = new BarcodeScannerConfiguration();
configuration.BarcodeFormats = new[]
{
    BarcodeFormat.Code128,
    BarcodeFormat.QrCode,
    BarcodeFormat.Ean13
};

// Open full-screen camera scanner — UI takes over the entire screen
var result = await ScanbotBarcodeSDK.BarcodeScanner.Open(configuration);

if (result.Status == OperationResult.Ok)
{
    foreach (var barcode in result.Barcodes)
        Console.WriteLine($"{barcode.Format}: {barcode.Text}");
}

// In MauiProgram.cs or App.xaml.cs — initialization required before any scan
ScanbotSDK.Initialize(new ScanbotSDKConfiguration
{
    LicenseKey = "YOUR-SCANBOT-LICENSE-KEY",
    EnableLogging = false
});

// Configure accepted formats and camera appearance
var configuration = new BarcodeScannerConfiguration();
configuration.BarcodeFormats = new[]
{
    BarcodeFormat.Code128,
    BarcodeFormat.QrCode,
    BarcodeFormat.Ean13
};

// Open full-screen camera scanner — UI takes over the entire screen
var result = await ScanbotBarcodeSDK.BarcodeScanner.Open(configuration);

if (result.Status == OperationResult.Ok)
{
    foreach (var barcode in result.Barcodes)
        Console.WriteLine($"{barcode.Format}: {barcode.Text}");
}

Imports System

' In MauiProgram.vb or App.xaml.vb — initialization required before any scan
ScanbotSDK.Initialize(New ScanbotSDKConfiguration With {
    .LicenseKey = "YOUR-SCANBOT-LICENSE-KEY",
    .EnableLogging = False
})

' Configure accepted formats and camera appearance
Dim configuration As New BarcodeScannerConfiguration()
configuration.BarcodeFormats = New BarcodeFormat() {
    BarcodeFormat.Code128,
    BarcodeFormat.QrCode,
    BarcodeFormat.Ean13
}

' Open full-screen camera scanner — UI takes over the entire screen
Dim result = Await ScanbotBarcodeSDK.BarcodeScanner.Open(configuration)

If result.Status = OperationResult.Ok Then
    For Each barcode In result.Barcodes
        Console.WriteLine($"{barcode.Format}: {barcode.Text}")
    Next
End If

The SDK processes live video frames in real time, highlights detected barcodes in the viewfinder, and returns when a barcode is confirmed or the user cancels. The configuration object controls camera UI appearance, not processing behavior. That is the complete model.

Detailed Feature Comparison

Scanbot SDK Approach

Scanbot's architecture is built around a native camera pipeline. When BarcodeScanner.Open(configuration) is called, the library hands control to a full-screen camera experience powered by the device's native camera APIs on iOS and Android. The library processes live video frames continuously, applies barcode detection to each frame, and returns control to the calling application when a barcode is confirmed or the user dismisses the scanner. There is no concept of a static image in the Scanbot model — the input is always a stream of live video frames from the device camera.

This design produces a polished scanning experience: real-time barcodes highlighted in the viewfinder, configurable scan region with aspect ratio control, torch toggle, audio and haptic feedback, and orientation locking. These are UI features that Scanbot has invested in for the mobile camera use case. The tradeoff is that the library is inseparable from the camera hardware and the mobile operating system that drives it.

IronBarcode Approach

IronBarcode accepts any binary representation of a barcode-containing image and returns decoded results through the same static method regardless of how the image was obtained:

// Install: dotnet add package IronBarcode
IronBarCode.License.LicenseKey = "YOUR-KEY";

// From a file path — works in any project type
var results = BarcodeReader.Read("barcode.png");
foreach (var result in results)
    Console.WriteLine($"{result.Value} ({result.Format})");

// From a PDF — reads all barcodes on all pages
var pdfResults = BarcodeReader.Read("invoice.pdf");
foreach (var result in pdfResults)
    Console.WriteLine($"Page {result.PageNumber}: {result.Value}");

// From a stream — useful for HTTP file uploads
using var stream = File.OpenRead("document.pdf");
var streamResults = BarcodeReader.Read(stream);

// With processing options
var options = new BarcodeReaderOptions { Speed = ReadingSpeed.Balanced };
var configuredResults = BarcodeReader.Read("image.png", options);

// Install: dotnet add package IronBarcode
IronBarCode.License.LicenseKey = "YOUR-KEY";

// From a file path — works in any project type
var results = BarcodeReader.Read("barcode.png");
foreach (var result in results)
    Console.WriteLine($"{result.Value} ({result.Format})");

// From a PDF — reads all barcodes on all pages
var pdfResults = BarcodeReader.Read("invoice.pdf");
foreach (var result in pdfResults)
    Console.WriteLine($"Page {result.PageNumber}: {result.Value}");

// From a stream — useful for HTTP file uploads
using var stream = File.OpenRead("document.pdf");
var streamResults = BarcodeReader.Read(stream);

// With processing options
var options = new BarcodeReaderOptions { Speed = ReadingSpeed.Balanced };
var configuredResults = BarcodeReader.Read("image.png", options);

Imports IronBarCode
Imports System.IO

' Install: dotnet add package IronBarcode
License.LicenseKey = "YOUR-KEY"

' From a file path — works in any project type
Dim results = BarcodeReader.Read("barcode.png")
For Each result In results
    Console.WriteLine($"{result.Value} ({result.Format})")
Next

' From a PDF — reads all barcodes on all pages
Dim pdfResults = BarcodeReader.Read("invoice.pdf")
For Each result In pdfResults
    Console.WriteLine($"Page {result.PageNumber}: {result.Value}")
Next

' From a stream — useful for HTTP file uploads
Using stream = File.OpenRead("document.pdf")
    Dim streamResults = BarcodeReader.Read(stream)
End Using

' With processing options
Dim options = New BarcodeReaderOptions With {.Speed = ReadingSpeed.Balanced}
Dim configuredResults = BarcodeReader.Read("image.png", options)

The same call runs in a console app, an ASP.NET Core controller, an Azure Function, a WPF form, or a MAUI page. IronBarcode reads barcodes from PDFs natively — not as images extracted from PDFs, but by parsing the PDF structure directly and finding barcodes on each page.

Scanbot SDK Approach

Scanbot's package targets net8.0-android and net8.0-ios. A .NET MAUI Application project that declares only those two targets will build successfully. However, when net8.0-windows or net8.0-maccatalyst is added to TargetFrameworks, the Scanbot package reference fails to resolve on those targets. This is not a configuration issue — the package does not provide assemblies for Windows or macOS. The failure appears during the first build attempt on the desktop target, not at NuGet install time.

This constraint means Scanbot is structurally incompatible with multi-target MAUI projects that include desktop platforms, and it cannot be used in any non-MAUI server or desktop project type regardless of framework version.

IronBarcode Approach

IronBarcode is distributed as a single NuGet package that resolves correctly across all .NET project types and target frameworks:

// Same package, same API — works in ASP.NET Core, WPF, console, MAUI, Azure Functions
dotnet add package IronBarcode

// Same package, same API — works in ASP.NET Core, WPF, console, MAUI, Azure Functions
dotnet add package IronBarcode

net

For MAUI applications that also target Windows or macOS desktop, IronBarcode supports all four MAUI targets from a single package reference with no platform-conditional configuration. Teams building a MAUI project that targets iOS, Android, and Windows can add IronBarcode once and use BarcodeReader.Read() on all three platforms without modification.

Scanbot SDK Approach

In a MAUI project targeting iOS and Android, Scanbot provides a native camera viewfinder embedded in the app's navigation flow. The BarcodeScanner.Open() call presents the full-screen scanner, and the result returns to the calling page when the user completes or dismisses the scan. This integration gives the mobile application a specialized scanning UI that feels native to the platform.

The limitation appears when the project expands. Adding a Windows or macOS target to the MAUI project breaks the build on those platforms. Adding a server-side component that needs barcode processing requires a separate library. The Scanbot dependency cannot follow the project beyond iOS and Android.

IronBarcode Approach

In a MAUI project, IronBarcode works with the platform's MediaPicker to capture photos and read barcodes from the resulting images. The scanning workflow uses the system camera rather than a custom viewfinder:

// Works on iOS, Android, Windows, and macOS MAUI targets
// NuGet: dotnet add package IronBarcode
using IronBarCode;

private async void ScanButton_Clicked(object sender, EventArgs e)
{
    var photo = await MediaPicker.CapturePhotoAsync();
    if (photo == null) return;

    using var stream = await photo.OpenReadAsync();
    using var ms = new MemoryStream();
    await stream.CopyToAsync(ms);

    var results = BarcodeReader.Read(ms.ToArray());
    foreach (var result in results)
        await DisplayAlert("Scanned", $"{result.Format}: {result.Value}", "OK");
}

// Works on iOS, Android, Windows, and macOS MAUI targets
// NuGet: dotnet add package IronBarcode
using IronBarCode;

private async void ScanButton_Clicked(object sender, EventArgs e)
{
    var photo = await MediaPicker.CapturePhotoAsync();
    if (photo == null) return;

    using var stream = await photo.OpenReadAsync();
    using var ms = new MemoryStream();
    await stream.CopyToAsync(ms);

    var results = BarcodeReader.Read(ms.ToArray());
    foreach (var result in results)
        await DisplayAlert("Scanned", $"{result.Format}: {result.Value}", "OK");
}

Imports IronBarCode

Private Async Sub ScanButton_Clicked(sender As Object, e As EventArgs)
    Dim photo = Await MediaPicker.CapturePhotoAsync()
    If photo Is Nothing Then Return

    Using stream = Await photo.OpenReadAsync()
        Using ms As New MemoryStream()
            Await stream.CopyToAsync(ms)

            Dim results = BarcodeReader.Read(ms.ToArray())
            For Each result In results
                Await DisplayAlert("Scanned", $"{result.Format}: {result.Value}", "OK")
            Next
        End Using
    End Using
End Sub

The trade is the live viewfinder overlay. The user sees the system camera UI rather than a custom scan region, which is adequate for business applications where point-and-capture is sufficient. The .NET MAUI barcode scanner tutorial covers the full MAUI integration pattern for iOS and Android targets including permission handling and project configuration.

Scanbot Approach

Scanbot operates on a yearly flat fee model. The annual license cost is fixed regardless of scan volume — 100 scans per year or 10 million scans per year, the fee is the same. This provides predictable annual budgeting for teams with stable mobile-only deployments. Exact pricing requires contacting Scanbot's sales team; published figures are not available. The annual renewal obligation means the license is an ongoing operational cost.

IronBarcode Approach

IronBarcode is sold as a one-time perpetual purchase at four tiers: Lite at $749, Plus at $1,499, Professional at $2,999, and Unlimited at $5,999. There is no annual renewal requirement for continued use of the purchased version. Software updates within the license period are included. Pricing is published on the Iron Software website without requiring a sales conversation.

Server-Side and Backend Processing

A mobile app built with Scanbot often exists alongside a server-side component that handles document uploads, batch jobs, or API endpoints. When that server-side component needs barcode processing — extracting barcodes from uploaded PDFs, validating barcode values in incoming documents, or processing barcode data from image attachments — Scanbot is not available. The package does not compile in ASP.NET Core, Azure Functions, console applications, or any non-MAUI project. Teams in this situation find themselves maintaining a mobile barcode dependency alongside a separate server-side barcode solution, or evaluating whether IronBarcode can cover both roles with a single package.

Desktop Application Requirements

MAUI's value proposition is often cross-platform coverage: a single codebase that targets iOS, Android, and Windows. When the Windows MAUI target enters the roadmap — either from initial requirements or as a later addition — Scanbot's package fails to resolve on that target. The Windows build cannot proceed with Scanbot in the dependency list. Teams discover this during the first attempt to build the desktop target, and the resolution requires removing Scanbot from the shared dependency list. For teams where the Windows desktop target is a firm requirement, IronBarcode becomes the only option among mobile-focused barcode libraries that also covers the desktop platform.

PDF and Document Workflows

Applications that move from live scanning toward document automation encounter a capability boundary with Scanbot. Reading barcodes from a PDF invoice, extracting tracking codes from a scanned shipping label image, or processing barcode data from an archived document — none of these workflows are possible within the Scanbot model, because the input must always be a live camera feed. IronBarcode handles all of these file-based inputs natively. The same package that runs in the MAUI mobile app can extract barcodes from PDF documents in a background processing job, without any additional dependencies.

Predictable Licensing Costs

Annual renewal costs invite re-evaluation at each renewal cycle. Teams that started with Scanbot under a small-scale mobile deployment and expanded into a broader deployment with more users or platforms may find the annual fee less favorable as scope grows. IronBarcode's one-time perpetual model eliminates the renewal obligation. Teams performing license renewal evaluations often consider whether a one-time purchase aligns better with their long-term cost planning, particularly when the expanded project scope includes server-side or desktop platforms that fall outside Scanbot's coverage anyway.

No Live Viewfinder Equivalent

Scanbot's real-time camera viewfinder — with the scan region overlay, continuous detection, and haptic feedback — has no direct equivalent in IronBarcode. The replacement pattern uses MAUI's MediaPicker.CapturePhotoAsync() to open the system camera, capture a photo, and return the image for processing. The user experience is a photo capture flow rather than a continuous scanning flow. For business applications (inventory, logistics, document processing), this distinction is rarely significant. For consumer apps where the live overlay is central to the product experience, this is a genuine UX difference that should be evaluated before committing to the migration.

Event Callback Pattern to Direct Return

Scanbot's BarcodeScanner.Open() is async and returns an OperationResult with a status field and a Barcodes collection. IronBarcode's BarcodeReader.Read() returns a collection directly — there is no wrapper object with a status field. The success check changes from result.Status == OperationResult.Ok to results.Any() or a null check on results.FirstOrDefault().

Format Enum Namespace Change

Scanbot's BarcodeFormat enum (for example, BarcodeFormat.Code128) and IronBarcode's BarcodeEncoding enum (for example, BarcodeEncoding.Code128) contain similar members but are different types in different namespaces. Code that stores or compares format values by enum type requires the type reference updated. String comparisons based on .ToString() output are generally compatible since the member names are similar, but explicit enum type comparisons require updating to BarcodeEncoding values.

Windows Build Additions

If the Scanbot package was causing Windows MAUI build failures before the migration, removing it resolves those failures. After adding IronBarcode, verify that Windows-specific capabilities — file picker dialogs, local file paths, Windows permissions — are handled appropriately in the MAUI app code, since these differ from iOS and Android file access patterns.