Skip to footer content
  1. IronPDF
  2. IronPDF Blog
  3. Using IronPDF
  4. Asp .NET Core PDF Viewer
USING IRONPDF

ASP.NET Core PDF Viewer: Display PDF Documents in Browser without External Plugins

Curtis Chau
Curtis Chau
Updated:

IronPDF allows for smooth PDF display, saving, and printing in ASP.NET Core applications through server-side rendering with a Chrome engine. This eliminates the need for plugins while providing full cross-platform support, including Docker containers for your DevOps pipelines.

Displaying PDF documents directly in web browsers is essential for modern ASP.NET Core applications. Whether generating invoices, reports, or contracts, users expect smooth PDF viewing without downloading files or installing Adobe Acrobat Reader. This tutorial demonstrates how IronPDF simplifies PDF display, saving, and printing in your ASP.NET Core PDF viewer through its Chrome-based rendering engine.

IronPDF C# PDF Library promotional banner highlighting HTML to PDF conversion, editing tools, deployment flexibility, and free trial offer

How Do Browsers Handle PDF Viewing in ASP.NET Core?

Modern browsers include built-in PDF viewers that activate when receiving a PDF with the correct MIME type (application/pdf). When your ASP.NET Core application returns a PDF with appropriate headers, the browser displays it inline automatically. This eliminates the need for external plugins, Adobe Acrobat Reader, or complex JavaScript libraries. According to MDN Web Docs, proper header configuration is essential for controlling browser file handling.

IronPDF uses this capability by generating high-quality PDFs server-side using its ChromePdfRenderer class. The renderer uses a complete Chrome engine internally, ensuring documents display exactly as intended with full CSS, JavaScript, digital signatures, and web fonts support. Unlike simple viewers, IronPDF provides complete control over PDF processing and rendering. The library also supports SVG graphics, custom fonts, and UTF-8 character encoding for international content.

For containerized environments, the Chrome rendering engine excels. It runs entirely in-process without external services or dependencies, making it perfect for Docker deployments. The renderer handles resource management and cleanup automatically, preventing memory leaks in long-running services. This architecture ensures reliable performance in production without complex configuration. You can also deploy to AWS Lambda or Azure Functions with improved configurations.

Four-column feature grid displaying PDF software capabilities: Create PDFs, Convert PDFs, Edit PDFs, and Sign and Secure PDFs, with detailed feature lists under each category

Why Does Server-Side PDF Rendering Matter for Container Deployments?

Server-side rendering ensures consistent PDF output across all environments. When deploying to containers, client-side rendering introduces variability based on user browsers. IronPDF's server-side approach guarantees identical rendering whether running on Windows, Linux, or containerized environments. This consistency is crucial for compliance documents, invoices, and contracts where exact formatting matters. The native engine can also run as a remote container for distributed architectures.

What Performance Benefits Does In-Process Chrome Engine Provide?

The in-process Chrome engine eliminates network latency and inter-process communication overhead. Traditional headless browser approaches require managing separate processes and communication channels. IronPDF's integrated engine runs within your application process, reducing memory usage and improving response times. This architecture particularly benefits microservices and serverless deployments where resource efficiency is critical. For optimal performance, see our guide on async and multithreading techniques.

What Tools Do You Need to Display/View PDF Files in ASP.NET Core?

Setting up IronPDF in your ASP.NET Core project takes just a few steps. First, create a new project in Visual Studio or via command line. Open Visual Studio and select the ASP.NET Core Web Application template:

dotnet new mvc -n PdfViewerApp
cd PdfViewerApp
dotnet new mvc -n PdfViewerApp
cd PdfViewerApp
SHELL

How Do You Install IronPDF in Your Container Environment?

Install IronPDF via NuGet Package Manager in your project:

Install-Package IronPdf
Install-Package IronPdf
SHELL

For containerized deployments, IronPDF offers IronPdf.Slim package which reduces initial size. This helps with environments having package limitations like AWS Lambda:

Install-Package IronPdf.Slim
Install-Package IronPdf.Slim
SHELL

Visual Studio Package Manager Console displaying the installation progress of IronPDF NuGet package, showing multiple dependency downloads including IronSoftware components, gRPC, and System.Threading.Channels

