1. IronBarcode
  2. How-Tos
  3. Checksum & Format Validation

How to Validate Barcode Checksums and Use Format-Aware Reading in C#

Darrius Serrant
Darrius Serrant
Updated:

Barcode checksums exist to catch substitution errors — a single transposed digit in an EAN-13 label can route a package to the wrong warehouse. Format-aware reading adds a second validation layer: constraining the decoder to expected symbologies eliminates false positives from background noise and reduces scan time by skipping irrelevant format detectors.

IronBarcode handles checksum verification implicitly during decode — every symbology's check-digit algorithm runs automatically, and barcodes that fail verification are discarded before results reach calling code. The BarcodeReaderOptions.ExpectBarcodeTypes property constrains reads to specific formats, and RemoveFalsePositive adds a secondary verification pass. This article covers checksum behavior, format-constrained reading, and the combined validation pattern.

Quickstart: Validate Barcodes with Checksum and Format Constraints

Configure BarcodeReaderOptions with ExpectBarcodeTypes and RemoveFalsePositive to constrain reads to expected symbologies with automatic checksum verification.

  1. Install IronBarcode with NuGet Package Manager

    PM > Install-Package BarCode

  2. Copy and run this code snippet.

    using IronBarCode;

// Format-constrained read with false-positive removal
var options = new BarcodeReaderOptions
{
    ExpectBarcodeTypes = BarcodeEncoding.EAN13 | BarcodeEncoding.Code128,
    RemoveFalsePositive = true,
    Speed = ReadingSpeed.Balanced
};

BarcodeResults results = BarcodeReader.Read("label.png", options);

  3. Deploy to test on your live environment

    Start using IronBarcode in your project today with a free trial

    arrow pointer

Minimal Workflow (5 steps)

  1. Download the IronBarcode library from NuGet
  2. Create a BarcodeReaderOptions instance
  3. Set ExpectBarcodeTypes to the symbologies present in the pipeline
  4. Enable RemoveFalsePositive for secondary verification
  5. Call BarcodeReader.Read() — checksums are validated automatically during decode

How to Validate Barcode Checksums?

IronBarcode validates checksums at decode time as part of each symbology's specification. When the library reads an EAN-13 barcode, the Mod10 check digit is computed from the first 12 digits and compared against the 13th. A mismatch causes the barcode to be silently rejected — it never appears in the BarcodeResults collection. The same principle applies to every format with a mandatory check digit: UPC-A, UPC-E, EAN-8, Code128, ITF, and others.

This implicit model differs from libraries that expose an explicit toggle. The table below compares the two approaches:

Checksum Validation Model Comparison — IronBarcode vs. Aspose.BarCode
AspectIronBarcodeAspose.BarCode
Validation triggerAutomatic — runs during every decodeExplicit — ChecksumValidation.On / Off / Default
Developer action requiredNone — invalid barcodes are excluded from resultsMust set BarcodeSettings.ChecksumValidation before reading
Disable checksum?Not exposed — checksums are always enforced for mandatory formatsYes — ChecksumValidation.Off skips verification
Optional-checksum formats (Code39)Reader uses Confidence + RemoveFalsePositive to filter low-quality readsMust explicitly enable with EnableChecksum.Yes
Failure behaviorBarcode silently omitted from resultsBarcode may appear with separate checksum value for manual inspection

The practical consequence: calling code that receives a BarcodeResult from IronBarcode can trust that the check digit is valid for any format with a mandatory checksum. There is no configuration step to forget and no flag to accidentally leave in the wrong state.

For symbologies where checksums are optional — Code39 being the primary example — the library relies on confidence scoring and the RemoveFalsePositive mechanism rather than an explicit checksum toggle. The Confidence property on each BarcodeResult reports how reliably the barcode was decoded, and the ConfidenceThreshold on BarcodeReaderOptions (default 0.7) sets the ML-detection floor.

//:path=/static-assets/barcode/content-code-examples/how-to/checksum-and-format-validation/checksum-confidence.cs
using IronBarCode;

var options = new BarcodeReaderOptions
{
    ExpectBarcodeTypes = BarcodeEncoding.AllOneDimensional,
    RemoveFalsePositive = true,
    ConfidenceThreshold = 0.85,
    Speed = ReadingSpeed.Detailed
};

