Skip to main content

Resize PDF Pages in C#: Change PDF Page Size

 PDF page size is often overlooked until a document needs to be printed, archived, or processed in bulk. In many business systems, PDF files may come from different sources: scanned documents, exported reports, generated invoices, or legacy templates. As a result, the page dimensions may not be consistent.

In a .NET application, one practical way to resize PDF pages is to create a new PDF document with the desired page size, then draw each original page onto the new page as a template. This keeps the visual content of the source PDF, including text, images, tables, and layout, while producing a document with standardized page dimensions.

This article demonstrates how to resize PDF pages in C# for two common scenarios:

  • Changing PDF pages to a standard paper size such as A4, A3, A1, Letter, or Legal
  • Changing PDF pages to a custom size defined in inches or millimeters

The examples use C# and Spire.PDF for .NET.

Resize PDF Pages in C#: Change PDF Page Size

Install the PDF Library

Install the package from NuGet:

PM> Install-Package Spire.PDF

Or use the .NET CLI:

dotnet add package Spire.PDF

Then add the required namespaces:

using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;

How PDF Page Resizing Works

A PDF page has a fixed coordinate system. Unlike a Word document or an HTML page, its content does not automatically reflow when the page size changes.

For this reason, resizing a PDF page usually requires a different approach:

  1. Load the original PDF document.
  2. Create a new PDF document.
  3. Add a new page with the target page size.
  4. Convert the original page into a template.
  5. Draw the template onto the new page.
  6. Save the resized PDF file.

The key operation is creating a template from the original page:

PdfTemplate template = sourcePage.CreateTemplate();
template.Draw(newPage, new PointF(0, 0), layout);

This approach preserves the page appearance and scales the original page content into the new page area.

Resize PDF Pages to a Standard Paper Size in C#

If the target size is a common paper format, you can use predefined values from PdfPageSize, such as A4, A3, A1, Letter, or Legal.

The following example resizes every page in a PDF document to A1 size.

using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;

namespace ResizePdfToStandardSize
{
    class Program
    {
        static void Main(string[] args)
        {
            PdfDocument sourcePdf = new PdfDocument();
            sourcePdf.LoadFromFile("Sample.pdf");

            PdfDocument outputPdf = new PdfDocument();

            foreach (PdfPageBase sourcePage in sourcePdf.Pages)
            {
                PdfPageBase newPage = outputPdf.Pages.Add(
                    PdfPageSize.A1,
                    new PdfMargins(0)
                );

                PdfTextLayout layout = new PdfTextLayout();
                layout.Layout = PdfLayoutType.OnePage;

                PdfTemplate template = sourcePage.CreateTemplate();
                template.Draw(newPage, new PointF(0, 0), layout);
            }

            outputPdf.SaveToFile("ResizeToA1.pdf");

            sourcePdf.Close();
            outputPdf.Close();
        }
    }
}

To resize the PDF to A4 instead, replace PdfPageSize.A1 with PdfPageSize.A4:

PdfPageBase newPage = outputPdf.Pages.Add(
    PdfPageSize.A4,
    new PdfMargins(0)
);

Other standard page sizes can be used in the same way:

PdfPageSize.A3
PdfPageSize.A4
PdfPageSize.Letter
PdfPageSize.Legal

The second argument controls the page margins:

new PdfMargins(0)

A margin value of 0 allows the original page template to use the full target page area. If you need additional whitespace around the content, you can set a larger margin value:

new PdfMargins(20)

Keep in mind that margins reduce the available drawing area, so the rendered page content may appear smaller.

Why PdfLayoutType.OnePage Is Important

The following setting is important when drawing the original page onto the resized page:

PdfTextLayout layout = new PdfTextLayout();
layout.Layout = PdfLayoutType.OnePage;

PdfLayoutType.OnePage helps fit the source page content into a single target page. Without this setting, the content may not scale as expected, especially when the original page size and the target page size are significantly different.

This is especially relevant when:

  • Resizing large pages to A4 or Letter
  • Enlarging small pages to A3 or A1
  • Processing scanned PDF pages
  • Normalizing PDFs with inconsistent page dimensions

It does not redesign the PDF layout, but it helps preserve the original page as a scaled visual representation.

Resize PDF Pages to a Custom Size in C#

In some cases, a standard paper size is not suitable. For example, you may need to generate PDFs for labels, tickets, certificates, forms, or a specific print template.

Spire.PDF uses points as the measurement unit for page dimensions. One inch equals 72 points. Instead of calculating the values manually, you can use PdfUnitConvertor to convert inches, millimeters, or other units to points.

The following example resizes all pages to 6.5 × 8.5 inches.

using Spire.Pdf;
using Spire.Pdf.Graphics;
using System.Drawing;

namespace ResizePdfToCustomSize
{
    class Program
    {
        static void Main(string[] args)
        {
            PdfDocument sourcePdf = new PdfDocument();
            sourcePdf.LoadFromFile("Sample.pdf");

            PdfDocument outputPdf = new PdfDocument();

            PdfUnitConvertor convertor = new PdfUnitConvertor();

            float width = convertor.ConvertUnits(
                6.5f,
                PdfGraphicsUnit.Inch,
                PdfGraphicsUnit.Point
            );

            float height = convertor.ConvertUnits(
                8.5f,
                PdfGraphicsUnit.Inch,
                PdfGraphicsUnit.Point
            );

            SizeF customPageSize = new SizeF(width, height);

            foreach (PdfPageBase sourcePage in sourcePdf.Pages)
            {
                PdfPageBase newPage = outputPdf.Pages.Add(
                    customPageSize,
                    new PdfMargins(0)
                );

                PdfTextLayout layout = new PdfTextLayout();
                layout.Layout = PdfLayoutType.OnePage;

                PdfTemplate template = sourcePage.CreateTemplate();
                template.Draw(newPage, new PointF(0, 0), layout);
            }

            outputPdf.SaveToFile("ResizeToCustomSize.pdf");

            sourcePdf.Close();
            outputPdf.Close();
        }
    }
}

