DEV Community: Jack9012

Convert HTML to PDF in C#: A Chrome-Based Approach

Jack9012 — Tue, 20 Oct 2026 01:25:44 +0000

Converting HTML or web pages to PDF is a common requirement in business applications, from exporting reports and printing invoices to archiving web pages and generating PDFs from dynamic HTML content.

Common approaches include:

HTML rendering libraries that work without a browser but offer limited support for complex CSS and JavaScript.
Headless browser solutions such as PhantomJS or Puppeteer, which require deploying a browser engine.
Rendering with a locally installed Chrome browser , which reuses Google Chrome on the target machine and uses its native rendering engine to handle modern CSS, JavaScript, images, fonts, and complex page layouts.

This article introduces the Spire.Additions.Chrome module included with Spire.PDF for Python . It wraps the process of exporting PDFs through a local Chrome installation, allowing you to convert a web page URL to PDF with just a few lines of C# code.

⚠️ Important prerequisites

Install Google Chrome on the machine that will run the code, and locate the chrome.exe executable.

Close all Chrome windows before running the application ; otherwise, the conversion will fail.

Both web page URLs and local HTML files are supported.

Environment Setup

Install Spire.PDF for Python

The project requires Spire.PDF for Python. The Spire.Additions.Chrome namespace is included with the product, so no separate component needs to be installed.

Locate the Chrome Executable

The default Chrome installation path on Windows is:

C:\Program Files\Google\Chrome\Application\chrome.exe

If Chrome is installed in a different directory, update the chromeLocation value in the code accordingly.

Complete C# Code Example

using Spire.Additions.Chrome;

namespace ConvertHtmlToPdfUsingChrome
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // Input web page URL
            string inputUrl = @"https://www.example.com/webpage.html";

            // Output PDF file path
            string outputFile = @"HtmlToPDF.pdf";

            // Path to the local Chrome executable
            string chromeLocation = @"C:\Program Files\Google\Chrome\Application\chrome.exe";

            // Create a Chrome HTML converter instance
            ChromeHtmlConverter converter = new ChromeHtmlConverter(chromeLocation);

            // Configure conversion options
            ConvertOptions options = new ConvertOptions();

            // Set the conversion timeout in milliseconds
            options.Timeout = 10 * 3000;

            // Set the PDF page size and margins:
            // A4 paper in inches, with no margins
            options.PageSettings = new PageSettings()
            {
                PaperWidth = 8.27,
                PaperHeight = 11.69,
                MarginTop = 0,
                MarginLeft = 0,
                MarginRight = 0,
                MarginBottom = 0
            };

            // Convert the web page URL to PDF
            converter.ConvertToPdf(inputUrl, outputFile, options);
        }
    }
}

Understanding the Code

1. ChromeHtmlConverter

ChromeHtmlConverter is the main conversion class in the Spire.Additions.Chrome namespace, which is included with Spire.PDF for Python .

Its constructor accepts the path to chrome.exe, allowing the converter to launch the local Chrome browser in headless mode and render the page.

Note: Chrome must be closed when you run the code. The library automatically launches a headless Chrome process and closes it when the conversion finishes.

2. ConvertOptions

ConvertOptions controls the conversion settings:

Timeout: The conversion timeout in milliseconds. Increase this value for pages that take longer to load. In this example, 10 * 3000 sets a timeout of 30 seconds.
PageSettings: The PDF page dimensions and margins, measured in inches. The example uses A4 paper, measuring 8.27 × 11.69 inches, with all margins set to zero for edge-to-edge output.

You can change the width and height to use a custom paper size, or adjust the margin properties to add whitespace around the page content.

3. ConvertToPdf()

ConvertToPdf() performs the conversion. It accepts a web page URL and saves the resulting PDF to the specified local file path.

In addition to URLs, the API also supports local HTML file paths.

Advantages and Limitations

Advantages

Native Chrome rendering Chrome’s rendering engine handles complex web pages, CSS3, dynamically rendered JavaScript content, SVG, and web fonts.
No additional browser engine to bundle Reusing the Chrome installation on the target machine helps reduce the application’s package size.
Simple configuration and API The converter avoids the need to write complex headless browser command-line arguments.
Included with the product Spire.Additions.Chrome is built into Spire.PDF for Python and is available after installing the product.

Limitations

Google Chrome must be installed on the target machine, and all Chrome windows must be closed during conversion.
Server deployments require Chrome to be installed on the server. Container environments also require additional Chrome configuration.
The solution depends on the locally installed browser version, so Chrome updates may affect compatibility.

Common Issues and Troubleshooting

1. Conversion Fails Because of a Chrome Process Conflict

Cause: One or more Chrome windows are still open.

Solution: Close all Chrome windows, then run the application again.

2. The Application Cannot Find chrome.exe

Cause: The configured path is incorrect, or Chrome is installed in a user-specific directory such as AppData\Local.

Solution: Locate chrome.exe in File Explorer and copy its actual path into the code.

3. The Output Is Blank or Images Are Missing

Check for network problems or page-loading timeouts. Increase options.Timeout if necessary.

Also check whether the page requires a login session or cookie-based authentication.

4. The Page Layout Looks Incorrect

Adjust the paper dimensions and margins in PageSettings.

Responsive layouts may also affect the output. If you control the HTML, consider adding print-specific CSS to improve the PDF layout.

Additional Notes on Spire.PDF for Python

Although the example above is written in C#, this Chrome-based HTML-to-PDF capability is provided by Spire.PDF for Python , with Spire.Additions.Chrome included as a built-in namespace. The Python API follows the same general design as the C# API.

The overall workflow is:

Install the Spire.PDF for Python package to access the namespace.
Install Chrome locally and close it before running the script.
Configure the Chrome path, page dimensions, and timeout, then call the conversion method to export the PDF.

Recommended Use Cases

This approach is suitable for:

Exporting web-based reports and preview pages from internal management systems.
Archiving static web pages, invoices, and other business documents as PDFs.
Generating PDFs that need to retain complex front-end layouts and web styling.

Conclusion

Combining the Spire.Additions.Chrome namespace included with Spire.PDF for Python and a local Google Chrome installation provides a straightforward way to convert HTML to PDF with minimal C# code.

Chrome’s rendering engine offers strong support for complex web pages compared with custom HTML rendering engines. The converter also provides a higher-level interface than Puppeteer, reducing the need to manage browser processes manually.

Splitting Word Documents by Page or Section Using Python

Jack9012 — Thu, 15 Oct 2026 01:55:21 +0000

In document processing, it is often necessary to split a large Word document into multiple separate files. For example, splitting a hundreds-page report by chapters, or extracting a specified page range for separate distribution.

Common libraries for processing Word documents with Python include python-docx and Spire.Doc for Python. python-docx excels at paragraph-level reading and writing, but it does not natively support direct access to page break information after document rendering. In contrast, Spire.Doc for Python can directly read a document’s page layout and Section structure. It supports two widely used splitting strategies:

Split by page range : Extract a specified page range to generate a new document based on the final rendered page layout of the file.
Split by document section : Save each section as an individual file according to Word section breaks, ideal for documents divided by chapters.

Note: Spire.Doc for Python is a standalone document processing library. Microsoft Word does not need to be installed in the runtime environment.

Environment Setup

Install the dependency package directly via pip:

pip install Spire.Doc

Method 1: Split Word Documents by Page Range

The ExtractPages(startIndex, count) method extracts a continuous range of pages according to the rendered page layout and creates a new document. Page indices start at 0 . startIndex refers to the starting page index, and count is the number of pages to extract.

Example requirement: Extract the first 3 pages into one file and save the remaining pages as another file.

from spire.doc import *
# Load the Word document
doc = Document()
doc.LoadFromFile("input.docx")
# Extract pages 1-3
first_part = doc.ExtractPages(0, min(3, doc.PageCount))
first_part.SaveToFile("Page1-3.docx", FileFormat.Docx)
first_part.Dispose()
# Extract the remaining pages if the document has more than 3 pages
if doc.PageCount > 3:
    second_part = doc.ExtractPages(3, doc.PageCount - 3)
    second_part.SaveToFile("Page4-End.docx", FileFormat.Docx)
    second_part.Dispose()
doc.Dispose()

Code Explanation

doc.LoadFromFile("input.docx"): Load the source Word document.
doc.PageCount: Get the total number of pages in the document.
min(3, doc.PageCount): Boundary protection to prevent errors when the document has fewer than 3 pages.
ExtractPages returns a new Document object. Call SaveToFile to export it as a docx file.
Dispose(): Release document resources to avoid memory consumption.

Attention: Page-based splitting relies on the final typesetting layout of the document. Changes to fonts, images or page margins will affect pagination results, which match the pages you see when opening the file in Word.

Method 2: Split Word Documents by Document Section

A Word Section is defined by section breaks. Sections are commonly used to separate different chapters, distinct headers and footers, mixed portrait and landscape orientation, and other content. This approach works well for books, papers, manuals and other documents naturally divided into chapters with section breaks.