BarcodeResults results = BarcodeReader.Read("warehouse-rack.png", options);

foreach (BarcodeResult result in results)
{
    // Every result here has passed checksum validation (mandatory formats)
    // and exceeded the 85% confidence threshold (all formats)
    Console.WriteLine($"[{result.BarcodeType}] {result.Value} — Confidence: {result.Confidence}%");
}

if (results.Count == 0)
{
    Console.Error.WriteLine("No valid barcodes found. Possible causes:");
    Console.Error.WriteLine("  - Check digit mismatch (barcode silently rejected)");
    Console.Error.WriteLine("  - Confidence below 85% threshold");
    Console.Error.WriteLine("  - Format not in ExpectBarcodeTypes");
}
//:path=/static-assets/barcode/content-code-examples/how-to/checksum-and-format-validation/checksum-confidence.cs
using IronBarCode;

var options = new BarcodeReaderOptions
{
    ExpectBarcodeTypes = BarcodeEncoding.AllOneDimensional,
    RemoveFalsePositive = true,
    ConfidenceThreshold = 0.85,
    Speed = ReadingSpeed.Detailed
};

BarcodeResults results = BarcodeReader.Read("warehouse-rack.png", options);

foreach (BarcodeResult result in results)
{
    // Every result here has passed checksum validation (mandatory formats)
    // and exceeded the 85% confidence threshold (all formats)
    Console.WriteLine($"[{result.BarcodeType}] {result.Value} — Confidence: {result.Confidence}%");
}

if (results.Count == 0)
{
    Console.Error.WriteLine("No valid barcodes found. Possible causes:");
    Console.Error.WriteLine("  - Check digit mismatch (barcode silently rejected)");
    Console.Error.WriteLine("  - Confidence below 85% threshold");
    Console.Error.WriteLine("  - Format not in ExpectBarcodeTypes");
}
Imports IronBarCode

Dim options As New BarcodeReaderOptions With {
    .ExpectBarcodeTypes = BarcodeEncoding.AllOneDimensional,
    .RemoveFalsePositive = True,
    .ConfidenceThreshold = 0.85,
    .Speed = ReadingSpeed.Detailed
}

Dim results As BarcodeResults = BarcodeReader.Read("warehouse-rack.png", options)

For Each result As BarcodeResult In results
    ' Every result here has passed checksum validation (mandatory formats)
    ' and exceeded the 85% confidence threshold (all formats)
    Console.WriteLine($"[{result.BarcodeType}] {result.Value} — Confidence: {result.Confidence}%")
Next

If results.Count = 0 Then
    Console.Error.WriteLine("No valid barcodes found. Possible causes:")
    Console.Error.WriteLine("  - Check digit mismatch (barcode silently rejected)")
    Console.Error.WriteLine("  - Confidence below 85% threshold")
    Console.Error.WriteLine("  - Format not in ExpectBarcodeTypes")
End If
$vbLabelText   $csharpLabel

Raising ConfidenceThreshold above the 0.7 default is the closest equivalent to "stricter checksum enforcement" for optional-checksum symbologies. Barcodes that decode but fall below the threshold are excluded from results, providing a tunable quality gate that complements the fixed checksum verification.

How to Use Format-Aware Barcode Reading?

The BarcodeEncoding enum is a flags type — multiple formats can be combined with the bitwise OR operator. Setting ExpectBarcodeTypes restricts the reader to those formats, skipping detection routines for all others.

Common BarcodeEncoding Values
ValueCategoryDescriptionChecksum
BarcodeEncoding.AllMetaScan for all supported formats (default)Per-format
BarcodeEncoding.AllOneDimensionalMetaAll linear (1D) formats including stackedPer-format
BarcodeEncoding.AllTwoDimensionalMetaAll matrix/grid (2D) formatsPer-format
BarcodeEncoding.Code1281DHigh-density alphanumeric — logistics, shippingMandatory (weighted Mod103)
BarcodeEncoding.EAN131DRetail product identification — 13 digitsMandatory (Mod10)
BarcodeEncoding.QRCode2DHigh-capacity matrix — URLs, structured dataReed-Solomon ECC
BarcodeEncoding.Code391DAlphanumeric — defense, automotiveOptional (Mod43)
BarcodeEncoding.UPCA1DNorth American retail — 12 digitsMandatory (Mod10)
BarcodeEncoding.DataMatrix2DCompact matrix — electronics, pharmaReed-Solomon ECC
BarcodeEncoding.PDF4172DStacked — ID cards, transportReed-Solomon ECC

