How to convert Excel to pdf using aspose.cells

JohnAnish · November 10, 2025, 9:54am

I have an encoded base64 string for an .Xlsx file.I want this to be converted to pdf

Professionalize.Discourse · November 10, 2025, 9:56am

Summary
You can decode the Base‑64 string, load the resulting bytes into an Aspose.Cells.Workbook, and save the workbook as a PDF – all in memory, without creating temporary files.

Why it happens
Aspose.Cells can read workbooks from any Stream. After decoding the Base‑64 string you obtain a byte array that can be wrapped in a MemoryStream. The library then uses its built‑in PDF renderer to produce a PDF file (or a PDF stream).

What to do next

Add the Aspose.Cells NuGet package

dotnet add package Aspose.Cells --version 25.10.0

Write the conversion code

using System;
using System.IO;
using Aspose.Cells;

class ExcelToPdfConverter
{
static void Main()
{
// 2.1 Base‑64 encoded .xlsx content
string base64Excel = "UEsDBBQABgAIAAAAIQD..."; // replace with the full string

// 2.2 Decode to a byte array
byte[] excelBytes = Convert.FromBase64String(base64Excel);

// 2.3 Load the workbook from memory
using (var excelStream = new MemoryStream(excelBytes))
{
var workbook = new Workbook(excelStream);

// 2.4 (Optional) configure PDF save options
var pdfOptions = new PdfSaveOptions
{
OnePagePerSheet = true, // one PDF page per worksheet
EmbedStandardFonts = true // embed standard fonts in the PDF
};

// 2.5 Save to a PDF file
string outputPath = "Result.pdf";
workbook.Save(outputPath, SaveFormat.Pdf, pdfOptions);

// 2.6 (Optional) return the PDF as a Base‑64 string
byte[] pdfBytes = File.ReadAllBytes(outputPath);
string base64Pdf = Convert.ToBase64String(pdfBytes);
Console.WriteLine("PDF Base‑64: " + base64Pdf);
}
}
}

If you need the PDF only as a stream (e.g., in a web API), replace step 2.5 with:

using (var pdfStream = new MemoryStream())
{
workbook.Save(pdfStream, SaveFormat.Pdf, pdfOptions);
string base64Pdf = Convert.ToBase64String(pdfStream.ToArray());
// return base64Pdf to the caller
}

Validate the result

Run the program and open Result.pdf to confirm that the worksheets are rendered as expected.
If you used the in‑memory approach, decode the printed Base‑64 string and open the resulting PDF to verify the same.

Troubleshooting tips

Ensure the Base‑64 string represents a valid .xlsx file (remove any stray whitespace or line‑breaks before decoding).
For workbooks that use custom fonts, you can set pdfOptions.FontEmbeddingMode = FontEmbeddingMode.EmbedAll to embed those fonts in the PDF.
For very large files, keep the processing stream‑based (as shown) to avoid excessive memory consumption.

I could not fully verify this explanation against the retrieved sources. Please double-check the behaviour in your environment and confirm the exact SDK/version.

amjad.sahi · November 10, 2025, 10:00am

@JohnAnish,

Yes, you can use Aspose.Cells for this purpose. You can use it to render PDF from Base64 encoded strings.
See the following sample code for your reference.
e.g.,
Sample code:

// Decode Base64 string
byte[] excelData = Convert.FromBase64String(yourbase64String);

// Load Excel file from byte array
MemoryStream stream = new MemoryStream(excelData);
Workbook workbook = new Workbook(stream);

// Save Excel file to PDF
workbook.Save("e:\\test2\\out1.pdf");

Hope, this helps a bit.

JohnAnish · November 10, 2025, 10:17am

In our code we are using
await using var memoryStream = new MemoryStream(Convert.FromBase64String(EncodedResultDoc));

Code part:
pdfStream=memoryStream ;
case “.XLS”:
case “.XLSX”:
{
// 1. INPUT: Use the stream holding the Excel data (we’ll call it excelStream)
// NOTE: If ‘pdfStream’ contains the decoded Excel data, use it here.
Aspose.Cells.Workbook workbook = new Aspose.Cells.Workbook(pdfStream); // Assuming pdfStream holds EXCEL data
Aspose.Cells.Worksheet sheetToRender = workbook.Worksheets[0];
workbook.Worksheets.ActiveSheetIndex = sheetToRender.Index;
sheetToRender.PageSetup.PrintArea = “A1:AS1000”; // Manual range fix

    // 2. OUTPUT: Create a new MemoryStream for the PDF output
    using (MemoryStream pdfOutputStream = new MemoryStream())
    {
        Aspose.Cells.PdfSaveOptions saveOptions = new Aspose.Cells.PdfSaveOptions();
        saveOptions.OnePagePerSheet = false;
        saveOptions.AllColumnsInOnePagePerSheet = true;
        saveOptions.EmbedStandardWindowsFonts = true;

        workbook.Save(pdfOutputStream, saveOptions);

        // Ensure the stream position is set back to 0 before reading bytes
        pdfOutputStream.Position = 0;

        // Safely transfer final PDF data to the byte array
        pdfBytes = pdfOutputStream.ToArray();
    } // pdfOutputStream is now disposed

    // 3. Update the primary stream reference IF you need it for external return value.
    // Otherwise, you only need the pdfBytes array.

    break;
}

