What are the key differences between Dynamsoft Barcode Reader and IronBarcode?

Dynamsoft Barcode Reader is optimized for live camera scanning with real-time processing, suitable for mobile SDKs on iOS and Android, and requires internet-based license activation. IronBarcode, on the other hand, excels in server-side file processing with native PDF support, offline license validation, and a static API that simplifies document processing workflows.

How does IronBarcode handle PDF barcode reading compared to Dynamsoft?

IronBarcode reads barcodes directly from PDF files without the need for additional libraries or rendering loops, streamlining the process. Dynamsoft often requires pre-rendering PDF pages to images, adding dependencies such as PdfiumViewer and extra operational overhead.

Can IronBarcode be used in environments with restricted internet access?

Yes, IronBarcode is designed to operate fully offline with local license validation. This makes it ideal for deployments in air-gapped environments where internet access is restricted, unlike Dynamsoft which requires online license activation or a complex offline license-bundle workflow.

Does IronBarcode require a separate library for barcode generation?

No, IronBarcode includes support for both barcode reading and generation, unlike Dynamsoft Barcode Reader which is primarily focused on reading and requires a separate library for generation.

What is the licensing process for IronBarcode?

IronBarcode utilizes a straightforward license key assignment that is evaluated locally without requiring network access, simplifying the licensing process significantly compared to Dynamsoft's online license activation and periodic online re-validation.

Which barcode formats are supported by IronBarcode?

IronBarcode supports a wide range of barcode formats, including Code 128, QR codes, Data Matrix, PDF417, Aztec, EAN, and UPC, among others.

How does IronBarcode compare in containerized environments like Docker?

IronBarcode is well-suited for use in containerized environments such as Docker, as it requires only a single license variable without the need for recurring license-bundle refreshes, in contrast to Dynamsoft's licensing workflows which can be cumbersome in these environments.

Is IronBarcode compatible with .NET platforms?

Yes, IronBarcode supports .NET platforms ranging from .NET 4.6.2 through .NET 9, making it versatile for a variety of .NET applications.

Why might a team choose IronBarcode over Dynamsoft Barcode Reader for server-side processing?

Teams might choose IronBarcode for its native PDF support, offline capabilities, reduced dependencies, and a static API that aligns better with server-side document processing needs without the need for camera-specific optimizations, which are central to Dynamsoft's architecture.

Can IronBarcode be used to generate QR codes with error correction and logos?

Yes, IronBarcode can generate QR codes with different levels of error correction and embed logos, providing robust capabilities for creating high-quality QR codes tailored to specific branding and data integrity requirements.

The C# Barcode Library

Explore IronBarcode Start Free Trial

Barcode Quickstart

See All Code Examples

using IronBarCode;
using System.Drawing;

// Reading a barcode is easy with IronBarcode!
var resultFromFile = BarcodeReader.Read(@"file/barcode.png"); // From a file
var resultFromBitMap = BarcodeReader.Read(new Bitmap("barcode.bmp")); // From a bitmap
var resultFromImage = BarcodeReader.Read(Image.FromFile("barcode.jpg")); // From an image file
var resultFromPdf = BarcodeReader.ReadPdf(@"file/mydocument.pdf"); // From PDF use ReadPdf

// To configure and fine-tune barcode reading, utilize the BarcodeReaderOptions class
var myOptionsExample = new BarcodeReaderOptions
{
    // Choose a reading speed from: Faster, Balanced, Detailed, ExtremeDetail
    // There is a tradeoff in performance as more detail is set
    Speed = ReadingSpeed.Balanced,

    // Reader will stop scanning once a single barcode is found (if set to true)
    ExpectMultipleBarcodes = true,

    // By default, all barcode formats are scanned for
    // Specifying a subset of barcode types to search for would improve performance
    ExpectBarcodeTypes = BarcodeEncoding.AllOneDimensional,

    // Utilize multiple threads to read barcodes from multiple images in parallel
    Multithreaded = true,

    // Maximum threads for parallelized barcode reading
    // Default is 4
    MaxParallelThreads = 2,

    // The area of each image frame in which to scan for barcodes
    // Specifying a crop area will significantly improve performance and avoid noisy parts of the image
    CropArea = new Rectangle(),

    // Special setting for Code39 barcodes
    // If a Code39 barcode is detected, try to read with both the base and extended ASCII character sets
    UseCode39ExtendedMode = true
};

// Read with the options applied
var results = BarcodeReader.Read("barcode.png", myOptionsExample);

// Create a barcode with one line of code
var myBarcode = BarcodeWriter.CreateBarcode("12345", BarcodeWriterEncoding.EAN8);