Specifying the expected format delivers two benefits: the reader skips detection routines for irrelevant symbologies (improving scan speed), and barcodes of unexpected types are excluded from results even if physically present in the image. This second property is the format-awareness validation — the reader returns only what the pipeline expects.

//:path=/static-assets/barcode/content-code-examples/how-to/checksum-and-format-validation/format-constrained.cs
using IronBarCode;

// Scenario: shipping labels contain only Code128 barcodes
var constrainedOptions = new BarcodeReaderOptions
{
    ExpectBarcodeTypes = BarcodeEncoding.Code128,
    Speed = ReadingSpeed.Faster,
    ExpectMultipleBarcodes = false
};

// Scenario: auto-detect all formats (default behavior)
var broadOptions = new BarcodeReaderOptions
{
    ExpectBarcodeTypes = BarcodeEncoding.All,
    Speed = ReadingSpeed.Detailed,
    ExpectMultipleBarcodes = true
};

string imagePath = "shipping-label.png";

// Constrained read — faster, only returns Code128 results
BarcodeResults constrained = BarcodeReader.Read(imagePath, constrainedOptions);
Console.WriteLine($"Constrained: {constrained.Count} Code128 barcode(s) found");

// Broad read — slower, returns all detected formats
BarcodeResults broad = BarcodeReader.Read(imagePath, broadOptions);
Console.WriteLine($"Broad: {broad.Count} barcode(s) found across all formats");

foreach (BarcodeResult result in broad)
{
    Console.WriteLine($"  [{result.BarcodeType}] {result.Value}");
}
//:path=/static-assets/barcode/content-code-examples/how-to/checksum-and-format-validation/format-constrained.cs
using IronBarCode;

// Scenario: shipping labels contain only Code128 barcodes
var constrainedOptions = new BarcodeReaderOptions
{
    ExpectBarcodeTypes = BarcodeEncoding.Code128,
    Speed = ReadingSpeed.Faster,
    ExpectMultipleBarcodes = false
};

// Scenario: auto-detect all formats (default behavior)
var broadOptions = new BarcodeReaderOptions
{
    ExpectBarcodeTypes = BarcodeEncoding.All,
    Speed = ReadingSpeed.Detailed,
    ExpectMultipleBarcodes = true
};

string imagePath = "shipping-label.png";

// Constrained read — faster, only returns Code128 results
BarcodeResults constrained = BarcodeReader.Read(imagePath, constrainedOptions);
Console.WriteLine($"Constrained: {constrained.Count} Code128 barcode(s) found");

// Broad read — slower, returns all detected formats
BarcodeResults broad = BarcodeReader.Read(imagePath, broadOptions);
Console.WriteLine($"Broad: {broad.Count} barcode(s) found across all formats");

foreach (BarcodeResult result in broad)
{
    Console.WriteLine($"  [{result.BarcodeType}] {result.Value}");
}
Imports IronBarCode

' Scenario: shipping labels contain only Code128 barcodes
Dim constrainedOptions As New BarcodeReaderOptions With {
    .ExpectBarcodeTypes = BarcodeEncoding.Code128,
    .Speed = ReadingSpeed.Faster,
    .ExpectMultipleBarcodes = False
}

' Scenario: auto-detect all formats (default behavior)
Dim broadOptions As New BarcodeReaderOptions With {
    .ExpectBarcodeTypes = BarcodeEncoding.All,
    .Speed = ReadingSpeed.Detailed,
    .ExpectMultipleBarcodes = True
}

Dim imagePath As String = "shipping-label.png"

' Constrained read — faster, only returns Code128 results
Dim constrained As BarcodeResults = BarcodeReader.Read(imagePath, constrainedOptions)
Console.WriteLine($"Constrained: {constrained.Count} Code128 barcode(s) found")

' Broad read — slower, returns all detected formats
Dim broad As BarcodeResults = BarcodeReader.Read(imagePath, broadOptions)
Console.WriteLine($"Broad: {broad.Count} barcode(s) found across all formats")

