Skip to footer content
  1. IronPDF
  2. IronPDF Blog
  3. Migration Guides
  4. migration from telerik document processing to ironpdf
MIGRATION GUIDES

How to Migrate from Telerik Document Processing to IronPDF in C#

Curtis Chau
Curtis Chau
Published:

Telerik Document Processing has served the .NET ecosystem as part of the DevCraft suite, offering developers PDF generation capabilities alongside Word, Excel, and PowerPoint processing. However, as modern web standards evolve and projects demand full CSS3, Flexbox, and Bootstrap support, many development teams are discovering fundamental limitations in Telerik's HTML-to-PDF rendering architecture.

This guide provides a complete migration path from Telerik Document Processing to IronPDF, with step-by-step instructions, code comparisons, and practical examples drawn directly from real migration scenarios.

Why Migrate from Telerik Document Processing

The decision to migrate from Telerik Document Processing typically stems from technical limitations that become apparent when working with modern web content. Understanding these limitations helps justify the migration effort and sets expectations for what IronPDF resolves.

Critical Technical Limitations

Telerik Document Processing has fundamental issues when handling modern HTML and CSS:

IssueImpactIronPDF Solution
CSS parsing limitationsModern CSS frameworks like Bootstrap failFull Chromium CSS support
Div-to-paragraph conversionHTML structure flattened, layouts breakDirect HTML rendering
Flow document modelForces intermediate conversionNative HTML-to-PDF
External CSS issuesComplex selectors ignoredFull CSS file support
Memory issuesOutOfMemoryException on large docsEfficient streaming

The Core Problem: HTML Is Not Rendered Correctly

Telerik Document Processing converts HTML to an intermediate "Flow Document" model before generating PDF. This architectural decision creates cascading problems:

  1. Flattens HTML structure — <div> elements become paragraphs
  2. Ignores modern CSS — Flexbox and Grid layouts fail completely
  3. Breaks Bootstrap — Column systems don't render as columns
  4. Loses formatting — Complex CSS selectors are ignored

Consider this modern HTML that uses standard CSS layouts:


<div class="container">
    <div class="row">
        <div class="col-md-6">Column 1</div>
        <div class="col-md-6">Column 2</div>
    </div>
</div>

<div style="display: flex; gap: 20px;">
    <div style="flex: 1;">Flex Item 1</div>
    <div style="flex: 1;">Flex Item 2</div>
</div>

<div style="display: grid; grid-template-columns: repeat(3, 1fr);">
    <div>Grid Item 1</div>
    <div>Grid Item 2</div>
    <div>Grid Item 3</div>
</div>

<div class="container">
    <div class="row">
        <div class="col-md-6">Column 1</div>
        <div class="col-md-6">Column 2</div>
    </div>
</div>

<div style="display: flex; gap: 20px;">
    <div style="flex: 1;">Flex Item 1</div>
    <div style="flex: 1;">Flex Item 2</div>
</div>

<div style="display: grid; grid-template-columns: repeat(3, 1fr);">
    <div>Grid Item 1</div>
    <div>Grid Item 2</div>
    <div>Grid Item 3</div>
</div>
HTML

In Telerik Document Processing, all of these layouts render as sequential paragraphs. The two-column Bootstrap layout becomes two lines of text. The flexbox items stack vertically. The CSS Grid items appear one after another.

CSS Features That Fail in Telerik Document Processing

Developers have documented extensive CSS compatibility issues:

/* ❌ These CSS features DON'T WORK in Telerik Document Processing */

/* Flexbox - Not supported */
.container { display: flex; }
.item { flex: 1; }

/* CSS Grid - Not supported */
.grid { display: grid; grid-template-columns: repeat(3, 1fr); }

/* Bootstrap columns - Converted to paragraphs */
.col-md-6 { /* Ignored, becomes linear text */ }