// After creating a barcode, we may choose to resize
myBarcode.ResizeTo(400, 100);

// Save our newly-created barcode as an image
myBarcode.SaveAsImage("EAN8.jpeg");

// Get the barcode as an image for further processing
var myBarcodeImage = myBarcode.Image;

using IronBarCode;
using System.Drawing;

// Reading a barcode is easy with IronBarcode!
var resultFromFile = BarcodeReader.Read(@"file/barcode.png"); // From a file
var resultFromBitMap = BarcodeReader.Read(new Bitmap("barcode.bmp")); // From a bitmap
var resultFromImage = BarcodeReader.Read(Image.FromFile("barcode.jpg")); // From an image file
var resultFromPdf = BarcodeReader.ReadPdf(@"file/mydocument.pdf"); // From PDF use ReadPdf

// To configure and fine-tune barcode reading, utilize the BarcodeReaderOptions class
var myOptionsExample = new BarcodeReaderOptions
{
    // Choose a reading speed from: Faster, Balanced, Detailed, ExtremeDetail
    // There is a tradeoff in performance as more detail is set
    Speed = ReadingSpeed.Balanced,

    // Reader will stop scanning once a single barcode is found (if set to true)
    ExpectMultipleBarcodes = true,

    // By default, all barcode formats are scanned for
    // Specifying a subset of barcode types to search for would improve performance
    ExpectBarcodeTypes = BarcodeEncoding.AllOneDimensional,

    // Utilize multiple threads to read barcodes from multiple images in parallel
    Multithreaded = true,

    // Maximum threads for parallelized barcode reading
    // Default is 4
    MaxParallelThreads = 2,

    // The area of each image frame in which to scan for barcodes
    // Specifying a crop area will significantly improve performance and avoid noisy parts of the image
    CropArea = new Rectangle(),

    // Special setting for Code39 barcodes
    // If a Code39 barcode is detected, try to read with both the base and extended ASCII character sets
    UseCode39ExtendedMode = true
};

// Read with the options applied
var results = BarcodeReader.Read("barcode.png", myOptionsExample);

// Create a barcode with one line of code
var myBarcode = BarcodeWriter.CreateBarcode("12345", BarcodeWriterEncoding.EAN8);

// After creating a barcode, we may choose to resize
myBarcode.ResizeTo(400, 100);

// Save our newly-created barcode as an image
myBarcode.SaveAsImage("EAN8.jpeg");

// Get the barcode as an image for further processing
var myBarcodeImage = myBarcode.Image;

PM >Install-Package BarCode

Install-Package BarCode

COMPARE TO OTHER COMPONENTS

Dynamsoft Barcode Reader vs IronBarcode: C# Barcode Library Comparison

Curtis Chau

Updated: August 1, 2026

Dynamsoft Barcode Reader is genuinely excellent at what it was designed for: reading barcodes from a live camera feed at 30 frames per second. The algorithms are fast, the symbology support is broad, and the mobile SDK that wraps it on iOS and Android is one of the better choices in that space. If your product is a warehouse scanning app where a worker points a phone at a pallet label and expects sub-100ms recognition, Dynamsoft is a credible option.

If your barcodes are in PDF files on a server that cannot reach the internet, the library is mismatched to the use case - and the license activation will remind you the first time you deploy. LicenseManager.InitLicense performs an online handshake with Dynamsoft's license server on first activation and re-validates periodically. In an air-gapped datacenter, an isolated VPC, or any environment where outbound internet access is restricted, that first activation needs an alternative. The offline path - obtaining a license-content blob from Dynamsoft and replaying it via InitLicenseFromLicenseContent - works, but adds operational overhead that most document processing workflows did not budget for.

This comparison is about use-case fit, not library quality. Dynamsoft built a camera-first library and built it well. The question is whether the camera-first assumptions translate to a server-side document processing workflow.

Understanding Dynamsoft Barcode Reader

Dynamsoft's architecture reflects its camera origin. The startup sequence requires an online license activation, the settings model includes timeout values appropriate for real-time frame processing, and the API exposes settings tuned for the variable focus and motion blur conditions of a handheld camera:

// Dynamsoft: license activation required at startup
using Dynamsoft.CVR;
using Dynamsoft.DBR;
using Dynamsoft.License;
using Dynamsoft.Core;

// LicenseManager.InitLicense performs an online activation on first run
int errorCode = LicenseManager.InitLicense("YOUR-DYNAMSOFT-LICENSE-KEY", out string errorMsg);
if (errorCode != (int)EnumErrorCode.EC_OK)
    throw new InvalidOperationException($"License activation failed: {errorMsg}");