For Each result As BarcodeResult In broad
    Console.WriteLine($"  [{result.BarcodeType}] {result.Value}")
Next
$vbLabelText   $csharpLabel

When the image contains a barcode in an unexpected format — a QR code on a shipping label that should only carry Code128 — the constrained reader returns zero results rather than throwing an exception. This is by design: format mismatch is a data-level concern, not an error condition. The calling code should treat empty results from a format-constrained read as a validation signal and log the discrepancy for investigation.

For pipelines processing images with multiple barcode types (e.g., a packing slip with both an EAN-13 product code and a Code128 tracking number), combine the expected formats:

var options = new BarcodeReaderOptions
{
    ExpectBarcodeTypes = BarcodeEncoding.EAN13 | BarcodeEncoding.Code128,
    ExpectMultipleBarcodes = true
};
var options = new BarcodeReaderOptions
{
    ExpectBarcodeTypes = BarcodeEncoding.EAN13 | BarcodeEncoding.Code128,
    ExpectMultipleBarcodes = true
};
Dim options As New BarcodeReaderOptions With {
    .ExpectBarcodeTypes = BarcodeEncoding.EAN13 Or BarcodeEncoding.Code128,
    .ExpectMultipleBarcodes = True
}
$vbLabelText   $csharpLabel

The reader will find and return barcodes of both types while ignoring any other symbology present in the image. Each returned BarcodeResult.BarcodeType identifies which format was decoded, enabling downstream routing logic.

Which Symbologies Support Checksum Validation?

Not all barcode formats use checksums in the same way. The following table maps common symbologies to their error-detection characteristics, which informs how aggressively to set ConfidenceThreshold and RemoveFalsePositive for each format:

Checksum Characteristics by Symbology
SymbologyChecksum TypeMandatory?Recommendation
EAN-13 / EAN-8Mod10YesDefault settings sufficient — checksum always enforced
UPC-A / UPC-EMod10YesDefault settings sufficient — auto-corrected during write
Code128Weighted Mod103YesDefault settings sufficient — mandatory per specification
Code39Mod43OptionalRaise ConfidenceThreshold to 0.8+ and enable RemoveFalsePositive
CodabarMod16OptionalSame as Code39 — use confidence as the quality gate
ITFMod10OptionalEnable RemoveFalsePositive for interleaved formats
QRCode / DataMatrixReed-Solomon ECCBuilt-inError correction is structural — no additional configuration needed
PDF417Reed-Solomon ECCBuilt-inSame as QR/DataMatrix — error correction is inherent

For 2D symbologies (QR, DataMatrix, PDF417), error correction is part of the encoding structure itself — these formats can recover from partial damage without relying on a simple check digit. The ConfidenceThreshold still applies to the ML detection phase, but the decode step benefits from the symbology's built-in redundancy.

How to Combine Checksums with Format Constraints?

The production-ready pattern configures ExpectBarcodeTypes, RemoveFalsePositive, ConfidenceThreshold, and Speed in a single BarcodeReaderOptions object. Together, these properties form a layered validation gate: format constraint narrows the search space, checksum validation (implicit) ensures data integrity, confidence thresholding filters marginal decodes, and false-positive removal adds a secondary verification pass.

//:path=/static-assets/barcode/content-code-examples/how-to/checksum-and-format-validation/combined-validation.cs
using IronBarCode;

// Production configuration: retail POS scanning with EAN-13 and UPC-A
var options = new BarcodeReaderOptions
{
    // Layer 1: Format constraint — only retail symbologies
    ExpectBarcodeTypes = BarcodeEncoding.EAN13 | BarcodeEncoding.UPCA | BarcodeEncoding.UPCE,

    // Layer 2: Confidence threshold — reject marginal decodes
    ConfidenceThreshold = 0.8,

    // Layer 3: False-positive removal — double-scan verification
    RemoveFalsePositive = true,

    // Performance tuning
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = false,
    MinScanLines = 3
};

string[] scanFiles = Directory.GetFiles("pos-scans/", "*.png");