Logic: Iterate over all Sections of the document, clone each Section, add it to a new Document object, and save each as a separate file.

from spire.doc import *
# Load the Word document
doc = Document()
doc.LoadFromFile("Sample.docx")
# Split the document by section
for i in range(doc.Sections.Count):
    new_doc = Document()
    # Clone the current section and add it to the new document
    new_doc.Sections.Add(doc.Sections.get_Item(i).Clone())
    # Save the section as an individual Word document
    new_doc.SaveToFile(
        f"output/SplitDocument/SplitBySectionBreak_{i+1}.docx"
    )
    new_doc.Close()
doc.Close()

Code Explanation

doc.Sections.Count: Get the total number of sections inside the document.
doc.Sections.get_Item(i).Clone(): Clone the current section. Cloning fully preserves page settings, headers, footers and styles of that section.
Create a blank document in each loop iteration, add the cloned section, then save it as an independent file.
new_doc.Close(): Close the sub-document and release resources.

Tip: You need to manually create the output/SplitDocument directory before running the code; otherwise, a path-not-found exception will be thrown when saving files.

Comparison of the Two Splitting Approaches

Splitting Method	Basis for Splitting	Applicable Scenarios	Limitations
Split by page range	Rendered page layout of the document	Extract fixed page ranges, cut documents by page count	Pagination positions will change after document content is modified
Split by section	Word section breaks	Documents with chapters divided by section breaks and independent headers/footers	If no section breaks are inserted in the document, there will only be one section and splitting cannot be performed

General Notes

Resource release : Always call Dispose() / Close() after finishing using Document objects to prevent memory leaks during long-running batch document processing.
Pre-create directories : When outputting files to subfolders, use os.makedirs() to create folders.
Trial version limitations : The trial version of Spire.Doc adds watermarks to output documents and has partial function restrictions. Refer to the official licensing instructions for production environment use.
File encoding and paths : On Windows, English paths are recommended for files containing Chinese characters to avoid encoding issues.

Extended Ideas

Batch splitting: Traverse all .docx files in a folder and run the splitting script in a loop.
Single-page splitting: Call ExtractPages(i,1) in a loop to save each page as a separate document.
Hybrid strategy: Split by sections first, then extract pages from each split document.

Summary

Spire.Doc for Python provides two straightforward ways to split Word documents. Splitting by page range suits visual page cutting, while splitting by section is designed for chapter splitting based on document structure (section breaks). Automated document splitting can be achieved with just dozens of lines of code, eliminating repetitive manual copy work. It can be integrated into office automation scripts and data processing pipelines.

If needed, I can also provide a fully runnable batch single-page splitting script , or an enhanced version with automatic output directory creation and exception handling.

How to Print PDFs in Java: Silent Printing and Print Dialog Selection

Jack9012 — Tue, 13 Oct 2026 05:56:35 +0000

PDF printing is a common business requirement in daily Java backend and desktop development scenarios, such as report printing, document slip printing, and document archiving printing. Java natively provides the core printing API java.awt.print. However, this native API cannot directly parse and render PDF documents. Third-party PDF parsing libraries are required to work alongside it to achieve full printing capabilities.

This article combines two technologies: Spire.PDF for Java (for PDF parsing and rendering) and java.awt.print (for system print job scheduling). It implements two mainstream PDF printing scenarios: silent printing to the default printer without pop-up windows, and printing with a dialog for manual printer selection. Complete runnable code and detailed explanations of underlying principles are provided.

1. Tech Stack and Environment Setup

1.1 Core Dependency Overview

java.awt.print : The built-in JDK printing toolkit with no extra dependencies required. It is mainly responsible for retrieving system printers, configuring print page formats, scheduling print jobs, and catching printing exceptions. It serves as the foundational core for Java printing functions.
Spire.PDF for Java : A professional PDF parsing library used to load local PDF files and render PDF page content. It adapts to the print rendering interface of the native printing API and addresses the limitation that vanilla Java cannot print PDFs directly.

1.2 Project Dependency Configuration

For Maven projects, add the Spire.PDF dependency in pom.xml:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>
<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.pdf</artifactId>
        <version>12.9.0</version>
    </dependency>
</dependencies>

2. Scenario 1: Silent Printing to Default Printer (No Print Dialog)

This scenario applies to background automatic printing with no manual intervention . The system directly sends print jobs to the default printer without popping up any print configuration windows, running silently throughout the process.

Core implementation logic: Obtain the system default print job via PrinterJob, customize the printable area of the print page, load the PDF document and bind it to the print job, then trigger printing directly.

Full Runnable Code

import com.spire.pdf.PdfDocument;
import java.awt.print.PageFormat;
import java.awt.print.Paper;
import java.awt.print.PrinterException;
import java.awt.print.PrinterJob;
/**
 * PDF Silent Printing (Default Printer, No Dialog)
 */
public class PrintWithDefaultPrinter {
    public static void main(String[] args) {
        // 1. Get print job object for the system default printer
        PrinterJob printerJob = PrinterJob.getPrinterJob();
        // 2. Initialize page format and retrieve default page size and orientation
        PageFormat pageFormat = printerJob.defaultPage();
        // 3. Get paper object for the page and customize printable area
        Paper paper = pageFormat.getPaper();
        // Set full printable area of the paper (remove default margins to fit full PDF page)
        paper.setImageableArea(0, 0, pageFormat.getWidth(), pageFormat.getHeight());
        // Bind customized paper settings to page format
        pageFormat.setPaper(paper);
        // 4. Load local PDF document
        PdfDocument pdf = new PdfDocument();
        // Replace with your actual local PDF file path
        pdf.loadFromFile("input.pdf");
        // 5. Bind PDF document with page format to prepare print rendering
        printerJob.setPrintable(pdf, pageFormat);
        // 6. Execute silent print job
        try {
            printerJob.print();
            System.out.println("PDF silent print job completed");
        } catch (PrinterException e) {
            e.printStackTrace();
            System.err.println("PDF silent printing failed: " + e.getMessage());
        }
    }
}

Key Code Explanations

PrinterJob.getPrinterJob(): Retrieves the system default print job instance and automatically binds to the machine’s default printer.
paper.setImageableArea(): Resets the paper printable area and removes default margin padding, preventing incomplete PDF output or excessive white space on printed pages.
printerJob.print(): Triggers the print job directly with no interactive dialog, ideal for automated printing workflows.

3. Scenario 2: Printing with Dialog Popup (Manual Printer Configuration)

This scenario is suitable for cases where users need to select printers and adjust print parameters . After the program starts, the native system print dialog opens. Users may switch printers, set print copies, page ranges, portrait/landscape orientation and other parameters before confirming to print.

Core implementation logic: Based on the silent printing logic, add a print dialog check. The print job will only execute after user confirmation, offering greater flexibility.

Full Runnable Code

import com.spire.pdf.PdfDocument;
import java.awt.print.PageFormat;
import java.awt.print.Paper;
import java.awt.print.PrinterException;
import java.awt.print.PrinterJob;
/**
 * PDF Printing with Dialog (Manual Printer Selection & Parameter Configuration)
 */
public class PrintWithPrintDialog {
    public static void main(String[] args) {
        // 1. Initialize print job
        PrinterJob printerJob = PrinterJob.getPrinterJob();
        // 2. Configure print page and paper format
        PageFormat pageFormat = printerJob.defaultPage();
        Paper paper = pageFormat.getPaper();
        paper.setImageableArea(0, 0, pageFormat.getWidth(), pageFormat.getHeight());
        pageFormat.setPaper(paper);
        // 3. Load local PDF file
        PdfDocument pdf = new PdfDocument();
        pdf.loadFromFile("input.pdf");
        // 4. Bind PDF document and print format
        printerJob.setPrintable(pdf, pageFormat);
        // 5. Bring up system print dialog and check user confirmation
        if (printerJob.printDialog()) {
            try {
                // Execute printing after user confirmation
                printerJob.print();
                System.out.println("PDF print job with dialog completed");
            } catch (PrinterException e) {
                e.printStackTrace();
                System.err.println("PDF printing with dialog failed: " + e.getMessage());
            }
        } else {
            System.out.println("User cancelled the print job");
        }
    }
}

Key Code Explanations

printerJob.printDialog(): Launches the native system print dialog and returns a boolean value. true means the user confirms printing; false means the user cancels.
All print parameters (printer selection, copy count, page numbers) are configured via the system dialog instead of hardcoding in code, accommodating diverse printing requirements.
Custom printable area configuration is retained to ensure complete and intact PDF print layout.

4. Common Issues and Notes

4.1 File Path Compatibility

The example uses Windows absolute paths. When deployed on Linux or macOS, modify the paths to match the target operating system and ensure the application has read permissions for the PDF file.

4.2 Incomplete Printed Content / Excessive White Margins

The primary solution is the paper.setImageableArea() method shown in code. It resets the printable area and overrides default system margin restrictions to match the original PDF dimensions.

4.3 Print Exception Handling

PrinterException is caught in the code, which can capture printing failures such as offline printers, out-of-paper status, or corrupted files, enabling business-layer alerting and logging.