using var router = new CaptureVisionRouter();

// Settings tuned for camera frame processing
SimplifiedCaptureVisionSettings settings = router.GetSimplifiedSettings(
    PresetTemplate.PT_READ_BARCODES);
settings.BarcodeSettings.ExpectedBarcodesCount = 1; // single barcode per frame
settings.Timeout = 100;                              // 100ms suits a 30fps pipeline
router.UpdateSettings(PresetTemplate.PT_READ_BARCODES, settings);

// Dynamsoft: license activation required at startup
using Dynamsoft.CVR;
using Dynamsoft.DBR;
using Dynamsoft.License;
using Dynamsoft.Core;

// LicenseManager.InitLicense performs an online activation on first run
int errorCode = LicenseManager.InitLicense("YOUR-DYNAMSOFT-LICENSE-KEY", out string errorMsg);
if (errorCode != (int)EnumErrorCode.EC_OK)
    throw new InvalidOperationException($"License activation failed: {errorMsg}");

using var router = new CaptureVisionRouter();

// Settings tuned for camera frame processing
SimplifiedCaptureVisionSettings settings = router.GetSimplifiedSettings(
    PresetTemplate.PT_READ_BARCODES);
settings.BarcodeSettings.ExpectedBarcodesCount = 1; // single barcode per frame
settings.Timeout = 100;                              // 100ms suits a 30fps pipeline
router.UpdateSettings(PresetTemplate.PT_READ_BARCODES, settings);

Imports Dynamsoft.CVR
Imports Dynamsoft.DBR
Imports Dynamsoft.License
Imports Dynamsoft.Core

' Dynamsoft: license activation required at startup

' LicenseManager.InitLicense performs an online activation on first run
Dim errorCode As Integer = LicenseManager.InitLicense("YOUR-DYNAMSOFT-LICENSE-KEY", errorMsg:=Nothing)
If errorCode <> CType(EnumErrorCode.EC_OK, Integer) Then
    Throw New InvalidOperationException($"License activation failed: {errorMsg}")
End If

Using router As New CaptureVisionRouter()

    ' Settings tuned for camera frame processing
    Dim settings As SimplifiedCaptureVisionSettings = router.GetSimplifiedSettings(PresetTemplate.PT_READ_BARCODES)
    settings.BarcodeSettings.ExpectedBarcodesCount = 1 ' single barcode per frame
    settings.Timeout = 100                              ' 100ms suits a 30fps pipeline
    router.UpdateSettings(PresetTemplate.PT_READ_BARCODES, settings)
End Using

Imports Dynamsoft.CVR
Imports Dynamsoft.DBR
Imports Dynamsoft.License
Imports Dynamsoft.Core

' Dynamsoft: license activation required at startup

' LicenseManager.InitLicense performs an online activation on first run
Dim errorCode As Integer = LicenseManager.InitLicense("YOUR-DYNAMSOFT-LICENSE-KEY", errorMsg:=Nothing)
If errorCode <> CType(EnumErrorCode.EC_OK, Integer) Then
    Throw New InvalidOperationException($"License activation failed: {errorMsg}")
End If

Using router As New CaptureVisionRouter()

    ' Settings tuned for camera frame processing
    Dim settings As SimplifiedCaptureVisionSettings = router.GetSimplifiedSettings(PresetTemplate.PT_READ_BARCODES)
    settings.BarcodeSettings.ExpectedBarcodesCount = 1 ' single barcode per frame
    settings.Timeout = 100                              ' 100ms suits a 30fps pipeline
    router.UpdateSettings(PresetTemplate.PT_READ_BARCODES, settings)
End Using

This is a well-designed API for its purpose. The Timeout = 100 setting makes sense when you are processing 30 frames per second from a camera and cannot afford to spend 500ms on a single frame. For a server processing an uploaded PDF, a 100ms timeout serves no purpose and can cause reads to fail on denser barcodes.

The router-and-session design - new CaptureVisionRouter(), router.Dispose() - follows camera session semantics: you open a router, process frames, dispose. For file processing, this lifecycle adds boilerplate without benefit.

The PDF Problem

Dynamsoft Barcode Reader can accept some PDF inputs directly on Windows builds, but for cross-platform deployments many teams still pre-render each PDF page to an image before passing it to CaptureVisionRouter.Capture. This typically pulls in a separate PDF rendering library - PdfiumViewer is commonly used - which adds a NuGet dependency, a native binary dependency (pdfium.dll on Windows or libpdfium on Linux), and a render loop around every PDF operation:

// Dynamsoft PDF processing — typical cross-platform pattern with PdfiumViewer
// dotnet add package PdfiumViewer
using PdfiumViewer;
using System.Drawing.Imaging;
using Dynamsoft.CVR;
using Dynamsoft.DBR;

public List<string> ReadBarcodesFromPdf(string pdfPath)
{
    var results = new List<string>();

    using (var pdfDoc = PdfDocument.Load(pdfPath))
    using (var router = new CaptureVisionRouter())
    {
        for (int page = 0; page < pdfDoc.PageCount; page++)
        {
            // Render each page at 300 DPI
            using var image = pdfDoc.Render(page, 300, 300, true);
            using var ms = new MemoryStream();
            image.Save(ms, ImageFormat.Png);
            byte[] imageBytes = ms.ToArray();

            // Now pass rendered image bytes to the Capture Vision Router
            CapturedResult result = router.Capture(imageBytes,
                PresetTemplate.PT_READ_BARCODES);
            foreach (var item in result.GetDecodedBarcodesResult().GetItems())
                results.Add(item.GetText());
        }
    }

    return results;
}

// Dynamsoft PDF processing — typical cross-platform pattern with PdfiumViewer
// dotnet add package PdfiumViewer
using PdfiumViewer;
using System.Drawing.Imaging;
using Dynamsoft.CVR;
using Dynamsoft.DBR;

public List<string> ReadBarcodesFromPdf(string pdfPath)
{
    var results = new List<string>();

    using (var pdfDoc = PdfDocument.Load(pdfPath))
    using (var router = new CaptureVisionRouter())
    {
        for (int page = 0; page < pdfDoc.PageCount; page++)
        {
            // Render each page at 300 DPI
            using var image = pdfDoc.Render(page, 300, 300, true);
            using var ms = new MemoryStream();
            image.Save(ms, ImageFormat.Png);
            byte[] imageBytes = ms.ToArray();

            // Now pass rendered image bytes to the Capture Vision Router
            CapturedResult result = router.Capture(imageBytes,
                PresetTemplate.PT_READ_BARCODES);
            foreach (var item in result.GetDecodedBarcodesResult().GetItems())
                results.Add(item.GetText());
        }
    }

    return results;
}

Imports PdfiumViewer
Imports System.Drawing.Imaging
Imports Dynamsoft.CVR
Imports Dynamsoft.DBR
Imports System.IO

Public Function ReadBarcodesFromPdf(pdfPath As String) As List(Of String)
    Dim results As New List(Of String)()

    Using pdfDoc = PdfDocument.Load(pdfPath)
        Using router = New CaptureVisionRouter()
            For page As Integer = 0 To pdfDoc.PageCount - 1
                ' Render each page at 300 DPI
                Using image = pdfDoc.Render(page, 300, 300, True)
                    Using ms As New MemoryStream()
                        image.Save(ms, ImageFormat.Png)
                        Dim imageBytes As Byte() = ms.ToArray()

                        ' Now pass rendered image bytes to the Capture Vision Router
                        Dim result As CapturedResult = router.Capture(imageBytes, PresetTemplate.PT_READ_BARCODES)
                        For Each item In result.GetDecodedBarcodesResult().GetItems()
                            results.Add(item.GetText())
                        Next
                    End Using
                End Using
            Next
        End Using
    End Using

    Return results
End Function

Imports PdfiumViewer
Imports System.Drawing.Imaging
Imports Dynamsoft.CVR
Imports Dynamsoft.DBR
Imports System.IO

Public Function ReadBarcodesFromPdf(pdfPath As String) As List(Of String)
    Dim results As New List(Of String)()

    Using pdfDoc = PdfDocument.Load(pdfPath)
        Using router = New CaptureVisionRouter()
            For page As Integer = 0 To pdfDoc.PageCount - 1
                ' Render each page at 300 DPI
                Using image = pdfDoc.Render(page, 300, 300, True)
                    Using ms As New MemoryStream()
                        image.Save(ms, ImageFormat.Png)
                        Dim imageBytes As Byte() = ms.ToArray()

                        ' Now pass rendered image bytes to the Capture Vision Router
                        Dim result As CapturedResult = router.Capture(imageBytes, PresetTemplate.PT_READ_BARCODES)
                        For Each item In result.GetDecodedBarcodesResult().GetItems()
                            results.Add(item.GetText())
                        Next
                    End Using
                End Using
            Next
        End Using
    End Using

    Return results
End Function