foreach (string file in scanFiles)
{
    BarcodeResults results = BarcodeReader.Read(file, options);

    if (results.Count == 0)
    {
        // No barcode passed all validation layers
        Console.Error.WriteLine($"REJECT {Path.GetFileName(file)}: "
            + "no valid EAN-13/UPC barcode (checksum, confidence, or format mismatch)");
        continue;
    }

    BarcodeResult primary = results.First();

    // Post-read assertion: verify the decoded format matches expectations
    if (primary.BarcodeType != BarcodeEncoding.EAN13
        && primary.BarcodeType != BarcodeEncoding.UPCA
        && primary.BarcodeType != BarcodeEncoding.UPCE)
    {
        Console.Error.WriteLine($"UNEXPECTED FORMAT {Path.GetFileName(file)}: "
            + $"got {primary.BarcodeType}, expected EAN-13/UPC");
        continue;
    }

    Console.WriteLine($"OK {Path.GetFileName(file)}: "
        + $"[{primary.BarcodeType}] {primary.Value} — {primary.Confidence}%");
}
//:path=/static-assets/barcode/content-code-examples/how-to/checksum-and-format-validation/combined-validation.cs
using IronBarCode;

// Production configuration: retail POS scanning with EAN-13 and UPC-A
var options = new BarcodeReaderOptions
{
    // Layer 1: Format constraint — only retail symbologies
    ExpectBarcodeTypes = BarcodeEncoding.EAN13 | BarcodeEncoding.UPCA | BarcodeEncoding.UPCE,

    // Layer 2: Confidence threshold — reject marginal decodes
    ConfidenceThreshold = 0.8,

    // Layer 3: False-positive removal — double-scan verification
    RemoveFalsePositive = true,

    // Performance tuning
    Speed = ReadingSpeed.Balanced,
    ExpectMultipleBarcodes = false,
    MinScanLines = 3
};

string[] scanFiles = Directory.GetFiles("pos-scans/", "*.png");

foreach (string file in scanFiles)
{
    BarcodeResults results = BarcodeReader.Read(file, options);

    if (results.Count == 0)
    {
        // No barcode passed all validation layers
        Console.Error.WriteLine($"REJECT {Path.GetFileName(file)}: "
            + "no valid EAN-13/UPC barcode (checksum, confidence, or format mismatch)");
        continue;
    }

    BarcodeResult primary = results.First();

    // Post-read assertion: verify the decoded format matches expectations
    if (primary.BarcodeType != BarcodeEncoding.EAN13
        && primary.BarcodeType != BarcodeEncoding.UPCA
        && primary.BarcodeType != BarcodeEncoding.UPCE)
    {
        Console.Error.WriteLine($"UNEXPECTED FORMAT {Path.GetFileName(file)}: "
            + $"got {primary.BarcodeType}, expected EAN-13/UPC");
        continue;
    }

    Console.WriteLine($"OK {Path.GetFileName(file)}: "
        + $"[{primary.BarcodeType}] {primary.Value} — {primary.Confidence}%");
}
Imports IronBarCode

' Production configuration: retail POS scanning with EAN-13 and UPC-A
Dim options As New BarcodeReaderOptions With {
    ' Layer 1: Format constraint — only retail symbologies
    .ExpectBarcodeTypes = BarcodeEncoding.EAN13 Or BarcodeEncoding.UPCA Or BarcodeEncoding.UPCE,
    
    ' Layer 2: Confidence threshold — reject marginal decodes
    .ConfidenceThreshold = 0.8,
    
    ' Layer 3: False-positive removal — double-scan verification
    .RemoveFalsePositive = True,
    
    ' Performance tuning
    .Speed = ReadingSpeed.Balanced,
    .ExpectMultipleBarcodes = False,
    .MinScanLines = 3
}

Dim scanFiles As String() = Directory.GetFiles("pos-scans/", "*.png")

For Each file As String In scanFiles
    Dim results As BarcodeResults = BarcodeReader.Read(file, options)

    If results.Count = 0 Then
        ' No barcode passed all validation layers
        Console.Error.WriteLine($"REJECT {Path.GetFileName(file)}: " &
                                "no valid EAN-13/UPC barcode (checksum, confidence, or format mismatch)")
        Continue For
    End If

    Dim primary As BarcodeResult = results.First()

    ' Post-read assertion: verify the decoded format matches expectations
    If primary.BarcodeType <> BarcodeEncoding.EAN13 AndAlso
       primary.BarcodeType <> BarcodeEncoding.UPCA AndAlso
       primary.BarcodeType <> BarcodeEncoding.UPCE Then
        Console.Error.WriteLine($"UNEXPECTED FORMAT {Path.GetFileName(file)}: " &
                                $"got {primary.BarcodeType}, expected EAN-13/UPC")
        Continue For
    End If

    Console.WriteLine($"OK {Path.GetFileName(file)}: " &
                      $"[{primary.BarcodeType}] {primary.Value} — {primary.Confidence}%")