Or in Solution Explorer, right-click your project and select "Manage NuGet Packages". Choose the package source and search for IronPDF. For advanced installation methods, including F# support and VB.NET configurations, check our installation guides.

That's all the setup needed. IronPDF works smoothly with ASP.NET Core 3.1+ including .NET 6, 7, and 8. The library receives frequent updates ensuring framework compatibility. For detailed instructions, visit the IronPDF installation guide. The package includes everything for PDF generation, editing, and processing.

For teams using Docker containers, IronPDF provides improved base images and examples. The library supports both Linux and Windows containers with automatic dependency resolution. Health checks integrate easily by wrapping PDF generation in standard ASP.NET Core middleware, keeping services monitorable in orchestrated environments. You can also use macOS for development or deploy to Android devices via MAUI.

IronPDF feature comparison showing three key benefits: pixel-perfect rendering with Chromium-grade HTML/CSS/JS support, 5-minute setup with PM install command, and cross-platform compatibility across Windows, Linux, macOS and cloud environments

Which Framework Versions Work Best with IronPDF?

IronPDF supports .NET Core 3.1 through .NET 8, with optimal performance on .NET 6 and later. These versions include performance improvements and better container support. For new projects, .NET 8 provides the best combination of features, performance, and long-term support. Legacy applications on .NET Core 3.1 work without modification, ensuring smooth migration paths. The quickstart guide provides framework-specific examples.

What Are Common Installation Issues in Container Environments?

Container deployments sometimes encounter missing system dependencies. Linux containers require libgdiplus and related libraries for graphics operations. The Dockerfile example provided includes these dependencies. Windows containers typically work without additional configuration. For minimal container sizes, use multi-stage builds separating build and runtime dependencies. For troubleshooting, enable custom logging and review our performance assistance guide.

How Can You Display PDF Files in the Browser Using ASP.NET Core?

Creating and displaying PDFs in the browser requires minimal code. Here's a complete controller action that generates a PDF from HTML and displays it inline:

using IronPdf;
using Microsoft.AspNetCore.Mvc;
public class PdfController : Controller
{
    public IActionResult ViewPdf()
    {
        var renderer = new ChromePdfRenderer();
        // Configure rendering options for the PDF viewer
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
        renderer.RenderingOptions.EnableJavaScript = true;
        renderer.RenderingOptions.RenderDelay = 100; // Wait for JS execution

        // Generate PDF from HTML string
        var html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; width: 100%; }
                </style>
            </head>
            <body>
                <h1>Invoice #12345</h1>
                <div class='content'>
                    <p>Date: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
                    <p>Thank you for your business!</p>
                </div>
            </body>
            </html>";
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Return PDF for inline viewing in the browser
        return File(pdf.BinaryData, "application/pdf");
    }
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;
public class PdfController : Controller
{
    public IActionResult ViewPdf()
    {
        var renderer = new ChromePdfRenderer();
        // Configure rendering options for the PDF viewer
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
        renderer.RenderingOptions.EnableJavaScript = true;
        renderer.RenderingOptions.RenderDelay = 100; // Wait for JS execution

        // Generate PDF from HTML string
        var html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; width: 100%; }
                </style>
            </head>
            <body>
                <h1>Invoice #12345</h1>
                <div class='content'>
                    <p>Date: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
                    <p>Thank you for your business!</p>
                </div>
            </body>
            </html>";
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Return PDF for inline viewing in the browser
        return File(pdf.BinaryData, "application/pdf");
    }
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

Public Class PdfController
    Inherits Controller

    Public Function ViewPdf() As IActionResult
        Dim renderer = New ChromePdfRenderer()
        ' Configure rendering options for the PDF viewer
        renderer.RenderingOptions.PrintHtmlBackgrounds = True
        renderer.RenderingOptions.CreatePdfFormsFromHtml = True
        renderer.RenderingOptions.EnableJavaScript = True
        renderer.RenderingOptions.RenderDelay = 100 ' Wait for JS execution

        ' Generate PDF from HTML string
        Dim html = "
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; width: 100%; }
                </style>
            </head>
            <body>
                <h1>Invoice #12345</h1>
                <div class='content'>
                    <p>Date: " & DateTime.Now.ToString("yyyy-MM-dd") & "</p>
                    <p>Thank you for your business!</p>
                </div>
            </body>
            </html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)

        ' Return PDF for inline viewing in the browser
        Return File(pdf.BinaryData, "application/pdf")
    End Function