That is three dependencies (Dynamsoft, PdfiumViewer, and a platform-specific native binary), a per-page render loop, and memory overhead that scales with page count.

IronBarcode reads directly from a PDF file:

// IronBarcode: PDF is native — no extra library, no render loop
// NuGet: dotnet add package BarCode
var results = BarcodeReader.Read("invoice.pdf");
foreach (var result in results)
{
    Console.WriteLine($"{result.Format}: {result.Value}");
}

// IronBarcode: PDF is native — no extra library, no render loop
// NuGet: dotnet add package BarCode
var results = BarcodeReader.Read("invoice.pdf");
foreach (var result in results)
{
    Console.WriteLine($"{result.Format}: {result.Value}");
}

Imports IronBarCode

' IronBarcode: PDF is native — no extra library, no render loop
' NuGet: dotnet add package BarCode
Dim results = BarcodeReader.Read("invoice.pdf")
For Each result In results
    Console.WriteLine($"{result.Format}: {result.Value}")
Next

Imports IronBarCode

' IronBarcode: PDF is native — no extra library, no render loop
' NuGet: dotnet add package BarCode
Dim results = BarcodeReader.Read("invoice.pdf")
For Each result In results
    Console.WriteLine($"{result.Format}: {result.Value}")
Next

One call. No PDF renderer. No per-page loop. No platform-specific native binary for PDF support.

License Complexity

Online license activation is straightforward when the server has internet access. When it does not - or when network policies require explicit allowlisting of outbound hosts - the validation failure surface area grows:

// Dynamsoft: error code pattern required
int errorCode = LicenseManager.InitLicense("YOUR-DYNAMSOFT-LICENSE-KEY", out string errorMsg);
if (errorCode != (int)EnumErrorCode.EC_OK)
{
    // Possible causes: network timeout, license server unreachable,
    // invalid key, expired key, activation quota exceeded, etc.
    throw new InvalidOperationException($"Dynamsoft license failed [{errorCode}]: {errorMsg}");
}

// Dynamsoft: error code pattern required
int errorCode = LicenseManager.InitLicense("YOUR-DYNAMSOFT-LICENSE-KEY", out string errorMsg);
if (errorCode != (int)EnumErrorCode.EC_OK)
{
    // Possible causes: network timeout, license server unreachable,
    // invalid key, expired key, activation quota exceeded, etc.
    throw new InvalidOperationException($"Dynamsoft license failed [{errorCode}]: {errorMsg}");
}

Imports System

' Dynamsoft: error code pattern required
Dim errorCode As Integer = LicenseManager.InitLicense("YOUR-DYNAMSOFT-LICENSE-KEY", errorMsg)
Dim errorMsg As String
If errorCode <> CType(EnumErrorCode.EC_OK, Integer) Then
    ' Possible causes: network timeout, license server unreachable,
    ' invalid key, expired key, activation quota exceeded, etc.
    Throw New InvalidOperationException($"Dynamsoft license failed [{errorCode}]: {errorMsg}")
End If

Imports System

' Dynamsoft: error code pattern required
Dim errorCode As Integer = LicenseManager.InitLicense("YOUR-DYNAMSOFT-LICENSE-KEY", errorMsg)
Dim errorMsg As String
If errorCode <> CType(EnumErrorCode.EC_OK, Integer) Then
    ' Possible causes: network timeout, license server unreachable,
    ' invalid key, expired key, activation quota exceeded, etc.
    Throw New InvalidOperationException($"Dynamsoft license failed [{errorCode}]: {errorMsg}")
End If

Offline licensing with Dynamsoft is a separate workflow. On a connected machine you perform an initial online activation to fetch a license bundle, persist it, then activate the offline machine by replaying that bundle via InitLicenseFromLicenseContent:

// Dynamsoft offline license — replay a pre-fetched license bundle
int errorCode = LicenseManager.InitLicenseFromLicenseContent(
    licenseContent, out string errorMsg);
if (errorCode != (int)EnumErrorCode.EC_OK)
    throw new InvalidOperationException($"Offline activation failed: {errorMsg}");

// Dynamsoft offline license — replay a pre-fetched license bundle
int errorCode = LicenseManager.InitLicenseFromLicenseContent(
    licenseContent, out string errorMsg);
if (errorCode != (int)EnumErrorCode.EC_OK)
    throw new InvalidOperationException($"Offline activation failed: {errorMsg}");

Imports System

' Dynamsoft offline license — replay a pre-fetched license bundle
Dim errorCode As Integer = LicenseManager.InitLicenseFromLicenseContent(licenseContent, errorMsg)
Dim errorMsg As String = Nothing
If errorCode <> CType(EnumErrorCode.EC_OK, Integer) Then
    Throw New InvalidOperationException($"Offline activation failed: {errorMsg}")
