Forem: jelizaveta

How to Download a PDF from a URL in C#

jelizaveta — Fri, 17 Apr 2026 06:15:22 +0000

How to Download a PDF from a URL in C

In everyday development, we often need to retrieve resources from the internet, especially PDF documents. Whether it is automatically backing up online reports, batch-downloading electronic invoices, or fetching dynamically generated contract files, efficiently and reliably saving remote PDFs locally is a very practical skill.

This article explains how to use the Spire.PDF for .NET library with C# to download a PDF document from a specified URL and save it locally. Spire.PDF provides a rich set of PDF processing features beyond just downloading and saving files.

Prerequisites

First, you need to install Spire.PDF for .NET in your project. You can do this via the NuGet Package Manager Console:

Install-Package Spire.PDF

Or via the .NET CLI:

dotnet add package Spire.PDF

This library supports .NET Framework 4.0 and above, .NET Core 3.1, .NET 5.0, and later versions.

Implementation Code

Below is the complete code example:

using System.IO;
using System.Net;
using Spire.Pdf;

namespace DownloadPdfFromUrl
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a PdfDocument object
            PdfDocument doc = new PdfDocument();

            // Create a WebClient object for downloading web resources
            WebClient webClient = new WebClient();

            // Download PDF data from the URL into a memory stream
            using (MemoryStream ms = new MemoryStream(
                webClient.DownloadData("http://www.example.com/sample.pdf")))
            {
                // Load PDF data from the stream into the PdfDocument object
                doc.LoadFromStream(ms);
            }

            // Save the PDF document to a local file
            doc.SaveToFile("result.pdf", FileFormat.PDF);

            // Release resources
            webClient.Dispose();
            doc.Close();
        }
    }
}

Code Explanation

1. Creating a PdfDocument Object

PdfDocument is the core class of Spire.PDF, representing a PDF document instance. It is used to hold and manipulate the PDF data downloaded from the internet.

2. Using WebClient to Download Data

WebClient is a simple HTTP download class in .NET. The DownloadData method returns a byte[], which represents the raw binary content of the PDF file.

3. Using MemoryStream as a Bridge

Wrapping the byte array into a MemoryStream allows us to use the doc.LoadFromStream(ms) method. This avoids the inefficient process of saving the file to disk before reading it again, enabling in-memory processing.

4. Loading and Saving the PDF

The LoadFromStream method parses the memory stream into a usable PDF document. Finally, SaveToFile persists the document to local storage with the filename result.pdf.

Notes

Exception Handling : In production environments, it is recommended to add try-catch blocks to handle network timeouts, invalid URLs, PDF format errors, and other exceptions.
Memory Management : Both WebClient and PdfDocument implement the IDisposable interface, so resources should be properly released. In the example, MemoryStream is handled with a using statement, but it is also recommended to explicitly dispose of webClient and doc, or wrap them in using blocks as well.
Asynchronous Version : For large files, consider using WebClient.DownloadDataTaskAsync or switching to HttpClient with async methods to avoid blocking the UI thread.
URL Validity : Ensure the URL directly points to a PDF file rather than a redirect page.

Extended Applications

With Spire.PDF, you can perform additional operations immediately after downloading a PDF, such as:

Extracting text or images
Merging multiple PDF files
Adding watermarks or headers/footers
Converting PDFs to images or Word format

Summary

This article demonstrated how to download a PDF from a URL and save it locally using C# and Spire.PDF for .NET. The entire process is simple and efficient, requiring only a few lines of core code.

Spire.PDF is not only a document loading and saving tool but also a powerful PDF processing library worth exploring further.

Can’t Copy Text from a PDF? Here Are 3 Ways to Fix It

jelizaveta — Tue, 14 Apr 2026 02:32:15 +0000

Have you ever run into this frustrating situation: after finally finding an important PDF report or academic paper, you realize it’s “protected”—your cursor turns into a blocked symbol, the right-click menu is grayed out, and you can’t even copy a few words.

That “so close, yet untouchable” feeling is incredibly annoying. The good news is that PDF protection isn’t always as solid as it seems. Today, let’s walk through three practical methods—and share a few behind-the-scenes insights you might not know.

Method 1: Google Docs — A Free “Icebreaker”

This method may sound like a workaround, but the underlying idea is clever: when Google Docs opens a PDF, it tries to reconstruct the document structure—and in the process, it often ignores the original copy restrictions.

Steps:

Open Google Drive and sign in
Upload the protected PDF file
Right-click the file and choose Open with → Google Docs
Wait for the conversion to complete, then copy the text

This works because most PDF “protection” is just a permission flag rather than true encryption. When Google Docs converts the file, it creates a brand-new document structure, so the original restriction flags don’t carry over.

However, note that this won’t work if the PDF is a scanned image rather than text-based content.

Method 2: PDF24 Online Converter — Simple but Mind the Privacy

PDF24 is a free toolkit provided by a German company, known for being reliable, with no annoying watermarks or file size limits.

Steps:

Visit the PDF24 website and open the PDF to TXT tool
Upload the protected PDF file
Click convert and wait for processing
Download the TXT file and freely copy the text

Behind the convenience of online tools lies an often-overlooked issue—privacy. Your files are processed on third-party servers. If your document contains contracts, internal reports, or sensitive personal data, think twice before uploading.

A practical tip: upload a harmless test file first to evaluate processing speed and review the site’s privacy policy before using it for important documents.

