How to Convert a PDF to Byte Array in C#

using IronPdf;

// Create a new PDF document from HTML
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Sample Document</h1><p>This is test content.</p>");

// Method 1: Direct conversion to byte array
byte[] pdfBytes = pdf.BinaryData;

// Method 2: Using MemoryStream
using (var memoryStream = pdf.Stream)
{
    byte[] pdfBytesFromStream = memoryStream.ToArray();
}

// Save byte array length for verification
System.Console.WriteLine($"PDF size: {pdfBytes.Length} bytes");

Imports IronPdf

' Create a new PDF document from HTML
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Sample Document</h1><p>This is test content.</p>")

' Method 1: Direct conversion to byte array
Dim pdfBytes As Byte() = pdf.BinaryData

' Method 2: Using MemoryStream
Using memoryStream = pdf.Stream
    Dim pdfBytesFromStream As Byte() = memoryStream.ToArray()
End Using

' Save byte array length for verification
System.Console.WriteLine($"PDF size: {pdfBytes.Length} bytes")

using IronPdf;
using System.IO;

// Load an existing PDF document
var existingPdf = PdfDocument.FromFile("report.pdf");

// Convert to byte array
byte[] fileBytes = existingPdf.BinaryData;

// Alternative: Using System.IO for direct file reading
byte[] directBytes = File.ReadAllBytes("report.pdf");

// Create PdfDocument from byte array
var loadedPdf = new PdfDocument(directBytes);

// Verify pages were loaded correctly
int pageCount = loadedPdf.PageCount;
System.Console.WriteLine($"Loaded PDF with {pageCount} pages");

Imports IronPdf
Imports System.IO

' Load an existing PDF document
Dim existingPdf As PdfDocument = PdfDocument.FromFile("report.pdf")

' Convert to byte array
Dim fileBytes As Byte() = existingPdf.BinaryData

' Alternative: Using System.IO for direct file reading
Dim directBytes As Byte() = File.ReadAllBytes("report.pdf")

' Create PdfDocument from byte array
Dim loadedPdf As New PdfDocument(directBytes)

' Verify pages were loaded correctly
Dim pageCount As Integer = loadedPdf.PageCount
System.Console.WriteLine($"Loaded PDF with {pageCount} pages")

using IronPdf;

// Example byte array (typically from database or API)
byte[] pdfBytes = GetPdfBytesFromDatabase();

// Create PdfDocument from byte array
var pdfDocument = new PdfDocument(pdfBytes);

// Save the modified PDF
pdfDocument.SaveAs("modified-document.pdf");

// Or get updated bytes for storage
byte[] updatedBytes = pdfDocument.BinaryData;

// Mock method to simulate fetching PDF bytes from a database
byte[] GetPdfBytesFromDatabase()
{
    // Simulate fetching PDF bytes
    return File.ReadAllBytes("example.pdf");
}

Imports IronPdf

' Example byte array (typically from database or API)
Dim pdfBytes As Byte() = GetPdfBytesFromDatabase()

' Create PdfDocument from byte array
Dim pdfDocument As New PdfDocument(pdfBytes)

' Save the modified PDF
pdfDocument.SaveAs("modified-document.pdf")

' Or get updated bytes for storage
Dim updatedBytes As Byte() = pdfDocument.BinaryData

' Mock method to simulate fetching PDF bytes from a database
Private Function GetPdfBytesFromDatabase() As Byte()
    ' Simulate fetching PDF bytes
    Return File.ReadAllBytes("example.pdf")
End Function

using IronPdf;
using System.IO;

var renderer = new ChromePdfRenderer();

// Generate PDF in memory
using (var newMemoryStream = new MemoryStream())
{
    // Create PDF and save to stream
    var pdf = renderer.RenderHtmlAsPdf("<h1>Invoice</h1><p>Total: $100</p>");
    pdf.SaveAs(newMemoryStream);

    // Convert stream to byte array
    byte[] pdfData = newMemoryStream.ToArray();

    // Use bytes for web response, email attachment, or storage
    SaveToDatabase(pdfData);
}

// Load PDF from byte array into new MemoryStream
byte[] storedBytes = GetFromDatabase();
using (var newMemoryStream = new MemoryStream(storedBytes))
{
    var restoredPdf = new PdfDocument(newMemoryStream);
    // Work with restored document
}

Imports IronPdf
Imports System.IO

Dim renderer As New ChromePdfRenderer()