End If

Imports System

' Dynamsoft offline license — replay a pre-fetched license bundle
Dim errorCode As Integer = LicenseManager.InitLicenseFromLicenseContent(licenseContent, errorMsg)
Dim errorMsg As String = Nothing
If errorCode <> CType(EnumErrorCode.EC_OK, Integer) Then
    Throw New InvalidOperationException($"Offline activation failed: {errorMsg}")
End If

License bundles obtained this way have an expiry window (typically days to a year) and need refreshing before they lapse, which means a connected machine has to participate in the workflow on a recurring basis.

IronBarcode license activation is a single assignment evaluated locally:

// IronBarCode: local validation, no network required
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";

// IronBarCode: local validation, no network required
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";

' IronBarCode: local validation, no network required
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY"

' IronBarCode: local validation, no network required
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY"

No error code to check. No network dependency. No license-bundle refresh cycle. The same line works on a development machine, in a CI/CD pipeline, in a Docker container, and on an air-gapped server.

Camera vs File Use Cases

Dynamsoft and IronBarcode are optimized for different primary scenarios. The table below describes this rather than declaring one library universally better:

Scenario	Dynamsoft Barcode Reader	IronBarcode
Live camera feed (30fps)	Optimized for real-time	Not the primary use case
Mobile SDK (iOS/Android)	Full SDK available	.NET only
Server-side file processing	Supported via CaptureVisionRouter	Primary use case
PDF barcode reading	Direct on Windows; render loop common cross-platform	Native support
Air-gapped deployment	Requires offline license bundle workflow	Works out of the box
Docker / ephemeral containers	License-bundle refresh per environment	Single env var
Offline license	License-content blob from prior online activation	Standard license key
ASP.NET Core API	Supported (extra license boilerplate)	Supported
Azure Functions	Outbound network for first activation	No network requirement
Barcode generation	Reading only in the Barcode Reader bundle	Yes - generation and reading
QR code generation	Not in the Barcode Reader bundle	Yes - QRCodeWriter

Understanding IronBarcode

IronBarcode is a .NET library for both generating and reading barcodes. The API is static - no instances, no dispose calls, no session lifecycle. License activation is local. PDF support is built in:

// NuGet: dotnet add package BarCode
using IronBarCode;

// License — local validation, no network call
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";

// Read from an image file
var results = BarcodeReader.Read("label.png");
foreach (var result in results)
    Console.WriteLine($"{result.Format}: {result.Value}");

// Read from a PDF — native, no extra library
var pdfResults = BarcodeReader.Read("manifest.pdf");

// Read with options for high-accuracy or high-throughput scenarios
var options = new BarcodeReaderOptions
{
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = true,
    MaxParallelThreads = 4
};
var multiResults = BarcodeReader.Read("multi-barcode-sheet.png", options);

// NuGet: dotnet add package BarCode
using IronBarCode;

// License — local validation, no network call
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY";

// Read from an image file
var results = BarcodeReader.Read("label.png");
foreach (var result in results)
    Console.WriteLine($"{result.Format}: {result.Value}");

// Read from a PDF — native, no extra library
var pdfResults = BarcodeReader.Read("manifest.pdf");

// Read with options for high-accuracy or high-throughput scenarios
var options = new BarcodeReaderOptions
{
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = true,
    MaxParallelThreads = 4
};
var multiResults = BarcodeReader.Read("multi-barcode-sheet.png", options);

Imports IronBarCode

' License — local validation, no network call
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY"

' Read from an image file
Dim results = BarcodeReader.Read("label.png")
For Each result In results
    Console.WriteLine($"{result.Format}: {result.Value}")
Next

' Read from a PDF — native, no extra library
Dim pdfResults = BarcodeReader.Read("manifest.pdf")

' Read with options for high-accuracy or high-throughput scenarios
Dim options As New BarcodeReaderOptions With {
    .Speed = ReadingSpeed.Balanced,
    .ExpectMultipleBarcodes = True,
    .MaxParallelThreads = 4
}
Dim multiResults = BarcodeReader.Read("multi-barcode-sheet.png", options)

Imports IronBarCode

' License — local validation, no network call
IronBarCode.License.LicenseKey = "YOUR-LICENSE-KEY"

' Read from an image file
Dim results = BarcodeReader.Read("label.png")
For Each result In results
    Console.WriteLine($"{result.Format}: {result.Value}")
Next