5. Summary

This article implements two core PDF printing solutions in Java using the native java.awt.print API together with Spire.PDF:

Silent Printing : No dialog window, fully automatic execution for background automated printing tasks.
Dialog-Based Printing : Supports manual parameter configuration with high flexibility for user-initiated printing on the frontend.

Both code samples are concise, reusable and free of redundant logic. They can be directly adopted in Java desktop and backend projects. The implementation solves the core limitation that native Java cannot print PDFs directly while ensuring reliable and complete print layout rendering.

Extracting Table Data from PDFs Using Python

Jack9012 — Sat, 10 Oct 2026 01:33:31 +0000

PDF is one of the most common document formats in daily work, but its "tables" are a different thing from tables in Excel: a PDF file itself does not store structured table data. A table on a page is merely a visual effect presented by text and lines according to their positional relationships. Therefore, reading PDF tables programmatically is essentially about letting a library analyze the page layout and identify the structure of rows and columns.

This article uses Spire.PDF for Python's PdfTableExtractor to demonstrate how to detect tables in a PDF page by page and read each cell as text. The overall process has only three steps: load the document → extract tables page by page → iterate through rows and columns to read cells.

1. Environment Setup

Install the library via pip:

pip install Spire.PDF

If you are just learning or handling small documents, you can also install the free version:

pip install Spire.Pdf.Free

Note that the free version has a page limit when loading and processing PDFs (at most the first 10 pages). Documents longer than 10 pages need to be split before processing, or you need to use the full PyPI version.

2. Core Code

from spire.pdf import PdfDocument, PdfTableExtractor

# Load PDF document
pdf = PdfDocument()
pdf.LoadFromFile("input.pdf")

# Create a PdfTableExtractor object
table_extractor = PdfTableExtractor(pdf)

# Extract tables from each page
for i in range(pdf.Pages.Count):
    tables = table_extractor.ExtractTable(i)
    for table_index, table in enumerate(tables):
        print(f"Table {table_index + 1} on page {i + 1}:")
        for row in range(table.GetRowCount()):
            row_data = []
            for col in range(table.GetColumnCount()):
                text = table.GetText(row, col).replace("\n", " ")
                row_data.append(text.strip())
            print("\t".join(row_data))

3. Step-by-Step Code Explanation

1. Load the PDF document

pdf = PdfDocument()
pdf.LoadFromFile("input.pdf")

PdfDocument is the document entry object. LoadFromFile() loads the PDF by passing in the file path. The file path can be either relative or absolute.

2. Create the table extractor

table_extractor = PdfTableExtractor(pdf)

PdfTableExtractor is responsible for analyzing the layout page by page and detecting table structures. When constructing it, you need to pass in the already loaded PdfDocument object.

3. Extract tables page by page

for i in range(pdf.Pages.Count):
    tables = table_extractor.ExtractTable(i)

pdf.Pages.Count is the total number of pages in the document, and ExtractTable(i) returns all tables detected on page i. Note that it returns a list — a single page may contain multiple tables at the same time; if there are no tables on that page, it returns an empty list.

4. Iterate through the table's rows and columns

for row in range(table.GetRowCount()):
    row_data = []
    for col in range(table.GetColumnCount()):
        text = table.GetText(row, col).replace("\n", " ")
        row_data.append(text.strip())
    print("\t".join(row_data))

GetRowCount() / GetColumnCount() get the number of rows and columns in the table;
GetText(row, col) reads the text of the specified cell. A cell may contain line breaks; here \n is replaced with a space, and then strip() removes leading and trailing whitespace to avoid extra blank lines in the output;
Finally, \t (tab) is used to join the cells of a row for output, making it easy to copy into Excel or use as TSV.

4. Running Effect

Running the above code on a PDF containing a simple table produces output roughly as follows:

Table 1 on page 1:
Name    Department  Salary
Zhang San   Technical Department    12000
Li Si   Marketing Department    9800
Wang Wu Finance Department  10500

Each line corresponds to a row in the table, and cells are separated by tabs, so it can be pasted directly into spreadsheet software.

5. Advanced: Save the Results as CSV

Printing to the console is only suitable for quick viewing. If you want to save the results, you can use Python's built-in csv module, with no need to install an additional library:

import csv
from spire.pdf import PdfDocument, PdfTableExtractor

pdf = PdfDocument()
pdf.LoadFromFile("input.pdf")
extractor = PdfTableExtractor(pdf)

