COMPARISON

Iron Suite vs Spire.Office

Spire.Office and Iron Suite are both perpetual per-developer bundles with one year of updates, so a side-by-side procurement decision often comes down to two questions: which license actually covers your deployment shape, and at what published price? Spire.Office bundles twelve E-iceblue libraries at public tier names (Developer Small Business, Developer OEM, Site Small Business, Site OEM), but exact USD figures sit behind sales contact, and SaaS, Docker, and any public-facing deployment are confined to the OEM tier. Iron Suite bundles ten Iron Software products at five publicly priced tiers from $2,998, royalty-free for licensed seats, with one Redistribution Add-On for SaaS and OEM rather than a locked higher tier.

This comparison leads with what a procurement-led decision actually hangs on: how each suite is priced, how its license handles SaaS and Docker deployment, and what's actually in the box. The capability detail and code follow below for the engineers who'll ship it.

At-a-Glance Comparison

DimensionSpire.Office for .NETIron Suite
Pricing positioningPublic tier names (Developer/Site, Small Business/OEM); exact USD figures not crawlableLite $2,998 / Plus $4,498 / Professional $8,998 / Unlimited $17,998 (Enterprise custom). All 10 products for the price of 2, save 75%
License modelPerpetual per-developer with 1 yr free updates; tiers gate SaaS/Docker to OEM; "Free Spire" tier with per-doc capsPerpetual per-developer; royalty-free for licensed seats; SaaS/OEM via Redistribution Add-On
Components in bundle12 libraries (Doc, XLS, Spreadsheet, Presentation, PDF, DataExport, OfficeViewer, PDFViewer, DocViewer, Barcode, OCR, Email)10 products (IronPDF, IronWord, IronXL, IronPPT, IronOCR, IronBarcode, IronQR, IronPrint, IronZIP, IronWebScraper)
Format / capability coverageDOCX/XLSX/PPTX/PDF + Email + Barcode + OCR + bundled viewersPDF, Office, OCR, Barcode/QR, ZIP, Print, Web Scraping
Cross-platform / cloudWindows, Linux, macOS, Docker (Docker/SaaS only on OEM tier)Windows, Linux, macOS, Docker, Azure, AWS Lambda
.NET runtime support.NET Framework 4.0/4.8, .NET 6, .NET 9, .NET 10.NET Framework 4.6.2+, .NET Core, .NET 6/7/8/9/10
Target marketSMB and mid-market .NET developers; budget-conscious teamsIndependent developers, SMB, mid-market .NET teams, ISVs
VendorE-iceblue Co., Ltd.Iron Software

Spire.Office tier prices are not publicly listed (Buy/ pages return 403 to scraping); Free Spire exists as a per-document-capped free tier. Iron Suite Lite is $2,998 per developer, with the full ten-product bundle and public USD pricing on every paid tier. The decision tilts on whether Spire's strong DOCX/XLSX/PPTX conversion fidelity outweighs the contact-sales motion against Iron Suite's published-price perpetual model.

Pricing and Licensing

Spire.Office offers perpetual per-developer licensing with one year of free updates. The public tier structure is well known (One Developer Small Business, One Developer OEM, One Site Small Business, One Site OEM) and the OEM tier is required for any deployment to SaaS, public-facing websites, Docker, or cloud-based applications. Exact USD figures for the current Spire.Office tiers are not crawlable from e-iceblue's Buy/ pages; pricing is best obtained directly from the vendor or via reseller channels. A "Free Spire" tier exists with per-document feature caps.

Iron Suite is sold as a single perpetual per-developer license at five tier levels (Lite, Plus, Professional, Unlimited, and Enterprise) starting from $2,998, with the marketing positioning of "all 10 products for the price of 2, save 75%." The base license is royalty-free for the licensed seats, locations, or projects, and SaaS, OEM, or distributed redistribution beyond the base license uses a single, separately priced Redistribution Add-On rather than locking SaaS into a more expensive OEM tier.

