I have an encoded base64 string for an .Xlsx file.I want this to be converted to pdf
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.pdfto 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
.xlsxfile (remove any stray whitespace or line‑breaks before decoding). - For workbooks that use custom fonts, you can set
pdfOptions.FontEmbeddingMode = FontEmbeddingMode.EmbedAllto 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.
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.
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;
}
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.
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);
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
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.
Some code change done .Pdf conversion is happening but there is some issue with the pdf generated
why are those red colored displayed in the header?
how can I format the output pdf content?
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.PDF forum with all the details and resource files, so Aspose.PDF team could look into it soon.
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
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.PDF forum along with all the necessary details and resource files so that the Aspose.PDF 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)?
Updated code
Aspose.Cells.Workbook workbook = new Aspose.Cells.Workbook(stream); // Assuming pdfStream holds EXCEL data
using (MemoryStream pdfOutputStream = new MemoryStream())
{
Aspose.Cells.PdfSaveOptions saveOptions = new Aspose.Cells.PdfSaveOptions();
saveOptions.Compliance = Aspose.Cells.Rendering.PdfCompliance.PdfA2b;
saveOptions.OnePagePerSheet = false;
saveOptions.AllColumnsInOnePagePerSheet = false;
saveOptions.DefaultFont = "Arial";
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();
}
_logger.LogDebug("{conversionId} PDF-A conversion started", conversionId);
using var pdfStreamForPdfA = new MemoryStream(pdfBytes);
using var pdf = new Document(pdfStreamForPdfA);
result.PdfA = ConvertPdfToPdfA(pdf, resultStream, options.PdfA, conversionId);
private PdfAConverterResult ConvertPdfToPdfA(Document sourcePdf, Stream targetStream, PdfAConverterOptions options, Guid conversionId)
{
var result = new PdfAConverterResult();
sourcePdf.FontSubstitution += (font, newFont) =>
{
result.HasChangedFonts = true;
_logger.LogInformation("{conversionId} Font \"{oldFont}\" was replaced with font \"{newFont}\"",
conversionId,
font.FontName,
newFont.FontName);
};
// modify document security to allow all actions
var documentPrivilege = Aspose.Pdf.Facades.DocumentPrivilege.AllowAll;
using var fileSecurity = new Aspose.Pdf.Facades.PdfFileSecurity(sourcePdf);
fileSecurity.SetPrivilege(documentPrivilege);
using var pdfSign = new Aspose.Pdf.Facades.PdfFileSignature();
_logger.LogDebug("{conversionId} check signature", conversionId);
pdfSign.BindPdf(sourcePdf);
if (pdfSign.ContainsSignature())
{
_logger.LogDebug("{conversionId} signature detected -> removing signature", conversionId);
// remove signatures for the archive
foreach (var signName in pdfSign.GetSignNames())
{
pdfSign.RemoveSignature(signName, false);
}
}
else
{
_logger.LogDebug("{conversionId} no signature detected", conversionId);
}
//if (options.Flatten)
//{
// _logger.LogDebug("{conversionId} flattening document", conversionId);
// sourcePdf.Flatten();
// result.IsFlattened = true;
//}
_logger.LogDebug("{conversionId} begin conversion", conversionId);
var convertErrorAction = ConvertErrorAction.None;
if (options.IgnoreUnconvertible)
{
_logger.LogDebug("{conversionId} ignoring unconvertible elements", conversionId);
convertErrorAction = ConvertErrorAction.Delete;
result.IgnoredUnconvertible = true;
}
var pdfFormat = PdfFormat.PDF_A_2B;
using var conversionStream = new MemoryStream();
if (!sourcePdf.Convert(conversionStream,
pdfFormat,
convertErrorAction))
{
conversionStream.Position = 0;
using var conversionReader = new StreamReader(conversionStream);
var conversionLog = conversionReader.ReadToEnd();
using var validationStream = new MemoryStream();
sourcePdf.Validate(validationStream, pdfFormat);
validationStream.Position = 0;
using var validationReader = new StreamReader(validationStream);
var validationLog = validationReader.ReadToEnd();
_logger.LogDebug("{conversionId} Conversion log size: {conversionLogSize:0.###} kB, validation log size {validationLogSize:0.###} kB",
conversionId, conversionStream.Length.Bytes().Kilobytes, validationStream.Length.Bytes().Kilobytes);
throw new Exception(conversionLog, new Exception(validationLog));
}
_logger.LogDebug("{conversionId} conversion done", conversionId);
sourcePdf.Save(targetStream);
targetStream.Position = targetStream.Length;
_logger.LogDebug("{conversionId} save done", conversionId);
return result;
}
with this code also output is not perfect.
Font "null" was replaced with font "Arial" log is displayed in the code part
sourcePdf.FontSubstitution += (font, newFont) =>
{
result.HasChangedFonts = true;
_logger.LogInformation("{conversionId} Font \"{oldFont}\" was replaced with font \"{newFont}\"",
conversionId,
font.FontName,
newFont.FontName);
};
Why its null to arial?
Output.zip (576.8 KB)
Thank you for providing the updated code snippets.
Your issue might be related to Aspose.PDF. We had requested you to post your issue (with details and resource files) in the relevant forums so the appropriate team could evaluate it promptly. However, it appears this step was not taken. No worries, I will now move your thread to the Aspose.Total category and have requested the relevant developers to review and address the issue. @asad.ali FYI.
Output.zip (576.8 KB)
In the output pdf column headers are visible ,but the data is not in correct format
Aspose.Cells.Workbook workbook = new Aspose.Cells.Workbook(stream); // Assuming pdfStream holds EXCEL data
string safeFontName = "Arial Unicode MS";
Style defaultStyle = workbook.DefaultStyle;
defaultStyle.Font.Name = safeFontName;
workbook.DefaultStyle = defaultStyle;
//Aspose.Cells.PdfSaveOptions saveOptions = new Aspose.Cells.PdfSaveOptions();
//saveOptions.Compliance = Aspose.Cells.Rendering.PdfCompliance.PdfA2b;
//saveOptions.OnePagePerSheet = false;
//saveOptions.AllColumnsInOnePagePerSheet = false;
//saveOptions.DefaultFont = "Arial Unicode MS";
//saveOptions.EmbedStandardWindowsFonts = true;
Aspose.Cells.PdfSaveOptions saveOptions = new Aspose.Cells.PdfSaveOptions();
saveOptions.Compliance = Aspose.Cells.Rendering.PdfCompliance.PdfA2b;
saveOptions.OnePagePerSheet = false;
saveOptions.AllColumnsInOnePagePerSheet = false;
// CRITICAL: Ensure the safe font is the fallback for any remaining null references
saveOptions.DefaultFont = safeFontName;
saveOptions.EmbedStandardWindowsFonts = true;
// 2. OUTPUT: Create a new MemoryStream for the PDF output
using (MemoryStream pdfOutputStream = new MemoryStream())
{
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();
}
Our colleagues from the Aspose.PDF team will review the issue and respond to you soon. Sorry for the inconvenience caused.
Would you kindly share the definition of ConvertPdfToPdfA() method so that we can test the scenario in our environment and address it accordingly?
Issue is fixed.
ConvertPdfToPdfA() method is used to convert to pdfa.
In this scenario already the excel file is complaint to pdfa3b.
“saveOptions.Compliance = Aspose.Cells.Rendering.PdfCompliance.PdfA3b;”
Secondary conversion is not required.When this method is bypassed for excel files,the output is perfectly displayed
It is nice to know that your issue has been resolved. Please keep using our APIs and feel free to create a new topic in case you need any kind of assistance.