DEV Community

IronSoftware
IronSoftware

Posted on

Export and Save PDF in C# (.NET Guide)

#csharp #dotnet

Once you've generated a PDF, you need to get it somewhere—a file, a database, a web response, or cloud storage. Here are all the ways to export PDFs in C#.

using IronPdf;
// Install via NuGet: Install-Package IronPdf

var renderer = new [ChromePdfRenderer](https://ironpdf.com/blog/videos/how-to-render-an-html-file-to-pdf-in-csharp-ironpdf/)();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Save to file
pdf.SaveAs("output.pdf");

// Get as byte array
byte[] bytes = pdf.BinaryData;

// Get as stream
Stream stream = pdf.Stream;
Enter fullscreen mode Exit fullscreen mode

Three outputs from one PDF. File, bytes, or stream—your choice based on where the PDF needs to go.

How Do I Save to a File?

The simplest export—write directly to disk:

using IronPdf;
// Install via NuGet: Install-Package IronPdf

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Invoice #12345</h1>");

// Save to current directory
pdf.SaveAs("invoice.pdf");

// Save to specific path
pdf.SaveAs(@"C:\invoices\2024\invoice-12345.pdf");

// Ensure directory exists first
Directory.CreateDirectory(@"C:\invoices\2024");
pdf.SaveAs(@"C:\invoices\2024\invoice-12345.pdf");
Enter fullscreen mode Exit fullscreen mode

SaveAs overwrites existing files. Check for existence first if you need to prevent overwrites.

How Do I Get the PDF as a Byte Array?

For database storage, API responses, or in-memory processing:

using IronPdf;
// Install via NuGet: Install-Package IronPdf

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Report</h1>");

// Get binary data
byte[] pdfBytes = pdf.BinaryData;

// Now you can:
// - Store in database BLOB column
// - Send via HTTP response
// - Upload to cloud storage
// - Encrypt/process further

Console.WriteLine($"PDF size: {pdfBytes.Length} bytes");
Enter fullscreen mode Exit fullscreen mode

Byte arrays are the universal format for moving binary data around.

How Do I Get the PDF as a Stream?

For streaming scenarios without loading everything into memory:

using IronPdf;
// Install via NuGet: Install-Package IronPdf

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Large Report</h1>");

// Get as MemoryStream
Stream pdfStream = pdf.Stream;

// Reset position for reading
pdfStream.Position = 0;

// Stream to file
using (var fileStream = File.Create("streamed.pdf"))
{
    pdfStream.CopyTo(fileStream);
}
Enter fullscreen mode Exit fullscreen mode

Streams are better for large files where you don't want to hold everything in memory at once.

How Do I Return a PDF from ASP.NET Core?

Serve PDFs as downloads from a web application:

using IronPdf;
using Microsoft.AspNetCore.Mvc;
// Install via NuGet: Install-Package IronPdf

[ApiController]
[Route("api/[controller]")]
public class ReportsController : ControllerBase
{
    [HttpGet("invoice/{id}")]
    public IActionResult GetInvoice(int id)
    {
        var renderer = new ChromePdfRenderer();
        var html = GenerateInvoiceHtml(id);
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Return as file download
        return File(pdf.BinaryData, "application/pdf", $"invoice-{id}.pdf");
    }

    [HttpGet("report")]
    public IActionResult GetReport()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Monthly Report</h1>");

        // Stream the response
        return new FileStreamResult(pdf.Stream, "application/pdf")
        {
            FileDownloadName = "report.pdf"
        };
    }
}
Enter fullscreen mode Exit fullscreen mode

Use FileDownloadName to suggest a filename when the browser downloads it.

How Do I Return a PDF from ASP.NET MVC?

For traditional MVC applications:

using IronPdf;
using System.Web.Mvc;
// Install via NuGet: Install-Package IronPdf

public class PdfController : Controller
{
    public ActionResult Download()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Document</h1>");

        return File(pdf.BinaryData, "application/pdf", "document.pdf");
    }

    public ActionResult ViewInBrowser()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Preview</h1>");

        // Display inline (no download prompt)
        Response.AddHeader("Content-Disposition", "inline; filename=preview.pdf");
        return File(pdf.BinaryData, "application/pdf");
    }
}
Enter fullscreen mode Exit fullscreen mode

The Content-Disposition header controls whether browsers download or display inline.

How Do I Save to a Database?

Store PDFs as BLOB data:

using IronPdf;
using Microsoft.Data.SqlClient;
// Install via NuGet: Install-Package IronPdf

public async Task SavePdfToDatabase(int documentId, byte[] pdfData)
{
    using var connection = new SqlConnection(connectionString);
    await connection.OpenAsync();

    var command = new SqlCommand(
        "INSERT INTO Documents (Id, PdfData, CreatedAt) VALUES (@Id, @PdfData, @CreatedAt)",
        connection);

    command.Parameters.AddWithValue("@Id", documentId);
    command.Parameters.AddWithValue("@PdfData", pdfData);
    command.Parameters.AddWithValue("@CreatedAt", DateTime.UtcNow);

    await command.ExecuteNonQueryAsync();
}

// Usage
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Contract</h1>");
await SavePdfToDatabase(123, pdf.BinaryData);
Enter fullscreen mode Exit fullscreen mode

Use VARBINARY(MAX) column type for SQL Server. Other databases have equivalent BLOB types.