Buyers comfortable with a contact-sales motion for pricing and an OEM-gated path for SaaS/Docker deployment go to Spire.Office. Buyers who want USD numbers on every public tier and a single Redistribution Add-On for SaaS/OEM extension go to Iron Suite.

What is Spire.Office for .NET

Spire.Office for .NET is the master bundle from E-iceblue Co., Ltd., a Chinese-headquartered components vendor with strong DOC/XLSX/PDF conversion fidelity. The suite aggregates twelve Spire libraries into a single license, and the same engines also ship as standalone packages (Spire.Doc, Spire.XLS, Spire.PDF, etc.). Spire.Office is positioned for SMB and mid-market .NET teams looking for an Aspose alternative at a noticeably lower price point, with a "Free Spire" tier that lets developers ship small projects with no license cost (subject to per-document feature caps). The 11.4.0 NuGet meta-package, released April 30 2026, targets .NET Framework 4.0/4.8 and modern .NET 6/9/10.

Key bundled components and capabilities:

  • Spire.Doc: Word DOCX/DOC creation, conversion, and editing
  • Spire.XLS: Excel XLSX engine with formula recalculation and PDF export
  • Spire.PDF: PDF creation, editing, and manipulation
  • Spire.Presentation: PowerPoint PPTX support
  • Spire.Barcode + Spire.OCR: recognition stack inside the bundle
  • Spire.Email + Spire.DataExport + Spire.OfficeViewer/PDFViewer/DocViewer: adjacent tooling rounding out the suite

What is Iron Suite

Iron Suite is Iron Software's ten-product .NET bundle where the Office stack (IronWord for DOCX, IronXL for XLSX with formula recalc, IronPPT for PPTX) sits alongside IronPDF for PDF generation and manipulation, the recognition stack (IronOCR, IronBarcode, IronQR) for OCR and barcode work, and three utility libraries (IronPrint, IronZIP, IronWebScraper) for printing, archives, and scraping. Sold as a single perpetual per-developer license at five tier levels (Lite, Plus, Professional, Unlimited, Enterprise) from $2,998. Royalty-free for the licensed seats. SaaS and OEM redistribution use a separate Redistribution Add-On.

The ten components, grouped by relevance to a programmatic Office and PDF workflow:

  • Office stack (anchor): IronWord (DOCX with paragraph and text-run object graphs that map directly to OOXML, with custom styles, fonts, headers, footers, tables, and content extraction); IronXL (XLSX with formula recalculation, chart creation across Area, Bar, Column, Lines, Pie, and Scatter, pivot tables, conditional formatting, data validation); IronPPT (PPTX creation, editing, conversion, and content extraction).
  • PDF generation (IronPDF): HTML-to-PDF and URL-to-PDF rendering with bundled Chromium, native merge and split via PdfDocument.Merge, PKCS#12 plus HSM plus TSA signing, PDF/A-1 through PDF/A-4, PDF/UA-1 and PDF/UA-2, encryption, AcroForm fill and flattening, font management, rasterization, compression and linearization.
  • Recognition: IronOCR (Tesseract 5, 125+ languages, handwriting at ~90% English); IronBarcode (30+ symbologies); IronQR (ML-powered with batch ReadPdfs).
  • Utility: IronPrint (silent and dialog printing); IronZIP (ZIP/TAR/GZIP/BZIP2 with AES); IronWebScraper (in-process structured scraping).

Capability Comparison

Word Processing

DOCX-to-PDF conversion is a flagship Spire workload, and the API has been refined over many years for fidelity. IronWord targets a similar everyday workload but with a modern object-graph API.

// Spire.Doc converts and edits Word documents without Office installed.
// NuGet: Install-Package Spire.Office
using Spire.Doc;

class Program
{
    static void Main()
    {
        Document doc = new Document();
        doc.LoadFromFile("contract.docx");
        doc.SaveToFile("contract.pdf", FileFormat.PDF);
        doc.Close();
    }
}
// Spire.Doc converts and edits Word documents without Office installed.
// NuGet: Install-Package Spire.Office
using Spire.Doc;