The custom page size is created with SizeF:

SizeF customPageSize = new SizeF(width, height);

Then the custom size is used when adding pages to the output PDF:

PdfPageBase newPage = outputPdf.Pages.Add(
    customPageSize,
    new PdfMargins(0)
);

This method is useful when the target PDF page size comes from a business requirement rather than a standard paper format.

Convert Millimeters to PDF Page Size

Print specifications are often written in millimeters. For example, an A4-sized page is commonly represented as 210mm × 297mm.

You can convert millimeters to points like this:

PdfUnitConvertor convertor = new PdfUnitConvertor();

float width = convertor.ConvertUnits(
    210f,
    PdfGraphicsUnit.Millimeter,
    PdfGraphicsUnit.Point
);

float height = convertor.ConvertUnits(
    297f,
    PdfGraphicsUnit.Millimeter,
    PdfGraphicsUnit.Point
);

SizeF pageSize = new SizeF(width, height);

Then use the converted pageSize when creating the new page:

PdfPageBase newPage = outputPdf.Pages.Add(
    pageSize,
    new PdfMargins(0)
);

Using PdfUnitConvertor keeps the code readable and avoids hardcoded point values that may be difficult to understand later.

Practical Considerations

Check the Aspect Ratio

If the original page and the target page use different aspect ratios, the resized PDF may contain extra whitespace or slightly compressed content. For example, converting a landscape page to portrait A4 can preserve the page content, but the visual result may not be ideal.

Review Scanned PDFs Carefully

Scanned PDFs often include hidden margins, uneven borders, or slightly rotated images. Resizing the page will also preserve these visual details, so the output should be checked manually if the source file comes from scans.

Avoid Overwriting the Original PDF

It is better to save the resized file as a new PDF instead of replacing the original one directly. This makes it easier to compare the output and roll back if the result is not correct.

Be Careful with Mixed Page Sizes

Some PDFs contain pages with different sizes by design. The examples above resize every page to the same target size, which is useful for printing and archiving, but it may not be suitable for every document.

Conclusion

Resizing PDF pages in C# is not just about changing a page property. A more reliable approach is to create a new PDF with the target page size and draw each original page onto the new page as a template.

For standard paper sizes such as A4, A3, Letter, or Legal, predefined page sizes can be used directly. For custom dimensions, the width and height can be converted from inches or millimeters to points before creating the new page.

This method works well when the goal is to preserve the original visual layout while standardizing page dimensions. After generating the resized PDF, it is still worth reviewing a few pages manually, especially when the source file contains scanned pages, mixed page sizes, or unusual aspect ratios.

Comments

Post a Comment

Popular posts from this blog

3 Ways to Generate Word Documents from Templates in Java

A template is a document with pre-applied formatting like styles, tabs, line spacing and so on. You can quickly generate a batch of documents with the same structure based on the template. In this article, I am going to show you the different ways to generate Word documents from templates programmatically in Java using Free Spire.Doc for Java library. Prerequisite First of all, you need to add needed dependencies for including Free Spire.Doc for Java into your Java project. There are two ways to do that. If you use maven, you need to add the following code to your project’s pom.xml file. <repositories>               <repository>                   <id>com.e-iceblue</id>                   <name>e-iceblue</name>...
Post a Comment
Read more

Insert and Extract OLE objects in Word in Java

You can use OLE (Object Linking and Embedding) to include content from other programs, such as another Word document, an Excel or PowerPoint document to an existing Word document. This article demonstrates how to insert and extract embedded OLE objects in a Word document in Java by using Free Spire.Doc for Java API.   Add dependencies First of all, you need to add needed dependencies for including Free Spire.Doc for Java into your Java project. There are two ways to do that. If you use maven, you need to add the following code to your project’s pom.xml file.     <repositories>               <repository>                   <id>com.e-iceblue</id>                   <name>e-iceblue</name>    ...
Post a Comment
Read more

Simple Java Code to Convert Excel to PDF in Java

This article demonstrates a simple solution to convert an Excel file to PDF in Java by using free Excel API – Free Spire.XLS for Java . The following examples illustrate two possibilities to convert Excel to PDF:      Convert the whole Excel file to PDF     Convert a particular Excel Worksheet to PDF Before start with coding, you need to Download Free Spire.XLS for Java package , unzip it and import Spire.Xls.jar file from the lib folder in your project as a denpendency. 1. Convert the whole Excel file to PDF Spire.XLS for Java provides saveToFile method in Workbook class that enables us to easily save a whole Excel file to PDF. import com.spire.xls.FileFormat; import com.spire.xls.Workbook; public class ExcelToPDF {     public static void main(String[] args){         //Create a Workbook         Workbook workbook = new Workbook();   ...
Post a Comment
Read more