Scandit SDK vs IronBarcode: C# Barcode Library Comparison

The DataCaptureContext Pipeline

Every Scandit integration begins with this camera initialization sequence before a single barcode can be read:

// Scandit SDK: full camera pipeline setup
// NuGet: Scandit.BarcodePicker

var dataCaptureContext = DataCaptureContext.ForLicenseKey("YOUR-SCANDIT-LICENSE");

var settings = BarcodeCaptureSettings.Create();
settings.EnableSymbologies(new HashSet<Symbology>
{
    Symbology.Ean13Upca,
    Symbology.Ean8,
    Symbology.Code128,
    Symbology.QrCode
});

var barcodeCapture = BarcodeCapture.Create(dataCaptureContext, settings);
var camera = Camera.GetDefaultCamera();
await dataCaptureContext.SetFrameSourceAsync(camera);
await camera.SwitchToDesiredStateAsync(FrameSourceState.On);
barcodeCapture.IsEnabled = true;

// Scandit SDK: full camera pipeline setup
// NuGet: Scandit.BarcodePicker

var dataCaptureContext = DataCaptureContext.ForLicenseKey("YOUR-SCANDIT-LICENSE");

var settings = BarcodeCaptureSettings.Create();
settings.EnableSymbologies(new HashSet<Symbology>
{
    Symbology.Ean13Upca,
    Symbology.Ean8,
    Symbology.Code128,
    Symbology.QrCode
});

var barcodeCapture = BarcodeCapture.Create(dataCaptureContext, settings);
var camera = Camera.GetDefaultCamera();
await dataCaptureContext.SetFrameSourceAsync(camera);
await camera.SwitchToDesiredStateAsync(FrameSourceState.On);
barcodeCapture.IsEnabled = true;

Imports Scandit.DataCapture.Core
Imports Scandit.DataCapture.Barcode
Imports Scandit.DataCapture.Barcode.Capture
Imports Scandit.DataCapture.Core.Source
Imports System.Collections.Generic

' Scandit SDK: full camera pipeline setup
' NuGet: Scandit.BarcodePicker

Dim dataCaptureContext = DataCaptureContext.ForLicenseKey("YOUR-SCANDIT-LICENSE")

Dim settings = BarcodeCaptureSettings.Create()
settings.EnableSymbologies(New HashSet(Of Symbology) From {
    Symbology.Ean13Upca,
    Symbology.Ean8,
    Symbology.Code128,
    Symbology.QrCode
})

Dim barcodeCapture = BarcodeCapture.Create(dataCaptureContext, settings)
Dim camera = Camera.GetDefaultCamera()
Await dataCaptureContext.SetFrameSourceAsync(camera)
Await camera.SwitchToDesiredStateAsync(FrameSourceState.On)
barcodeCapture.IsEnabled = True

Every line in this block is camera infrastructure. There is no file path argument. There is no PDF. There is no stream. The library assumes a running camera before any barcode work can begin.

Detailed Feature Comparison

Scandit SDK Approach

Scandit processes camera frames in real time. The DataCaptureContext holds an active camera session, and BarcodeCapture listens for barcodes in each incoming frame. Barcode results are delivered asynchronously through the BarcodeScanned event. Reading a static image file with Scandit requires adapting the camera pipeline to treat a file as a frame source — a workflow that is not natively supported and requires engineering effort to approximate.

// Scandit SDK: event-callback result delivery
barcodeCapture.BarcodeScanned += (sender, args) =>
{
    foreach (var barcode in args.Session.NewlyRecognizedBarcodes)
    {
        string value = barcode.Data;
        string symbology = barcode.Symbology.ToString();
        ProcessBarcode(value, symbology);
    }
};

// Scandit SDK: event-callback result delivery
barcodeCapture.BarcodeScanned += (sender, args) =>
{
    foreach (var barcode in args.Session.NewlyRecognizedBarcodes)
    {
        string value = barcode.Data;
        string symbology = barcode.Symbology.ToString();
        ProcessBarcode(value, symbology);
    }
};