with open("output.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    for i in range(pdf.Pages.Count):
        for table in extractor.ExtractTable(i):
            for row in range(table.GetRowCount()):
                row_data = [
                    table.GetText(row, col).replace("\n", " ").strip()
                    for col in range(table.GetColumnCount())
                ]
                writer.writerow(row_data)

pdf.Close()

When writing with csv.writer, the program automatically handles special characters such as commas and quotation marks contained in cells, which is more reliable than manually concatenating strings.

6. Notes and Limitations

1. Suitable for tables with clear borders. PdfTableExtractor relies on analyzing the page layout. It recognizes tables with clear borders and regular structures relatively well; for tables without visible borders, cells spanning multiple lines, or complex layouts where headers are not clearly identified, it may fail to detect them or produce incomplete structures.

2. Scanned documents require OCR first. If the PDF is a scanned image (without a text layer), no text-based tool can directly read the content. You need to use OCR first to convert the image into text. This library does not provide OCR functionality.

3. Page limit of the free version. The free version can process at most the first 10 pages. When handling long documents, it is recommended to add a min(pdf.Pages.Count, 10) limit in the loop, or split the document by page.

4. Release resources after use. When batch processing a large number of files, remember to call pdf.Close() at the end to release resources.

7. Other Optional Libraries

If you encounter complex tables that Spire.PDF cannot handle, you can try the following open-source libraries as supplements:

pdfplumber : Based on pdfminer.six, it provides finer-grained access to page objects and is suitable for handling complex layouts;
camelot : Identifies structures by detecting table lines and works well for bordered tables;
tabula-py : Wraps Java's tabula, and its output is directly compatible with pandas DataFrame.

In actual projects, you can combine them according to the table type: regular tables can be handled by any library, while for complex ones, it is better to test on a small sample first before choosing.

8. Summary

The process of extracting PDF tables with Spire.PDF for Python is very straightforward: load the document → create PdfTableExtractor → call ExtractTable() page by page → iterate through rows and columns to read cells. It is suitable for handling bordered, clearly structured tables, and with the csv module, the results can be saved to disk. For special cases such as borderless tables and scanned documents, OCR or other libraries are needed as supplements.

Downloading PDF Documents from URLs with Python

Jack9012 — Thu, 08 Oct 2026 01:31:01 +0000

In scenarios such as automated office work, document collection, and batch resource fetching, it is often necessary to download PDF files from the network programmatically. Directly writing the binary stream returned by an interface to a local file can easily lead to corrupted files or format anomalies. This article uses requests to handle network requests, combined with Spire.PDF for .NET to complete PDF stream validation and persistent saving, providing a ready-to-run download solution with built-in file validity checking.

1. Installing Environment Dependencies

1.1 Network Request Library: requests

Used to make HTTP requests and retrieve remote PDF binary data:

pip install requests

1.2 PDF Processing Library

This example relies on this library for in-memory stream loading, PDF validation, and local file export. The installation command is as follows:

pip install spire.pdf

2. Complete Runnable Code

import requests
from spire.pdf import *

def download_pdf_from_url():
    # Specify the remote PDF resource URL
    url = "resource/sample.pdf"

    # Send a GET request to fetch the file's binary data
    response = requests.get(url)
    # Automatically raise 4xx/5xx HTTP errors to catch dead links and server issues in advance
    response.raise_for_status()
    # Wrap the downloaded byte data as an in-memory stream
    stream = Stream(response.content)
    # Load the PDF document from the memory stream, automatically validating whether the file is a legitimate PDF
    document = PdfDocument(stream)
    # Save the validated PDF to a local file
    document.SaveToFile("Downloaded.pdf")
    # Close the document to release memory resources
    document.Close()
    print("PDF downloaded and saved successfully!")

if __name__ == "__main__":
    download_pdf_from_url()

3. Line-by-Line Code Breakdown

3.1 Module Imports

import requests
from spire.pdf import *

requests: a general-purpose Python HTTP library, responsible for remote file downloads;
The PDF-related namespace: from Spire.PDF for .NET, providing full capabilities for stream reading and PDF document operations.

3.2 Remote Request and Exception Handling

response = requests.get(url)
response.raise_for_status()

raise_for_status() is crucial fault-tolerant logic: when a link returns 404, the server returns 500, or access is denied, the program throws an exception directly instead of generating a corrupted blank file.

3.3 Loading the PDF from a Memory Stream (Core Advantage)

The conventional download logic directly uses open to write the byte stream to a file, without being able to determine whether the returned data is a valid PDF.

This solution first converts the binary data returned by the interface into a Stream, then hands it to PdfDocument for loading:

Automatically validates whether the data stream conforms to the PDF standard;
Filters out anomalies such as interrupted downloads and HTML error pages returned in place of the file;
Processes everything in memory, without generating temporary cache files.

3.4 Saving the File and Releasing Resources

SaveToFile supports custom output locations via relative or absolute paths. After processing, call Close() to release the memory occupied by the document, which effectively prevents memory overflow during long batch download loops.

4. Practical Usage Notes

URL requirements In the example, resource/sample.pdf is a relative resource path; in production, replace it with a full http/https public PDF link. For private links requiring login authentication or Cookie validation, add the headers and cookies parameters to requests.get.
Extended exception handling The basic code only intercepts HTTP errors. In a production environment, it is recommended to wrap the logic in try except to catch exceptions such as PDF parsing failures and insufficient file-write permissions:

   try:
       # Complete download logic
   except requests.exceptions.RequestException as http_err:
       print(f"Network request failed: {http_err}")
   except Exception as pdf_err:
       print(f"PDF processing failed, the file may be corrupted: {pdf_err}")

Batch download adaptation Store multiple PDF URLs in a list, call download_pdf_from_url in a loop, and modify the output file names to avoid overwriting, enabling batch archiving of remote PDFs.

5. Summary

This download solution combines the network capabilities of requests with Spire.PDF for .NET's PDF parsing capabilities. Its biggest highlight is validating file legitimacy at download time, solving the pain point of ordinary download methods easily producing corrupted PDFs. The code is compact and highly extensible, making it suitable for various development scenarios such as script automation, backend document synchronization, and crawler resource collection.

How to Add Watermarks to Excel in C#: Two Practical Approaches

Jack9012 — Tue, 29 Sep 2026 06:11:43 +0000

In scenarios such as report distribution, contract archiving, and confidential data sharing, adding a watermark to an Excel document is a simple and practical means of copyright identification. A watermark can be composed of either an image or text. Watermarks with wording such as "Confidential," "Internal Use Only," and "Do Not Distribute" are widely used across business contexts worldwide.

This article will demonstrate how to use a free .NET Excel library to add watermarks to Excel documents in C#, compare two implementation approaches—header image watermarks and background image watermarks—and supplement this with a piece of helper code for generating text watermark images, so that it can be used directly even when no ready-made watermark image is available.

Installation

The library can be brought into the project via NuGet.

NuGet Package Manager Console

  Install-Package FreeSpire.XLS

.NET CLI

  dotnet add package FreeSpire.XLS

After installation is complete, import the namespace Spire.Xls in the code to use it.

Comparison of the Two Watermark Solutions

An Excel watermark is not a true "watermark" object. It is essentially simulated through a header image or a worksheet background image, so the two solutions differ significantly in terms of printing, view, positioning, and other aspects.

Comparison Item	Header Image Watermark	Background Image Watermark
Print output	Printed along with the document	Does not appear in the print result
View visibility	Visible only in "Page Layout" or "Page Break Preview" mode, not in Normal view	Visible in all view modes
Position control	Header area margins need to be adjusted manually to center the image	Automatically fills the entire worksheet data area
Visual consistency	Affected by pagination; adjacent pages may be misaligned	The entire worksheet displays only the same image

Header Image Watermark

Advantages : The watermark appears in the document's final print output, making it suitable for scenarios that must be printed and archived.
Disadvantages : It is not visible in Excel's "Normal" view and can only be seen in "Page Layout" or "Page Break Preview"; to position the image exactly in the center of the page, the top and left margins of the image must be adjusted carefully.

Background Image Watermark

Advantages : The watermark image covers the entire worksheet, producing a consistent effect.
Disadvantages : The watermark does not appear in the print output.

Solution 1: Add an Image Watermark Through the Header

The following example iterates through all worksheets in the document and sets the same watermark image in the center position of the header.

using Spire.Xls;
using System.Drawing;

namespace AddWatermarkToExcelUsingHeader
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a Workbook object
            Workbook workbook = new Workbook();

            // Load the Excel document
            workbook.LoadFromFile(@"C:\Users\Administrator\Desktop\Input.xlsx");

            // Load the watermark image
            Image image = Image.FromFile(@"C:\Users\Administrator\Desktop\confidential.png");

            // Iterate through all worksheets in the document
            for (int i = 0; i < workbook.Worksheets.Count; i++)
            {
                // Get the specified worksheet
                Worksheet worksheet = workbook.Worksheets[i];

                // Insert an image placeholder in the center of the header
                worksheet.PageSetup.CenterHeader = "&G";

                // Set the image in the center of the header
                worksheet.PageSetup.CenterHeaderImage = image;
            }

            // Save the resulting file
            workbook.SaveToFile("AddWatermark.xlsx", ExcelVersion.Version2016);

            // Release resources
            workbook.Dispose();
        }
    }
}

Note: &G is Excel's own header image placeholder. All text (such as the word "Confidential") should be baked directly into the image, rather than written into the CenterHeader string.

Solution 2: Set the Image as a Worksheet Background

The following example uses an image as a worksheet background watermark, which is suitable for screen-only viewing scenarios that require strong visibility.

using Spire.Xls;
using System.Drawing;

namespace AddWatermarkToExcelUsingBackground
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a Workbook object
            Workbook workbook = new Workbook();

            // Load the Excel document
            workbook.LoadFromFile(@"C:\Users\Administrator\Desktop\Input.xlsx");

            // Load the watermark image
            Bitmap bitmapImage = new Bitmap(Image.FromFile(@"C:\Users\Administrator\Desktop\sample.png"));

            // Iterate through all worksheets in the document
            for (int i = 0; i < workbook.Worksheets.Count; i++)
            {
                // Get the specified worksheet
                Worksheet worksheet = workbook.Worksheets[i];

                // Set the image as the background of the worksheet
                worksheet.PageSetup.BackgroundImage = bitmapImage;
            }

            // Save the resulting file
            workbook.SaveToFile("AddWatermark.xlsx", ExcelVersion.Version2016);

            // Release resources
            workbook.Dispose();
        }
    }
}

Generation of Text Watermarks

In real-world business scenarios, watermarks are often dynamic text such as "Confidential" or "Internal Use Only," and there is no need for a designer to provide a PNG every time. You can use System.Drawing to draw a text watermark image with a transparent background in memory, and then reuse it with Solution 1 or Solution 2.

using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;

public static class WatermarkHelper
{
    /// <summary>
    /// Generates a text watermark image (transparent background, tilted -30°)
    /// </summary>
    /// <param name="text">Watermark text, such as "Confidential"</param>
    /// <param name="width">Canvas width</param>
    /// <param name="height">Canvas height</param>
    /// <returns>A Bitmap object with a transparent background</returns>
    public static Bitmap Create(string text, int width, int height)
    {
        Bitmap bmp = new Bitmap(width, height, PixelFormat.Format32bppArgb);

        using (Graphics g = Graphics.FromImage(bmp))
        {
            g.Clear(Color.Transparent);
            g.SmoothingMode = SmoothingMode.AntiAlias;
            g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit;

            using (Font font = new Font("Arial", 60, FontStyle.Bold))
            using (SolidBrush brush = new SolidBrush(Color.FromArgb(60, Color.Red)))
            {
                // Calculate the text size and center it
                SizeF size = g.MeasureString(text, font);

                // Translate to the center of the canvas, then rotate, so that the drawn text is centered
                g.TranslateTransform(width / 2f, height / 2f);
                g.RotateTransform(-30);

                g.DrawString(text, font, brush, -size.Width / 2f, -size.Height / 2f);
            }
        }

        return bmp;
    }
}

When calling it, simply pass the generated Bitmap directly to either of the two solutions above:

// Generate a text watermark image
Bitmap watermarkImage = WatermarkHelper.Create("Confidential", 800, 600);

// Use it as a worksheet background watermark
workbook.Worksheets[0].PageSetup.BackgroundImage = watermarkImage;

Font Consistency Recommendations

System.Drawing renders text using fonts installed on the system by default. In different environments (such as Linux servers or containerized deployments), font loss may occur, causing text to render incorrectly. In production environments, it is recommended to:

Package font files into the application;
Load private fonts through PrivateFontCollection and then pass them to the Font constructor;
Or render all potentially used watermark text into PNGs in advance and distribute them as static resources with the project.

Solution Selection Reference

Scenario	Recommended Solution
Reports need to be printed and archived, and documents need to be retained long-term	Solution 1: Header image watermark
Screen-only viewing, internal presentations, emphasis on intuitive visibility	Solution 2: Background image watermark

Summary

The free .NET Excel library itself does not directly provide a "watermark" object. Instead, it implements watermarks through two mechanisms: header images or worksheet background images. By passing any Image/Bitmap to CenterHeaderImage or BackgroundImage, watermark addition is complete; combined with a short piece of text drawing code, watermarks such as "Confidential" and "Internal Use Only" can be generated flexibly without relying on external assets.

In actual projects, it is recommended to encapsulate "image generation + watermark injection" into independent utility methods, exposing only a small number of parameters such as file path, watermark text, and visibility to the outside. This minimizes the cost of reuse when dealing with multiple business lines and multiple templates.