Next
$vbLabelText   $csharpLabel

The MinScanLines = 3 setting raises the minimum number of agreeing scan lines for a 1D barcode to be considered valid — the default is 2. Increasing this value reduces the probability of a noisy scan line producing a phantom read, at the cost of potentially missing thin or partially damaged barcodes. For a retail POS environment with clean printed labels, 3 is a conservative choice that tightens the validation gate without impacting throughput.

The post-read BarcodeType assertion is a defense-in-depth pattern. While ExpectBarcodeTypes already constrains the reader, the explicit check documents intent and catches edge cases in future library versions or configuration drift. This assertion costs nothing at runtime and provides a clear diagnostic message when violated.

For further tuning, the Speed property controls how much computational effort the reader applies. ReadingSpeed.Faster skips some image preprocessing steps and is appropriate for clean machine-printed labels. ReadingSpeed.Detailed or ReadingSpeed.ExtremeDetail applies progressively more image filters and rotation attempts, which can recover barcodes from damaged or poorly lit images at the cost of longer scan times.

What Are My Next Steps?

This article covered IronBarcode's implicit checksum validation model, the BarcodeEncoding flags enum for format-constrained reads, and a combined validation pattern using ExpectBarcodeTypes, ConfidenceThreshold, RemoveFalsePositive, and MinScanLines as layered quality gates.

For further reading, explore these resources:

Get a free trial license to test every feature in a live environment, or view licensing options when the pipeline is ready for production.

Frequently Asked Questions

What is barcode checksum validation?

Barcode checksum validation is a process that ensures the accuracy of barcode data by verifying the calculated checksum against the value encoded within the barcode. This helps in detecting errors in the scanning process.

How does IronBarcode handle checksum validation?

IronBarcode implicitly handles checksum validation by calculating the checksum for the barcode data and verifying it against the encoded checksum, ensuring data integrity during the scanning process.

What are BarcodeEncoding filters?

BarcodeEncoding filters in IronBarcode allow you to specify which barcode formats to read or ignore during scanning, enabling more accurate and efficient barcode processing by focusing on specific barcode types.

Can IronBarcode perform combined validation?

Yes, IronBarcode can perform combined validation by checking both the checksum and the format of barcodes during the scanning process, ensuring that only valid and correctly formatted barcodes are processed.

Is it possible to constrain barcode reads by format in C# with IronBarcode?

Yes, IronBarcode allows you to constrain barcode reads by specifying the formats you want to include or exclude, ensuring that your application processes only relevant barcode types.

Why is format-aware reading important in barcode processing?

Format-aware reading is important because it allows your application to process only specific types of barcodes, improving speed and accuracy by ignoring irrelevant or unsupported barcode formats.

How do I implement format-aware reading in IronBarcode?

To implement format-aware reading in IronBarcode, use BarcodeEncoding filters to specify the barcode formats you wish to read. This can be done through the library's API, which allows for precise control over barcode scanning requirements.

What are the benefits of using IronBarcode for barcode validation?

IronBarcode offers several benefits for barcode validation, including robust checksum verification, format-aware reading, and the ability to handle a wide range of barcode standards, ensuring high accuracy and flexibility in barcode processing.

Darrius Serrant
Darrius Serrant
  Chat with engineering team now
Full Stack Software Engineer (WebOps)

Darrius Serrant holds a Bachelor’s degree in Computer Science from the University of Miami and works as a Full Stack WebOps Marketing Engineer at Iron Software. Drawn to coding from a young age, he saw computing as both mysterious and accessible, making it the perfect medium for creativity ...

Read More
Ready to Get Started?
Nuget Downloads 2,094,439 | Version: 2026.3 just released
Still Scrolling Icon

Still Scrolling?

Want proof fast? PM > Install-Package BarCode
run a sample watch your string become a barcode.