class Program
{
    static void Main()
    {
        Document doc = new Document();
        doc.LoadFromFile("contract.docx");
        doc.SaveToFile("contract.pdf", FileFormat.PDF);
        doc.Close();
    }
}
Imports Spire.Doc

Class Program
    Shared Sub Main()
        Dim doc As New Document()
        doc.LoadFromFile("contract.docx")
        doc.SaveToFile("contract.pdf", FileFormat.PDF)
        doc.Close()
    End Sub
End Class
$vbLabelText   $csharpLabel
// NuGet: Install-Package IronWord
using IronWord;
using IronWord.Models;

class Program
{
    static void Main()
    {
        var doc = new WordDocument();
        var heading = new Paragraph();
        heading.AddChild(new TextRun("Quarterly Report — Q1 2026") { FontSize = 18, Bold = true });
        doc.AddParagraph(heading);

        var body = new Paragraph();
        body.AddChild(new TextRun("Revenue grew 14% quarter-over-quarter."));
        doc.AddParagraph(body);

        doc.SaveAs("report.docx");
    }
}
// NuGet: Install-Package IronWord
using IronWord;
using IronWord.Models;

class Program
{
    static void Main()
    {
        var doc = new WordDocument();
        var heading = new Paragraph();
        heading.AddChild(new TextRun("Quarterly Report — Q1 2026") { FontSize = 18, Bold = true });
        doc.AddParagraph(heading);

        var body = new Paragraph();
        body.AddChild(new TextRun("Revenue grew 14% quarter-over-quarter."));
        doc.AddParagraph(body);

        doc.SaveAs("report.docx");
    }
}
Imports IronWord
Imports IronWord.Models

Class Program
    Shared Sub Main()
        Dim doc As New WordDocument()
        Dim heading As New Paragraph()
        heading.AddChild(New TextRun("Quarterly Report — Q1 2026") With {.FontSize = 18, .Bold = True})
        doc.AddParagraph(heading)

        Dim body As New Paragraph()
        body.AddChild(New TextRun("Revenue grew 14% quarter-over-quarter."))
        doc.AddParagraph(body)

        doc.SaveAs("report.docx")
    End Sub
End Class
$vbLabelText   $csharpLabel

Spire.Doc's LoadFromFile/SaveToFile convention is consistent across every Spire product (Spire.XLS, Spire.PDF, Spire.Presentation all use the same pattern), which makes the suite predictable but stylistically dated. IronWord's paragraph/text-run object graph maps directly to the OOXML structure and reads as modern C#. Pure DOCX-to-PDF round-tripping with strong fidelity on legacy-format edge cases is one area Spire has been investing into — for code-first DOCX generation, IronWord requires less ceremony.

Excel Processing

Both suites cover the everyday Excel workload (create or load XLSX, write data, recalculate formulas, export to PDF) and both have a strong calculation engine.

// Spire.XLS handles XLSX read/write, formula recalculation, and PDF export.
using Spire.Xls;

class Program
{
    static void Main()
    {
        Workbook book = new Workbook();
        book.LoadFromFile("financials.xlsx");
        book.CalculateAllValue();
        book.ConverterSetting.SheetFitToPage = true;
        book.SaveToFile("financials.pdf", FileFormat.PDF);
    }
}
// Spire.XLS handles XLSX read/write, formula recalculation, and PDF export.
using Spire.Xls;

class Program
{
    static void Main()
    {
        Workbook book = new Workbook();
        book.LoadFromFile("financials.xlsx");
        book.CalculateAllValue();
        book.ConverterSetting.SheetFitToPage = true;
        book.SaveToFile("financials.pdf", FileFormat.PDF);
    }
}
Imports Spire.Xls

Class Program
    Shared Sub Main()
        Dim book As New Workbook()
        book.LoadFromFile("financials.xlsx")
        book.CalculateAllValue()
        book.ConverterSetting.SheetFitToPage = True
        book.SaveToFile("financials.pdf", FileFormat.PDF)
    End Sub
End Class
$vbLabelText   $csharpLabel
// NuGet: Install-Package IronXL.Excel
using IronXL;