How to Change Page Margins of a PDF Using Python

Jack9012 — Wed, 23 Sep 2026 01:31:58 +0000

In document processing scenarios, we may encounter the need to adjust the blank edges (margins) of PDF files, such as reserving blank space for printing, cropping excess white edges, or unifying document layout formats. There are several PDF processing libraries in the Python ecosystem. This article uses Free Spire.PDF for Python to implement pure-code, watermark-free, and lightweight PDF margin increase and decrease operations.

This solution requires no complex dependencies. Through the core logic of creating a new PDF document, reconstructing page sizes, and redrawing pages using templates, it precisely controls the blank edges on all four sides (top, bottom, left, and right) of a PDF, and is suitable for single-page and multi-page PDF documents.

1. Setup the Environment

First, install the required third-party library. Free Spire.PDF for Python focuses on basic PDF editing, with a concise and easy-to-understand API, making it suitable for rapid development. Run the following pip command to complete the installation:

pip install spire.pdf

2. Overview of Implementation Principles

The core logic of the two margin adjustment methods in this article is the same; only the size calculation and drawing parameters differ:

Increase margins : Expand the PDF page size, keep the original page content centered, and use the newly added blank area as margins.
Decrease margins : Shrink the PDF page size, and crop the blank edges of the original page by offsetting the content drawing coordinates.

General workflow: Load the original PDF → Calculate the new page size → Iterate through pages to generate templates → Create new pages and redraw content → Save the new file and release resources.

3. Increase PDF Page Margins in Python

This scenario is suitable for situations where PDF content is too close to the edges, where printing whitespace needs to be added, or where document margin specifications need to be unified. Below is simplified, directly runnable code where you can customize the margin increments for the top, bottom, left, and right sides.

from spire.pdf.common import SizeF
from spire.pdf import PdfDocument

# 1. Load the original PDF document
original_pdf = PdfDocument()
original_pdf.LoadFromFile("sample.pdf")

# 2. Customize the margins to be added on all four sides
margin_top = 40
margin_bottom = 40
margin_left = 40
margin_right = 40

# 3. Calculate the new page size based on the first page size (applicable to all pages)
first_page = original_pdf.Pages[0]
new_page_width = first_page.Size.Width + margin_left + margin_right
new_page_height = first_page.Size.Height + margin_top + margin_bottom
new_page_size = SizeF(new_page_width, new_page_height)

# 4. Create a new PDF document and redraw all pages
new_pdf = PdfDocument()
for page_idx in range(original_pdf.Pages.Count):
    # Generate a template of the original page, preserving the complete content
    page_template = original_pdf.Pages[page_idx].CreateTemplate()
    # Add a new page with the custom size
    new_page = new_pdf.Pages.Add(new_page_size)
    # Draw the original content at the origin of the new page, automatically generating uniform whitespace
    page_template.Draw(new_page, 0.0, 0.0)

# 5. Save the file and release resources
new_pdf.SaveToFile("increase_pdf_margins.pdf")
original_pdf.Dispose()
new_pdf.Dispose()
print("PDF margin increase completed!")

Core explanation : By adding the four margin values to the original page width and height, the page size is expanded. The original content is fully preserved at the top-left corner of the page, and the remaining area automatically forms uniform blank margins.

4. Decrease PDF Page Margins in Python

This scenario is commonly used to remove excess default blank edges from PDFs, compress the visible document size, and make the content display close to the edges. The core is to shrink the page size while offsetting the content drawing coordinates in the opposite direction to crop excess whitespace.

from spire.pdf.common import SizeF, PdfMargins
from spire.pdf import PdfDocument

# 1. Load the original PDF document
original_pdf = PdfDocument()
original_pdf.LoadFromFile("sample.pdf")

# 2. Customize the blank margins to be cropped on all four sides
reduce_top = 20.0
reduce_bottom = 20.0
reduce_left = 20.0
reduce_right = 20.0

# 3. Calculate the new page size after cropping
first_page = original_pdf.Pages[0]
new_page_width = first_page.Size.Width - reduce_left - reduce_right
new_page_height = first_page.Size.Height - reduce_top - reduce_bottom
new_page_size = SizeF(new_page_width, new_page_height)

# 4. Create a new PDF document, redraw and crop page whitespace
new_pdf = PdfDocument()
for page_idx in range(original_pdf.Pages.Count):
    page_template = original_pdf.Pages[page_idx].CreateTemplate()
    # Add a new page with no margins
    new_page = new_pdf.Pages.Add(new_page_size, PdfMargins(0.0))
    # Offset the drawing coordinates in the opposite direction to crop the original blank edges
    page_template.Draw(new_page, -reduce_left, -reduce_top)

# 5. Save the file and release resources
new_pdf.SaveToFile("decrease_pdf_margins.pdf")
original_pdf.Dispose()
new_pdf.Dispose()
print("PDF margin cropping completed!")

Core explanation : Subtract the whitespace size to be cropped from the page size, and at the same time offset the content drawing coordinates to the left and upward, so that the original page's edge whitespace extends beyond the new page range, thereby achieving the white edge cropping effect.

5. Key Notes

Unit description : All margin values in the code use the standard PDF unit (points). 1 inch ≈ 72 points, and they can be freely converted and adjusted as needed.
Multi-page adaptation : The code uses a globally uniform margin rule, so all pages apply the same increase or decrease parameters, making it suitable for standardized document processing.
Resource release : The Dispose() method must be called to release document resources and avoid memory usage buildup.
Parameter threshold : When decreasing margins, the cropping value must not exceed the original page whitespace; otherwise, the content may be abnormally cropped.

6. Summary

With Free Spire.PDF for Python, custom adjustment of PDF margins can be implemented in a minimal and efficient way, without relying on Adobe software or complex PDF parsing algorithms. The two sets of code provided in this article respectively cover the two high-frequency scenarios of increasing whitespace and cropping white edges . The code is concise, with complete comments, and can be directly embedded into automated document processing scripts, office tools, and batch processing programs.

How to Extract Text and Images from PowerPoint Using C#

Jack9012 — Mon, 21 Sep 2026 01:38:20 +0000

In development scenarios, we may encounter the need for PowerPoint document content parsing, such as batch-extracting text from courseware and reports for archiving, or batch-exporting embedded images from presentations for asset organization.

The native .NET framework does not provide a built-in API for directly parsing PowerPoint files. Manually working with the OpenXML format results in redundant code, complex logic, and a large number of format compatibility issues. Free Spire.Presentation for .NET is a lightweight, free PowerPoint parsing library that supports the entire .NET version range and can quickly implement core features such as text reading, image extraction, and document parsing for PowerPoint files, greatly reducing development costs.

This article is based on .NET 10 syntax conventions and uses Free Spire.Presentation to implement two core features:

Batch-extract all text from every slide in a PowerPoint file and export it to a TXT file
Batch-extract all embedded images from a PowerPoint file and save them as local PNG files

Environment Preparation

Development Environment

Development framework: .NET 6+
Development tools: Visual Studio 2022 / Rider
Target files: .pptx presentation documents (compatible with mainstream PowerPoint formats)

Installing the NuGet Dependency

The project needs to reference the Free Spire.Presentation core package. Search for and install it in the NuGet Package Manager, or install it via the command line:

Install-Package FreeSpire.Presentation

This package is a free, open-source version that meets the development needs of daily non-commercial, batch PowerPoint parsing, with no forced watermark and no marketing bindings.

Extracting All Text from a PowerPoint File

Feature Description

Traverse all slides and all shape components in the PowerPoint file, filter for text container components, read the text content paragraph by paragraph, and finally combine all content and export it to a local TXT document. The code is streamlined using minimalist .NET 10 features such as top-level statements and implicit namespaces, making it more concise and readable.

Complete Code

using Spire.Presentation;
using System.Text;

// Initialize a PowerPoint document instance and load the target file
using Presentation presentation = new();
presentation.LoadFromFile("Island.pptx");

// Initialize the text concatenation container
StringBuilder textBuilder = new();

// Iterate through all slides
foreach (ISlide slide in presentation.Slides)
{
    // Iterate through all components on a single slide
    foreach (IShape shape in slide.Shapes)
    {
        // Filter for text shape components and read paragraph text
        if (shape is IAutoShape autoShape)
        {
            foreach (TextParagraph paragraph in autoShape.TextFrame.Paragraphs)
            {
                textBuilder.AppendLine(paragraph.Text);
            }
        }
    }
}

// Export the text to a local TXT file
File.WriteAllText("ExtractText.txt", textBuilder.ToString());

Explanation of the Core Logic

Automatic resource release : Uses the using variable declaration syntax supported by .NET 10, eliminating the need to manually call Dispose. The PowerPoint file resources are automatically released after the program finishes executing, avoiding file locking and memory leaks.
Type pattern matching : Uses is variable declaration pattern matching to complete type checking and casting in one step, replacing the traditional redundant approach of first checking the type and then casting. This is the recommended optimal syntax in .NET 10.
Layered traversal logic : The PowerPoint text storage hierarchy is Slide -> Shape -> TextParagraph. Through this three-level traversal, all text on a page (titles, body text, and note text) can be precisely captured.
Batch text export : Uses StringBuilder to efficiently concatenate text, avoiding the performance overhead of frequent string concatenation, and finally writes everything to a local file in one go.