Method 3: Python Automation — Add an Engine for Batch Processing

When dealing with dozens or even hundreds of protected PDFs, manual methods become inefficient. That’s where Python scripts come in.

Install the required library:

pip install spire.pdf.free

Code Example:

from spire.pdf import *

doc = PdfDocument()
doc.LoadFromFile("Secured.pdf")

for i in range(doc.Pages.Count):
    page = doc.Pages[i]
    textExtractor = PdfTextExtractor(page)

    extractOptions = PdfTextExtractOptions()
    extractOptions.IsExtractAllText = True

    text = textExtractor.ExtractText(extractOptions)

    with open(f'output/TextOfPage-{i+1}.txt', 'w', encoding='utf-8') as file:
        lines = text.split("\n")
        for line in lines:
            if line != '':
                file.write(line)

doc.Close()

The real value of this approach lies not just in extraction, but in integration. You can embed this script into a data processing pipeline—for example, automatically monitoring a folder and extracting text from newly added protected PDFs into a database.

Also, note the easily overlooked parameter: IsExtractAllText = True. It forces extraction of text marked as “non-copyable,” effectively bypassing the permission checks enforced by PDF readers.

Note:

The free version of Spire.PDF for Python only supports documents with up to 10 pages. For larger files, you can split them into smaller parts or use alternative libraries.

Final Thoughts

These three methods serve different needs:

For occasional use, Google Docs is the easiest
For quick results (if privacy isn’t a concern), online tools are convenient
For batch processing or automation, Python is the best choice

One last point: while technology can solve whether you can copy text, it doesn’t answer whether you should . Before extracting content, always check the document’s copyright and usage terms. After all, tools themselves are neutral—it’s how we use them that matters.

Convert Excel to High-Quality JPG Using C#

jelizaveta — Fri, 10 Apr 2026 02:15:06 +0000

In everyday office development, there is often a need to convert Excel spreadsheets into images. Whether for report previews, data presentation, or preventing formatting issues, converting Excel to JPG is a practical solution. Today, we’ll show how to use the Spire.XLS library with C# to achieve high-quality Excel-to-JPG conversion.

Why High-Quality Conversion Matters

Taking screenshots or using basic conversion methods often results in blurry images and unclear text. This becomes especially problematic when printing or zooming in, as low-resolution images cannot meet quality requirements. By setting the resolution to 300 DPI, you can ensure the generated JPG images reach print-level clarity.

Implementation Steps

First, install the Spire.XLS library. You can search for Spire.XLS in the NuGet Package Manager and install it.

The core process consists of three parts:

Load the Excel file : Use the Workbook class to load the target worksheet
Convert to EMF stream : Export the specified range as an EMF memory stream
Adjust resolution and save : Set the resolution to 300 DPI using the ResetResolution method, then save as JPG

Complete Code

using Spire.Xls;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

namespace Convert
{
    class Program
    {
        static void Main(string[] args)
        {
            Workbook workbook = new Workbook();
            workbook.LoadFromFile("Input.xlsx", ExcelVersion.Version2013);
            Worksheet worksheet = workbook.Worksheets[0];

            using (MemoryStream ms = new MemoryStream())
            {
                worksheet.ToEMFStream(ms, 1, 1, worksheet.LastRow, worksheet.LastColumn);
                Image image = Image.FromStream(ms);
                Bitmap images = ResetResolution(image as Metafile, 300);
                images.Save("Result.jpg", ImageFormat.Jpeg);
            }
        }

        private static Bitmap ResetResolution(Metafile mf, float resolution)
        {
            int width = (int)(mf.Width * resolution / mf.HorizontalResolution);
            int height = (int)(mf.Height * resolution / mf.VerticalResolution);
            Bitmap bmp = new Bitmap(width, height);
            bmp.SetResolution(resolution, resolution);
            Graphics g = Graphics.FromImage(bmp);
            g.DrawImage(mf, 0, 0);
            g.Dispose();
            return bmp;
        }
    }
}

Key Code Explanation

The ToEMFStream method exports a specified worksheet range as an EMF (Enhanced Metafile) format, which is a vector format that preserves quality when scaled
The ResetResolution method takes a Metafile object and a target resolution, returning a resized Bitmap
Using MemoryStream avoids creating temporary files and allows the entire process to run in memory

Use Cases

Reporting systems : Convert data tables into images for embedding in Word, PowerPoint, or web pages
Data presentation : Ensure accessibility even when users don’t have Excel installed
Archiving and backup : Save important spreadsheets as images for long-term preservation without format changes

With this approach, you can easily convert Excel spreadsheets into high-resolution JPG images suitable for most office scenarios. If you need batch conversion, simply iterate through multiple worksheets in the workbook.

C#: Generate Word Documents Rapidly from a Template

jelizaveta — Wed, 08 Apr 2026 03:40:05 +0000

In daily development, we often encounter scenarios where we need to generate Word documents in bulk, such as contracts, notices, and reports. The most elegant approach is to prepare a template file and then use code to replace placeholders, quickly producing the final documents. In this article, we’ll show how to easily achieve this using Free Spire.Doc.

Why Choose Free Spire.Doc?

Free Spire.Doc is a free and easy-to-use Word processing library that allows you to create, read, edit, and save documents without installing Microsoft Office. It supports both .NET Framework and .NET Core, making it ideal for server-side batch processing.