End Class
$vbLabelText   $csharpLabel

This code creates a ChromePdfRenderer and configures it to include backgrounds and convert HTML forms. The RenderHtmlAsPdf method transforms HTML into a PDF. Returning the PDF with application/pdf MIME type tells browsers to display it inline rather than downloading. This server-side approach ensures consistent rendering across platforms. You can also render from HTML files, HTML strings, or ZIP archives.

For production deployments, consider async PDF generation to improve throughput:

public async Task<IActionResult> ViewPdfAsync()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.Timeout = 60; // 60 second timeout

    var html = await GetHtmlContentAsync(); // Your async HTML generation
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);

    return File(pdf.BinaryData, "application/pdf");
}
public async Task<IActionResult> ViewPdfAsync()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.Timeout = 60; // 60 second timeout

    var html = await GetHtmlContentAsync(); // Your async HTML generation
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);

    return File(pdf.BinaryData, "application/pdf");
}
Imports System.Threading.Tasks

Public Class YourClassName
    Public Async Function ViewPdfAsync() As Task(Of IActionResult)
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.Timeout = 60 ' 60 second timeout

        Dim html As String = Await GetHtmlContentAsync() ' Your async HTML generation
        Dim pdf = Await renderer.RenderHtmlAsPdfAsync(html)

        Return File(pdf.BinaryData, "application/pdf")
    End Function
End Class
$vbLabelText   $csharpLabel

What Does the Generated PDF Look Like?

Example of a basic PDF invoice viewed in a web-based PDF viewer with standard navigation controls

For existing HTML files or Razor pages, use alternative rendering methods:

// Render from URL - useful for complex pages
var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_125___");

// Render from HTML file in the same location
var pdf = renderer.RenderHtmlFileAsPdf("Views/Invoice.html");

// Render from wwwroot folder
var pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report.html");

// Render from Razor view (MVC)
var pdf = renderer.RenderRazorViewToPdf(this, "InvoiceView", model);
// Render from URL - useful for complex pages
var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_125___");

// Render from HTML file in the same location
var pdf = renderer.RenderHtmlFileAsPdf("Views/Invoice.html");

// Render from wwwroot folder
var pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report.html");

// Render from Razor view (MVC)
var pdf = renderer.RenderRazorViewToPdf(this, "InvoiceView", model);
' Render from URL - useful for complex pages
Dim pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_125___")

' Render from HTML file in the same location
Dim pdf = renderer.RenderHtmlFileAsPdf("Views/Invoice.html")

' Render from wwwroot folder
Dim pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report.html")

' Render from Razor view (MVC)
Dim pdf = renderer.RenderRazorViewToPdf(Me, "InvoiceView", model)
$vbLabelText   $csharpLabel

These methods provide flexibility while maintaining high-quality rendering. You can also load existing PDFs, edit files, and work with Word and Excel formats. Learn more about HTML to PDF options. For advanced processing, see the API reference. The library also supports ASPX pages, CSHTML files, and Blazor components.

When Should You Use Async PDF Generation?

Async generation becomes essential when handling multiple concurrent requests or generating large PDFs. Synchronous generation blocks threads, limiting scalability. Use async methods for web applications serving multiple users, especially in containerized environments with limited resources. The async approach improves response times and allows better resource utilization across container instances. For high-volume scenarios, consider parallel processing techniques.

How Do You Handle Large HTML Content Efficiently?

For large HTML documents, implement streaming and chunking strategies. Break content into logical sections and render incrementally. Use pagination for reports exceeding 100 pages. Memory-efficient approaches include rendering to temporary files rather than memory for extremely large documents. This prevents out-of-memory errors in resource-constrained containers. The WaitFor methods help ensure content loads completely before rendering.

How Do Users Save PDF Documents from the Browser?