Imports System

' Scandit SDK: event-callback result delivery
AddHandler barcodeCapture.BarcodeScanned, Sub(sender, args)
    For Each barcode In args.Session.NewlyRecognizedBarcodes
        Dim value As String = barcode.Data
        Dim symbology As String = barcode.Symbology.ToString()
        ProcessBarcode(value, symbology)
    Next
End Sub

The event-driven model is appropriate for continuous live scanning, where barcodes arrive unpredictably in a video stream. For file-based processing, the model introduces unnecessary complexity: the input has a known completion boundary, the camera session never terminates naturally, and the asynchronous callback pattern does not compose well with request-response server architectures.

IronBarcode Approach

IronBarcode treats every input as a discrete document with a deterministic result. The BarcodeReader.Read method accepts a file path, stream, or byte array, performs all detection synchronously, and returns a collection of results. There is no session to open, no frame source to configure, and no event to subscribe to.

// IronBarcode: direct file reading
// NuGet: dotnet add package IronBarcode

IronBarCode.License.LicenseKey = "YOUR-KEY";
var results = BarcodeReader.Read("barcode.png");
foreach (var result in results)
    Console.WriteLine($"{result.Value} ({result.Format})");

// IronBarcode: direct file reading
// NuGet: dotnet add package IronBarcode

IronBarCode.License.LicenseKey = "YOUR-KEY";
var results = BarcodeReader.Read("barcode.png");
foreach (var result in results)
    Console.WriteLine($"{result.Value} ({result.Format})");

' IronBarcode: direct file reading
' NuGet: dotnet add package IronBarcode

IronBarCode.License.LicenseKey = "YOUR-KEY"
Dim results = BarcodeReader.Read("barcode.png")
For Each result In results
    Console.WriteLine($"{result.Value} ({result.Format})")
Next

For reading barcodes from images, the stateless API requires no initialization beyond the license key. Format detection is automatic. The complete program above reads any supported barcode format from an image file in three lines of operational code.

Scandit SDK Approach

Scandit's architecture requires camera hardware and a mobile platform that can expose it through a native camera API. iOS and Android are the primary supported targets. Windows desktop is a secondary target. ASP.NET Core, Azure Functions, Docker containers, and Linux servers are outside the design scope of the library. The DataCaptureContext assumes a running camera session, which has no equivalent in serverless compute environments, containerized deployments, or background processing services.

IronBarcode Approach

IronBarcode was built for server, cloud, and containerized environments. The stateless API has no hardware dependencies and no platform-specific initialization requirements. Deploying to Azure Functions for barcode processing is a supported, documented path. Docker on Linux is a standard deployment target. ASP.NET Core endpoints reading barcodes from uploaded files represent a core supported scenario with no architectural workarounds required.

Scandit SDK Approach

Scandit's camera pipeline was designed for a single camera session serving a single user or device. The FrameSourceState model assumes a persistent, continuous camera session — not a queue of documents being processed at throughput. Adapting the library to process batches of files requires simulating a camera session per document or serializing document processing through a shared pipeline, neither of which represents a supported or efficient pattern.

IronBarcode Approach

Because IronBarcode's BarcodeReader.Read method is stateless, it is inherently safe to call from multiple threads simultaneously. Concurrent batch processing requires no special configuration beyond defining BarcodeReaderOptions:

// IronBarcode: concurrent batch processing
var options = new BarcodeReaderOptions
{
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = true,
    MaxParallelThreads = 4
};

var files = Directory.GetFiles("./incoming/", "*.pdf");
var allResults = new ConcurrentBag<BarcodeResult>();

Parallel.ForEach(files, file =>
{
    var results = BarcodeReader.Read(file, options);
    foreach (var r in results)
        allResults.Add(r);
});

// IronBarcode: concurrent batch processing
var options = new BarcodeReaderOptions
{
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = true,
    MaxParallelThreads = 4
};