Install via NuGet:

PM> Install-Package FreeSpire.Doc

Implementation Steps

Design a Word template in advance (e.g., template.docx) and mark placeholders for dynamic content
Load the template in code and replace placeholders with actual data
Support both text replacement and image insertion (e.g., profile photos)
Save the result as a new Word document

Complete Code

using Spire.Doc;
using Spire.Doc.Documents;
using Spire.Doc.Fields;
using System.Drawing;

namespace CreateWordByReplacingPlaceholders
{
    class Program
    {
        static void Main(string[] args)
        {
            // Initialize a new Document object
            Document document = new Document();

            // Load the template Word file
            document.LoadFromFile("C:\\Users\\Administrator\\Desktop\\template.docx");

            // Dictionary to hold placeholders and their replacements
            Dictionary<string, string> replaceDict = new Dictionary<string, string>
            {
        { "#name#", "Michael Johnson" },
        { "#gender#", "Male" },
        { "#birthdate#", "March 20, 1990" },
        { "#address#", "1234 Maple Street" },
        { "#city#", "Los Angeles" },
        { "#province#", "California" },
        { "#postal#", "90001" },
        { "#country#", "United States" }
            };

            // Replace placeholders in the document with corresponding values
            foreach (KeyValuePair<string, string> kvp in replaceDict)
            {
                document.Replace(kvp.Key, kvp.Value, true, true);
            }

            // Path to the image file
            String imagePath = "C:\\Users\\Administrator\\Desktop\\portrait.png";

            // Replace the placeholder for the photograph with an image
            ReplaceTextWithImage(document, "#photo#", imagePath);

            // Save the modified document
            document.SaveToFile("ReplacePlaceholders.docx", FileFormat.Docx);

            // Release resources
            document.Dispose();
        }

        // Method to replace a placeholder in the document with an image
        static void ReplaceTextWithImage(Document document, String stringToReplace, String imagePath)
        {
            // Load the image from the specified path
            Image image = Image.FromFile(imagePath);
            DocPicture pic = new DocPicture(document);
            pic.LoadImage(image);
            pic.Width = 130;

            // Find the placeholder in the document
            TextSelection selection = document.FindString(stringToReplace, false, true);

            // Get the range of the found text
            TextRange range = selection.GetAsOneRange();
            int index = range.OwnerParagraph.ChildObjects.IndexOf(range);

            // Insert the image and remove the placeholder text
            range.OwnerParagraph.ChildObjects.Insert(index, pic);
            range.OwnerParagraph.ChildObjects.Remove(range);
        }
    }
}

Code Explanation

1. Text Replacement

First, prepare a dictionary that maps placeholders to their replacement values:

Dictionary<string, string> replaceDict = new Dictionary<string, string>
{
    { "#name#", "Michael Johnson" },
    { "#gender#", "Male" },
    // ... other fields
};

Then iterate through the dictionary and call the document.Replace method. The last two parameters indicate whether the replacement is case-sensitive and whether to match whole words only.

2. Image Replacement

Replacing text with an image is slightly more complex. The key steps are:

Load the image using Image.FromFile
Create a DocPicture object, load the image, and set its width
Locate the placeholder using FindString
Get the paragraph and index of the placeholder
Insert the image at the same position and remove the placeholder text

3. Save the Document

Finally, call SaveToFile to save the new document and release resources.

Output:

Template Preparation Tips

In your Word template, mark dynamic fields with placeholders, for example:

Field	Placeholder
Name	#name#
Gender	#gender#
Birth Date	#birthdate#
Photo	#photo#

Notes