To enable downloads instead of inline viewing, modify the Content-Disposition header. This is essential when users need offline document access:

public IActionResult DownloadPdf()
{
    var renderer = new ChromePdfRenderer();

    // Configure for optimal file size
    renderer.RenderingOptions.ImageQuality = 85;
    renderer.RenderingOptions.EnableWebSecurity = false; // For local resources

    // Create PDF with CSS styling and images
    var html = @"<h1>Download Me</h1>
                 <img src='logo.png' width='100' />";
    var pdf = renderer.RenderHtmlAsPdf(html, @"wwwroot/images");

    // Apply compression for smaller file size
    pdf.CompressImages(30);

    // Force download with custom filename
    return File(pdf.BinaryData, "application/pdf", "invoice-2024.pdf");
}
public IActionResult DownloadPdf()
{
    var renderer = new ChromePdfRenderer();

    // Configure for optimal file size
    renderer.RenderingOptions.ImageQuality = 85;
    renderer.RenderingOptions.EnableWebSecurity = false; // For local resources

    // Create PDF with CSS styling and images
    var html = @"<h1>Download Me</h1>
                 <img src='logo.png' width='100' />";
    var pdf = renderer.RenderHtmlAsPdf(html, @"wwwroot/images");

    // Apply compression for smaller file size
    pdf.CompressImages(30);

    // Force download with custom filename
    return File(pdf.BinaryData, "application/pdf", "invoice-2024.pdf");
}
Imports Microsoft.AspNetCore.Mvc

Public Class YourController
    Inherits Controller

    Public Function DownloadPdf() As IActionResult
        Dim renderer = New ChromePdfRenderer()

        ' Configure for optimal file size
        renderer.RenderingOptions.ImageQuality = 85
        renderer.RenderingOptions.EnableWebSecurity = False ' For local resources

        ' Create PDF with CSS styling and images
        Dim html As String = "<h1>Download Me</h1>
                              <img src='logo.png' width='100' />"
        Dim pdf = renderer.RenderHtmlAsPdf(html, "wwwroot/images")

        ' Apply compression for smaller file size
        pdf.CompressImages(30)

        ' Force download with custom filename
        Return File(pdf.BinaryData, "application/pdf", "invoice-2024.pdf")
    End Function
End Class
$vbLabelText   $csharpLabel

Adding the filename parameter sets Content-Disposition to "attachment," prompting download. Users can also save inline PDFs using browser functionality via Ctrl+S or the PDF toolbar. The default behavior lets users choose their preferred location. You can export PDFs in various formats and save to memory streams for flexible handling.

For container environments, implement PDF compression to reduce bandwidth:

public IActionResult OptimizedDownload()
{
    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf("<h1>Improve PDF</h1>");

    // Compress the PDF for reduced size
    pdf.CompressImages(50); // 50% quality
    var compressed = pdf.SaveAsCompressed();

    return File(compressed, "application/pdf", "improve.pdf");
}
public IActionResult OptimizedDownload()
{
    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf("<h1>Improve PDF</h1>");

    // Compress the PDF for reduced size
    pdf.CompressImages(50); // 50% quality
    var compressed = pdf.SaveAsCompressed();

    return File(compressed, "application/pdf", "improve.pdf");
}
Public Function OptimizedDownload() As IActionResult
    Dim renderer = New ChromePdfRenderer()
    Dim pdf = renderer.RenderHtmlAsPdf("<h1>Improve PDF</h1>")

    ' Compress the PDF for reduced size
    pdf.CompressImages(50) ' 50% quality
    Dim compressed = pdf.SaveAsCompressed()

    Return File(compressed, "application/pdf", "improve.pdf")
End Function
$vbLabelText   $csharpLabel

How Does Browser Download Behavior Work?

Example of a PDF document generated using IronPDF for .NET, displayed in a standard PDF viewer interface

For better memory efficiency with large documents, use streams:

public IActionResult StreamPdf()
{
    var renderer = new ChromePdfRenderer();

    // Configure for memory efficiency
    renderer.RenderingOptions.UseMarginsOnHeaderAndFooter = UseMargins.All;

    // Load and process HTML with images
    var html = "<h1>Streamed Content</h1>";
    var pdf = renderer.RenderHtmlAsPdf(html);

    // Stream the PDF file to the browser
    var stream = pdf.Stream;
    stream.Position = 0;
    return File(stream, "application/pdf", "document.pdf");
}
public IActionResult StreamPdf()
{
    var renderer = new ChromePdfRenderer();

    // Configure for memory efficiency
    renderer.RenderingOptions.UseMarginsOnHeaderAndFooter = UseMargins.All;

    // Load and process HTML with images
    var html = "<h1>Streamed Content</h1>";
    var pdf = renderer.RenderHtmlAsPdf(html);

    // Stream the PDF file to the browser
    var stream = pdf.Stream;
    stream.Position = 0;
    return File(stream, "application/pdf", "document.pdf");
}
Public Function StreamPdf() As IActionResult
    Dim renderer = New ChromePdfRenderer()

    ' Configure for memory efficiency
    renderer.RenderingOptions.UseMarginsOnHeaderAndFooter = UseMargins.All

    ' Load and process HTML with images
    Dim html = "<h1>Streamed Content</h1>"
    Dim pdf = renderer.RenderHtmlAsPdf(html)

    ' Stream the PDF file to the browser
    Dim stream = pdf.Stream
    stream.Position = 0
    Return File(stream, "application/pdf", "document.pdf")
End Function
$vbLabelText   $csharpLabel

This reduces memory consumption by streaming directly without intermediate arrays. You can also load existing PDFs from various locations, edit, and stream modified versions. For advanced manipulation and image processing, explore the PdfDocument API. The component supports text extraction, form filling, and digital signatures. You can also implement barcode generation and QR code creation for improved functionality.

What Compression Strategies Work Best for Different PDF Types?

Text-heavy PDFs compress well with standard algorithms, achieving 60-80% size reduction. Image-rich PDFs benefit from targeted image compression, balancing quality and size. For scanned documents, consider 70-85% image quality. Financial reports with graphs need 85-95% quality to maintain clarity. Test compression levels based on your content type and user requirements. The linearization feature can improve perceived performance for large documents.

Why Use Streaming for Large PDF Downloads?

Streaming prevents memory spikes when serving large PDFs to multiple users. Traditional approaches load entire PDFs into memory before sending, causing issues in containerized environments with memory limits. Streaming sends data progressively, reducing peak memory usage by 70-90%. This enables serving larger files without increasing container resources. For extremely large files, consider splitting PDFs into smaller segments.## Can Users Print PDF Documents Directly from ASP.NET Core Web Applications?

IronPDF improves PDFs for printing by configuring CSS media type and page settings. This ensures professional output for physical printers or PDF saves:

public IActionResult PrintablePdf()
{
    var renderer = new ChromePdfRenderer();

    // Configure printing options for the PDF viewer
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
    renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

    // Set margins in millimeters for print standards
    renderer.RenderingOptions.MarginTop = 25;
    renderer.RenderingOptions.MarginBottom = 25;
    renderer.RenderingOptions.MarginLeft = 25;
    renderer.RenderingOptions.MarginRight = 25;

    // Enable print-specific features
    renderer.RenderingOptions.PrintOptionsHeader = new TextHeaderFooter
    {
        CenterText = "Confidential Document",
        DrawDividerLine = true
    };

    // Load HTML with print-specific CSS
    var html = @"
        <style>
            @media print {
                .no-print { display: none; }
                .page-break { page-break-after: always; }
            }
        </style>
        <h1>Print-Improved Document</h1>
        <p>This document is improved for printing.</p>
        <div class='page-break'></div>
        <h2>Page 2</h2>
        <p>Content continues here.</p>";

    var pdf = renderer.RenderHtmlAsPdf(html);

    // Return the PDF file for viewing and printing
    return File(pdf.BinaryData, "application/pdf");
}
public IActionResult PrintablePdf()
{
    var renderer = new ChromePdfRenderer();

    // Configure printing options for the PDF viewer
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
    renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

    // Set margins in millimeters for print standards
    renderer.RenderingOptions.MarginTop = 25;
    renderer.RenderingOptions.MarginBottom = 25;
    renderer.RenderingOptions.MarginLeft = 25;
    renderer.RenderingOptions.MarginRight = 25;

    // Enable print-specific features
    renderer.RenderingOptions.PrintOptionsHeader = new TextHeaderFooter
    {
        CenterText = "Confidential Document",
        DrawDividerLine = true
    };

    // Load HTML with print-specific CSS
    var html = @"
        <style>
            @media print {
                .no-print { display: none; }
                .page-break { page-break-after: always; }
            }
        </style>
        <h1>Print-Improved Document</h1>
        <p>This document is improved for printing.</p>
        <div class='page-break'></div>
        <h2>Page 2</h2>
        <p>Content continues here.</p>";

    var pdf = renderer.RenderHtmlAsPdf(html);

    // Return the PDF file for viewing and printing
    return File(pdf.BinaryData, "application/pdf");
}
Imports Microsoft.AspNetCore.Mvc

