DEV Community

Cover image for How to Convert Word to PDF in C# Without Microsoft Office (Fast & Server-Safe)
Jen
Jen

Posted on

How to Convert Word to PDF in C# Without Microsoft Office (Fast & Server-Safe)

#csharp #dotnet #tutorial #productivity

If you've ever tried to convert Word to PDF in C# using Microsoft Office Interop, you probably know the pain.

COM dependency issues, unstable server-side automation, and the requirement to install the full Microsoft Office suite just to perform document conversion.

This approach might work on a local machine, but it quickly becomes problematic in production environments:

  • Office automation is not recommended for server-side applications.
  • It introduces heavy dependencies.
  • It often causes performance and stability issues.

So what's the better way?

In this guide, we'll show how to convert Word documents to PDF in C# without installing Microsoft Office, using Spire.Doc for .NET - a lightweight .NET library designed for programmatic Word processing.

Why Spire.Doc for .NET for Word to PDF Conversion?

Before we write any code, let's address the obvious question: why Spire.Doc specifically?

Unlike Office automation, it allows developers to work with Word documents directly through a managed .NET API.

Here is a quick comparison of common approaches:

Feature Spire.Doc Word Interop LibreOffice Headless
Office required ✅ None ❌ Full install ✅ None
Linux / Docker ✅ Yes ❌ No ✅ Yes (via CLI)
Conversion fidelity ✅ High ✅ High ⚠️ Variable
Server-side safe ✅ Yes ❌ Not recommended ⚠️ Via subprocess
Offline / air-gapped ✅ Yes ✅ Yes ✅ Yes
Latency ✅ In-process 🐢 Slow (COM) 🐢 Process spin-up
Cost model One-time license Office license Free

The pattern is pretty clear. Word Interop is the go-to for desktop apps where Office is already present - but it's explicitly not recommended by Microsoft for server-side use. LibreOffice headless is a solid free option, but spawning a new process per conversion under load creates its own reliability headaches.

Spire.Doc hits the sweet spot for server-side automation: it's a single NuGet package, fully managed .NET, no external processes, no Office, no network calls.

Spire.Doc for .NET

This makes it a reliable solution for modern .NET applications.

💡Tip: Spire.Doc for .NET offers a free version for evaluation and small projects. A commercial license is required for full features and production use.

🚀 If your .NET application runs in Linux containers, make sure the libgdiplus package is installed. It provides the GDI+ compatibility layer required for document rendering.

Setup: Install Spire.Doc

Installation only takes a few seconds using NuGet.

PM> Install-Package Spire.Doc
Enter fullscreen mode Exit fullscreen mode

Once installed, you're ready to start converting Word documents programmatically.

Basic Conversion - Word to PDF in C

Let's start with the simplest scenario: converting a .docx file to PDF.

using Spire.Doc;