Extracting All Embedded Images from a PowerPoint File

Feature Description

Directly read the global image resource collection of the PowerPoint document, batch-traverse all embedded images, export them uniformly as PNG image files, and automatically name and archive them, making it suitable for batch asset extraction scenarios.

Complete Code

using Spire.Presentation;
using Spire.Presentation.Collections;

// Initialize and load the PowerPoint document
using Presentation presentation = new();
presentation.LoadFromFile("Template.pptx");

// Get the collection of all embedded images in the PowerPoint file
ImageCollection imageCollection = presentation.Images;

// Iterate through the image collection and export in batches
for (int i = 0; i < imageCollection.Count; i++)
{
    // Name and save images by index to avoid duplicate file names
    string savePath = Path.Combine("Presentation", $"Images{i}.png");

    // Create the storage directory (automatically created if it does not exist)
    Directory.CreateDirectory(Path.GetDirectoryName(savePath)!);

    // Save the image locally
    imageCollection[i].Image.Save(savePath);
}

Explanation of the Core Logic

Global image reading : Unlike traversing slides page by page, this directly obtains all embedded images in the document through presentation.Images, eliminating the need to repeatedly traverse pages and resulting in higher execution efficiency.
Automatic directory creation : Adds directory checking logic to automatically detect whether the image storage folder exists and create it if it does not, avoiding save failures caused by missing directories and improving code robustness.
.NET 10 string optimization : Uses string interpolation instead of traditional string.Format, resulting in cleaner syntax and stronger readability. This is the recommended approach in newer versions of .NET.
Safe resource release : The using syntax manages the lifecycle of the PowerPoint instance, ensuring that resources are completely released after the file has been read.

Key Considerations

File format compatibility : This component only supports parsing .pptx files. Older .ppt formats must be converted before parsing.
Path conventions : The code uses relative paths by default. You can change them to absolute paths according to business needs to adapt to different runtime environments such as servers and desktops.
Special content compatibility : This solution can normally extract ordinary text and images. For WordArt, background fill images, and encrypted content, additional compatibility handling is required.
.NET version compatibility : The code in this article is based on minimalist .NET 10 syntax. If compatibility with lower .NET versions is needed, top-level statements can be changed to the traditional class and Main method style.

Conclusion

With the FreeSpire.Presentation library, we can quickly implement batch extraction of PowerPoint text and images using minimalist .NET 10 code, completely avoiding the complex logic of native OpenXML parsing.

The entire codebase is lightweight, free of redundancy, and does not depend on third-party software. It can be directly applied to business scenarios such as batch document parsing, content archiving, asset extraction, and office automation , making it an efficient solution for handling basic PowerPoint parsing needs on the .NET platform.

Adding Custom Text to PDF Documents with Python

Jack9012 — Thu, 17 Sep 2026 03:49:30 +0000

When processing documents, it is often necessary to append text to existing PDF files for purposes such as supplementary notes, explanatory labels, watermark text, and page number annotations. Python boasts an extensive collection of PDF processing libraries. Among them, Free Spire.PDF for Python stands out with its streamlined APIs, comprehensive style customization, and independence from local Adobe components. It enables efficient PDF text editing with support for personalized effects including custom fonts, colors, transparency, and text rotation.

This tutorial provides an objective and complete walkthrough of adding text to PDFs using Free Spire.PDF, covering basic executable code and advanced style customization to meet diverse PDF text editing requirements.

1. Environment Setup

1.1 Library Installation

First, install the Free Spire.PDF dependency via pip by running the following command:

pip install spire-pdf-free

This library supports Python 3.7 and above, and is cross-platform compatible with Windows, macOS and Linux. After installation, you may directly call its APIs to edit PDF files.

1.2 Overview of Core Modules

Below is a breakdown of key modules used in this practical project and their core functionalities:

PdfDocument : The core class for PDF file operations, responsible for loading, saving and closing documents
Font-related classes : PdfCjkStandardFont, PdfTrueTypeFont, PdfFont — designed for CJK fonts, custom system fonts, and built-in standard PDF fonts respectively
PdfSolidBrush & PdfRGBColor : Used to configure text drawing colors and brush styles
PointF : Defines the coordinate position for rendering text on PDF pages

2. Basic Implementation: Insert Plain Text into a PDF

This basic workflow loads an existing PDF file and inserts custom text at a specified coordinate on a target page, alongside basic font and color configuration. Below is fully runnable code with detailed comments.

from spire.pdf import PdfDocument, PdfFontStyle, PdfSolidBrush, PdfRGBColor, PointF, PdfCjkStandardFont, PdfCjkFontFamily

# Initialize a PDF document object and load the local PDF file
pdf = PdfDocument()
pdf.LoadFromFile("input.pdf")  

# Retrieve the first page of the PDF (index starts at 0)
page = pdf.Pages.get_Item(0) 

# Configure CJK font: Monotype Hei Medium, size 16, bold weight
font = PdfCjkStandardFont(PdfCjkFontFamily.MonotypeHeiMedium, 16.0, PdfFontStyle.Bold)

# Create a brush and set text color to light orange
brush = PdfSolidBrush(PdfRGBColor(255,200, 180)) 

# Define coordinates for text rendering (unit: point)
location = PointF(72.0, 300.0)

# Draw custom text at the specified position
page.Canvas.DrawString("This is newly added text.", font, brush, location)

# Save the modified PDF file
pdf.SaveToFile("AddedText.pdf")
# Close the document to release occupied resources
pdf.Close()

Core Workflow of the Code

Load document → Select target page → Configure font and color styles → Set rendering coordinates → Draw text → Save file and release resources. The workflow is concise and free of redundant logic.

3. Advanced Style Customization

Spire.PDF offers abundant text styling extensions to accommodate various layout scenarios, including multiple font types, custom colors, text transparency, and rotated text. Practical implementations of each feature are covered below.

3.1 Multi-Font & Custom Color Configuration

Three mainstream font initialization methods are available for CJK text, third-party system fonts, and built-in PDF standard fonts. Custom RGB colors of any shade are also supported.

# Method 1: Load system TrueType font (Calibri), italic, size 16, embed font into PDF
font1 = PdfTrueTypeFont("Calibri", 16.0, PdfFontStyle.Italic, True)

# Method 2: Use PDF built-in Times Roman standard font, italic, size 16
font2 = PdfFont(PdfFontFamily.TimesRoman, 16.0, PdfFontStyle.Italic)

# Create a brush with forest green text color
brush = PdfSolidBrush(PdfRGBColor(34, 139, 34))

Enabling font embedding ensures consistent font rendering across all devices when opening the PDF, making it ideal for documents shared cross-platform.

3.2 Adjust Text Transparency

The SetTransparency canvas method creates semi-transparent text, commonly used for subtle watermarks and light annotations. The transparency value ranges from 0.0 (fully transparent) to 1.0 (fully opaque).

# Set text to 40% opacity (transparency = 0.4)
page.Canvas.SetTransparency(0.4)

# Render semi-transparent text
page.Canvas.DrawString("Semi-transparent text", font, brush, PointF(100.0, 100.0))

3.3 Create Rotated Text

You may rotate the canvas coordinate system to render text at any tilt angle, perfect for diagonal watermarks and marginal notes. Negative values rotate counterclockwise, while positive values rotate clockwise.

# Rotate canvas 45 degrees counterclockwise
page.Canvas.RotateTransform(-45)

# Draw rotated text
page.Canvas.DrawString("Rotated text", font, brush, PointF(100.0, 100.0))

Note: Canvas rotation applies globally. Reset canvas transformations after drawing if you need to revert to the default orientation.

4. Key Development Notes

Resource Release : Always call the Close() method after completing PDF operations to free file handles and avoid file locks or memory leaks.
Coordinate System : PDF coordinates use points as units, with the top-left corner of a page serving as the origin. Adjust rendering coordinates based on page dimensions as needed.
CJK Text Compatibility : Prioritize PdfCjkStandardFont or system Chinese fonts for Chinese text to prevent garbled characters or missing font errors.
Combined Styling : Transparency, rotation and font styles can be combined freely to build complex text display effects.

5. Conclusion

Spire.PDF for Python delivers lightweight yet powerful PDF text editing capabilities, enabling developers to implement core features including basic text insertion, multi-font compatibility, custom color schemes, transparent text and rotated text with minimal code. Compared with traditional PDF libraries, its key advantages lie in intuitive APIs, full styling support, and native Chinese & English compatibility. It is well-suited for use cases such as automated PDF editing, batch document processing and watermark generation.

How to Convert Excel to Markdown and Vice Versa in C#

Jack9012 — Tue, 15 Sep 2026 01:54:16 +0000