Ensure that the template file path and image path are correct
Use unique placeholder patterns (e.g., #fieldname#) to avoid accidental replacements
Adjust Width and Height when inserting images to control display size
Always call Dispose() to release resources after processing

Summary

With Free Spire.Doc, you only need to maintain a single template file to generate thousands of personalized documents efficiently. The library also supports advanced features such as merging table cells, setting font styles, and adding headers and footers. Feel free to explore more!

Convert Images to a PDF Using Python (Including Merging)

jelizaveta — Thu, 02 Apr 2026 06:39:21 +0000

In everyday office or document work, we often need to merge multiple images into a single PDF file. Whether organizing scans, creating an e-book, or archiving materials, converting images to PDF is a very practical task. This article shows how to use Python and the Spire.PDF for Python library to easily convert and merge images into a PDF.

Why Use Spire.PDF for Python?

Spire.PDF for Python is a powerful PDF manipulation library that not only supports creating, reading, and editing PDF documents but also provides rich image-handling features. Compared with other libraries, Spire.PDF’s API is simple and intuitive, enabling easy image-to-PDF conversion and allowing precise control of page size and image layout.

Install it via PyPI:

pip install spire.pdf

Complete Code Example

The following code demonstrates how to merge all JPG/JPEG images in a specified folder into a single PDF file:

from spire.pdf import *
import os

# Folder path containing images
image_folder = r"C:\Users\Administrator\Desktop\Images"

# Output PDF file path
output_file = "output/CombinedImages.pdf"

# Ensure the output directory exists
os.makedirs(os.path.dirname(output_file), exist_ok=True)

# Create a PDF document object
doc = PdfDocument()

# Remove page margins so images fill the whole page
doc.PageSettings.SetMargins(0.0)

# Get all JPG/JPEG files and sort them
image_files = sorted([
    f for f in os.listdir(image_folder)
    if f.lower().endswith((".jpg", ".jpeg"))
])

# Add each image to the PDF
for image_name in image_files:
    image_path = os.path.join(image_folder, image_name)

    # Load the image
    image = PdfImage.FromFile(image_path)

    # Get image dimensions
    width = image.PhysicalDimension.Width
    height = image.PhysicalDimension.Height

    # Create a page with the same size as the image
    page = doc.Pages.Add(SizeF(width, height))

    # Draw the image on the page
    page.Canvas.DrawImage(image, 0.0, 0.0, width, height)

# Save the merged PDF file
doc.SaveToFile(output_file)
doc.Dispose()

Code Explanation

Import libraries and set paths: Import Spire.PDF and the os module, and define the image folder path and output file path.
Create the PDF document: Create an empty PDF document with PdfDocument() and remove page margins with SetMargins(0.0) so images can fill the page completely.
Read image files: Use os.listdir() to get files in the folder, filter for JPG and JPEG using endswith(), and sort with sorted() to ensure images are merged in filename order.
Add images one by one: For each image, load it with PdfImage.FromFile(), get its original dimensions, create a PDF page with matching size, and draw the image on the page using DrawImage().
Save and release resources: Save the PDF with SaveToFile() and call Dispose() to free document resources.

Output

After running the code above, the program will automatically generate CombinedImages.pdf in the output folder. Each page of the PDF corresponds to one original image, and the page size matches the image dimensions, ensuring optimal display.

Extensions

Based on the code above, you can easily extend functionality:

Support more image formats: Add .png, .bmp, etc., to the filter.
Custom page size: Use a fixed page size instead of matching the image size.
Add image compression: Adjust image quality to control the PDF file size.
Batch processing: Generate separate PDFs for multiple folders.

Summary

Using Spire.PDF for Python to convert images to PDF results in concise, easy-to-understand code without requiring additional dependencies. Whether for personal or enterprise use, this feature can be quickly integrated. I hope this helps you improve efficiency in document handling and makes image management and sharing more convenient.

C# Tutorial: Easily Extract Text from PDF Files

jelizaveta — Tue, 31 Mar 2026 02:05:43 +0000

In daily office and data-processing work, PDF files are widely used because they are cross-platform and have stable formatting. However, extracting text from PDFs can be troublesome. Whether you're organizing materials, analyzing data, or building a text-retrieval system, efficient and accurate PDF text extraction is a fundamental need. This article shows how to use the powerful Spire.PDF for .NET component to easily extract PDF text using C# code.

Introduction to Spire.PDF for .NET

Spire.PDF for .NET is a professional PDF component that lets developers create, read, edit, and convert PDF files on the .NET platform—without installing Adobe Acrobat or other external dependencies.

Key features include:

Rich API for comprehensive PDF manipulation
Practical text-extraction capabilities
Support for extracting entire pages or text from specified regions

Install via NuGet:

Install-Package Spire.PDF

Extract All Text from a Specified Page

A common requirement is to extract all the text from a particular page of a PDF. Spire.PDF makes this straightforward.

Complete C# code:

using Spire.Pdf;
using Spire.Pdf.Texts;
using System.IO;

namespace ExtractTextFromIndividualPages
{
    internal class Program  
    {
        static void Main(string[] args)
        {
            // Create a PDF document instance
            PdfDocument pdf = new PdfDocument();
            // Load the PDF file
            pdf.LoadFromFile("Input.pdf");

            // Get the page to extract text from (index 1 = second page; index starts at 0)
            PdfPageBase page = pdf.Pages[1];

            // Create a PdfTextExtractor for the selected page
            PdfTextExtractor extractor = new PdfTextExtractor(page);
            // Set extraction options
            PdfTextExtractOptions option = new PdfTextExtractOptions
            {
                IsExtractAllText = true
            };
            // Extract text from the specified page
            string text = extractor.ExtractText(option);

            // Save the extracted text to a text file
            File.WriteAllText("Extracted.txt", text);
            // Close the PDF document
            pdf.Close();
        }
    }
}

Code flow:

Create a PdfDocument object and load the target PDF
Retrieve the specified page from the Pages collection
Set IsExtractAllText = true to ensure no text is omitted
Create a PdfTextExtractor with the page instance and call ExtractText
Write the extracted text to a local file and close the document

The process is simple—only a few core lines of code to convert a PDF page to plain text.

Extract Text from a Specified Area

In some scenarios you don't need the entire page, but only text from a specific region—for example:

A column in a table
A header area
A signature block

Spire.PDF provides a flexible solution for region-based extraction.

Complete C# code:

using Spire.Pdf;
using Spire.Pdf.Texts;
using System.IO;
using System.Drawing;

namespace ExtractTextFromDefinedArea
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // Create a PDF document instance
            PdfDocument pdf = new PdfDocument();
            // Load the PDF file
            pdf.LoadFromFile("Input.pdf");

            // Get the second page (index 1 corresponds to the second page)
            PdfPageBase page = pdf.Pages[1];

            // Create a PdfTextExtractor for the selected page
            PdfTextExtractor textExtractor = new PdfTextExtractor(page);
            // Set extraction options (specify a rectangular area)
            PdfTextExtractOptions extractOptions = new PdfTextExtractOptions
            {
                // Rectangle parameters: X, Y, width, height
                ExtractArea = new RectangleF(0, 0, 595, 300)
            };

            // Extract text from the specified rectangle
            string text = textExtractor.ExtractText(extractOptions);

            // Save the extracted text to a text file
            File.WriteAllText("Extracted.txt", text);

            // Close the PDF document
            pdf.Close();
        }
    }
}

