Iron Suite vs GemBox.Bundle
At $2,200 per developer for the entry tier, GemBox.Bundle sets a clear procurement marker: seven document libraries (Spreadsheet, Document, PDF, Presentation, Email, Imaging, PdfViewer) under a single perpetual license with royalty-free unlimited deployment included at every paid tier. Iron Suite sets a different marker: ten products under one perpetual license starting from $2,998, with royalty-free deployment for the licensed seats and a separate Redistribution Add-On for SaaS or OEM scenarios beyond the base. Both are no-Office-dependency, both run cross-platform on modern .NET, both ship perpetual licenses.
This article leads with what a procurement-led decision actually hangs on: how each suite is priced, what's in the bundle, and how SaaS redistribution is handled. The developer-level surface and code samples follow below for the engineers integrating it.
At-a-Glance Comparison
| Dimension | GemBox.Bundle | Iron Suite |
|---|---|---|
| Pricing positioning | Single Developer $2,200; Small Team (10 devs) $11,000; Large Team (50 devs) $33,000. Renewals 40% off (60% if before expiration). | Lite $2,998 / Plus $4,498 / Professional $8,998 / Unlimited $17,998 (Enterprise custom); all 10 products for the price of 2 |
| License model | Perpetual per-developer with 1 year of free updates and 1 year of professional support; royalty-free unlimited deployment at every paid tier; Free-Limited tier with per-file caps | Perpetual per-developer; royalty-free for licensed seats; SaaS/OEM via Redistribution Add-On |
| Components in bundle | 7 libraries (Spreadsheet, Document, Pdf, Presentation, Email, Imaging, PdfViewer) | 10 products (IronPDF, IronWord, IronXL, IronPPT, IronOCR, IronBarcode, IronQR, IronPrint, IronZIP, IronWebScraper) |
| Format / capability coverage | XLSX, DOCX, PDF, PPTX, MSG/EML + SMTP/POP/IMAP, raster images | PDF, Office, OCR, Barcode/QR, ZIP, Print, Web Scraping |
| Cross-platform / cloud | Windows, Linux, macOS. Only .NET required for deployment | Windows, Linux, macOS, Docker, Azure, AWS Lambda |
| .NET runtime support | .NET Framework 3.5+, .NET Standard 2.0/2.1, modern .NET 6/7/8/9 (per-component, verify on NuGet) | .NET Framework 4.6.2+, .NET Core, .NET 6/7/8/9/10 |
| Target market | SMB and mid-market .NET developers; lean Office/PDF/Email toolkit buyers | Independent developers, SMB, mid-market .NET teams, ISVs |
| Vendor | GemBox Software | Iron Software |
If royalty-free unlimited deployment at every paid tier matters most (ISVs shipping to many customer sites without a separate OEM SKU), GemBox.Bundle has that built in at $2,200 for Single Developer. If a lower entry price and a broader bundle (OCR with handwriting, barcode, QR, web scraping, programmatic printing) matter most, Iron Suite covers that surface at $2,998 for the Lite tier.
Pricing and Licensing
GemBox.Bundle is sold as a perpetual per-developer license at three tier levels: Single Developer at $2,200, Small Team (up to 10 developers) at $11,000, and Large Team (up to 50 developers) at $33,000. Each tier includes one year of professional support and one year of free updates. Crucially, every paid tier includes royalty-free unlimited deployments. There is no separate OEM or server SKU to negotiate. Renewals run at 40% off the standard rate (60% off if renewed before expiration). A Free-Limited tier exists for prototyping and small projects, gated by per-document feature caps and requires the literal license key "FREE-LIMITED-KEY".
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.
Over a 3-to-5 year horizon, GemBox.Bundle runs as a perpetual seat with annual updates included for year 1, then renewal at 40% off the standard rate (60% off if renewed before expiration) for continued updates. Iron Suite is a one-time perpetual purchase at $2,998 per developer for the Lite tier (higher tiers scale by developer count); deployment is royalty-free for the licensed seats under the base license, with the Redistribution Add-On as the only separately-priced item for SaaS/OEM extension at scale.
What is GemBox.Bundle
GemBox.Bundle is the master bundle from GemBox Software, a focused, lean components vendor known for the small dependency footprint of its libraries. The bundle aggregates seven GemBox libraries into a single perpetual license with a 40% discount versus buying components individually, and offers a Free-Limited tier with per-document feature caps that lets teams prototype and ship small projects at no license cost. The latest reference release is the GemBox.Bundle meta-package version 2026.5.101, published 2026-05-05 on NuGet. GemBox is positioned as a lightweight, performance-oriented alternative to Aspose and Spire for teams whose workload sits squarely inside the Office/PDF/Email category.
Key bundled components and capabilities:
- GemBox.Spreadsheet: XLSX/XLS/XLSB/CSV/HTML/ODS read/write with formula recalculation
- GemBox.Document: Word DOCX/DOC/PDF/RTF/HTML/MD/ODT creation and editing
- GemBox.Pdf: PDF read/write/edit/merge
- GemBox.Presentation: PowerPoint PPTX/PPT/PPSX support
- GemBox.Email: MSG/EML handling with SMTP, POP, IMAP protocol support
- GemBox.Imaging + GemBox.PdfViewer: image processing and embedded PDF display
What is Iron Suite
Iron Suite is Iron Software's ten-product .NET bundle. The Office stack (IronWord, IronXL, IronPPT) handles DOCX, XLSX, and PPTX programmatically; IronPDF carries the PDF surface across generation, signing, redaction, and rasterization; the recognition stack (IronOCR, IronBarcode, IronQR) adds OCR, barcode, and QR; and IronPrint, IronZIP, and IronWebScraper round out printing, archives, and scraping. Sold as a single perpetual per-developer license at five tier levels 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 graph, custom styling, content extraction); IronXL (XLSX with formula recalculation, charts, pivot tables, conditional formatting); IronPPT (PPTX creation, editing, content extraction).
- PDF generation (IronPDF): HTML-to-PDF and URL-to-PDF rendering, native merge and split, PKCS#12 plus HSM plus TSA signing, PDF/A 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
Excel Processing
Both suites cover Excel creation, formula recalculation, and PDF export. GemBox.Spreadsheet is one of the longest-running .NET Excel libraries and has a particularly small dependency footprint.
// GemBox.Spreadsheet handles XLSX/CSV with formula recalculation and PDF export.
// NuGet: Install-Package GemBox.Bundle
using GemBox.Spreadsheet;
class Program
{
static void Main()
{
SpreadsheetInfo.SetLicense("FREE-LIMITED-KEY");
ExcelFile book = new ExcelFile();
ExcelWorksheet sheet = book.Worksheets.Add("Revenue");
sheet.Cells["A1"].Value = "Region";
sheet.Cells["B1"].Value = "Revenue";
sheet.Cells["A2"].Value = "EMEA";
sheet.Cells["B2"].Value = 120000;
sheet.Cells["B4"].Formula = "=SUM(B2:B3)";
book.Save("revenue.xlsx");
book.Save("revenue.pdf");
}
}// GemBox.Spreadsheet handles XLSX/CSV with formula recalculation and PDF export.
// NuGet: Install-Package GemBox.Bundle
using GemBox.Spreadsheet;
class Program
{
static void Main()
{
SpreadsheetInfo.SetLicense("FREE-LIMITED-KEY");
ExcelFile book = new ExcelFile();
ExcelWorksheet sheet = book.Worksheets.Add("Revenue");
sheet.Cells["A1"].Value = "Region";
sheet.Cells["B1"].Value = "Revenue";
sheet.Cells["A2"].Value = "EMEA";
sheet.Cells["B2"].Value = 120000;
sheet.Cells["B4"].Formula = "=SUM(B2:B3)";
book.Save("revenue.xlsx");
book.Save("revenue.pdf");
}
}Imports GemBox.Spreadsheet
Module Program
Sub Main()
SpreadsheetInfo.SetLicense("FREE-LIMITED-KEY")
Dim book As New ExcelFile()
Dim sheet As ExcelWorksheet = book.Worksheets.Add("Revenue")
sheet.Cells("A1").Value = "Region"
sheet.Cells("B1").Value = "Revenue"
sheet.Cells("A2").Value = "EMEA"
sheet.Cells("B2").Value = 120000
sheet.Cells("B4").Formula = "=SUM(B2:B3)"
book.Save("revenue.xlsx")
book.Save("revenue.pdf")
End Sub
End Module// 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 ModuleGemBox.Spreadsheet requires an explicit SpreadsheetInfo.SetLicense(...) call before any API use, even in the free tier, which adds a setup line but is consistent across every GemBox library. IronXL uses an idiomatic indexer-style cell API (sheet["A1"].Value = …, sheet["B4"].Formula = …, workbook.EvaluateAll()) and can save directly to both XLSX and PDF. Both engines cover the read/write/recalc scope cleanly — raw read/write throughput on large workbooks is one area GemBox has been investing into, whereas IronXL has been focused on API conciseness for ad-hoc XLSX generation.
Word Processing
GemBox.Document is the standout among GemBox libraries, it has wide format support (DOCX, DOC, PDF, RTF, HTML, MD, ODT) and a clean object model. IronWord targets DOCX creation and manipulation with a similar modern object-graph API.
// GemBox.Document creates and converts DOCX/PDF/RTF/HTML/ODT without Office.
using GemBox.Document;
class Program
{
static void Main()
{
ComponentInfo.SetLicense("FREE-LIMITED-KEY");
DocumentModel doc = new DocumentModel();
doc.Sections.Add(new Section(doc,
new Paragraph(doc, "Quarterly Report") { ParagraphFormat = { Style = doc.Styles[StyleTemplateType.Heading1] } },
new Paragraph(doc, "Generated from .NET with no Microsoft Word dependency.")
));
doc.Save("report.pdf");
}
}// GemBox.Document creates and converts DOCX/PDF/RTF/HTML/ODT without Office.
using GemBox.Document;
class Program
{
static void Main()
{
ComponentInfo.SetLicense("FREE-LIMITED-KEY");
DocumentModel doc = new DocumentModel();
doc.Sections.Add(new Section(doc,
new Paragraph(doc, "Quarterly Report") { ParagraphFormat = { Style = doc.Styles[StyleTemplateType.Heading1] } },
new Paragraph(doc, "Generated from .NET with no Microsoft Word dependency.")
));
doc.Save("report.pdf");
}
}Imports GemBox.Document
Module Program
Sub Main()
ComponentInfo.SetLicense("FREE-LIMITED-KEY")
Dim doc As New DocumentModel()
doc.Sections.Add(New Section(doc,
New Paragraph(doc, "Quarterly Report") With {.ParagraphFormat = New ParagraphFormat() With {.Style = doc.Styles(StyleTemplateType.Heading1)}},
New Paragraph(doc, "Generated from .NET with no Microsoft Word dependency.")
))
doc.Save("report.pdf")
End Sub
End Module// 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
Module Program
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 ModuleGemBox.Document's expression style, passing Sections/Paragraphs into constructors, is concise and lets a developer build a document tree inline. IronWord uses an AddChild/AddParagraph pattern that maps directly to OOXML and reads as straightforward C#. GemBox.Document has been investing format-conversion depth (Markdown and ODT in particular) — IronWord stays inside the DOCX, PDF, and HTML lane that covers most backend workflows.
PDF Generation and Merging
Both suites cover PDF read/write/merge. GemBox.Pdf builds and edits PDFs at the object-model level. IronPDF renders PDFs from HTML using a real Chrome engine.
// GemBox.Pdf reads, edits, and merges PDFs without Adobe.
using GemBox.Pdf;
class Program
{
static void Main()
{
ComponentInfo.SetLicense("FREE-LIMITED-KEY");
using PdfDocument combined = new PdfDocument();
foreach (string path in new[] { "invoice.pdf", "terms.pdf", "appendix.pdf" })
{
using PdfDocument part = PdfDocument.Load(path);
combined.Pages.AddClone(part.Pages);
}
combined.Save("merged.pdf");
}
}// GemBox.Pdf reads, edits, and merges PDFs without Adobe.
using GemBox.Pdf;
class Program
{
static void Main()
{
ComponentInfo.SetLicense("FREE-LIMITED-KEY");
using PdfDocument combined = new PdfDocument();
foreach (string path in new[] { "invoice.pdf", "terms.pdf", "appendix.pdf" })
{
using PdfDocument part = PdfDocument.Load(path);
combined.Pages.AddClone(part.Pages);
}
combined.Save("merged.pdf");
}
}Imports GemBox.Pdf
Module Program
Sub Main()
ComponentInfo.SetLicense("FREE-LIMITED-KEY")
Using combined As New PdfDocument()
For Each path As String In {"invoice.pdf", "terms.pdf", "appendix.pdf"}
Using part As PdfDocument = PdfDocument.Load(path)
combined.Pages.AddClone(part.Pages)
End Using
Next
combined.Save("merged.pdf")
End Using
End Sub
End Module// NuGet: Install-Package IronPdf
// Docs: https://ironpdf.com/how-to/merge-or-split-pdfs/
using IronPdf;
using System.Collections.Generic;
class Program
{
static void Main()
{
// PdfDocument.Merge accepts an array or params list of PdfDocument objects.
// Order is preserved, and metadata, bookmarks, and annotations are retained.
string[] inputs = { "invoice.pdf", "terms.pdf", "appendix.pdf" };
List<PdfDocument> parts = new List<PdfDocument>();
foreach (string path in inputs)
parts.Add(PdfDocument.FromFile(path));
PdfDocument merged = PdfDocument.Merge(parts.ToArray());
merged.SaveAs("contract-package.pdf");
}
}// NuGet: Install-Package IronPdf
// Docs: https://ironpdf.com/how-to/merge-or-split-pdfs/
using IronPdf;
using System.Collections.Generic;
class Program
{
static void Main()
{
// PdfDocument.Merge accepts an array or params list of PdfDocument objects.
// Order is preserved, and metadata, bookmarks, and annotations are retained.
string[] inputs = { "invoice.pdf", "terms.pdf", "appendix.pdf" };
List<PdfDocument> parts = new List<PdfDocument>();
foreach (string path in inputs)
parts.Add(PdfDocument.FromFile(path));
PdfDocument merged = PdfDocument.Merge(parts.ToArray());
merged.SaveAs("contract-package.pdf");
}
}Imports IronPdf
Imports System.Collections.Generic
Module Program
Sub Main()
' PdfDocument.Merge accepts an array or params list of PdfDocument objects.
' Order is preserved, and metadata, bookmarks, and annotations are retained.
Dim inputs As String() = {"invoice.pdf", "terms.pdf", "appendix.pdf"}
Dim parts As New List(Of PdfDocument)()
For Each path As String In inputs
parts.Add(PdfDocument.FromFile(path))
Next
Dim merged As PdfDocument = PdfDocument.Merge(parts.ToArray())
merged.SaveAs("contract-package.pdf")
End Sub
End ModuleBoth engines merge directly against the PDF object model. GemBox.Pdf exposes Pages.AddClone for fine-grained page-tree manipulation; IronPDF's PdfDocument.Merge accepts an array and preserves metadata, bookmarks, and annotations. The HTML round-trip in IronPDF only happens when creating a PDF from HTML; merge, split, sign, and redact all operate on the native PDF structure.
Email (MSG/EML/SMTP/IMAP)
GemBox.Email is one of the differentiated components inside GemBox.Bundle. It handles MSG and EML file formats plus SMTP, POP, and IMAP protocol clients. Iron Suite does not bundle an equivalent email-protocol library.
// GemBox.Email handles MSG/EML plus SMTP/POP/IMAP — useful for transactional mail flows.
using GemBox.Email;
using GemBox.Email.Smtp;
class Program
{
static void Main()
{
ComponentInfo.SetLicense("FREE-LIMITED-KEY");
MailMessage msg = new MailMessage
{
From = "billing@example.com",
Subject = "Invoice 44213",
BodyHtml = "<p>Your invoice is attached.</p>"
};
msg.To.Add("customer@example.com");
msg.Attachments.Add(new Attachment("invoice.pdf"));
using SmtpClient smtp = new SmtpClient("smtp.example.com", 587);
smtp.Connect();
smtp.Authenticate("billing@example.com", "secret");
smtp.SendMessage(msg);
}
}// GemBox.Email handles MSG/EML plus SMTP/POP/IMAP — useful for transactional mail flows.
using GemBox.Email;
using GemBox.Email.Smtp;
class Program
{
static void Main()
{
ComponentInfo.SetLicense("FREE-LIMITED-KEY");
MailMessage msg = new MailMessage
{
From = "billing@example.com",
Subject = "Invoice 44213",
BodyHtml = "<p>Your invoice is attached.</p>"
};
msg.To.Add("customer@example.com");
msg.Attachments.Add(new Attachment("invoice.pdf"));
using SmtpClient smtp = new SmtpClient("smtp.example.com", 587);
smtp.Connect();
smtp.Authenticate("billing@example.com", "secret");
smtp.SendMessage(msg);
}
}Imports GemBox.Email
Imports GemBox.Email.Smtp
Module Program
Sub Main()
ComponentInfo.SetLicense("FREE-LIMITED-KEY")
Dim msg As New MailMessage With {
.From = "billing@example.com",
.Subject = "Invoice 44213",
.BodyHtml = "<p>Your invoice is attached.</p>"
}
msg.To.Add("customer@example.com")
msg.Attachments.Add(New Attachment("invoice.pdf"))
Using smtp As New SmtpClient("smtp.example.com", 587)
smtp.Connect()
smtp.Authenticate("billing@example.com", "secret")
smtp.SendMessage(msg)
End Using
End Sub
End ModuleIron Suite's bundle stays focused on the document and recognition stack: PDF, Office, OCR, Barcode, QR, Print, ZIP, and web scraping. Email file parsing (MSG, EML) plus SMTP, POP, and IMAP protocol clients in the same library is the case GemBox.Email is sold for. Iron Suite users compose, System.Net.Mail.SmtpClient (or a transactional service such as SendGrid or Postmark) for outbound sending, MailKit or similar for MSG and EML parsing.
Why Choose Iron Suite for Code-First .NET Document Automation
$2,998 entry tier (vs $2,200 GemBox.Bundle Single Developer). Perpetual per-developer license at five tier levels. Royalty-free deployment for the licensed seats. Ten products including OCR (Tesseract 5, 125+ languages, handwriting), barcode (30+ symbologies, MAUI scanner), QR (ML-powered), programmatic printing, ZIP/TAR/GZIP/BZIP2 with AES, and in-process web scraping. PDF/A-1 through PDF/A-4 plus PDF/UA-1 and PDF/UA-2. That is the Iron Suite proposition for teams whose work extends past the GemBox Office + PDF + Email + Imaging quadrant. Structural edges that matter for everyday code-first .NET document work:
- Lower entry tier: Iron Suite Lite starts at $2,998; GemBox.Bundle starts at $2,200
- Broader 10-product bundle: Iron Suite includes IronOCR, IronBarcode, IronQR, IronPrint, IronZIP, and IronWebScraper, none of which have a GemBox equivalent
- HTML-first PDF generation with full browser fidelity (CSS, web fonts, SVG) for web-data-to-PDF workloads
- Perpetual per-developer licensing with transparent USD pricing on every tier
How is Iron Suite Different from GemBox.Bundle
- Lower entry price. Iron Suite Lite starts at $2,998 vs GemBox.Bundle's $2,200 Single Developer tier; and Iron Suite covers ten product categories vs GemBox's seven.
- Recognition stack out of the box. IronOCR, IronBarcode, and IronQR have no GemBox equivalent. For workflows that include scanning, recognition, or QR generation, GemBox cannot cover the use case alone.
- Web scraping and ZIP ship inside Iron Suite (IronWebScraper, IronZIP). GemBox.Bundle covers Office + PDF + Email + Imaging but not these adjacent backend categories.
- HTML-first PDF generation with real browser fidelity vs GemBox.Pdf's object-model primitive API.
- Single license-key registration model across products. GemBox requires either
SpreadsheetInfo.SetLicense(...)orComponentInfo.SetLicense(...)per namespace at process start, which adds verbosity in multi-product workloads. - Bundle scope discipline. GemBox's tight focus on Office/PDF/Email/Imaging is intentional and works well for teams whose workload sits squarely inside that lane; Iron Suite extends that lane to include recognition and adjacent categories at a lower starting price.
Conclusion
For the lean SMB ISV shipping a forms-and-reports product to many customer deployments without a redistribution surcharge, GemBox.Bundle is the kit. Office, PDF, Email, and Imaging under a Single Developer tier of $2,200 with royalty-free unlimited deployment included at every paid tier. For the backend team whose document workload extends past Office and PDF into OCR (including handwriting), barcode and QR recognition, web scraping, and programmatic printing under one license, Iron Suite is the kit. From $2,998 at ironsoftware.com/csharp/suite, perpetual and royalty-free for the licensed seats, with a separate Redistribution Add-On for SaaS and OEM redistribution at scale.