' Read from a PDF — native, no extra library
Dim pdfResults = BarcodeReader.Read("manifest.pdf")

' Read with options for high-accuracy or high-throughput scenarios
Dim options As New BarcodeReaderOptions With {
    .Speed = ReadingSpeed.Balanced,
    .ExpectMultipleBarcodes = True,
    .MaxParallelThreads = 4
}
Dim multiResults = BarcodeReader.Read("multi-barcode-sheet.png", options)

Generation is equally straightforward:

// Generate Code 128
BarcodeWriter.CreateBarcode("SHIP-7734-X", BarcodeEncoding.Code128)
    .ResizeTo(400, 100)
    .SaveAsPng("shipping-label.png");

// Generate QR with error correction and embedded logo
QRCodeWriter.CreateQrCode("https://track.example.com/7734", 500, QRCodeWriter.QrErrorCorrectionLevel.Highest)
    .AddBrandLogo("company-logo.png")
    .SaveAsPng("tracking-qr.png");

// Get bytes for HTTP response
byte[] bytes = BarcodeWriter.CreateBarcode("ITEM-001", BarcodeEncoding.Code128)
    .ResizeTo(400, 100)
    .ToPngBinaryData();

// Generate Code 128
BarcodeWriter.CreateBarcode("SHIP-7734-X", BarcodeEncoding.Code128)
    .ResizeTo(400, 100)
    .SaveAsPng("shipping-label.png");

// Generate QR with error correction and embedded logo
QRCodeWriter.CreateQrCode("https://track.example.com/7734", 500, QRCodeWriter.QrErrorCorrectionLevel.Highest)
    .AddBrandLogo("company-logo.png")
    .SaveAsPng("tracking-qr.png");

// Get bytes for HTTP response
byte[] bytes = BarcodeWriter.CreateBarcode("ITEM-001", BarcodeEncoding.Code128)
    .ResizeTo(400, 100)
    .ToPngBinaryData();

Imports System

' Generate Code 128
BarcodeWriter.CreateBarcode("SHIP-7734-X", BarcodeEncoding.Code128) _
    .ResizeTo(400, 100) _
    .SaveAsPng("shipping-label.png")

' Generate QR with error correction and embedded logo
QRCodeWriter.CreateQrCode("https://track.example.com/7734", 500, QRCodeWriter.QrErrorCorrectionLevel.Highest) _
    .AddBrandLogo("company-logo.png") _
    .SaveAsPng("tracking-qr.png")

' Get bytes for HTTP response
Dim bytes As Byte() = BarcodeWriter.CreateBarcode("ITEM-001", BarcodeEncoding.Code128) _
    .ResizeTo(400, 100) _
    .ToPngBinaryData()

Imports System

' Generate Code 128
BarcodeWriter.CreateBarcode("SHIP-7734-X", BarcodeEncoding.Code128) _
    .ResizeTo(400, 100) _
    .SaveAsPng("shipping-label.png")

' Generate QR with error correction and embedded logo
QRCodeWriter.CreateQrCode("https://track.example.com/7734", 500, QRCodeWriter.QrErrorCorrectionLevel.Highest) _
    .AddBrandLogo("company-logo.png") _
    .SaveAsPng("tracking-qr.png")

' Get bytes for HTTP response
Dim bytes As Byte() = BarcodeWriter.CreateBarcode("ITEM-001", BarcodeEncoding.Code128) _
    .ResizeTo(400, 100) _
    .ToPngBinaryData()

Feature Comparison

Feature	Dynamsoft Barcode Reader	IronBarcode
Barcode reading	Yes - camera-optimized	Yes - file and document-optimized
Barcode generation	No	Yes
QR code generation	No	Yes - QRCodeWriter
Native PDF support	Direct on Windows; render loop common cross-platform	Yes - BarcodeReader.Read(pdf)
License validation	Online activation + periodic re-check	Local
Air-gapped / offline	License-content blob workflow	Standard key, works offline
Docker / container	License-bundle workflow per environment	Single environment variable
Azure Functions	Outbound network for first activation	No network requirement
AWS Lambda	Outbound network for first activation	No network requirement
Mobile SDK	iOS and Android available	.NET only
Real-time camera (30fps)	Primary design target	Not designed for this
Code 128	Yes	Yes
QR Code	Yes (reading)	Yes (reading and generation)
Data Matrix	Yes	Yes
PDF417	Yes	Yes
Aztec	Yes	Yes
EAN / UPC	Yes	Yes
Instance management	new CaptureVisionRouter() + Dispose()	Static - no instance
Multi-barcode reading	ExpectedBarcodesCount on BarcodeSettings	ExpectMultipleBarcodes = true
Reading speed control	Timeout + template tuning	ReadingSpeed enum
Parallel reading	Manual threading	MaxParallelThreads
Pricing model	Annual subscription / negotiated perpetual	Perpetual from $999
.NET support	.NET 6.0+ and .NET Framework 3.5+	.NET 4.6.2 through .NET 9
Platforms	Windows (x86/x64), Linux (x64)	Windows, Linux, macOS, Docker, Azure, AWS Lambda