Public Class YourController
    Inherits Controller

    Public Function PrintablePdf() As IActionResult
        Dim renderer = New ChromePdfRenderer()

        ' Configure printing options for the PDF viewer
        renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4

        ' Set margins in millimeters for print standards
        renderer.RenderingOptions.MarginTop = 25
        renderer.RenderingOptions.MarginBottom = 25
        renderer.RenderingOptions.MarginLeft = 25
        renderer.RenderingOptions.MarginRight = 25

        ' Enable print-specific features
        renderer.RenderingOptions.PrintOptionsHeader = New TextHeaderFooter With {
            .CenterText = "Confidential Document",
            .DrawDividerLine = True
        }

        ' Load HTML with print-specific CSS
        Dim html = "
            <style>
                @media print {
                    .no-print { display: none; }
                    .page-break { page-break-after: always; }
                }
            </style>
            <h1>Print-Improved Document</h1>
            <p>This document is improved for printing.</p>
            <div class='page-break'></div>
            <h2>Page 2</h2>
            <p>Content continues here.</p>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)

        ' Return the PDF file for viewing and printing
        Return File(pdf.BinaryData, "application/pdf")
    End Function
End Class
$vbLabelText   $csharpLabel

Setting CssMediaType.Print applies print-specific CSS styles for correct printed output. Margin settings provide proper paper spacing. Users print PDFs directly from the browser viewer using standard print dialog, maintaining printer selection control. Learn about PDF rendering options for fine-tuning. The PDF viewer handles printing automatically. You can also configure custom paper sizes and custom margins for specific requirements.

For production environments, implement page break controls for professional formatting:

public IActionResult MultiPagePrintable()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

    // Add automatic page numbers
    renderer.RenderingOptions.PrintOptionsFooter = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        FontSize = 10
    };

    var pdf = renderer.RenderHtmlAsPdf(GetMultiPageHtml());
    return File(pdf.BinaryData, "application/pdf");
}
public IActionResult MultiPagePrintable()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

    // Add automatic page numbers
    renderer.RenderingOptions.PrintOptionsFooter = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        FontSize = 10
    };

    var pdf = renderer.RenderHtmlAsPdf(GetMultiPageHtml());
    return File(pdf.BinaryData, "application/pdf");
}
Public Function MultiPagePrintable() As IActionResult
    Dim renderer = New ChromePdfRenderer()
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print

    ' Add automatic page numbers
    renderer.RenderingOptions.PrintOptionsFooter = New TextHeaderFooter With {
        .CenterText = "Page {page} of {total-pages}",
        .FontSize = 10
    }

    Dim pdf = renderer.RenderHtmlAsPdf(GetMultiPageHtml())
    Return File(pdf.BinaryData, "application/pdf")
End Function
$vbLabelText   $csharpLabel

What Does the Print Dialog Look Like?

Example of a print-improved PDF document as it appears in a standard PDF viewer, showing the characteristic message that indicates the file has been formatted specifically for printing rather than screen viewing

For advanced printing scenarios, you can print to physical printers directly from server-side code. The library supports headers and footers, page numbers, and watermarks for professional documents. You can also add annotations and implement redaction for sensitive information.