amjad.sahi · November 10, 2025, 10:35am

@JohnAnish,

Thank you for sharing the code snippet.

Your sample code appears to be OK and seems to achieve the intended task. If you still encounter any issue, please feel free to provide complete details along with sample files, and we will review and assist you soon.

JohnAnish · November 10, 2025, 10:38am

pdf conversion is done,But the data is blank in the pdf.Excel file contains only a simple table
with some data in sheet1

Atlast pdfa conversion is done

using var pdfStreamForPdfA = new MemoryStream(pdfBytes);

// The new stream starts at Position 0 automatically!
using var pdf = new Document(pdfStreamForPdfA);

result.PdfA = ConvertPdfToPdfA(pdf, resultStream, options.PdfA, conversionId);

amjad.sahi · November 10, 2025, 10:46am

@JohnAnish,

Could you please zip and share the following resource files and artifacts, so we could evaluate your issue precisely on our end.

Your source base64 (XLSX) string
Your complete runnable sample code using Aspose.Cells
Your output PDF file

johnson.shi · November 10, 2025, 10:53am

@JohnAnish

Would you please check and confirm whether the data saved to pdfBytes contains the correct result? We think you may save the data to one file and then open the file by some pdf viewer to check its content. If the saved file does not contains the correct pdf content, we need your template excel file to reproduce and trace the issue. If it contains the correct pdf content but the “result.PdfA” is not the expected result, we think you need to check the code using Document and ConvertPdfToPdfA.

JohnAnish · November 10, 2025, 10:56am

Code_EncodeString.zip (12.4 KB)

JohnAnish · November 10, 2025, 11:18am

Some code change done .Pdf conversion is happening but there is some issue with the pdf generated
outputpdf_screenshot.png (192.4 KB)

why are those red colored displayed in the header?
how can I format the output pdf content?

amjad.sahi · November 10, 2025, 11:30am

@JohnAnish,

Thanks for the base64 string, sample code snippet and screenshot.

I simply separated your issue and used only Aspose.Cells APIs to render to PDF using your base64 encoded string. The output PDF file is fine tuned. I do not see any redundant (red colored) data in the header of the PDF page. Mind you I am using a valid license to be instantiated and set for Aspose.Cells APIs at first and before using the following sample code.
e.g.,
Sample code:

string EncodedResultDoc = "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";
// Decode Base64 string
byte[] excelData = Convert.FromBase64String(EncodedResultDoc);

// Load Excel file from byte array
MemoryStream pdfStream = new MemoryStream(excelData);

Aspose.Cells.Workbook workbook = new Aspose.Cells.Workbook(pdfStream); // Assuming pdfStream holds EXCEL data
 Aspose.Cells.Worksheet sheetToRender = workbook.Worksheets[0];
 workbook.Worksheets.ActiveSheetIndex = sheetToRender.Index;
//sheetToRender.PageSetup.PrintArea = "A1:AS1000"; // Manual range fix

// 2. OUTPUT: Create a new MemoryStream for the PDF output
using (MemoryStream pdfOutputStream = new MemoryStream())
{
    Aspose.Cells.PdfSaveOptions saveOptions = new Aspose.Cells.PdfSaveOptions();
    saveOptions.OnePagePerSheet = false;
    saveOptions.AllColumnsInOnePagePerSheet = true;
    saveOptions.EmbedStandardWindowsFonts = true;

    workbook.Save(pdfOutputStream, saveOptions);
    // Ensure the stream position is set back to 0 before reading bytes
    pdfOutputStream.Position = 0;

    // Safely transfer final PDF data to the byte array
    byte[] pdfBytes = pdfOutputStream.ToArray();     
      
    System.IO.File.WriteAllBytes("e:\\test2\\out1", pdfBytes);
 }

Please find attached the output PDF file by Aspose.Cells which is fine to me.
out1.pdf (39.0 KB)

We think since the output PDF is OK but your processed resultant PdfA has an issue, so we think you should check the relevant code snippet for Document and ConvertPdfToPdfA. Alternatively, we recommend posting your issue in the Aspose.Words forum with all the details and resource files, so Aspose.Words team could look into it soon.

JohnAnish · November 11, 2025, 8:09am

Before the code hits the ConvertPdfToPdfA method,The output pdf is ok.Checked the
output before pdf_a conversion.
But after the pdf_a conversion the final output is having the issue with the font.I am able to see the table with data but the fonts are not in readable format

amjad.sahi · November 11, 2025, 8:29am

@JohnAnish,

Thank you for confirming this.

Since the PDF output generated by Aspose.Cells appears to be fine, but the issue arises with your processed resultant PdfA, we suggest reviewing the relevant code snippet used for ConvertPdfToPdfA. As mentioned earlier, you may consider posting your issue in the Aspose.Words forum along with all the necessary details and resource files so that the Aspose.Words team can assist you promptly. Additionally, could you please confirm if you are utilizing Aspose APIs in licensing mode (i.e., applying a valid license in your code at the start of the program before using Aspose APIs)?