Key differences from full-page extraction:

Load the PDF and get the target page (same as before)
Define the extraction area using the ExtractArea property
Set a rectangle with coordinates (X, Y), width, and height (units: points)
Extract only text within that region

This method is especially useful for structured PDFs like:

Financial statements
Invoices
Forms

It allows precise targeting of needed fields, greatly improving information retrieval efficiency and accuracy.

Practical Use and Notes

Common applications in real development:

Data collection – Extract contract clauses into a database
Content analysis – Pull abstracts from research paper PDFs for search and indexing
Document archiving – Convert PDF content to searchable plain text

Important notes when using Spire.PDF:

Ensure rectangle coordinates and dimensions are accurate—use preview or measurement tools for positioning
For complex PDFs (multi-column layouts or special fonts), consider enabling full extraction mode for best results
Always call Close() after extraction to release document resources and avoid memory issues

Conclusion

With Spire.PDF for .NET, C# developers can implement high-quality PDF text extraction with minimal code. Whether extracting full pages or specific regions, the component provides intuitive and reliable solutions.

For .NET projects that need to process PDF text, Spire.PDF is a highly efficient option worth considering.

Adding Watermarks to Word: 10-Line Python Script

jelizaveta — Thu, 26 Mar 2026 09:20:56 +0000

Adding watermarks to Word documents is a common requirement in everyday office work. Whether you need to mark a document as “Internal Use,” “Confidential,” etc., to indicate its status, or add a company logo as a picture watermark to protect copyright, watermarks can effectively improve a document’s professionalism and security.

This article shows how to use a free Word library to add text and image watermarks to Word documents with concise Python code.

Preparation

In this scenario, we'll use Free Spire.Doc for Python package. You can install it with pip:

pip install spire.doc.free

After installation you can start writing code.

Add a Text Watermark to Word

Text watermarks are the most common type and are typically used to indicate document status. The code below shows how to add a text watermark to a Word document:

from spire.doc import *
from spire.doc.common import *

# Create a Document object
document = Document()

# Load the Word document
document.LoadFromFile("Input.docx")

# Create a TextWatermark object
txtWatermark = TextWatermark()

# Set the text watermark's properties
txtWatermark.Text = "Internal Use Only"  # Watermark text
txtWatermark.FontSize = 65  # Font size
txtWatermark.FontName = "Times New Roman"  # Font name
txtWatermark.Color = Color.get_Green()  # Font color
txtWatermark.Layout = WatermarkLayout.Diagonal  # Layout (diagonal)

# Add the text watermark to the document
document.Watermark = txtWatermark

# Save the resulting document
document.SaveToFile("Output/TextWatermark.docx", FileFormat.Docx)
document.Close()

The core is the TextWatermark object; adjusting its properties lets you control the watermark’s appearance. The WatermarkLayout enum provides two layout options: Diagonal and Horizontal, so choose as needed.

Add an Image Watermark to Word

Image watermarks are commonly used to add a company logo, signature, or other graphic elements. Example code:

from spire.doc import *
from spire.doc.common import *

# Create a Document object
document = Document()

# Load the Word document
document.LoadFromFile("Input.docx")

# Create a PictureWatermark object
picture = PictureWatermark()

# Set the picture watermark's properties
picture.SetPicture("logo.png")  # Path to the watermark image
picture.Scaling = 100  # Scaling percentage
picture.IsWashout = False  # Whether to apply washout effect

# Add the picture watermark to the document
document.Watermark = picture

# Save the resulting document
document.SaveToFile("Output/ImageWatermark.docx", FileFormat.Docx)
document.Close()

The Scaling property controls the image size—the larger the value, the larger the image. The IsWashout property determines whether the washout (faded) effect is applied; setting it to False makes the image colors more vivid.

Complete Example and Notes

Combining the above code makes it easy to build a script that batch-adds watermarks. Keep these points in mind:

File paths: Make sure input Word documents and image file paths are correct; create the output directory in advance.
Document formats: The library supports formats such as .docx and .doc; specify the correct FileFormat when saving.
Resource release: Call Close() after operations to release resources.

Summary

With Free Spire.Doc for Python, you can add watermarks to Word documents in just a few lines of code. The library provides TextWatermark and PictureWatermark classes for handling text and image watermarks respectively, and developers can configure style, position, transparency, and other properties as needed. Compared with manual Word operations, automating this with Python is more efficient and makes batch processing and integration into business systems easier.

Whether you’re protecting sensitive documents or standardizing corporate document style, mastering this technique will make your work easier. I hope this article is helpful!

Easily Add Background Color or Image to PDFs Using Python

jelizaveta — Tue, 24 Mar 2026 03:04:37 +0000

Adding a background color or image to PDF files is a common task in office work and document processing, whether to enhance visual appearance or highlight important content. This article demonstrates how to use a free PDF library to add both background colors and background images to PDFs with just a few lines of code.

Preparation

First, install the Free Spire.PDF for Python library. Open a command-line terminal and run:

pip install spire.pdf.free

After installation, you can start writing code. Note that Free Spire.PDF is the free version and has a page limit (up to 10 pages per document). This is usually sufficient for everyday small-scale document processing.

