Converting a Word document to PDF in C# takes three lines of code with IronPDF: create a DocxToPdfRenderer, call RenderDocxAsPdf, and save the result. No Microsoft Office installation, no COM interop, no complex server configuration -- just a NuGet package and .NET code that works in any environment including cloud, Docker, and Windows services.
Open the Package Manager Console in Visual Studio and run the following command to install IronPDF:
Once the package is installed, add a using IronPdf; directive to your C# files. IronPDF targets .NET 8 and later, making it compatible with ASP.NET Core, ASP.NET Framework 4.6.2+, and modern worker service projects. No additional runtime components or Microsoft Office licenses are required.
Before running in production, set your license key once at application startup -- for example at the top of Program.cs. You can read the key from appsettings.json to keep credentials out of source control: IronPdf.License.LicenseKey = configuration["IronPdf:LicenseKey"]!;.
IronPDF supports the following platforms:
| Platform | Minimum Version | Notes |
|---|---|---|
| .NET | 8, 9, 10 | Full support, recommended |
| .NET Framework | 4.6.2 | Windows only |
| ASP.NET Core | 3.1+ | Middleware and MVC controllers |
| Azure Functions | v4 | Isolated process model |
| Docker / Linux | Any | Requires libgdiplus |
The DocxToPdfRenderer class is the entry point for all Word-to-PDF conversions. It accepts a file path, a byte array, or a Stream, and returns a PdfDocument object that you can save, encrypt, merge, or serve directly over HTTP.
Here is the simplest possible conversion:
using IronPdf;
// Set license key before first use
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
var renderer = new DocxToPdfRenderer();
var pdf = renderer.RenderDocxAsPdf("report.docx");
pdf.SaveAs("report.pdf");Imports IronPdf
' Set license key before first use
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
Dim renderer As New DocxToPdfRenderer()
Dim pdf = renderer.RenderDocxAsPdf("report.docx")
pdf.SaveAs("report.pdf")DocxToPdfRenderer preserves the following Word document elements during conversion:
For detailed behavior notes on edge cases such as embedded OLE objects or tracked changes, see the DocxToPdfRenderer documentation.
When you receive a DOCX file as an upload or read it from a database blob, you can pass the stream directly to the renderer:
using IronPdf;
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
using var docxStream = new FileStream("document.docx", FileMode.Open);
var renderer = new DocxToPdfRenderer();
var pdfDocument = renderer.RenderDocxAsPdf(docxStream);
pdfDocument.SaveAs("output.pdf");Imports IronPdf
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
Using docxStream As New FileStream("document.docx", FileMode.Open)
Dim renderer As New DocxToPdfRenderer()
Dim pdfDocument = renderer.RenderDocxAsPdf(docxStream)
pdfDocument.SaveAs("output.pdf")
End UsingThis approach avoids writing temporary files to disk, which is important in read-only file system environments such as Azure App Service.
When you need to process an entire folder of documents, iterate over the files and reuse a single DocxToPdfRenderer instance. Reusing the renderer avoids repeated initialization overhead:
using IronPdf;
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
var renderer = new DocxToPdfRenderer();
string[] docxFiles = Directory.GetFiles(@"C:\WordDocuments", "*.docx");
foreach (string docxFile in docxFiles)
{
var pdf = renderer.RenderDocxAsPdf(docxFile);
string pdfPath = Path.ChangeExtension(docxFile, ".pdf");
pdf.SaveAs(pdfPath);
Console.WriteLine($"Converted: {Path.GetFileName(pdfPath)}");
}Imports IronPdf
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
Dim renderer As New DocxToPdfRenderer()
Dim docxFiles As String() = Directory.GetFiles("C:\WordDocuments", "*.docx")
For Each docxFile As String In docxFiles
Dim pdf = renderer.RenderDocxAsPdf(docxFile)
Dim pdfPath As String = Path.ChangeExtension(docxFile, ".pdf")
pdf.SaveAs(pdfPath)
Console.WriteLine($"Converted: {Path.GetFileName(pdfPath)}")
Next
For high-throughput scenarios, consider parallelizing the loop with Parallel.ForEach. Create one DocxToPdfRenderer per thread if you run concurrent conversions, since the class is not thread-safe when shared across threads.
Mail Merge lets you define a DOCX template with placeholders and then populate those placeholders with data at runtime. This pattern is ideal for invoices, contracts, certificates, and any document where the structure is fixed but the content varies per recipient.
IronPDF's DocxToPdfRenderer accepts a DataTable, a Dictionary<string, string>, or a custom data source through the MailMergeDataSource property:
using IronPdf;
using System.Data;
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
// Build the data source
var data = new DataTable();
data.Columns.Add("CustomerName");
data.Columns.Add("InvoiceNumber");
data.Columns.Add("TotalAmount");
data.Rows.Add("Acme Corp", "INV-2026-001", "$4,500.00");
var renderer = new DocxToPdfRenderer();
renderer.MailMergeDataSource = data;
var pdf = renderer.RenderDocxAsPdf("invoice_template.docx");
pdf.SaveAs("acme_invoice.pdf");Imports IronPdf
Imports System.Data
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
' Build the data source
Dim data As New DataTable()
data.Columns.Add("CustomerName")
data.Columns.Add("InvoiceNumber")
data.Columns.Add("TotalAmount")
data.Rows.Add("Acme Corp", "INV-2026-001", "$4,500.00")
Dim renderer As New DocxToPdfRenderer()
renderer.MailMergeDataSource = data
Dim pdf = renderer.RenderDocxAsPdf("invoice_template.docx")
pdf.SaveAs("acme_invoice.pdf")In the DOCX template, surround each field name with double chevrons (e.g., <<CustomerName>>) to mark the merge fields. At conversion time, IronPDF replaces each placeholder with the corresponding column value from the data source. You can learn more about document automation patterns in the Microsoft Word mail merge documentation.
After conversion, you can apply password protection and permission restrictions directly on the PdfDocument object before saving. This is useful when distributing financial reports, legal agreements, or any document that should not be freely copied or printed:
using IronPdf;
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
var renderer = new DocxToPdfRenderer();
var pdf = renderer.RenderDocxAsPdf("confidential.docx");
// Require a password to open the file
pdf.SecuritySettings.UserPassword = "user123";
// Owner password allows overriding restrictions
pdf.SecuritySettings.OwnerPassword = "owner456";
// Restrict printing and content copying
pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.NoPrint;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SaveAs("secured_document.pdf");Imports IronPdf
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
Dim renderer As New DocxToPdfRenderer()
Dim pdf = renderer.RenderDocxAsPdf("confidential.docx")
' Require a password to open the file
pdf.SecuritySettings.UserPassword = "user123"
' Owner password allows overriding restrictions
pdf.SecuritySettings.OwnerPassword = "owner456"
' Restrict printing and content copying
pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.NoPrint
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SaveAs("secured_document.pdf")
IronPDF encrypts with 128-bit RC4 by default, with 128-bit and 256-bit AES available as selectable options. For more details on all available security options, see the IronPDF security documentation.
The following table summarizes the most commonly used security properties:
| Property | Type | Description |
|---|---|---|
| UserPassword | string | Password required to open the document |
| OwnerPassword | string | Password that overrides all restrictions |
| AllowUserPrinting | PdfPrintSecurity enum | Controls print permissions |
| AllowUserCopyPasteContent | bool | Allows or blocks text copying |
| AllowUserAnnotations | bool | Allows or blocks annotation tools |
| AllowUserFormData | bool | Allows or blocks form filling |
To expose Word-to-PDF conversion as an HTTP endpoint, inject the conversion logic into a controller action. The following example accepts a multipart form upload, converts the file in memory, and returns the PDF as a downloadable file response:
using IronPdf;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
[ApiController]
[Route("api/[controller]")]
public class DocumentController : ControllerBase
{
[HttpPost("convert")]
public IActionResult ConvertWordToPdf(IFormFile wordFile)
{
if (wordFile == null || wordFile.Length == 0)
return BadRequest("Please upload a valid Word document.");
using var stream = new MemoryStream();
wordFile.CopyTo(stream);
var renderer = new DocxToPdfRenderer();
var pdfDocument = renderer.RenderDocxAsPdf(stream.ToArray());
return File(pdfDocument.BinaryData, "application/pdf", "converted.pdf");
}
}Imports IronPdf
Imports Microsoft.AspNetCore.Http
Imports Microsoft.AspNetCore.Mvc
<ApiController>
<Route("api/[controller]")>
Public Class DocumentController
Inherits ControllerBase
<HttpPost("convert")>
Public Function ConvertWordToPdf(wordFile As IFormFile) As IActionResult
If wordFile Is Nothing OrElse wordFile.Length = 0 Then
Return BadRequest("Please upload a valid Word document.")
End If
Using stream As New MemoryStream()
wordFile.CopyTo(stream)
Dim renderer As New DocxToPdfRenderer()
Dim pdfDocument = renderer.RenderDocxAsPdf(stream.ToArray())
Return File(pdfDocument.BinaryData, "application/pdf", "converted.pdf")
End Using
End Function
End ClassFor larger applications, register DocxToPdfRenderer as a singleton via the built-in ASP.NET Core dependency injection system. In Program.cs, add builder.Services.AddSingleton<DocxToPdfRenderer>(); after setting the license key. Registering the renderer as a singleton means the object is initialized once and reused across all requests, which reduces per-request overhead. Inject it into controllers and services through the constructor as you would any other dependency.
Word documents can contain unsupported features or be malformed. Wrap conversion calls in a try/catch block to handle IronPdfException and return a meaningful response to the caller:
try
{
var pdf = renderer.RenderDocxAsPdf(stream.ToArray());
return File(pdf.BinaryData, "application/pdf", "output.pdf");
}
catch (IronPdfException ex)
{
// Log the exception and return a 422 Unprocessable Entity
return UnprocessableEntity($"Conversion failed: {ex.Message}");
}Try
Dim pdf = renderer.RenderDocxAsPdf(stream.ToArray())
Return File(pdf.BinaryData, "application/pdf", "output.pdf")
Catch ex As IronPdfException
' Log the exception and return a 422 Unprocessable Entity
Return UnprocessableEntity($"Conversion failed: {ex.Message}")
End TryGood error handling prevents unhandled exceptions from surfacing to end users and makes debugging conversion problems significantly easier.
A common workflow involves converting a DOCX cover letter and then prepending it to an existing PDF report. IronPDF's PDF merging capability makes this a one-liner:
using IronPdf;
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
var renderer = new DocxToPdfRenderer();
var coverLetter = renderer.RenderDocxAsPdf("cover_letter.docx");
var existingReport = PdfDocument.FromFile("annual_report.pdf");
// Merge cover letter (first) with existing report (second)
var merged = PdfDocument.Merge(coverLetter, existingReport);
merged.SaveAs("final_document.pdf");Imports IronPdf
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
Dim renderer As New DocxToPdfRenderer()
Dim coverLetter As PdfDocument = renderer.RenderDocxAsPdf("cover_letter.docx")
Dim existingReport As PdfDocument = PdfDocument.FromFile("annual_report.pdf")
' Merge cover letter (first) with existing report (second)
Dim merged As PdfDocument = PdfDocument.Merge(coverLetter, existingReport)
merged.SaveAs("final_document.pdf")You can merge as many PdfDocument objects as needed by passing a collection to PdfDocument.Merge. For more advanced document assembly scenarios, explore adding pages to an existing PDF or stamping watermarks onto the converted output.
After converting a DOCX file, you can add custom headers, footers, and text stamps to every page. This is useful for adding approval status, confidentiality notices, or branding to generated documents:
using IronPdf;
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
var renderer = new DocxToPdfRenderer();
var pdf = renderer.RenderDocxAsPdf("proposal.docx");
// Add a text stamp on every page
pdf.ApplyStamp(new TextStamp("DRAFT", new TextStampStyle
{
FontSize = 36,
FontColor = IronSoftware.Drawing.Color.FromArgb(100, 200, 0, 0),
VerticalAlignment = VerticalAlignment.Middle,
HorizontalAlignment = HorizontalAlignment.Center,
Rotation = -45
}));
pdf.SaveAs("proposal_draft.pdf");Imports IronPdf
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
Dim renderer As New DocxToPdfRenderer()
Dim pdf = renderer.RenderDocxAsPdf("proposal.docx")
' Add a text stamp on every page
pdf.ApplyStamp(New TextStamp("DRAFT", New TextStampStyle With {
.FontSize = 36,
.FontColor = IronSoftware.Drawing.Color.FromArgb(100, 200, 0, 0),
.VerticalAlignment = VerticalAlignment.Middle,
.HorizontalAlignment = HorizontalAlignment.Center,
.Rotation = -45
}))
pdf.SaveAs("proposal_draft.pdf")For HTML-based headers and footers that include page numbers, see the IronPDF headers and footers documentation.
Several libraries exist for converting DOCX files to PDF in .NET. Understanding the trade-offs helps you choose the right tool for your use case.
Telerik Document Processing (RadWordsProcessing) supports DOCX to PDF conversion and is included with the Telerik suite. It works entirely in managed code and does not require native dependencies, but its rendering fidelity for complex layouts can differ from Word. Aspose.Words is another established option with high fidelity and a rich API, though it carries a per-developer license cost similar to IronPDF.
For open-source alternatives, DocX by Xceed provides DOCX manipulation but does not include PDF conversion directly. Developers who need a zero-dependency option on Linux may also consider LibreOffice headless called from a process, though that introduces a large binary dependency and process-spawning overhead.
| Library | Rendering Fidelity | Office Required | Linux Support | License Model |
|---|---|---|---|---|
| IronPDF | High | No | Yes | Per-developer / SaaS |
| Aspose.Words | Very High | No | Yes | Per-developer |
| Telerik RadWords | Medium-High | No | Yes | Telerik suite |
| Microsoft.Office.Interop | Perfect | Yes | No | Office license |
| LibreOffice headless | Medium | No | Yes | Open source (MPL) |
The main advantage of IronPDF in this comparison is the combination of high fidelity, no native Office dependency, Linux support, and a straightforward NuGet-based installation. For teams already using an IronPDF license for HTML-to-PDF conversion, the DOCX renderer comes included at no additional cost.
IronPDF reads the Office Open XML (OOXML) format directly -- the same specification used by Microsoft Word. It does not invoke Word in the background or use a COM automation bridge. This means the conversion runs in-process within your .NET application, which makes it predictable, deterministic, and safe for multi-threaded server workloads.
The internal pipeline parses the OOXML XML package, resolves embedded resources (images, fonts, embedded objects), applies paragraph and run formatting, lays out the page geometry according to the document's section properties, and rasterizes the result into a PDF content stream. The PDF specification (ISO 32000) governs the output format, ensuring compatibility with all major PDF viewers.
You now have a solid foundation for converting Word documents to PDF in any .NET or ASP.NET application. Here is what to explore next:
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.
IronPDF is a part of IRONSUITE
10 .NET API products for your office documents
When you need your PDF to look like HTML, fast.