' Generate PDF in memory
Using newMemoryStream As New MemoryStream()
    ' Create PDF and save to stream
    Dim pdf = renderer.RenderHtmlAsPdf("<h1>Invoice</h1><p>Total: $100</p>")
    pdf.SaveAs(newMemoryStream)

    ' Convert stream to byte array
    Dim pdfData As Byte() = newMemoryStream.ToArray()

    ' Use bytes for web response, email attachment, or storage
    SaveToDatabase(pdfData)
End Using

' Load PDF from byte array into new MemoryStream
Dim storedBytes As Byte() = GetFromDatabase()
Using newMemoryStream As New MemoryStream(storedBytes)
    Dim restoredPdf As New PdfDocument(newMemoryStream)
    ' Work with restored document
End Using

// In an MVC Controller
public FileResult DownloadPdf()
{
    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf("<h1>Report</h1>");
    byte[] pdfBytes = pdf.BinaryData;
    return File(pdfBytes, "application/pdf", "report.pdf");
}

' In an MVC Controller
Public Function DownloadPdf() As FileResult
    Dim renderer = New ChromePdfRenderer()
    Dim pdf = renderer.RenderHtmlAsPdf("<h1>Report</h1>")
    Dim pdfBytes As Byte() = pdf.BinaryData
    Return File(pdfBytes, "application/pdf", "report.pdf")
End Function

using Microsoft.AspNetCore.Mvc;
using IronPdf;
using System;
using System.Threading.Tasks;

[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    private readonly ChromePdfRenderer _renderer;
    private readonly ILogger<PdfController> _logger;

    public PdfController(ILogger<PdfController> logger)
    {
        _logger = logger;
        _renderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                MarginTop = 25,
                MarginBottom = 25,
                CssMediaType = PdfCssMediaType.Print,
                EnableJavaScript = true,
                WaitFor = new WaitFor
                {
                    RenderDelay = 500, // Wait for JS execution
                    NetworkIdle0 = true // Wait for network requests
                }
            }
        };
    }

    [HttpGet("generate/{reportId}")]
    public async Task<IActionResult> GenerateReport(int reportId)
    {
        try
        {
            // Generate report HTML
            var html = await BuildReportHtml(reportId);

            // Convert to PDF
            var pdf = _renderer.RenderHtmlAsPdf(html);
            var pdfBytes = pdf.BinaryData;

            // Add response headers for caching
            Response.Headers.Add("Cache-Control", "public, max-age=3600");
            Response.Headers.Add("ETag", ComputeETag(pdfBytes));

            return File(pdfBytes, "application/pdf", $"report-{reportId}.pdf");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to generate PDF for report {ReportId}", reportId);
            return StatusCode(500, "PDF generation failed");
        }
    }
}

Imports Microsoft.AspNetCore.Mvc
Imports IronPdf
Imports System
Imports System.Threading.Tasks

<ApiController>
<Route("api/[controller]")>
Public Class PdfController
    Inherits ControllerBase

    Private ReadOnly _renderer As ChromePdfRenderer
    Private ReadOnly _logger As ILogger(Of PdfController)

    Public Sub New(logger As ILogger(Of PdfController))
        _logger = logger
        _renderer = New ChromePdfRenderer With {
            .RenderingOptions = New ChromePdfRenderOptions With {
                .MarginTop = 25,
                .MarginBottom = 25,
                .CssMediaType = PdfCssMediaType.Print,
                .EnableJavaScript = True,
                .WaitFor = New WaitFor With {
                    .RenderDelay = 500, ' Wait for JS execution
                    .NetworkIdle0 = True ' Wait for network requests
                }
            }
        }
    End Sub

    <HttpGet("generate/{reportId}")>
    Public Async Function GenerateReport(reportId As Integer) As Task(Of IActionResult)
        Try
            ' Generate report HTML
            Dim html = Await BuildReportHtml(reportId)

            ' Convert to PDF
            Dim pdf = _renderer.RenderHtmlAsPdf(html)
            Dim pdfBytes = pdf.BinaryData

            ' Add response headers for caching
            Response.Headers.Add("Cache-Control", "public, max-age=3600")
            Response.Headers.Add("ETag", ComputeETag(pdfBytes))

            Return File(pdfBytes, "application/pdf", $"report-{reportId}.pdf")
        Catch ex As Exception
            _logger.LogError(ex, "Failed to generate PDF for report {ReportId}", reportId)
            Return StatusCode(500, "PDF generation failed")
        End Try
    End Function
End Class