API Mapping Reference

For teams that have Dynamsoft code and need to understand how concepts translate:

Dynamsoft Barcode Reader	IronBarcode
`LicenseManager.InitLicense(key, out errorMsg)`	`IronBarCode.License.LicenseKey = "key"`
`errorCode != (int)EnumErrorCode.EC_OK` check	Not needed
`LicenseManager.InitLicenseFromLicenseContent(content, out msg)`	Not needed
`new CaptureVisionRouter()`	Static - no instance
`router.Dispose()`	Not needed
`router.Capture(imagePath, PresetTemplate.PT_READ_BARCODES)`	`BarcodeReader.Read(imagePath)`
`router.Capture(imageBytes, PresetTemplate.PT_READ_BARCODES)`	`BarcodeReader.Read(imageBytes)`
`BarcodeResultItem.GetText()`	`result.Value`
`BarcodeResultItem.GetFormatString()`	`result.Format`
`SimplifiedCaptureVisionSettings` via `GetSimplifiedSettings()`	`new BarcodeReaderOptions { ... }`
`settings.Timeout = 100`	`Speed = ReadingSpeed.Balanced`
`settings.BarcodeSettings.ExpectedBarcodesCount = 1`	`ExpectMultipleBarcodes = false` (default)
`router.UpdateSettings(template, settings)`	Passed as parameter to `Read()`
External PDF library + page render loop	`BarcodeReader.Read("doc.pdf")`

When Teams Switch

Server-side document processing, not camera scanning. The most common migration scenario is a team that chose Dynamsoft based on reputation, integrated it, and then discovered that the camera-centric API and PDF render step made document processing workflows awkward. Reading barcodes from uploaded PDFs in a web application is a core use case that requires extra plumbing in Dynamsoft but is a single call in IronBarcode.

Air-gapped or restricted network environments. Financial institutions, healthcare systems, and government deployments often prohibit outbound internet connections from application servers. Dynamsoft's online activation does not run in those environments without the offline license-bundle workflow, which adds operational steps. Teams in these environments often migrate to IronBarcode specifically because the license validation has no network component.

Docker and Kubernetes ephemeral containers. Containerized deployments where instances scale up and down frequently make recurring license-bundle refreshes awkward to manage. IronBarcode's license key works as a standard environment variable with no per-instance registration.

Need for generation as well as reading. The Dynamsoft Barcode Reader bundle is read-only. Applications that need to generate barcode labels, print QR codes for products, or create shipping manifests with embedded barcodes need a second library. Teams in this situation often consolidate onto IronBarcode to avoid managing two separate barcode dependencies.

Simplified operational footprint. Removing the Dynamsoft license server from the list of external dependencies that must be reachable, removing the PDF rendering library, and replacing router lifecycle management with static calls reduces the number of things that can go wrong in production.

Conclusion

Dynamsoft Barcode Reader is a high-quality library that fits its intended use case well: real-time camera-based barcode scanning, especially in mobile applications. The algorithms are well-tuned for the conditions of handheld scanning - variable lighting, motion blur, partial occlusion. If that is your use case, Dynamsoft competes well.

For server-side document processing - reading barcodes from PDFs, generating barcode labels, running in air-gapped environments, or deploying in ephemeral Docker containers - the library's architecture asks for more setup at each step. The online license activation, the cross-platform PDF render pattern, the camera-optimized timeout settings, and the offline license-bundle workflow are consequences of building for mobile camera use. They are not bugs; they are deliberate design choices for a different context.

IronBarcode is built for the document and server-side context. Local license validation, native PDF reading, static API, and generation support are all first-class features rather than workarounds. The decision comes down to which environment your barcodes actually live in.

Curtis Chau

Chat with engineering team now

Technical Writer

Curtis Chau holds a Bachelor’s degree in Computer Science (Carleton University) and specializes in front-end development with expertise in Node.js, TypeScript, JavaScript, and React. Passionate about crafting intuitive and aesthetically pleasing user interfaces, Curtis enjoys working with modern frameworks and creating well-structured, visually appealing manuals.

...