class Program
{
    static void Main()
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet sheet = workbook.CreateWorkSheet("Sales");

        sheet["A1"].Value = "Product";
        sheet["B1"].Value = "Units";
        sheet["A2"].Value = "Widget A";
        sheet["B2"].Value = 1024;
        sheet["A3"].Value = "Widget B";
        sheet["B3"].Value = 768;
        sheet["B4"].Formula = "=SUM(B2:B3)";

        workbook.EvaluateAll();
        workbook.SaveAs("sales.xlsx");
    }
}
// NuGet: Install-Package IronXL.Excel
using IronXL;

class Program
{
    static void Main()
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet sheet = workbook.CreateWorkSheet("Sales");

        sheet["A1"].Value = "Product";
        sheet["B1"].Value = "Units";
        sheet["A2"].Value = "Widget A";
        sheet["B2"].Value = 1024;
        sheet["A3"].Value = "Widget B";
        sheet["B3"].Value = 768;
        sheet["B4"].Formula = "=SUM(B2:B3)";

        workbook.EvaluateAll();
        workbook.SaveAs("sales.xlsx");
    }
}
Imports IronXL

Module Program
    Sub Main()
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim sheet As WorkSheet = workbook.CreateWorkSheet("Sales")

        sheet("A1").Value = "Product"
        sheet("B1").Value = "Units"
        sheet("A2").Value = "Widget A"
        sheet("B2").Value = 1024
        sheet("A3").Value = "Widget B"
        sheet("B3").Value = 768
        sheet("B4").Formula = "=SUM(B2:B3)"

        workbook.EvaluateAll()
        workbook.SaveAs("sales.xlsx")
    End Sub
End Module
$vbLabelText   $csharpLabel

Spire.XLS's book.CalculateAllValue() + SheetFitToPage give it a strong existing-workbook → polished PDF flow. IronXL's indexer-style cell access (sheet["A1"].Value = …, sheet["B4"].Formula = …, workbook.EvaluateAll()) feels more like everyday LINQ-era .NET and is what most developers reach for when generating XLSX from scratch. Both engines handle the common formula surface — complex existing-workbook conversion fidelity (legacy XLS quirks, chart-object handling) is one area Spire has been continuing to invest into.

PDF Generation

PDF is where the API style diverges most. Spire.PDF builds documents primitive-by-primitive on a page canvas, layering text, images, and shapes via PdfPageBase.Canvas. IronPDF renders the same content from HTML using a real Chrome engine.

// Spire.PDF builds PDFs primitive-by-primitive on a page canvas.
using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;

class Program
{
    static void Main()
    {
        PdfDocument pdf = new PdfDocument();
        PdfPageBase page = pdf.Pages.Add();

        PdfTrueTypeFont titleFont = new PdfTrueTypeFont(new Font("Arial", 20f, FontStyle.Bold), true);
        page.Canvas.DrawString("Statement of Account", titleFont, PdfBrushes.Black, 50, 50);

        PdfTrueTypeFont body = new PdfTrueTypeFont(new Font("Arial", 11f), true);
        page.Canvas.DrawString("Generated 2026-05-26", body, PdfBrushes.DarkSlateGray, 50, 90);

        pdf.SaveToFile("statement.pdf");
        pdf.Close();
    }
}
// Spire.PDF builds PDFs primitive-by-primitive on a page canvas.
using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;

class Program
{
    static void Main()
    {
        PdfDocument pdf = new PdfDocument();
        PdfPageBase page = pdf.Pages.Add();

        PdfTrueTypeFont titleFont = new PdfTrueTypeFont(new Font("Arial", 20f, FontStyle.Bold), true);
        page.Canvas.DrawString("Statement of Account", titleFont, PdfBrushes.Black, 50, 50);

        PdfTrueTypeFont body = new PdfTrueTypeFont(new Font("Arial", 11f), true);
        page.Canvas.DrawString("Generated 2026-05-26", body, PdfBrushes.DarkSlateGray, 50, 90);

        pdf.SaveToFile("statement.pdf");
        pdf.Close();
    }
}
Imports Spire.Pdf
Imports Spire.Pdf.Graphics
Imports System.Drawing