How Do Different Paper Sizes Affect Container Resource Usage?

Larger paper sizes like A3 or Legal require more memory during rendering. A4 and Letter sizes are better for standard resource allocations. When supporting multiple paper sizes, implement dynamic resource scaling. Monitor memory usage patterns for your common document types. Consider implementing size limits for user-generated content to prevent resource exhaustion. The viewport settings help control content scaling.

What Print Settings Ensure Cross-Browser Compatibility?

Standard margins (25mm) work across all browsers and printers. Avoid browser-specific print features. Use CSS print media queries for consistent formatting. Test print preview in Chrome, Firefox, Edge, and Safari. Implement fallback styles for older browsers. Page break controls should use standard CSS properties supported universally. For responsive designs, see our guide on responsive CSS.

How Does IronPDF Handle Cross-Platform and Container Deployments?

IronPDF runs smoothly across Windows, Linux, macOS, Docker containers, and cloud platforms like Azure and AWS. This cross-platform compatibility ensures your PDF viewer works consistently regardless of deployment environment. The library handles platform-specific details internally, so your code works everywhere without modification. For specialized deployments, IronPDF supports Blazor Server, MAUI applications, and remote engine configurations.

For Docker deployments, use official IronPDF Docker images as base:

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app

# Install IronPDF dependencies for Linux
RUN apt-get update && apt-get install -y \
    libgdiplus \
    libc6-dev \
    libx11-dev

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["YourApp.csproj", "./"]
RUN dotnet restore "YourApp.csproj"
COPY . .
RUN dotnet build "YourApp.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "YourApp.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "YourApp.dll"]

For production use, licenses start at $liteLicense and include complete support and updates. Visit the documentation for detailed API references and advanced features. Refer to our extensive code examples to quickly implement PDF functionality in your ASP.NET Core projects. The library supports PDF/A compliance for archival requirements and PDF/UA for accessibility standards.

Server-side processing ensures consistent PDF generation across platforms. Whether on Windows servers or Linux containers, the component maintains rendering quality. The library manages OS path differences automatically, handling files correctly. For containerized deployments, see the Docker deployment guide. The package includes platform dependencies requiring no extra configuration. You can also implement OpenAI integration for intelligent PDF processing and OCR capabilities for scanned documents.

For Kubernetes deployments, implement health checks for reliability:

// Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddHealthChecks()
        .AddCheck("pdf_generation", () =>
        {
            try
            {
                var renderer = new ChromePdfRenderer();
                var pdf = renderer.RenderHtmlAsPdf("<p>Health check</p>");
                return pdf.PageCount > 0 
                    ? HealthCheckResult.Healthy() 
                    : HealthCheckResult.Unhealthy();
            }
            catch
            {
                return HealthCheckResult.Unhealthy();
            }
        });
}
// Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddHealthChecks()
        .AddCheck("pdf_generation", () =>
        {
            try
            {
                var renderer = new ChromePdfRenderer();
                var pdf = renderer.RenderHtmlAsPdf("<p>Health check</p>");
                return pdf.PageCount > 0 
                    ? HealthCheckResult.Healthy() 
                    : HealthCheckResult.Unhealthy();
            }
            catch
            {
                return HealthCheckResult.Unhealthy();
            }
        });
}
' Startup.vb
Public Sub ConfigureServices(services As IServiceCollection)
    services.AddHealthChecks() _
        .AddCheck("pdf_generation", Function()
            Try
                Dim renderer As New ChromePdfRenderer()
                Dim pdf = renderer.RenderHtmlAsPdf("<p>Health check</p>")
                Return If(pdf.PageCount > 0, HealthCheckResult.Healthy(), HealthCheckResult.Unhealthy())
            Catch
                Return HealthCheckResult.Unhealthy()
            End Try
        End Function)
End Sub
$vbLabelText   $csharpLabel

Get started with a free trial and transform your document viewing capabilities. The trial includes full functionality for development and testing in containers. You can also explore product demos and download extension packages for improved features. For teams needing multiple licenses, check our upgrades options.

Why Do Health Checks Matter for Container Orchestration?