Add a Background Color to a PDF

Adding a background color to a PDF is very simple. Iterate through each page of the PDF and set its BackgroundColor property. Here is a complete example:

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

# Create a PdfDocument object
doc = PdfDocument()

# Load the PDF file
doc.LoadFromFile("C:\\Users\\Administrator\\Desktop\\input.pdf")

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

    # Set the background color to light green
    page.BackgroundColor = Color.get_LightGreen()

# Save the document
doc.SaveToFile("output.pdf")

Key Code Explanation

Create the document object: PdfDocument() instantiates a PDF document object on which all subsequent operations are based.
Load the source file: LoadFromFile() loads the PDF file to be processed; the argument is the file path.
Iterate pages: Use doc.Pages.Count to get the total number of pages and loop through each page.
Set background color: The page.BackgroundColor property sets the background color for the current page. Color.get_LightGreen() returns a light green color object. The Color class offers many predefined colors such as get_LightBlue(), get_LightYellow(), get_Pink(), etc., which you can choose as needed.
Save the file: SaveToFile() saves the modified document to the specified path.

Add a Background Image to a PDF

If you want to add a background image to a PDF, use the BackgroundImage property. The code is as follows:

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

# Create a PdfDocument object
doc = PdfDocument()

# Load the PDF file
doc.LoadFromFile("C:\\Users\\Administrator\\Desktop\\input.pdf")

# Load the image
image = Stream("C:\\Users\\Administrator\\Desktop\\img.jpg")

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

    # Set the background image
    page.BackgroundImage = image

# Save the document
doc.SaveToFile("output.pdf")

Key Code Explanation

Create and load: As with adding a background color, first create a PdfDocument object and load the target PDF file.
Iterate pages: Loop through every page so that the same background image is applied to all pages.
Set the background image: The page.BackgroundImage property accepts a Stream object; pass the image file path to create the image stream. Common formats such as JPG, PNG, BMP are supported. After setting, the image will automatically scale to fill the entire page as the background.
Save the result: Finally, save the processed document as a new file; the original file remains unchanged.

Notes and Tips

Path format: On Windows, use double backslashes \ or a raw string r"..." for file paths to avoid escape issues.
Image size: Background images automatically adapt to the page size, so manual scaling is not always required. However, very large images take longer to process and increase generation time.
Multi-page documents: The example code applies the same background image to every page. To set different backgrounds for different pages, use page-number checks and handle them individually.

Summary

With Free Spire.PDF for Python, you can add background colors or background images to PDFs with minimal code. The library provides an intuitive API that helps developers get started quickly. Whether you need to batch-process documents or add customized backgrounds to specific files, the methods above can help you accomplish the task efficiently.

I hope this article is helpful! If you have further PDF-processing needs, feel free to explore other features of Free Spire.PDF.

Easy Way to Compare PDF Files for Differences Using Python

jelizaveta — Thu, 19 Mar 2026 02:09:32 +0000

When handling contracts, legal files, or technical documentation, multiple versions of the same PDF are often involved. Identifying what has changed between versions manually can be tedious and prone to mistakes.

Fortunately, Spire.PDF for Python makes it easy to detect and highlight differences between two PDF files automatically , using only a small amount of code.

This tutorial shows you how to compare PDFs step by step, including setup and optional configuration.

Install the Library

To begin, install the required package from PyPI:

pip install spire.pdf

After installation, you can start comparing PDF documents right away.

Basic Example: Detect Differences Between Two PDFs

The example below compares an original document with an updated version and outputs a comparison file that visually marks the changes:

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

# Load the original PDF
original = PdfDocument("C:\\Users\\Administrator\\Desktop\\original.pdf")    

# Load the updated PDF
revised = PdfDocument("C:\\Users\\Administrator\\Desktop\\revised.pdf")  

# Initialize comparer
comparer = PdfComparer(original, revised)

# Generate comparison result
comparer.Compare("output/CompareResult.pdf") 

# Release resources
original.Dispose()
revised.Dispose()

Open the resulting file in a PDF viewer (such as Adobe Acrobat), and you’ll see a side-by-side comparison. Removed content appears highlighted in red in the original file, while added content is marked in yellow in the revised version.

Advanced Options for Comparison

You can further control how the comparison works by adjusting settings before calling the Compare method.

Compare Text Only

If you want to ignore layout or graphical differences and focus purely on text changes:

comparer.PdfCompareOptions.OnlyCompareText = True

Limit Comparison to Specific Pages

For large documents, you may only need to analyze certain sections. You can define page ranges like this:

comparer.PdfCompareOptions.SetPageRanges(1, 3, 1, 3)
# Parameters: (oldStartIndex, oldEndIndex, newStartIndex, newEndIndex)

This allows you to compare only selected pages instead of the entire document.

Conclusion

Manually reviewing differences between PDF versions can be inefficient and error-prone. By using Spire.PDF for Python, you can quickly produce a clear visual comparison and identify changes with ease. This method is especially useful for contract reviews, document proofreading, and version tracking in professional workflows.

Unlocking PDF Data: Converting PDF to Excel with Free Python APIs

jelizaveta — Tue, 17 Mar 2026 01:30:47 +0000

Transforming PDF documents into Excel spreadsheets is a critical process for tasks like data analysis, reporting, and automating workflows. This guide presents two effective methods for harnessing free Python libraries to accomplish this task:

Converting complete PDF pages or entire documents to Excel format
Extracting tables from PDF files and exporting them into Excel

By comparing these methods, you’ll gain insights to select the best approach tailored to your requirements.

Necessary Libraries to Install

To get started, you need to install the following Python libraries:

[ Free Spire.PDF for Python ]: This powerful library provides tools for handling PDF files, including the ability to convert PDF content to Excel and extract tabular data.
[ openpyxl ]: A well-known open-source library that facilitates reading, writing, and modifying Excel files.

You can install both libraries using pip:

pip install spire.pdf.free openpyxl

After installing the libraries, we can delve into the methods for conversion.

Method 1: Full PDF Document to Excel Conversion

This approach entails converting the entire content of a PDF—text, images, and layout—into an Excel spreadsheet, preserving the original design.

Essential Conversion Settings

The XlsxLineLayoutOptions class specifies how the conversion from PDF to Excel will occur. This class takes the following parameters:

convertToMultipleSheet (bool) : If set to True, each page of the PDF becomes a separate worksheet; if False, only the first page is converted.
rotatedText (bool) : Controls whether to show rotated text found in the PDF.
splitCell (bool) : If True, it splits multi-line text into separate cells in Excel; if False, it retains all text in a single cell.
wrapText (bool) : Activates text wrapping within Excel cells.
overlapText (bool) : Determines how overlapping text is handled.

Sample Code Implementation

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

# Instantiate the PdfDocument class
doc = PdfDocument()

# Load the desired PDF file
doc.LoadFromFile("C:\\Users\\Administrator\\Desktop\\input.pdf")

# Configure the XLSX conversion options
options = XlsxLineLayoutOptions(False, False, False, True, False)

# Apply these options to the document
doc.ConvertOptions.SetPdfToXlsxOptions(options)

# Save the output as an XLSX file
doc.SaveToFile("output/ToExcel.xlsx", FileFormat.XLSX)

# Close the document
doc.Close()

Evaluating Pros and Cons

Pros:

Preserves the original layout of the PDF, including text placement and formatting.
Effective for documents with complex layouts.

Cons:

May lead to cell merging or unwanted adjustments in row and column sizes.
Text might lose coherence with content spread across various cells.

Method 2: Table Data Extraction from PDF to Excel

This method is focused on extracting tabular data from a PDF and exporting it to Excel, ensuring the output is coherent and well-structured.

Code Example for Table Extraction

from spire.pdf import *
from openpyxl import Workbook
from openpyxl.utils import get_column_letter

# Create a PdfDocument object
doc = PdfDocument()

# Load the PDF file 
doc.LoadFromFile("C:/Users/Administrator/Desktop/AI.pdf")

# Set up a table extractor for the PDF document
extractor = PdfTableExtractor(doc)

# Create a new Excel workbook and remove the default sheet
workbook = Workbook()
workbook.remove(workbook.active)

# Extract tables across all pages
for page_index in range(doc.Pages.Count):
    tables = extractor.ExtractTable(page_index)
    for t_index, table in enumerate(tables):
        # Create a new worksheet for each extracted table
        sheet = workbook.create_sheet(title=f"Page {page_index + 1}_Table {t_index + 1}")

        # Track maximum lengths of each column
        max_lengths = [0] * table.GetColumnCount()

        for row in range(table.GetRowCount()):
            for col in range(table.GetColumnCount()):
                text = table.GetText(row, col).replace("\n", " ").strip()
                sheet.cell(row=row + 1, column=col + 1, value=text)
                max_lengths[col] = max(max_lengths[col], len(text))

        # Automatically adjust column widths
        for col in range(table.GetColumnCount()):
            adjusted_width = (max_lengths[col] + 2)  # Add buffer space
            sheet.column_dimensions[get_column_letter(col + 1)].width = adjusted_width

# Save the completed workbook to an Excel file
workbook.save("output/TableData.xlsx")

Advantages and Disadvantages

Advantages:

Focuses solely on extracting table data, resulting in a clear and organized output.
Improves readability in Excel (avoids issues with merged cells).

Disadvantages:

Does not retain any content that is not structured as a table (e.g., images or comments).
Requires a clearly defined table structure in the PDF for accurate extraction.

Method Comparison

Method	Data Integrity	PDF Layout Retention	Excel Clarity	Best Situations
Full Page Conversion	Comprehensive data	High (maintains layout)	Moderate (potential formatting issues)	Complex-formatted documents
Table Extraction	Limited to table data	Low (non-table formatting lost)	High (structured output)	PDFs with well-defined tables

Conclusion

Opt for the full page conversion method if preserving the original layout (including images and free text) is critical, especially in formal documents.
Choose the table extraction method when only structured data is desired for analysis.

Each method presents its own advantages; your choice should align with the specific requirements of your project.

Use Python to Convert JPG/PNG to PDF (Including Merging)

jelizaveta — Fri, 13 Mar 2026 01:20:04 +0000

In the digital age, the conversion and management of images and documents have become increasingly important. Especially when needing to merge multiple JPG or PNG images into a single PDF file, the Python programming language offers a simple and efficient solution. This article will introduce how to utilize the Spire.PDF for Python library to perform image conversion and merging operations.

1. Tool Preparation

Before starting, ensure that you have installed the Python environment and the Spire.PDF for Python library. You can install it using the following command:

pip install Spire.PDF

Additionally, make sure you have the JPG or PNG images you want to convert and place them in a single folder.

2. Code Implementation

Below is sample code to convert JPG and PNG images to a PDF file:

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

# Create PdfDocument object
doc = PdfDocument()

# Set page margins to 0
doc.PageSettings.SetMargins(0.0)

# Get the path of the folder containing images
path = "C:\\Users\\Administrator\\Desktop\\Images\\"
files = os.listdir(path)

# Traverse through the files in the folder
for root, dirs, files in os.walk(path):
    for file in files:

        # Load the specific image
        image = PdfImage.FromFile(os.path.join(root, file))

        # Get the width and height of the image
        width = image.PhysicalDimension.Width
        height = image.PhysicalDimension.Height

        # Add a page with the same size as the image
        page = doc.Pages.Add(SizeF(width, height))

        # Draw the image at the (0, 0) position on the page
        page.Canvas.DrawImage(image, 0.0, 0.0, width, height)

# Save the file
doc.SaveToFile("output/CombineImages.pdf")
doc.Dispose()

3. Code Explanation

Import Libraries :

First, import the required spire.pdf and os libraries, the latter being used for file and directory operations.

Create PdfDocument Object :

Initialize a PDF document object using PdfDocument(), which can be further manipulated.

Set Page Margins :

Call the SetMargins(0.0) method to set the page margins to zero, allowing the image to fill the entire page.

Read Images :

Use os.listdir(path) to retrieve all files in the specified directory, and utilize os.walk to traverse through all files in that directory.

Load and Process Images :

For each file, load the image using PdfImage.FromFile() and obtain its width and height.

Add Page :

Create a page with the same size as the image using the doc.Pages.Add() method.

Draw Image :

Use page.Canvas.DrawImage() to draw the image at the specified position on the page.

Save PDF File :

Finally, call doc.SaveToFile() to save the merged PDF file to the specified path.

4. Conclusion

By using the Spire.PDF for Python library, we can easily merge multiple JPG or PNG images into a single PDF file. This method is not only simple and efficient but also performs excellently when handling a large number of images. Whether for work or personal projects, this automated image processing method can save a significant amount of time. I hope this article helps you better grasp the skills of image conversion and merging!

Protect Word Documents in C#: Encryption & Document Permissions

jelizaveta — Wed, 11 Mar 2026 05:47:04 +0000

In the digital age, the security of documents has become increasingly important. To protect sensitive information and prevent unauthorized access, many users choose to encrypt Word documents or set permissions. In this article, we will introduce how to use the Spire.Doc for .NET library to encrypt Word documents and set document permissions.

What is Spire.Doc?

Spire.Doc is a powerful .NET library that allows developers to create, edit, and convert Word documents in C#. It provides a simple and easy-to-use API that makes document operations more efficient and convenient. With this library, we can easily implement document encryption and protection for Word files.

NuGet Installation:

PM> Install-Package Spire.Doc

Encrypting Word Documents

Encrypting Word documents is an effective way to protect important information. By setting a password, we can prevent unauthorized users from opening and viewing the document's contents. Below is a C# program example that demonstrates how to use Spire.Doc to encrypt a Word document:

using Spire.Doc;

namespace PasswordProtectWordDocument
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a Document object
            Document document = new Document();

            // Load the Word file
            document.LoadFromFile(@"C:\Users\Administrator\Desktop\Input.docx");

            // Encrypt the document with a password
            document.Encrypt("open-psd");

            // Save the encrypted document to a new Word file
            document.SaveToFile("Encryption.docx", FileFormat.Docx);
        }
    }
}

In the code above, we first create a Document object and load an existing Word file using the LoadFromFile method. Next, we use the Encrypt method to encrypt the document and specify a password. After encryption is complete, we save it as a new file, thus generating an encrypted Word document.

Setting Document Permissions

In addition to encryption, setting document permissions is also an important way to protect Word files. Different permission settings allow users to have only specific operation permissions. Here’s a sample code that demonstrates how to set document permissions:

using Spire.Doc;

namespace ChangeDocumentPermission
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a Document object
            Document document = new Document();

            // Load the Word document
            document.LoadFromFile(@"C:\Users\Administrator\Desktop\Input.docx");

            // Set document permissions and specify the permission password
            document.Protect(ProtectionType.AllowOnlyFormFields, "permission-psd");

            // Save the document with set permissions to a new Word file
            document.SaveToFile("Permission.docx");
        }
    }
}

In this example, we also create a Document object and load a Word file. Then, we use the Protect method to set the permissions. Here, we can specify different types of protection, such as AllowOnlyFormFields, which means users can only fill in form fields without editing other contents.

Types of Protection

Spire.Doc provides several types of protection to choose from, allowing you to control document access permissions:

AllowOnlyComments: Only allows comments on the document.
AllowOnlyFormFields: Only allows filling in form fields.
AllowOnlyReading: Only allows reading the document.
AllowOnlyRevisions: Only allows making revisions.
NoProtection: No protection; any user can freely edit the document.

Conclusion

Using Spire.Doc for .NET to encrypt and protect Word documents is very straightforward. Through the examples provided, developers can quickly get started and meet their document protection needs. Protecting documents not only maintains information security but also enhances user experience, ensuring privacy during the sharing process. With these tools, users can handle documents with more confidence, protecting important information for themselves and others.