Class Program
    Shared Sub Main()
        Dim pdf As New PdfDocument()
        Dim page As PdfPageBase = pdf.Pages.Add()

        Dim titleFont As New PdfTrueTypeFont(New Font("Arial", 20.0F, FontStyle.Bold), True)
        page.Canvas.DrawString("Statement of Account", titleFont, PdfBrushes.Black, 50, 50)

        Dim body As New PdfTrueTypeFont(New Font("Arial", 11.0F), True)
        page.Canvas.DrawString("Generated 2026-05-26", body, PdfBrushes.DarkSlateGray, 50, 90)

        pdf.SaveToFile("statement.pdf")
        pdf.Close()
    End Sub
End Class
$vbLabelText   $csharpLabel
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = @"<h1>Invoice 2026-0428</h1><p>Customer: Acme Corp</p><p>Total due: $1,240.00</p>";
        using var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("invoice.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string html = @"<h1>Invoice 2026-0428</h1><p>Customer: Acme Corp</p><p>Total due: $1,240.00</p>";
        using var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("invoice.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html As String = "<h1>Invoice 2026-0428</h1><p>Customer: Acme Corp</p><p>Total due: $1,240.00</p>"
        Using pdf = renderer.RenderHtmlAsPdf(html)
            pdf.SaveAs("invoice.pdf")
        End Using
    End Sub
End Class
$vbLabelText   $csharpLabel

Spire.PDF is the right pick when you need pixel-precise placement of primitives on an existing page (forms, stamping, redaction). IronPDF is the right pick when the PDF originates from web-app data: the same HTML/CSS that renders in the browser becomes the PDF, including modern CSS, web fonts, SVG, and JavaScript-rendered content.

PowerPoint Processing

PowerPoint conversion to PDF is a Spire strength inside the bundle. Iron Suite includes IronPPT for PowerPoint generation and manipulation, though the Iron Suite reference set positions IronPPT as a creation-focused product rather than a deep-fidelity conversion engine.

// Spire.Presentation reads/writes PPTX and exports to PDF or image without PowerPoint installed.
using Spire.Presentation;

class Program
{
    static void Main()
    {
        Presentation pres = new Presentation();
        pres.LoadFromFile("kickoff-deck.pptx");
        pres.SaveToFile("kickoff-deck.pdf", FileFormat.PDF);
        pres.Dispose();
    }
}
// Spire.Presentation reads/writes PPTX and exports to PDF or image without PowerPoint installed.
using Spire.Presentation;

class Program
{
    static void Main()
    {
        Presentation pres = new Presentation();
        pres.LoadFromFile("kickoff-deck.pptx");
        pres.SaveToFile("kickoff-deck.pdf", FileFormat.PDF);
        pres.Dispose();
    }
}
Imports Spire.Presentation

Class Program
    Shared Sub Main()
        Dim pres As New Presentation()
        pres.LoadFromFile("kickoff-deck.pptx")
        pres.SaveToFile("kickoff-deck.pdf", FileFormat.PDF)
        pres.Dispose()
    End Sub
End Class
$vbLabelText   $csharpLabel
// NuGet: Install-Package IronPPT
// Docs: https://ironsoftware.com/csharp/ppt/docs/
using IronPPT;
using IronPPT.Models;

class Program
{
    static void Main()
    {
        // PresentationDocument is the entry point for PPTX creation in IronPPT.
        // No Microsoft PowerPoint or Office Interop required.
        PresentationDocument document = new PresentationDocument();

        Slide titleSlide = new Slide();
        titleSlide.AddText("Quarterly Update");
        document.AddSlide(titleSlide);

        Slide bodySlide = new Slide();
        bodySlide.AddText("Generated from .NET, no PowerPoint dependency.");
        document.AddSlide(bodySlide);

        document.Save("update.pptx");
    }
}
// NuGet: Install-Package IronPPT
// Docs: https://ironsoftware.com/csharp/ppt/docs/
using IronPPT;
using IronPPT.Models;

class Program
{
    static void Main()
    {
        // PresentationDocument is the entry point for PPTX creation in IronPPT.
        // No Microsoft PowerPoint or Office Interop required.
        PresentationDocument document = new PresentationDocument();

        Slide titleSlide = new Slide();
        titleSlide.AddText("Quarterly Update");
        document.AddSlide(titleSlide);

        Slide bodySlide = new Slide();
        bodySlide.AddText("Generated from .NET, no PowerPoint dependency.");
        document.AddSlide(bodySlide);

        document.Save("update.pptx");
    }
}
Imports IronPPT
Imports IronPPT.Models

Module Program
    Sub Main()
        ' PresentationDocument is the entry point for PPTX creation in IronPPT.
        ' No Microsoft PowerPoint or Office Interop required.
        Dim document As New PresentationDocument()

        Dim titleSlide As New Slide()
        titleSlide.AddText("Quarterly Update")
        document.AddSlide(titleSlide)

        Dim bodySlide As New Slide()
        bodySlide.AddText("Generated from .NET, no PowerPoint dependency.")
        document.AddSlide(bodySlide)

        document.Save("update.pptx")
    End Sub
End Module
$vbLabelText   $csharpLabel

Spire.Presentation's load/save pattern matches the rest of the Spire family and covers conversion to PDF and image with continued investment in slide-master, theme, and SmartArt fidelity. IronPPT covers PowerPoint creation and the common manipulation surface (slides, text, images, basic shapes) — high-fidelity conversion of existing third-party decks with deep theme and animation preservation is one area Spire's engine has been growing into.

Barcode Generation and Reading

Both suites ship barcode generation and reading. Iron splits the workload across IronBarcode (1D/2D) and IronQR (QR-specific), giving teams a dedicated path for QR-heavy workflows. The Spire snippet below demonstrates generation; the IronBarcode snippet demonstrates the read path.

// Spire.Barcode generates and decodes 1D/2D symbologies; bundled into Spire.Office.
using Spire.Barcode;

class Program
{
    static void Main()
    {
        BarcodeSettings settings = new BarcodeSettings
        {
            Type = BarCodeType.QRCode,
            Data = "https://example.com/inv/2026-44213",
            Data2D = "https://example.com/inv/2026-44213",
            X = 1.5f
        };

        BarCodeGenerator generator = new BarCodeGenerator(settings);
        System.Drawing.Image image = generator.GenerateImage();
        image.Save("invoice-qr.png");
    }
}
// Spire.Barcode generates and decodes 1D/2D symbologies; bundled into Spire.Office.
using Spire.Barcode;

class Program
{
    static void Main()
    {
        BarcodeSettings settings = new BarcodeSettings
        {
            Type = BarCodeType.QRCode,
            Data = "https://example.com/inv/2026-44213",
            Data2D = "https://example.com/inv/2026-44213",
            X = 1.5f
        };

        BarCodeGenerator generator = new BarCodeGenerator(settings);
        System.Drawing.Image image = generator.GenerateImage();
        image.Save("invoice-qr.png");
    }
}
Imports Spire.Barcode
Imports System.Drawing

Class Program
    Shared Sub Main()
        Dim settings As New BarcodeSettings With {
            .Type = BarCodeType.QRCode,
            .Data = "https://example.com/inv/2026-44213",
            .Data2D = "https://example.com/inv/2026-44213",
            .X = 1.5F
        }

        Dim generator As New BarCodeGenerator(settings)
        Dim image As Image = generator.GenerateImage()
        image.Save("invoice-qr.png")
    End Sub
End Class
$vbLabelText   $csharpLabel
// NuGet: Install-Package IronBarcode
using IronBarCode;

class Program
{
    static void Main()
    {
        var results = BarcodeReader.Read("shipment-label.png");
        foreach (var barcode in results)
        {
            Console.WriteLine($"Value: {barcode.Value}");
            Console.WriteLine($"Format: {barcode.BarcodeType}");
        }
    }
}
// NuGet: Install-Package IronBarcode
using IronBarCode;

class Program
{
    static void Main()
    {
        var results = BarcodeReader.Read("shipment-label.png");
        foreach (var barcode in results)
        {
            Console.WriteLine($"Value: {barcode.Value}");
            Console.WriteLine($"Format: {barcode.BarcodeType}");
        }
    }
}
Imports IronBarCode

Class Program
    Shared Sub Main()
        Dim results = BarcodeReader.Read("shipment-label.png")
        For Each barcode In results
            Console.WriteLine($"Value: {barcode.Value}")
            Console.WriteLine($"Format: {barcode.BarcodeType}")
        Next
    End Sub
End Class
$vbLabelText   $csharpLabel

Spire.Barcode bundles 1D/2D and QR into one settings-driven generator, which is concise but requires reading the settings docs to discover all available options. IronBarcode + IronQR give dedicated entry points (BarcodeReader.Read, BarcodeWriter, plus a QR-specific reader/writer in IronQR) that auto-complete more cleanly in the IDE.

Why Choose Iron Suite for Code-First .NET Document Automation

Pick Iron Suite when SaaS, Docker, and public-facing deployment should fall under the base license rather than gate behind an OEM tier. Iron's APIs read as modern code-first .NET, the ten products share a consistent style across the bundle, and pricing is public and perpetual at five tier levels from $2,998. Structural edges that matter for everyday .NET document automation:

  • Transparent perpetual pricing with USD figures on every tier
  • SaaS, Docker, and public-facing deployment are not gated to the OEM tier: the base license covers licensed seats, and a single Redistribution Add-On covers redistribution scenarios
  • Royalty-free deployment for licensed seats, no runtime fees, no per-document metering
  • Code-first .NET API surface across all 10 products, no LoadFromFile/SaveToFile legacy patterns to learn
  • Creation and recognition (PDF/Word/Excel/PPT + OCR/Barcode/QR) in one bundle
  • HTML-first PDF generation with full browser fidelity

How is Iron Suite Different from Spire.Office

  • Public USD pricing on every tier. Spire's Buy/ pages are gated against scraping and pricing requires contacting sales; Iron publishes a number on every tier.
  • SaaS / Docker / public-facing deployment is base-license territory at Iron (with the Redistribution Add-On as a separate clean SKU). Spire confines those deployment shapes to the OEM tier, a sharper price step for any web-deployed app.
  • API consistency across products. Iron's 10 products share idiomatic .NET naming and structure; Spire's APIs are useful but variable across components (Spire.DataExport vs Spire.Spreadsheet vs Spire.Doc each feel slightly different).
  • Recognition + scraping + ZIP + Print + QR. IronWebScraper, IronZIP, and IronPrint sit on the Iron side with no Spire equivalent; IronQR is a dedicated QR library separate from IronBarcode.
  • HTML-first PDF generation with real browser fidelity vs Spire.PDF's primitive-by-primitive page-canvas API.
  • Single license-key registration model vs Spire's per-namespace license setter and OEM-gated deployment shapes.

Conclusion

Spire.Office is a long-standing, capable, budget-friendly Aspose alternative whose strongest cards are DOCX/XLSX/PPTX-to-PDF conversion fidelity and a generous "Free Spire" on-ramp. Iron Suite is a structurally simpler bundle whose strongest cards are licensing clarity, transparent perpetual pricing, an idiomatic code-first .NET API surface across all ten products, and a creation-plus-recognition bundle that does not gate SaaS or Docker behind an OEM tier. Teams whose primary need is conversion fidelity for existing Office documents will find Spire's engine excellent. Teams whose primary need is a single perpetual license covering PDF, Office, OCR, Barcode/QR, and adjacent tooling, without contacting sales for a price, will find Iron Suite the cleaner fit. Explore Iron Suite, including the $2,998 entry tier, at ironsoftware.com/csharp/suite.

Please noteSpire.Office is a registered trademark of its respective owner. This site is not affiliated with, endorsed by, or sponsored by Spire.Office. All product names, logos, and brands are property of their respective owners. Comparisons are for informational purposes only and reflect publicly available information at the time of writing.