namespace ConvertWordToPdf
{
    class Program
    {
        static void Main(string[] args)
        {
            Document doc = new Document();

            // Load a Word document
            doc.LoadFromFile("C:\\Users\\Tommy\\Desktop\\Sample.docx");

            // Save the document to PDF
            doc.SaveToFile("C:\\Users\\Tommy\\Desktop\\Sample.pdf", FileFormat.PDF);

            // Dispose resources
            doc.Dispose();
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

That's it.

Example output:

Convert Word to PDF in C#

The code performs three steps:

  • Load the Word document into memory.
  • Render the document layout.
  • Export the rendered content as a PDF file.

Advanced Word to PDF Conversion Settings

The default conversion works well, but production systems often need more control over the output. Spire.Doc provides several options that allow developers to tune PDF generation for different scenarios.

Stream-based Conversion - for Web API responses

If you're building an API endpoint that returns a PDF download, writing to disk first is wasteful. Spire.Doc can write directly to any Stream, which means you can pipe the output straight to the HTTP response:

using Spire.Doc;

[HttpPost("convert")]
public IActionResult ConvertToPdf(IFormFile wordFile)
{
    if (wordFile == null || wordFile.Length == 0)
        return BadRequest("No file uploaded.");

    using var inputStream = wordFile.OpenReadStream();
    using var outputStream = new MemoryStream();
    using var doc = new Document();

    // Load from upload stream directly — no temp file needed
    doc.LoadFromStream(inputStream, FileFormat.Docx);
    doc.SaveToStream(outputStream, FileFormat.PDF);

    // Rewind before returning
    outputStream.Position = 0;

    return File(
        outputStream,  //
        "application/pdf",
        Path.GetFileNameWithoutExtension(wordFile.FileName) + ".pdf"
    );
}
Enter fullscreen mode Exit fullscreen mode

Key Points Explanation:

  • doc.LoadFromStream(inputStream, FileFormat.Docx); - Loads Word document directly from upload stream, no temp file needed
  • doc.SaveToStream(outputStream, FileFormat.PDF); - Writes converted PDF directly to memory stream
  • outputStream.Position = 0; - Resets stream position before returning
  • return File(outputStream, "application/pdf", fileName); - Streams PDF directly to HTTP response

⚠️ Note on MemoryStream and large files: For documents under ~50 MB this pattern works fine. For larger files in high-throughput scenarios, consider writing to a FileStream on a temp path and streaming that back - holding very large documents in MemoryStream will put pressure on the LOH (Large Object Heap).

PDF output options - page size, image quality, font embedding

The default output is good, but Spire.Doc exposes a ToPdfParameterList object that gives you control over the most commonly tuned settings:

using Spire.Doc;
using Spire.Pdf;

namespace ConvertWordToPdf
{
    class Program
    {
        static void Main(string[] args)
        {
            Document doc = new Document();

            try
            {
                // Load a Word document
                doc.LoadFromFile(@"C:\Users\Tommy\Desktop\Sample.docx");

                // Create PDF parameter list for output options
                ToPdfParameterList pdfParams = new ToPdfParameterList();

                // 1. Set page size
                // Options: A1, A2, A3, A4, A5, Letter, Legal, etc.
                pdfParams.PdfPageSize = PdfPageSize.A4;

                // 2. Set image quality (0-100, higher = better quality, larger file size)
                pdfParams.ImageQuality = 80; // 80% quality, good balance

                // 3. Set font embedding
                pdfParams.IsEmbeddedAllFonts = true; // Embed all fonts for consistent display
                // Alternative: pdfParams.IsEmbeddedFonts = true; // Some versions use this

                // Optional: Set PDF conformance level (for long-term archiving)
                // pdfParams.PdfConformanceLevel = PdfConformanceLevel.Pdf_A1B;

                // Optional: Set compression level
                // pdfParams.CompressionLevel = PdfCompressionLevel.Best;

                // Save the document to PDF with custom parameters
                doc.SaveToFile(@"C:\Users\Tommy\Desktop\Sample.pdf", pdfParams);

                System.Console.WriteLine("PDF created successfully with custom options!");
            }
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

Code Explanation:

  • ToPdfParameterList - Object that configures PDF output settings like page size, image quality, and font embedding.
  • PdfPageSize.A4 - Sets the output page dimensions (A4, Letter, Legal, etc.).
  • ImageQuality = 80 - Controls image compression (0-100); 80 balances quality and file size.
  • IsEmbeddedAllFonts = true - Embeds all fonts to ensure cross-platform display consistency.

Batch conversion - process an entire folder

For report generation pipelines, scheduled exports, or migration jobs, you'll typically need to process multiple files. Here's a production-ready pattern with basic error isolation so one bad file doesn't abort the whole batch:

using Spire.Doc;
using System.IO;

class Program
{
    static void Main()
    {
        string sourceDir = @"C:\Users\Tommy\Desktop\WordFiles";
        string targetDir = @"C:\Users\Tommy\Desktop\PDFFiles";

        Directory.CreateDirectory(targetDir);

        foreach (string file in Directory.GetFiles(sourceDir, "*.docx"))
        {
            Document doc = new Document();
            doc.LoadFromFile(file);

            string pdfFile = Path.Combine(targetDir, 
                Path.GetFileNameWithoutExtension(file) + ".pdf");

            doc.SaveToFile(pdfFile, FileFormat.PDF);
            doc.Dispose();

            Console.WriteLine($"Convert: {Path.GetFileName(file)}");
          }
    }
}
Enter fullscreen mode Exit fullscreen mode

Typical use cases include:

  • document archiving systems.
  • automated report generation.
  • contract processing pipelines.

Key Points Explanation:

  • Directory.CreateDirectory(targetDir); - Ensures output folder exists before saving files.
  • Directory.GetFiles(sourceDir, "*.docx") - Retrieves all Word documents from the source folder for batch processing.
  • Path.Combine(targetDir, ...) - Constructs output file path while preserving filename.
  • Path.GetFileNameWithoutExtension(file) + ".pdf" - Generates PDF filename by replacing the original extension.
  • Creating a new Document instance per file ensures resources are released and prevents memory buildup during large batch jobs

Real-World Scenarios: ASP.NET Core Web API

The most common server-side pattern: a client POSTs a .docx, gets a .pdf back in the same response. Here's a complete, production-ready controller:

using Microsoft.AspNetCore.Mvc;
using Spire.Doc;

[Route("api/[controller]")]
[ApiController]
public class WordToPdfController : ControllerBase
{
    [HttpPost]
    public async Task<IActionResult> Post(IFormFile file)
    {
        using var ms = new MemoryStream();
        await file.CopyToAsync(ms);
        ms.Position = 0;

        using var doc = new Document();
        doc.LoadFromStream(ms, FileFormat.Docx);

        using var pdf = new MemoryStream();
        doc.SaveToStream(pdf, FileFormat.PDF);
        pdf.Position = 0;

        return File(pdf, "application/pdf", "output.pdf");
    }
}
Enter fullscreen mode Exit fullscreen mode

This approach is commonly used in:

  • document generation platforms.
  • SaaS reporting systems.
  • automated invoice processing.

Code Explanation:

  • [Route("api/[controller]")] and [ApiController] - Standard ASP.NET Core attributes that define the API endpoint and enable automatic model validation.
  • await file.CopyToAsync(ms); - Asynchronously copies uploaded file to memory stream for processing.
  • ms.Position = 0; and pdf.Position = 0; - Resets stream positions to beginning before reading or returning.
  • doc.LoadFromStream(ms, FileFormat.Docx); - Loads Word document directly from memory stream without saving to disk.
  • doc.SaveToStream(pdf, FileFormat.PDF); - Converts and writes PDF to memory stream.
  • return File(pdf, "application/pdf", "output.pdf"); - Streams PDF directly back to client as downloadable file.

Common Pitfalls Developers Hit When Converting Word to PDF

When implementing Word-to-PDF conversion in C# in production, there are a few common issues developers run into.

Missing Fonts on Linux ServersLinux

If your application runs on Linux, missing fonts can cause layout problems.

Install common fonts using:

sudo apt install fontconfig
Enter fullscreen mode Exit fullscreen mode

You may also need to install additional font packages depending on your document templates.

Large Document Memory Usage

Large documents with high-resolution images can consume significant memory.

Possible solutions include:

  • reducing image resolution.
  • streaming processing pipelines.
  • batch processing instead of single large jobs.

Layout Differences

Some complex Word features (especially embedded objects) may render slightly differently in PDF.

Testing with real-world documents is always recommended.

Wrap-up

If you're building a C# application that needs Word-to-PDF conversion:

  • Avoid Microsoft Office Interop for server environments.
  • Use a dedicated document library like Spire.Doc for .NET.
  • Implement stream-based or batch processing for scalable systems.

With just a few lines of code, you can integrate reliable Word-to-PDF conversion into your .NET applications - without installing Microsoft Office.

Top comments (0)