In document development and interface data synchronization workflows, bidirectional format conversion between Excel spreadsheets and Markdown tables is frequently required. Excel excels at data editing, statistical recording and archiving, while Markdown is ideal for document display, knowledge bases and README documentation. Enabling two-way conversion between them drastically boosts office and development efficiency.

This tutorial leverages the Spire.XLS for .NET library to provide a complete, step-by-step pure C# implementation for Excel-to-Markdown and Markdown-to-Excel conversion. The code is concise with no redundant logic, compatible with the full range of platforms including .NET Framework, .NET Core, and .NET 5/6/7/8.

All code snippets in this tutorial contain no extraneous third-party dependencies or promotional logic and can be directly deployed into production projects.

1. Development Environment Setup

1.1 Project Environment Requirements

Development Tool: Visual Studio 2019 / 2022
Runtime Platform: .NET Core 3.1 and above / .NET 5 and above / .NET Framework 4.0 and above
Core Dependency: Spire.XLS for .NET

1.2 Install the NuGet Dependency

Spire.XLS is a professional Excel manipulation library that supports conversion between Excel and multiple formats such as Markdown, HTML and CSV. It operates independently without requiring Microsoft Office components to be installed.

In Visual Studio, right-click your project → Manage NuGet Packages, then search for and install the package:

Spire.Xls

Installation via the NuGet Package Manager Console is also supported.

2. Excel to Markdown Implementation

2.1 Fully Runnable Code

using Spire.Xls;

namespace ExcelToMarkdownDemo
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // Initialize workbook object
            Workbook workbook = new Workbook();

            // Load local Excel file (supports .xls and .xlsx formats)
            workbook.LoadFromFile("Input.xlsx");

            // Export Excel content to a Markdown file
            workbook.SaveToMarkdown("output.md");

            // Release resources to prevent memory leaks
            workbook.Dispose();
        }
    }
}

2.2 Line-by-Line Code Explanation

Workbook workbook = new Workbook(): Initializes the core Excel workbook object, which handles all file operations.
workbook.LoadFromFile("Input.xlsx"): Reads a local Excel file; absolute and relative file paths are both supported, with compatibility for legacy .xls and modern .xlsx formats.
workbook.SaveToMarkdown("output.md"): Core conversion method that automatically parses worksheet data, generates standard Markdown tables, and saves the result locally.
workbook.Dispose(): Releases memory and file resources occupied by the workbook. This mandatory step prevents program memory overflow and persistent file locks.

2.3 Conversion Output Overview

Running the code generates an output.md file automatically. All table headers and data rows from the source Excel file are mapped completely to Markdown table structures, with blank cells filled with appropriate placeholders. The standardized output works seamlessly with mainstream platforms including GitHub, Gitee and Yuque.

3. Markdown to Excel Full Implementation

This feature supports reverse conversion of standard Markdown table files into Excel files, with built-in page adaptation configurations. The generated Excel files feature clean layouts optimized for printing and data editing.

3.1 Fully Runnable Code

using Spire.Xls;

namespace MarkdownToExcelDemo
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // Initialize workbook object
            Workbook workbook = new Workbook();

            // Load Markdown table file
            workbook.LoadFromMarkdown("Input.md");

            // Enable page auto-fit to adjust content to page width
            workbook.ConverterSetting.SheetFitToPage = true;

            // Save as Excel 2016 format, compatible with most office software
            workbook.SaveToFile("output.xlsx", ExcelVersion.Version2016);

            // Release occupied resources
            workbook.Dispose();
        }
    }
}

3.2 Core Configuration & Code Breakdown

LoadFromMarkdown: Dedicated Markdown parsing method that accurately recognizes standard Markdown table syntax and maps content to Excel rows and columns automatically. Non-table Markdown content (headings, paragraphs, etc.) is ignored during parsing.
SheetFitToPage = true: Conversion optimization setting that resizes worksheet content to fit page dimensions, eliminating column overflow and improving readability and print quality.
ExcelVersion.Version2016: Specifies the target Excel file version, offering maximum compatibility with Office 2016 and all later releases. This value can be replaced with Version2013, Version2019, etc., based on project requirements.

4. Project Compatibility & Optimization Tips

4.1 Using Absolute File Paths

Absolute file paths are recommended for development and deployment to avoid missing file errors caused by relative path issues. Example:

string excelPath = @"D:\Files\Input.xlsx";
string mdPath = @"D:\Files\output.md";

4.2 Exception Handling Improvements

Add exception handling in production environments to resolve errors such as missing files or invalid file formats:

try
{
    Workbook workbook = new Workbook();
    workbook.LoadFromFile("Input.xlsx");
    workbook.SaveToMarkdown("output.md");
    workbook.Dispose();
}
catch (FileNotFoundException ex)
{
    Console.WriteLine($"File not found: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"Conversion failed: {ex.Message}");
}

4.3 Multi-Worksheet Support

Spire.XLS natively supports multi-worksheet conversion. Multiple worksheets from an Excel file are converted into segmented tables within the Markdown file in sequence. During reverse conversion, separate Markdown tables are imported into distinct Excel worksheets automatically.

5. Common Issues & Troubleshooting

Distorted table formatting after conversion : Ensure source files follow standard Excel/Markdown table syntax; remove merged cells and complex nested formatting.
File load failure prompts : Verify the file path validity, check if the target file is locked by another process, and confirm the file uses a supported format.
Excessive memory consumption : Always call the Dispose() method to release resources. For batch conversion tasks, instantiate and dispose the workbook object for each individual conversion cycle.

6. Conclusion

The Spire.XLS for .NET library enables efficient bidirectional conversion between Excel and Markdown with minimal code, without requiring a local Microsoft Office installation. It is lightweight, cross-platform and high-performance. This solution fits a wide range of business scenarios including automated document generation, backend data export, and knowledge base format synchronization. The codebase is concise, stable, and ready for direct integration into production-grade projects.

How to Parse Excel Data, Images, and Charts with Python

Jack9012 — Thu, 10 Sep 2026 02:56:15 +0000

Reading cell data, embedded images, and chart elements from Excel files is a common requirement in Python-based backend processing, automated report analysis, and data migration. Compared with conventional Excel processing libraries, the component introduced in this article provides a unified way to read text and numeric values, handle different cell data types, extract images, and export charts without requiring Microsoft Office or another desktop Office environment. This makes it suitable for server-side and automated processing scenarios.

In this article, we will use practical Python code examples to demonstrate four core Excel parsing capabilities and explain the key implementation details behind each approach.

The examples are based on Free Spire.XLS for Python , which provides a lightweight API for reading and writing Excel files. It supports parsing common elements in .xlsx files and offers a simple API with relatively low resource overhead, making it suitable for automated Excel data processing.

1. Install the Required Component

Free Spire.XLS for Python can be installed directly with pip and integrated into a Python environment without additional system-level configuration. The following command installs the package:

Install with pip

pip install spire.xls.free

Installation Notes

The package can be installed directly with pip without manually configuring additional system dependencies.
If multiple Python versions are installed on your system, use pip3 or python -m pip as appropriate to ensure that the package is installed in the environment used by your application.
Once installation is complete, import the library with import spire.xls. No manual environment-variable configuration is required.

After installation, you can use the APIs described below to read Excel data, extract embedded images, and export charts.

2. Read Cell Data from a Worksheet

For common Excel data-processing tasks, you can obtain the worksheet's allocated data range and then iterate through its rows and columns to read cell values in batches. Because this approach only processes the area occupied by data, it avoids unnecessarily scanning the entire worksheet and is suitable for automated table-data extraction.

Code Example

from spire.xls import *

# Create a workbook and load the Excel file
wb = Workbook()
wb.LoadFromFile("Input.xlsx")

# Get the first worksheet
sheet = wb.Worksheets[0]

# Get the allocated data range
locatedRange = sheet.AllocatedRange

# Iterate through all cells and print their values
for i in range(len(locatedRange.Rows)):
    for j in range(len(locatedRange.Rows[i].Columns)):
        print(locatedRange[i + 1, j + 1].Value + "  ", end='')
    print("")

Key Details

The AllocatedRange property automatically identifies the used range of the worksheet, avoiding the overhead of iterating through unused rows and columns.
Cell indexing starts at 1, which is consistent with Excel's row and column numbering and eliminates the need for additional index conversion.
The nested loops iterate through the rows and columns of the allocated range and retrieve each cell's value while preserving the original table structure.

3. Read Different Types of Cell Data

Excel cells can contain text, numbers, formulas, dates, Boolean values, and other types of data. Using the general Value property alone may not always provide enough control when you need to distinguish between these data types. Free Spire.XLS provides dedicated properties for retrieving specific types of cell content.

Code Example

# Get a cell by row and column
cell = sheet.Range[row, column]

# Read different types of cell data
text = cell.Text                    # Text content
number = cell.NumberValue           # Numeric value
formula = cell.Formula              # Original formula
formulaResult = cell.FormulaValue   # Calculated formula result
date = cell.DateTimeValue            # Date and time value
boolean = cell.BooleanValue          # Boolean value
value = cell.Value                   # General value
value2 = cell.Value2                 # Object-based value

Key Details

For formula cells, Formula and FormulaValue allow you to retrieve the original formula and its calculated result separately. This is useful when you need to validate formulas or process their results.
DateTimeValue provides the date and time represented by a cell in a form that can be processed directly, avoiding manual string parsing.
Value2returns the cell value as an object, preserving its underlying data type. For example, date and Boolean cells can be returned asdatetimeandbool objects, respectively.

Using these dedicated properties gives you more precise control over how different types of Excel data are handled in your application.

4. Extract Embedded Images from a Worksheet

Excel worksheets often contain embedded images such as screenshots, product images, receipts, and other business-related resources. While some Excel libraries focus primarily on tabular data, Free Spire.XLS provides access to the images embedded in a worksheet.

You can iterate through the worksheet's picture collection and save each image as a standard PNG file for further processing or local storage.

Code Example

from spire.xls import *

workbook = Workbook()
workbook.LoadFromFile("Input.xlsx")
sheet = workbook.Worksheets[0]

# Iterate through all pictures in reverse order and save them
for i in range(sheet.Pictures.Count - 1, -1, -1):
    pic = sheet.Pictures[i]
    pic.Picture.Save(
        "ExtractImages\\Image-{0:d}.png".format(i),
        ImageFormat.get_Png()
    )

Key Details

The picture collection is traversed in reverse order, which can help avoid index-related issues when working with collections that may change during processing.
You can customize the output directory and file naming convention. The example saves the extracted images as PNG files.
Pictures.Count returns the number of pictures contained in the worksheet, allowing you to determine how many embedded images need to be processed.

This approach is particularly useful when Excel files are used as containers for both structured data and image-based content.

5. Export Excel Charts as Images

Excel files can contain various types of charts, including column charts, line charts, and pie charts. Chart elements cannot be retrieved through ordinary cell-value APIs. Instead, they can be rendered as images and exported for offline use, reporting, or further processing.

Free Spire.XLS provides the SaveChartAsImage method, which can be used to obtain chart images from a worksheet.

Code Example

from spire.xls import *

workbook = Workbook()
workbook.LoadFromFile("Input.xlsx")
sheet = workbook.Worksheets[0]

# Convert all charts in the worksheet to image streams
image_streams = workbook.SaveChartAsImage(sheet)

# Save the chart images
for i, image_stream in enumerate(image_streams):
    image_stream.Save(f"Output/chart-{i}.png")

# Release workbook resources
workbook.Dispose()

Key Details

SaveChartAsImage retrieves the charts in the specified worksheet as image streams, so you do not need to locate and process each chart individually.
Saving the results through image streams provides a convenient way to handle multiple charts and export them as image files.
Dispose() explicitly releases the resources associated with the workbook. This is especially important when processing a large number of Excel files to reduce the risk of excessive memory usage and file-locking issues.

6. Summary

In this article, we explored four common Excel parsing tasks with Python:

Reading cell data from a worksheet
Retrieving different types of cell values
Extracting embedded images
Exporting Excel charts as images

The approach does not require Microsoft Office to be installed and can therefore be integrated into server-side scripts, automated data-processing workflows, data synchronization tools, and report-processing systems.

The main advantage of this approach is that it provides a relatively lightweight API for handling both structured worksheet data and embedded visual elements. With support for multiple cell data types, image extraction, chart export, and explicit resource management, it can be used as part of automated workflows that process Excel files in batches.

Find and Highlight Text in PDF Files with Python

Jack9012 — Tue, 08 Sep 2026 02:06:12 +0000

In document processing, data analysis, content review, and similar workflows, you may often need to search PDF files for specific text and highlight the matching content so that important information can be identified more quickly.

Python provides a wide range of PDF processing libraries that make this kind of automation relatively easy to implement. In this article, we will introduce two practical approaches for finding and highlighting text in PDF files: exact text matching and regular-expression-based matching.

1. Library and Environment Setup

In this tutorial, we will use Free Spire.PDF for Python to search for text and add highlight annotations to PDF documents.

The library provides convenient APIs for page traversal, exact text searching, regular expression matching, and custom highlight colors, so there is no need to manually work with low-level PDF structures.

One limitation to keep in mind is that the free version supports PDF documents with up to 10 pages . This is generally sufficient for lightweight testing, small documents, and simple document-processing tasks.

Before getting started, install the required package with pip:

pip install spire.pdf.free

2. Scenario 1: Find and Highlight Exact Text Across a PDF

This approach is suitable when you already know the exact keyword or phrase you want to locate. The program can iterate through every page in the PDF and highlight all occurrences of the target text.

For example, the following code searches for the text "cloud service" throughout the document and highlights every match.

Complete Code

from spire.pdf import *
from spire.pdf.common import *

# Create a PdfDocument object and load the PDF file
pdf = PdfDocument()
pdf.LoadFromFile("inpue.pdf")

# Iterate through all pages in the PDF document
for i in range(pdf.Pages.Count):
    page = pdf.Pages.get_Item(i)

    # Create a text finder for the current page
    pdfTextFinder = PdfTextFinder(page)

    # Set the search parameter to find exact matches
    pdfTextFinde.Options.Parameter = TextFindParameter.IgnoreCase

    # Find all occurrences of the target text on the page
    result = pdfTextFinder.Find("cloud service")

    # Highlight all matched text in cyan
    for find in result:
        find.HighLight(Color.get_Cyan())

# Save the processed PDF document
pdf.SaveToFile("output/result.pdf")

# Release document resources
pdf.Close()

How the Code Works

Load the PDF document A PdfDocument object is created, and the LoadFromFile() method is used to open the source PDF.
Iterate through each page The program loops through all pages in the document to ensure that matching text is not missed.
Search for the target text A PdfTextFinder object is created for each page. The Find() method performs an exact search and returns all matching text fragments.
Apply highlighting Each matching result is processed with the HighLight() method. In this example, cyan is used as the highlight color, but it can be replaced with another supported color.
Save and close the document Finally, the modified PDF is saved to a new file, and Close() is called to release the document resources.

3. Scenario 2: Highlight Text Using Regular Expressions

In many cases, the text you want to find does not have a fixed value but follows a consistent pattern.

Typical examples include:

Numbers
Percentages
Phone numbers
Dates
Email addresses

For these situations, regular expressions provide a more flexible way to search for matching text.

In the following example, we use a regular expression to find and highlight integers, decimal numbers, and percentages.

Complete Code

from spire.pdf import *
from spire.pdf.common import *

# Create a PdfDocument object and load the PDF file
pdf = PdfDocument()
pdf.LoadFromFile("input.pdf")

# Get the first page of the PDF
# Change the page index if you want to process another page
page = pdf.Pages.get_Item(0)

# Create a text finder for the page
pdfTextFinder = PdfTextFinder(page)

# Enable regular expression matching
pdfTextFinder.Options.Parameter = TextFindParameter.Regex

# Regular expression for integers, decimals, and percentages
# Examples: 10, 99.9, 50%
pattern = r'\d+(?:\.\d+)?%?'

# Find all text fragments that match the pattern
result = pdfTextFinder.Find(pattern)

# Highlight the matched text in deep pink
for find in result:
    find.HighLight(Color.get_DeepPink())

# Save the processed PDF document
pdf.SaveToFile("output/result.pdf")

# Release document resources
pdf.Close()

Key Points

Enable regular expression mode Set Options.Parameter to TextFindParameter.Regex to switch from standard text searching to regular-expression matching.
Define the matching pattern The regular expression:

   \d+(?:\.\d+)?%?

matches several common numeric formats, including integers, decimal numbers, and percentages.

You can replace it with another pattern to search for phone numbers, dates, email addresses, or other structured text.

Process a specific page This example searches only the first page of the PDF. If you need to search the entire document, you can combine this approach with the page loop used in the first example.
Customize the highlight color The highlight color can be changed by using another supported color value. This makes it possible to apply different visual styles for different types of matched content.

4. Common Issues and Optimization Tips

1. The PDF Cannot Be Saved

Make sure that the output directory already exists before saving the file.

If the output folder does not exist, Python may raise a file-path-related error.

You can create the directory automatically with:

import os

os.makedirs("output", exist_ok=True)

2. The PDF Exceeds the Page Limit

The free version supports PDF documents with up to 10 pages.

For longer documents, you can split the PDF into smaller files before performing the search and highlight operation.

3. Improving Search Accuracy

By default, the search operation may match text fragments containing the specified keyword.

If you need more precise matching, such as whole-word matching or case-sensitive searching, you can configure the corresponding options through the text finder's Options settings.

5. Conclusion

This article demonstrated two ways to find and highlight text in PDF documents with Python: exact text matching and regular-expression-based matching.

Exact matching works well when the target keyword is already known, while regular expressions are more suitable for structured or variable content such as numbers, percentages, dates, and other formatted data.

Both approaches require relatively little code and can be easily integrated into automated document-processing scripts. For small and short PDF files, they provide a straightforward way to identify important content, prepare documents for further data extraction, and reduce the amount of manual document review required.