var files = Directory.GetFiles("./incoming/", "*.pdf");
var allResults = new ConcurrentBag<BarcodeResult>();

Parallel.ForEach(files, file =>
{
    var results = BarcodeReader.Read(file, options);
    foreach (var r in results)
        allResults.Add(r);
});

Imports System.IO
Imports System.Collections.Concurrent
Imports System.Threading.Tasks

' IronBarcode: concurrent batch processing
Dim options As New BarcodeReaderOptions With {
    .Speed = ReadingSpeed.Balanced,
    .ExpectMultipleBarcodes = True,
    .MaxParallelThreads = 4
}

Dim files = Directory.GetFiles("./incoming/", "*.pdf")
Dim allResults As New ConcurrentBag(Of BarcodeResult)()

Parallel.ForEach(files, Sub(file)
    Dim results = BarcodeReader.Read(file, options)
    For Each r In results
        allResults.Add(r)
    Next
End Sub)

For detailed patterns on async and multithreaded barcode reading, the IronBarcode documentation covers thread-safe patterns and throughput tuning options.

Scandit SDK Approach

Scandit has no native PDF support. Extracting barcodes from a PDF using Scandit requires rendering each PDF page to a raster image using a separate PDF rendering library, then feeding those images through the camera simulation pipeline. This approach introduces an additional dependency, additional licensing cost, and significant engineering effort for a task that is routine in document-processing workflows. Multi-page documents require iterating pages, managing memory for rendered images, and coordinating results across pages manually.

IronBarcode Approach

IronBarcode reads barcodes from PDF documents natively. A file path to a PDF is a valid argument to BarcodeReader.Read, and results include a PageNumber property indicating which page of the document each barcode was found on:

// IronBarcode: extract barcodes from every page of a PDF
var results = BarcodeReader.Read("shipping-manifest.pdf");

foreach (var barcode in results)
{
    Console.WriteLine($"Page {barcode.PageNumber}: {barcode.Value} ({barcode.Format})");
}

// IronBarcode: extract barcodes from every page of a PDF
var results = BarcodeReader.Read("shipping-manifest.pdf");

foreach (var barcode in results)
{
    Console.WriteLine($"Page {barcode.PageNumber}: {barcode.Value} ({barcode.Format})");
}

Imports IronBarcode

' IronBarcode: extract barcodes from every page of a PDF
Dim results = BarcodeReader.Read("shipping-manifest.pdf")

For Each barcode In results
    Console.WriteLine($"Page {barcode.PageNumber}: {barcode.Value} ({barcode.Format})")
Next

For complete guidance on reading barcodes from PDFs, including options for page range selection and multi-barcode extraction, the IronBarcode documentation covers the full range of PDF processing scenarios.

Scandit Approach

Scandit does not publish pricing. The product page lists features and product names — SparkScan, MatrixScan, ID Scanning, AR Overlays, Parser — and routes all inquiries through a sales conversation. The quote process involves explaining the use case, estimating scan volume, specifying devices, discussing support tiers, and negotiating contract length before a cost figure is provided. Reviews on platforms such as G2 and DiscoverSDK consistently note unpredictable costs for small and medium-sized enterprises and challenges with budget forecasting. Each Scandit product line is separately priced and separately contracted, meaning expanded feature access requires additional sales cycles.

IronBarcode Approach

IronBarcode publishes its licensing tiers on the product page without requiring a form submission or sales inquiry:

Licenses are perpetual. There are no per-scan fees, no per-device fees, and no volume thresholds that trigger tier changes. Annual renewal is optional at half the original cost, but the purchased license remains valid without renewal. All features across the single IronBarcode package — reading, generation, PDF support, multi-barcode detection — are included at every tier.

Server-Side Processing Requirements