Health checks enable orchestrators like Kubernetes to detect and replace failing instances automatically. PDF generation involves complex operations that can fail due to resource constraints or rendering issues. Proper health checks ensure high availability by identifying problems before users encounter errors. They also help with load balancing and scaling decisions. Consider implementing custom logging to track health check patterns.

How Do You Improve Container Images for Production?

Multi-stage builds reduce final image size by 60-70%. Include only runtime dependencies in production images. Use Alpine-based images where possible for minimal footprint. Cache NuGet packages in intermediate layers to speed builds. Remove debugging symbols and unnecessary files. Implement proper logging without storing large files in containers. The Windows installer provides alternative deployment options for traditional environments.

What Are the Key Benefits for Your DevOps Pipeline?

IronPDF transforms PDF handling in ASP.NET Core applications by combining server-side generation with browser-native viewing. With minimal code, you create professional PDFs from HTML, display files inline, enable downloads, and improve printing. The Chrome-based engine ensures pixel-perfect accuracy across platforms, eliminating third-party viewer needs.

This ASP.NET Core PDF viewer provides complete features including form filling, text selection, digital signatures, and PDF editing. The component also converts Word documents, Excel, and images to PDF. Whether building simple viewers or complex management systems, IronPDF delivers the tools you need. You can also work with Markdown files, RTF documents, and implement table of contents generation.

The library's integration and documentation simplify implementation. Your application displays PDFs directly while backend processing handles generation. The viewer works consistently whether loading from wwwroot, generating dynamically, or retrieving externally. With theme support and customizable settings, you match application design perfectly. Advanced features include DOM access, metadata management, and revision history tracking.

For DevOps teams, IronPDF offers deployment advantages:

  • Zero External Dependencies: No headless browsers or external services
  • Container-Ready: Improved for Docker and Kubernetes
  • Resource Efficient: Low memory footprint with automatic cleanup
  • Monitoring-Friendly: Easy health check integration
  • Platform Agnostic: Same code across all deployment targets

The library also provides milestone updates with continuous improvements in stability and performance. For secure document handling, implement encryption and permissions along with digital signatures including HSM support. You can generate PDF reports and handle JavaScript rendering for dynamic content.

Ready to implement PDF viewing in your ASP.NET Core application?

For production use, licenses start at $liteLicense with complete support. Visit the documentation for API details and advanced features. See our code examples to quickly implement PDF functionality. IronPDF also integrates with other Iron Software products for complete document processing solutions.

IronPDF offers flexible licensing options starting at $749 for single developers up to $3,999 for unlimited usage, with significant discounts currently available

Frequently Asked Questions

How can IronPDF help display PDFs in ASP.NET Core applications?

IronPDF simplifies the process by using a powerful Chrome-based rendering engine to display PDF files directly in web browsers without requiring downloads or additional plugins.

What are the benefits of using a PDF viewer in ASP.NET Core?

Using a PDF viewer like IronPDF in ASP.NET Core enhances user experience by allowing seamless viewing, saving, and printing of PDFs within the browser, eliminating the need for external applications like Adobe Acrobat Reader.

Is it necessary to install Adobe Acrobat Reader to view PDFs with IronPDF?

No, IronPDF enables viewing PDFs directly in the browser, eliminating the need for Adobe Acrobat Reader or any other plugins.

What types of documents can be displayed using IronPDF in an ASP.NET Core application?

IronPDF can be used to display various types of documents such as invoices, reports, and contracts seamlessly in ASP.NET Core applications.

Does IronPDF support printing of PDF documents in ASP.NET Core?

Yes, IronPDF supports the printing of PDF documents directly from the web application, providing a complete PDF management solution.

Can IronPDF render complex PDF layouts accurately in ASP.NET Core?

IronPDF uses a Chrome-based rendering engine to accurately render complex PDF layouts, ensuring high-quality display without fidelity loss.

Do I need to download PDF files to view them using IronPDF in ASP.NET Core?

No, IronPDF allows users to view PDF files directly in the web browser without the need to download them.

How does IronPDF improve the PDF viewing experience in web applications?

IronPDF improves the PDF viewing experience by offering seamless integration with ASP.NET Core, allowing users to view, save, and print PDFs directly in the browser.

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