How Do I Load a PDF from a Byte Array?

Restore a PDF from stored data:

using IronPdf;
// Install via NuGet: Install-Package IronPdf

// From database, API response, etc.
byte[] storedPdfData = GetPdfFromDatabase(documentId);

// Create PdfDocument from bytes
var pdf = new PdfDocument(storedPdfData);

// Now you can manipulate it
pdf.AddHtmlFooters(new HtmlHeaderFooter
{
    HtmlFragment = "Page {page}"
});

// Save modified version
pdf.SaveAs("modified.pdf");
Enter fullscreen mode Exit fullscreen mode

Round-trip: generate, store as bytes, retrieve, modify, export again.

How Do I Upload to Azure Blob Storage?

Cloud storage export:

using IronPdf;
using Azure.Storage.Blobs;
// Install via NuGet: Install-Package IronPdf
// Install via NuGet: Install-Package Azure.Storage.Blobs

public async Task UploadPdfToAzure(string blobName, byte[] pdfData)
{
    var connectionString = "your-azure-connection-string";
    var containerName = "documents";

    var blobServiceClient = new BlobServiceClient(connectionString);
    var containerClient = blobServiceClient.GetBlobContainerClient(containerName);
    var blobClient = containerClient.GetBlobClient(blobName);

    using var stream = new MemoryStream(pdfData);
    await blobClient.UploadAsync(stream, overwrite: true);
}

// Usage
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Report</h1>");
await UploadPdfToAzure("reports/monthly-2024.pdf", pdf.BinaryData);
Enter fullscreen mode Exit fullscreen mode

Similar patterns work for AWS S3, Google Cloud Storage, and other providers.

How Do I Send a PDF via Email?

Attach PDFs to emails:

using IronPdf;
using System.Net.Mail;
// Install via NuGet: Install-Package IronPdf

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Invoice</h1>");

using var message = new MailMessage();
message.From = new MailAddress("billing@company.com");
message.To.Add("customer@example.com");
message.Subject = "Your Invoice";
message.Body = "Please find your invoice attached.";

// Attach PDF from stream
var attachment = new Attachment(
    new MemoryStream(pdf.BinaryData),
    "invoice.pdf",
    "application/pdf");
message.Attachments.Add(attachment);

using var smtp = new SmtpClient("smtp.company.com");
smtp.Send(message);
Enter fullscreen mode Exit fullscreen mode

The PDF never touches disk—generated and attached in memory.

How Do I Export Multiple PDFs?

Batch export scenarios:

using IronPdf;
// Install via NuGet: Install-Package IronPdf

var invoices = GetPendingInvoices(); // Returns list of invoice data
var renderer = new ChromePdfRenderer();

foreach (var invoice in invoices)
{
    var html = GenerateInvoiceHtml(invoice);
    var pdf = renderer.RenderHtmlAsPdf(html);

    // Save each to file
    pdf.SaveAs($"invoices/{invoice.Id}.pdf");

    // Or collect for batch upload
    var bytes = pdf.BinaryData;
    await UploadToStorage($"invoices/{invoice.Id}.pdf", bytes);

    pdf.Dispose(); // Free memory between iterations
}
Enter fullscreen mode Exit fullscreen mode

Dispose PDFs after use when processing many documents to manage memory.

How Do I Export with Compression?

Reduce file sizes before export:

using IronPdf;
// Install via NuGet: Install-Package IronPdf

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(largeHtmlWithImages);

// Compress images (quality 1-100)
pdf.CompressImages(60);

// Get compressed size
byte[] compressed = pdf.BinaryData;
Console.WriteLine($"Compressed size: {compressed.Length / 1024} KB");

pdf.SaveAs("compressed-report.pdf");
Enter fullscreen mode Exit fullscreen mode

Image compression significantly reduces file size for image-heavy documents.

How Do I Handle Export Errors?

Robust export with error handling:

using IronPdf;
// Install via NuGet: Install-Package IronPdf

public bool TryExportPdf(string html, string outputPath, out string error)
{
    error = null;

    try
    {
        // Ensure directory exists
        var directory = Path.GetDirectoryName(outputPath);
        if (!string.IsNullOrEmpty(directory))
            Directory.CreateDirectory(directory);

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs(outputPath);
        return true;
    }
    catch (IOException ex)
    {
        error = $"File access error: {ex.Message}";
        return false;
    }
    catch (UnauthorizedAccessException ex)
    {
        error = $"Permission denied: {ex.Message}";
        return false;
    }
    catch (Exception ex)
    {
        error = $"Export failed: {ex.Message}";
        return false;
    }
}
Enter fullscreen mode Exit fullscreen mode

Handle file system errors, permission issues, and rendering failures gracefully.

Quick Reference

Export Type Code
Save to file pdf.SaveAs("file.pdf")
Get bytes byte[] data = pdf.BinaryData
Get stream Stream s = pdf.Stream
ASP.NET download File(pdf.BinaryData, "application/pdf", "name.pdf")
Inline display Content-Disposition: inline

Exporting PDFs is straightforward—choose the output format that matches your destination, whether it's disk, database, cloud, or web response.

For more export scenarios and options, see the IronPDF export documentation.

Written by Jacob Mellor, CTO at Iron Software. Jacob created IronPDF and leads a team of 50+ engineers building .NET document processing libraries.

Top comments (0)