Teams building ASP.NET Core APIs, background processing services, or Azure Functions encounter Scandit's architecture as a fundamental mismatch from the first line of integration. The DataCaptureContext and camera pipeline assume hardware that does not exist in a server environment. When a project's barcode requirements are entirely server-side — reading from uploaded files, processing document queues, extracting barcode data from incoming PDFs — the camera pipeline adds initialization complexity, async state machine overhead, and platform constraints that contribute nothing to the actual business requirement.

Batch Document Processing

Organizations processing high volumes of barcode-bearing documents — shipping manifests, invoices, inventory records, medical forms — find that Scandit's frame-source model does not compose with document queues. The library was designed for continuous camera sessions, not discrete documents with deterministic start and end points. When document volume grows and parallel processing becomes necessary, the camera pipeline's statefulness becomes an engineering obstacle rather than a feature.

Pricing Transparency

Development teams working on budget proposals, vendor comparisons, or cost-benefit analyses for new projects cannot complete that work with Scandit without entering a sales cycle first. When a project has a defined budget and a defined timeline, the inability to determine license cost without a sales conversation introduces delays and uncertainty that have downstream effects on project planning. Teams evaluating multiple library options simultaneously find that the absence of published pricing makes Scandit difficult to include in a structured comparison.

Reducing Pipeline Complexity

Even when Scandit is already deployed for mobile camera scanning, some teams discover that server-side barcode requirements in the same application require a different tool. The camera pipeline that is appropriate for real-time mobile scanning introduces unnecessary complexity when applied to static document processing. Teams reaching this point often adopt IronBarcode for server-side processing alongside an existing Scandit deployment, rather than attempting to extend the camera pipeline to use cases it was not designed to handle.

Camera Pipeline Has No File Equivalent

The entire DataCaptureContext initialization block — context creation, settings configuration, symbology enablement, camera acquisition, frame source assignment, and state transition — has no equivalent in IronBarcode's file-based API. When migrating server-side integration code, this block is deleted in its entirety. It is not translated; it is removed. The IronBarcode replacement is a license key assignment followed by a BarcodeReader.Read call.

Event Callback to Direct Return

Scandit delivers barcode results through the BarcodeScanned event because live camera scanning is asynchronous by nature. IronBarcode returns results synchronously as a typed collection because file-based reading has a known completion boundary. Migration involves converting event handler logic to standard iteration:

// Scandit callback pattern (removed during migration)
barcodeCapture.BarcodeScanned += (sender, args) =>
{
    foreach (var barcode in args.Session.NewlyRecognizedBarcodes)
        ProcessBarcode(barcode.Data, barcode.Symbology.ToString());
};

// IronBarcode direct return (replacement)
foreach (var result in BarcodeReader.Read("document.png"))
    ProcessBarcode(result.Value, result.Format.ToString());

// Scandit callback pattern (removed during migration)
barcodeCapture.BarcodeScanned += (sender, args) =>
{
    foreach (var barcode in args.Session.NewlyRecognizedBarcodes)
        ProcessBarcode(barcode.Data, barcode.Symbology.ToString());
};

// IronBarcode direct return (replacement)
foreach (var result in BarcodeReader.Read("document.png"))
    ProcessBarcode(result.Value, result.Format.ToString());

Imports System

' Scandit callback pattern (removed during migration)
AddHandler barcodeCapture.BarcodeScanned, Sub(sender, args)
    For Each barcode In args.Session.NewlyRecognizedBarcodes
        ProcessBarcode(barcode.Data, barcode.Symbology.ToString())
    Next
End Sub

' IronBarcode direct return (replacement)
For Each result In BarcodeReader.Read("document.png")
    ProcessBarcode(result.Value, result.Format.ToString())
Next

Symbology Declaration Removal

Scandit requires explicit EnableSymbologies calls before scanning begins. IronBarcode does not require symbology pre-declaration — all formats are detected automatically. During migration, all settings.EnableSymbologies(...) calls are removed. If the original Scandit code was restricting symbologies for performance reasons, equivalent optimization in IronBarcode is available through BarcodeReaderOptions.ExpectBarcodeTypes, but it is not required to get started.