/* CSS Variables - Not supported */
:root { --primary: #007bff; }
.btn { color: var(--primary); }

/* Complex selectors - Often ignored */
.container > .row:first-child { }
.item:hover { }
.content::before { }

/* Modern units - Limited support */
.box { width: calc(100% - 20px); }
.text { font-size: 1.2rem; }

Performance Issues with Large Documents

Beyond CSS limitations, Telerik Document Processing has documented OutOfMemoryException errors when processing large files. Development teams working with high-volume document generation have encountered stability issues that other libraries handle more efficiently.

IronPDF vs Telerik Document Processing: Feature Comparison

Understanding the feature differences helps technical decision-makers evaluate the migration investment:

FeatureTelerik Document ProcessingIronPDF
HTML RenderingFlow Document conversionDirect Chromium rendering
CSS3 SupportLimited, many features failFull CSS3
FlexboxNot supportedSupported
CSS GridNot supportedSupported
BootstrapBroken (div flattening)Supported including Bootstrap 5
External CSSPartialSupported
JavaScriptNot supportedFull ES2024 support
Large DocumentsMemory issuesEfficient streaming
API ComplexityComplex (providers, models)Simple (one class)
License ModelCommercial, part of DevCraftSimple standalone licensing

Quick Start Migration: 5 Minutes to Your First PDF

The migration from Telerik Document Processing to IronPDF can begin immediately. Here's the fastest path to generating your first PDF with IronPDF.

Step 1: Update NuGet Packages

Remove all Telerik document processing packages:

# Remove Telerik packages
dotnet remove package Telerik.Documents.Core
dotnet remove package Telerik.Documents.Flow
dotnet remove package Telerik.Documents.Flow.FormatProviders.Pdf
dotnet remove package Telerik.Documents.Fixed
# Remove Telerik packages
dotnet remove package Telerik.Documents.Core
dotnet remove package Telerik.Documents.Flow
dotnet remove package Telerik.Documents.Flow.FormatProviders.Pdf
dotnet remove package Telerik.Documents.Fixed
SHELL

Install IronPDF:

# Install IronPDF
dotnet add package IronPdf
# Install IronPDF
dotnet add package IronPdf
SHELL

Step 2: Update Using Statements

Replace Telerik namespaces with the IronPdf namespace:

// Before (Telerik Document Processing)
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using Telerik.Documents.Primitives;

// After (IronPDF)
using IronPdf;
// Before (Telerik Document Processing)
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using Telerik.Documents.Primitives;

// After (IronPDF)
using IronPdf;
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Step 3: Add License Key

Initialize your license at application startup:

// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Step 4: Update Your PDF Generation Code

The transformation from Telerik Document Processing to IronPDF dramatically simplifies your codebase.

Before (Telerik Document Processing):

using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;

HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(htmlContent);

PdfFormatProvider pdfProvider = new PdfFormatProvider();
byte[] pdfBytes = pdfProvider.Export(document);

File.WriteAllBytes("output.pdf", pdfBytes);
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;

HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(htmlContent);

PdfFormatProvider pdfProvider = new PdfFormatProvider();
byte[] pdfBytes = pdfProvider.Export(document);

File.WriteAllBytes("output.pdf", pdfBytes);
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

After (IronPDF):

using IronPdf;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("output.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("output.pdf");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

The difference is immediately apparent: 3 lines of IronPDF code replace 15+ lines of Telerik Document Processing code. More importantly, the IronPDF version will correctly render modern CSS that Telerik's Flow Document model cannot handle.

Code Migration Examples

Converting HTML to PDF

This is the most common use case for PDF generation. The architectural differences between Telerik Document Processing and IronPDF become clear in this comparison.

Telerik Document Processing Approach:

// NuGet: Install-Package Telerik.Documents.Flow
// NuGet: Install-Package Telerik.Documents.Flow.FormatProviders.Pdf
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using System.IO;

string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";

HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(html);

PdfFormatProvider pdfProvider = new PdfFormatProvider();
using (FileStream output = File.OpenWrite("output.pdf"))
{
    pdfProvider.Export(document, output);
}
// NuGet: Install-Package Telerik.Documents.Flow
// NuGet: Install-Package Telerik.Documents.Flow.FormatProviders.Pdf
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using System.IO;

string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";

HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(html);

PdfFormatProvider pdfProvider = new PdfFormatProvider();
using (FileStream output = File.OpenWrite("output.pdf"))
{
    pdfProvider.Export(document, output);
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

IronPDF Approach:

// NuGet: Install-Package IronPdf
using IronPdf;

string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
// NuGet: Install-Package IronPdf
using IronPdf;

string html = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

The Telerik version requires creating an HtmlFormatProvider, importing to a RadFlowDocument, creating a PdfFormatProvider, and managing file streams manually. IronPDF's ChromePdfRenderer handles the entire process with a single method call.

For more advanced HTML-to-PDF scenarios, see the HTML to PDF conversion guide.

Converting URLs to PDF

Capturing web pages as PDFs reveals another significant difference between the libraries.

Telerik Document Processing Approach:

// NuGet: Install-Package Telerik.Documents.Flow
// NuGet: Install-Package Telerik.Documents.Flow.FormatProviders.Pdf
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

string url = "https://example.com";

using HttpClient client = new HttpClient();
string html = await client.GetStringAsync(url);

HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(html);

PdfFormatProvider pdfProvider = new PdfFormatProvider();
using (FileStream output = File.OpenWrite("webpage.pdf"))
{
    pdfProvider.Export(document, output);
}
// NuGet: Install-Package Telerik.Documents.Flow
// NuGet: Install-Package Telerik.Documents.Flow.FormatProviders.Pdf
using Telerik.Windows.Documents.Flow.FormatProviders.Html;
using Telerik.Windows.Documents.Flow.FormatProviders.Pdf;
using Telerik.Windows.Documents.Flow.Model;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

string url = "https://example.com";

using HttpClient client = new HttpClient();
string html = await client.GetStringAsync(url);

HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
RadFlowDocument document = htmlProvider.Import(html);

PdfFormatProvider pdfProvider = new PdfFormatProvider();
using (FileStream output = File.OpenWrite("webpage.pdf"))
{
    pdfProvider.Export(document, output);
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

IronPDF Approach:

// NuGet: Install-Package IronPdf
using IronPdf;

string url = "https://example.com";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf(url);
pdf.SaveAs("webpage.pdf");
// NuGet: Install-Package IronPdf
using IronPdf;

string url = "https://example.com";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf(url);
pdf.SaveAs("webpage.pdf");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Telerik Document Processing has no native URL-to-PDF capability. You must manually fetch HTML content using HttpClient, losing external CSS, JavaScript execution, and dynamic content in the process. IronPDF's RenderUrlAsPdf method captures the complete rendered page exactly as it appears in a browser.

Explore the URL to PDF documentation for additional options including authentication and custom headers.

Merging Multiple PDFs

PDF merging demonstrates the verbosity difference between these .NET PDF libraries.

Telerik Document Processing Approach:

// NuGet: Install-Package Telerik.Documents.Fixed
using Telerik.Windows.Documents.Fixed.FormatProviders.Pdf;
using Telerik.Windows.Documents.Fixed.Model;
using System.IO;

PdfFormatProvider provider = new PdfFormatProvider();

RadFixedDocument document1;
using (FileStream input = File.OpenRead("document1.pdf"))
{
    document1 = provider.Import(input);
}

RadFixedDocument document2;
using (FileStream input = File.OpenRead("document2.pdf"))
{
    document2 = provider.Import(input);
}

RadFixedDocument mergedDocument = new RadFixedDocument();
foreach (var page in document1.Pages)
{
    mergedDocument.Pages.Add(page);
}
foreach (var page in document2.Pages)
{
    mergedDocument.Pages.Add(page);
}

using (FileStream output = File.OpenWrite("merged.pdf"))
{
    provider.Export(mergedDocument, output);
}
// NuGet: Install-Package Telerik.Documents.Fixed
using Telerik.Windows.Documents.Fixed.FormatProviders.Pdf;
using Telerik.Windows.Documents.Fixed.Model;
using System.IO;

PdfFormatProvider provider = new PdfFormatProvider();

RadFixedDocument document1;
using (FileStream input = File.OpenRead("document1.pdf"))
{
    document1 = provider.Import(input);
}

RadFixedDocument document2;
using (FileStream input = File.OpenRead("document2.pdf"))
{
    document2 = provider.Import(input);
}

RadFixedDocument mergedDocument = new RadFixedDocument();
foreach (var page in document1.Pages)
{
    mergedDocument.Pages.Add(page);
}
foreach (var page in document2.Pages)
{
    mergedDocument.Pages.Add(page);
}

using (FileStream output = File.OpenWrite("merged.pdf"))
{
    provider.Export(mergedDocument, output);
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

IronPDF Approach:

// NuGet: Install-Package IronPdf
using IronPdf;

var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");

var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");
// NuGet: Install-Package IronPdf
using IronPdf;

var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");

var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

The Telerik version requires importing each document separately, manually iterating through pages, adding them to a new document, and managing multiple file streams. IronPDF's PdfDocument.Merge() method handles everything in a single call.

For advanced merging scenarios including selective page extraction, see the merge and split PDFs guide.

Telerik Document Processing API to IronPDF Mapping

This reference table accelerates migration by showing direct API equivalents:

Telerik Document ProcessingIronPDF
HtmlFormatProviderChromePdfRenderer
RadFlowDocumentNot needed
PdfFormatProviderpdf.SaveAs()
RadFlowDocumentEditorHTML manipulation
SectionHTML <section>
ParagraphHTML <p>
PdfExportSettingsRenderingOptions
RadFixedDocumentPdfDocument
Manual page iterationPdfDocument.Merge()

Handling Headers and Footers

Telerik Document Processing uses a programmatic model for headers and footers. IronPDF provides HTML-based headers with dynamic placeholders.

Telerik Document Processing:

section.Headers.Default.Blocks.AddParagraph().Inlines.AddRun("Header Text");
section.Footers.Default.Blocks.AddParagraph().Inlines.AddRun("Footer Text");
section.Headers.Default.Blocks.AddParagraph().Inlines.AddRun("Header Text");
section.Footers.Default.Blocks.AddParagraph().Inlines.AddRun("Footer Text");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

IronPDF:

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align:center;'>Header Text</div>",
    MaxHeight = 25
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align:center;'>Footer Text</div>",
    MaxHeight = 25
};
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align:center;'>Header Text</div>",
    MaxHeight = 25
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<div style='text-align:center;'>Footer Text</div>",
    MaxHeight = 25
};
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

IronPDF's HTML-based approach allows full CSS styling in headers and footers, plus dynamic placeholders for page numbers and dates. Learn more in the headers and footers documentation.

Unit Conversion: DIPs to Millimeters

Telerik Document Processing uses device-independent pixels (DIPs) for measurements. IronPDF uses millimeters. This requires conversion during migration:

// Telerik uses DIPs (device-independent pixels)
// IronPDF uses millimeters

// 1 inch = 25.4mm
renderer.RenderingOptions.MarginTop = 25.4;    // 1 inch
renderer.RenderingOptions.MarginBottom = 25.4;

// Or use the helper method for paper size
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11);
// Telerik uses DIPs (device-independent pixels)
// IronPDF uses millimeters

// 1 inch = 25.4mm
renderer.RenderingOptions.MarginTop = 25.4;    // 1 inch
renderer.RenderingOptions.MarginBottom = 25.4;

// Or use the helper method for paper size
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11);
' Telerik uses DIPs (device-independent pixels)
' IronPDF uses millimeters

' 1 inch = 25.4mm
renderer.RenderingOptions.MarginTop = 25.4    ' 1 inch
renderer.RenderingOptions.MarginBottom = 25.4

' Or use the helper method for paper size
renderer.RenderingOptions.SetCustomPaperSizeInInches(8.5, 11)
$vbLabelText   $csharpLabel

Telerik Document Processing Migration Checklist

Pre-Migration Tasks

Audit your codebase to identify all Telerik Document Processing usage:

grep -r "using Telerik.Windows.Documents" --include="*.cs" .
grep -r "RadFlowDocument\|HtmlFormatProvider\|PdfFormatProvider" --include="*.cs" .
grep -r "using Telerik.Windows.Documents" --include="*.cs" .
grep -r "RadFlowDocument\|HtmlFormatProvider\|PdfFormatProvider" --include="*.cs" .
SHELL

Document existing implementations including format providers used, header/footer configurations, custom page settings, and any Flow Document model modifications.

During Migration

  1. Remove Telerik NuGet packages
  2. Install IronPdf NuGet package
  3. Update using statements from Telerik.Windows.Documents to IronPdf
  4. Add license key initialization at startup
  5. Replace HtmlFormatProvider with ChromePdfRenderer
  6. Remove RadFlowDocument intermediate steps
  7. Replace PdfFormatProvider exports with direct SaveAs() calls
  8. Update headers/footers to use HtmlHeaderFooter
  9. Convert page settings to RenderingOptions
  10. Update margin units from DIPs to millimeters

Post-Migration Verification

After migration, verify these improvements:

  • CSS rendering should improve significantly
  • Bootstrap layouts should render correctly (they don't in Telerik)
  • Flexbox and Grid layouts should work (they don't in Telerik)
  • JavaScript execution should function for dynamic content
  • Large document generation should complete without memory exceptions

Key Benefits of Migrating to IronPDF

Moving from Telerik Document Processing to IronPDF provides immediate advantages:

Modern Chromium Rendering Engine: IronPDF uses the same rendering engine as Google Chrome, ensuring PDFs render exactly as content appears in modern browsers. This eliminates the CSS compatibility issues inherent in Telerik's Flow Document model.

Full CSS3 and JavaScript Support: Flexbox, Grid, Bootstrap 5, CSS variables, and modern JavaScript all work correctly. As .NET 10 and C# 14 adoption increases through 2026, IronPDF's modern rendering ensures compatibility with contemporary web standards.

Simpler API: Fewer lines of code, no intermediate document models, and intuitive method names reduce development time and maintenance burden.

Standalone Licensing: IronPDF offers straightforward licensing without requiring a comprehensive suite purchase, providing a cost-effective solution for teams that only need PDF capabilities.

Active Development: Regular updates ensure compatibility with current and future .NET versions, security patches, and feature enhancements.

Curtis Chau
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.

...

Read More

Related Articles

30-day trial → Full product. No limits. No card. Start Free Trial