DEV Community: Dheeraj Malik

How to Create Pivot Tables in Excel with Java

Dheeraj Malik — Thu, 24 Sep 2026 09:33:40 +0000

When working with Excel data, raw information is usually stored as detailed records. For example, a sales worksheet may contain fields such as date, region, product, quantity, and sales amount.

As the amount of data grows, analyzing the original table directly becomes less convenient. Excel Pivot Tables provide a simple way to summarize and analyze data from different perspectives, such as:

Calculating sales amounts by region;
Summarizing data by product category;
Comparing values across different dimensions.

If you need to generate analysis reports automatically in a Java application, you can create Pivot Tables programmatically instead of manually opening Excel and configuring them each time.

This article explains how to create Excel Pivot Tables with Java and configure fields for data summarization.

Preparing the Environment

Create a Java project and add the Excel processing dependency through Maven.

Add the following configuration to 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.xls</artifactId>
        <version>latest-version</version>
    </dependency>
</dependencies>

Then import the required classes:

import com.spire.xls.*;

Prepare Excel Data

Before creating a Pivot Table, prepare the data source.

For example, a sales worksheet contains the following data:

Date	Region	Product	Sales Amount
2026-01-01	East	Phone	5000
2026-01-02	South	Laptop	8000
2026-01-03	East	Tablet	3000
2026-01-04	North	Phone	6000

In this worksheet:

The first row contains field names;
The remaining rows contain data records;
The range A1:D5 will be used as the Pivot Table data source.

The following example loads the Excel file and creates a Pivot Table based on the specified data range.

Create an Excel Pivot Table

Creating a Pivot Table usually involves the following steps:

Load the Excel file;
Get the data source range;
Create a PivotCache;
Add a PivotTable;
Apply formatting;
Save the result file.

The complete example is shown below:

import com.spire.xls.*;

public class CreatePivotTable {

    public static void main(String[] args) {

        // Create a Workbook object
        Workbook workbook = new Workbook();

        // Load the Excel file containing source data
        workbook.loadFromFile("SalesData.xlsx");

        // Get the first worksheet
        Worksheet sheet = workbook.getWorksheets().get(0);

        // Get the data source range
        CellRange dataRange = sheet.getCellRange("A1:D5");

        // Create a Pivot Cache from the data range
        PivotCache cache = workbook.getPivotCaches().add(dataRange);

        // Create a Pivot Table at the specified location
        PivotTable pivotTable = sheet.getPivotTables().add("SalesSummary", sheet.getCellRange("F3"), cache);

        // Apply a built-in Pivot Table style
        pivotTable.setBuiltInStyle(PivotBuiltInStyles.PivotStyleMedium10);

        // Save the result file
        workbook.saveToFile("CreatePivotTable.xlsx", ExcelVersion.Version2016);

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

After running the code, a Pivot Table named SalesSummary will be created at cell F3.

At this point, the Pivot Table structure is created, but fields still need to be configured.

Configure Pivot Table Fields

Pivot Table fields are mainly divided into two types:

Row Field: Used for grouping and displaying categories;
Data Field: Used for calculating summary values.

For example, to calculate sales amounts by region:

Set Region as the row field;
Add Sales Amount as the data field and calculate the total.

The following complete example opens the existing Pivot Table and configures the fields:

import com.spire.xls.*;
import com.spire.xls.core.IPivotField;

public class SetPivotFields {

    public static void main(String[] args) {

        // Create a Workbook object
        Workbook workbook = new Workbook();

        // Load the workbook containing the Pivot Table
        workbook.loadFromFile("CreatePivotTable.xlsx");

        // Get the worksheet
        Worksheet sheet = workbook.getWorksheets().get(0);

        // Get the first Pivot Table
        PivotTable pivotTable = sheet.getPivotTables().get(0);

        // Get the Region field and set it as a row field
        IPivotField regionField = pivotTable.getPivotFields().get("Region");
        regionField.setAxis(AxisTypes.Row);

        // Add the Sales Amount field and calculate the sum
        pivotTable.getDataFields().add(pivotTable.getPivotFields().get("Sales Amount"), "Total Sales", SubtotalTypes.Sum);

        // Save the result
        workbook.saveToFile("ConfiguredPivotTable.xlsx", ExcelVersion.Version2016);

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

The generated Pivot Table will look similar to:

Region	Total Sales
East	8000
South	8000
North	6000

The Region field is used for grouping, while Sales Amount is used for calculation.

Add Multiple Data Fields

A Pivot Table can contain multiple summary fields.

For example, you may want to calculate both total sales amount and total sales quantity.

import com.spire.xls.*;

public class AddMultipleDataFields {

    public static void main(String[] args) {

        // Create a Workbook object
        Workbook workbook = new Workbook();

        // Load the workbook containing the Pivot Table
        workbook.loadFromFile("CreatePivotTable.xlsx");

        // Get the worksheet
        Worksheet sheet = workbook.getWorksheets().get(0);

        // Get the Pivot Table
        PivotTable pivotTable = sheet.getPivotTables().get(0);

        // Add total sales amount
        pivotTable.getDataFields().add(pivotTable.getPivotFields().get("Sales Amount"), "Total Sales", SubtotalTypes.Sum);

        // Add total quantity
        pivotTable.getDataFields().add(pivotTable.getPivotFields().get("Quantity"), "Total Quantity", SubtotalTypes.Sum);

        // Save the file
        workbook.saveToFile("MultipleDataFields.xlsx", ExcelVersion.Version2016);

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

After adding multiple fields, the Pivot Table can display several metrics at the same time.

Save the Generated Excel File

After configuring the Pivot Table, save the result using saveToFile():

import com.spire.xls.*;

public class SavePivotTable {

    public static void main(String[] args) {

        // Create a Workbook object
        Workbook workbook = new Workbook();

        // Load the Excel file
        workbook.loadFromFile("ConfiguredPivotTable.xlsx");

        // Save the final file
        workbook.saveToFile("SalesAnalysisReport.xlsx", ExcelVersion.Version2016);

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

The generated Excel file can be opened directly in Microsoft Excel for further filtering or analysis.

Common Considerations

The Data Source Should Include Headers

When creating a Pivot Table, the first row should contain field names.

For example:

Correct:

Region	Product	Sales Amount
East	Phone	5000

Avoid:

A	B	C
East	Phone	5000

Field names are required when configuring Pivot Table fields.

Field Names Must Match Exactly

When setting fields:

pivotTable.getPivotFields().get("Region")

The field name must exactly match the header in the Excel data source.

Otherwise, the corresponding field cannot be found correctly.

Processing Large Data Sets

When working with large amounts of data:

Write data in batches instead of modifying cells repeatedly;
Avoid unnecessary worksheet operations;
Release the Workbook object after processing.

Conclusion

Pivot Tables are useful for grouping, summarizing, and analyzing structured Excel data.

By creating Pivot Tables with Java, developers can automate Excel report generation. After preparing the data source, you can configure fields and calculation methods programmatically to generate analysis-ready Excel files.

This approach is suitable for scenarios such as automated report generation and exporting Excel files with summarized data.

How to Extract Images and Image Information from PDF in Java

Dheeraj Malik — Wed, 23 Sep 2026 10:18:41 +0000

PDF files are widely used for storing reports, manuals, e-books, and other documents that combine text and visual content. Besides text, PDF documents often contain various image resources, including charts, diagrams, screenshots, scanned pages, and illustrations.

When processing PDF files programmatically, extracting images is often only part of the requirement. In many cases, developers also need additional information about those images, such as:

Which page contains the image
How many images exist on each page
The width and height of extracted images
The relationship between extracted images and the original document

This information is useful in scenarios such as document archiving, content analysis, and image resource management.

This article explains how to extract images from PDF files and retrieve image-related information using Java.

Preparing the Environment

Create a Java project and add the PDF processing dependency through Maven.

Add the following configuration to 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>

Then import the required classes:

import com.spire.pdf.PdfDocument;
import com.spire.pdf.PdfPageBase;
import com.spire.pdf.utilities.PdfImageHelper;
import com.spire.pdf.utilities.PdfImageInfo;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;

Extract Images from PDF Files

Images in PDF documents are usually stored as page resources. To extract them, load the PDF file, iterate through each page, and retrieve the image information from each page.

The following example extracts all images from a PDF file and saves them as PNG images:

public class ExtractImages {

    public static void main(String[] args) throws Exception {

        PdfDocument pdf = new PdfDocument();

        pdf.loadFromFile("Sample.pdf");

        PdfImageHelper imageHelper = new PdfImageHelper();

        int imageIndex = 0;

        for (int i = 0; i < pdf.getPages().getCount(); i++) {

            PdfPageBase page = pdf.getPages().get(i);

            PdfImageInfo[] imageInfos =
                    imageHelper.getImagesInfo(page);

            if (imageInfos != null) {

                for (PdfImageInfo imageInfo : imageInfos) {

                    BufferedImage image =
                            imageInfo.getImage();

                    ImageIO.write(
                            image,
                            "PNG",
                            new File("Image-" + imageIndex + ".png")
                    );

                    imageIndex++;
                }
            }
        }

        pdf.dispose();
    }
}

After execution, each extracted image will be saved as an independent PNG file.

For example:

Image-0.png
Image-1.png
Image-2.png

This approach is suitable for processing PDF files that contain multiple embedded images, such as reports, brochures, and technical documents.

Get the Number of Images in Each PDF Page

Before extracting images, you may want to check how many images exist in each page.

The following example counts images page by page:

public class CountImages {

    public static void main(String[] args) {

        PdfDocument pdf = new PdfDocument();

        pdf.loadFromFile("Sample.pdf");

        PdfImageHelper imageHelper = new PdfImageHelper();

        for (int i = 0; i < pdf.getPages().getCount(); i++) {

            PdfPageBase page = pdf.getPages().get(i);

            PdfImageInfo[] imageInfos =
                    imageHelper.getImagesInfo(page);

            int count = imageInfos == null ? 0 : imageInfos.length;

            System.out.println(
                    "Page " + (i + 1)
                    + " contains "
                    + count
                    + " images"
            );
        }

        pdf.dispose();
    }
}

Output example:

Page 1 contains 3 images
Page 2 contains 5 images
Page 3 contains 1 images

This allows you to quickly understand how images are distributed throughout a PDF document.

Get Image Dimensions

Besides extracting image files, you can also retrieve the width and height of each image.

This information can help determine image quality or filter images based on specific requirements.

Example:

public class GetImageSize {

    public static void main(String[] args) {

        PdfDocument pdf = new PdfDocument();

        pdf.loadFromFile("Sample.pdf");

        PdfImageHelper imageHelper = new PdfImageHelper();

        for (int i = 0; i < pdf.getPages().getCount(); i++) {

            PdfPageBase page = pdf.getPages().get(i);

            PdfImageInfo[] imageInfos =
                    imageHelper.getImagesInfo(page);

            if (imageInfos != null) {

                for (PdfImageInfo imageInfo : imageInfos) {

                    BufferedImage image =
                            imageInfo.getImage();

                    System.out.println(
                            "Width: "
                            + image.getWidth()
                            + ", Height: "
                            + image.getHeight()
                    );
                }
            }
        }

        pdf.dispose();
    }
}

Output example:

Width: 1200, Height: 800
Width: 640, Height: 480

With image dimensions, you can identify high-resolution images or classify extracted resources for further processing.

Extract Images with Page Information

In practical applications, saving image files alone is often not enough.

For example, a PDF report may contain dozens of images. During later processing, you may need to know which page each image came from.

You can include page numbers in the output filenames:

public class ExtractImagesWithPageInfo {

    public static void main(String[] args) throws Exception {

        PdfDocument pdf = new PdfDocument();

        pdf.loadFromFile("Sample.pdf");

        PdfImageHelper imageHelper = new PdfImageHelper();

        for (int pageIndex = 0;
             pageIndex < pdf.getPages().getCount();
             pageIndex++) {

            PdfPageBase page =
                    pdf.getPages().get(pageIndex);

            PdfImageInfo[] imageInfos =
                    imageHelper.getImagesInfo(page);

            if (imageInfos != null) {

                for (int imageIndex = 0;
                     imageIndex < imageInfos.length;
                     imageIndex++) {

                    BufferedImage image =
                            imageInfos[imageIndex].getImage();

                    String fileName =
                            "Page-"
                            + (pageIndex + 1)
                            + "-Image-"
                            + (imageIndex + 1)
                            + ".png";

                    ImageIO.write(
                            image,
                            "PNG",
                            new File(fileName)
                    );
                }
            }
        }

        pdf.dispose();
    }
}

The generated files will keep their original page references:

Page-1-Image-1.png
Page-1-Image-2.png
Page-2-Image-1.png

This naming approach makes it easier to trace extracted images back to their original locations.

Conclusion

Extracting images from PDF files is not only about saving image files. In real-world applications, information such as image count, dimensions, and page references can be equally important.

By processing PDF pages and retrieving image information in Java, developers can automate image extraction and resource analysis for document management, content analysis, and data processing workflows.

How to Add Data Validation to Excel in Java (Step-by-Step)

Dheeraj Malik — Tue, 15 Sep 2026 16:00:00 +0000

Excel data validation is useful when a worksheet is meant to be filled in by other people. Instead of accepting any value, a cell can be limited to a number range, a date period, a certain text length, or a predefined list of choices.

This is especially helpful for forms and reusable templates, where inconsistent input can create extra cleanup work later.

In this tutorial, we’ll add several common validation rules to an Excel worksheet with Java, including whole number, date, text length, list, and time validation.

Common Excel Data Validation Types

Excel supports several validation types for different kinds of input:

Validation Type	Typical Use
Whole number	Quantities, counts, IDs
Decimal	Prices, percentages, measurements
List	Status, department, category
Date	Deadlines, submission dates, schedules
Time	Appointments, shifts, working hours
Text length	Codes, abbreviations, identifiers

Most rules are built from three parts: the allowed data type, a comparison operator, and one or two limits.

For example, a quantity field may accept only whole numbers from 1 to 100, while a date field may allow only dates within a given year.

Environment Setup

Add the required Excel processing dependency to your Java project.

For Maven, add the following to 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.xls</artifactId>
        <version>16.8.4</version>
    </dependency>
</dependencies>

Import the required classes:

import com.spire.xls.*;

Step 1: Create a Workbook and Access the Worksheet

Create a workbook and get the first worksheet:

Workbook workbook = new Workbook();

Worksheet sheet = workbook.getWorksheets().get(0);

To make the sample worksheet easier to test, add a label for each validation type:

sheet.getCellRange("B2").setText("Whole Number Validation:");
sheet.getCellRange("B4").setText("Date Validation:");
sheet.getCellRange("B6").setText("Text Length Validation:");
sheet.getCellRange("B8").setText("List Validation:");
sheet.getCellRange("B10").setText("Time Validation:");

The corresponding input cells will be placed in column C.

Step 2: Apply Data Validation

Whole Number Validation

Suppose C2 is used for a quantity and should accept only whole numbers from 1 to 100:

CellRange rangeNumber = sheet.getCellRange("C2");

// Allow whole numbers only
rangeNumber.getDataValidation()
        .setAllowType(CellDataType.Integer);

// Restrict the value to a range
rangeNumber.getDataValidation()
        .setCompareOperator(
                ValidationComparisonOperator.Between
        );

// Set the minimum and maximum values
rangeNumber.getDataValidation().setFormula1("1");
rangeNumber.getDataValidation().setFormula2("100");

// Show an input prompt
rangeNumber.getDataValidation()
        .setInputMessage("Enter a whole number between 1 and 100");

// Highlight the input cell
rangeNumber.getCellStyle()
        .setKnownColor(ExcelColors.Gray25Percent);

This kind of rule works well for quantities, headcounts, inventory levels, and similar fields where decimal values should not be accepted.

Date Validation

For C4, limit the input to dates within 2026:

CellRange rangeDate = sheet.getCellRange("C4");

// Allow dates only
rangeDate.getDataValidation()
        .setAllowType(CellDataType.Date);

// Restrict the date to a specific range
rangeDate.getDataValidation()
        .setCompareOperator(
                ValidationComparisonOperator.Between
        );

// Set the start and end dates
rangeDate.getDataValidation()
        .setFormula1("1/1/2026");

rangeDate.getDataValidation()
        .setFormula2("12/31/2026");

// Show an input prompt
rangeDate.getDataValidation()
        .setInputMessage(
                "Enter a date between 1/1/2026 and 12/31/2026"
        );

rangeDate.getCellStyle()
        .setKnownColor(ExcelColors.Gray25Percent);

The comparison does not have to use Between. For a deadline field, for example, you could allow only dates on or after a certain day.

Text Length Validation

Text length validation is useful for fields such as internal codes, abbreviations, or short identifiers.

Here, C6 is limited to 10 characters:

CellRange rangeTextLength =
        sheet.getCellRange("C6");

// Validate the length of the entered text
rangeTextLength.getDataValidation()
        .setAllowType(CellDataType.TextLength);

// Limit the text to 10 characters
rangeTextLength.getDataValidation()
        .setCompareOperator(
                ValidationComparisonOperator.LessOrEqual
        );

rangeTextLength.getDataValidation()
        .setFormula1("10");

// Show an input prompt
rangeTextLength.getDataValidation()
        .setInputMessage(
                "Enter no more than 10 characters"
        );

rangeTextLength.getCellStyle()
        .setKnownColor(ExcelColors.Gray25Percent);

If a field must contain an exact number of characters, the comparison operator can be changed accordingly.

List Validation

For fields with a fixed set of values, a drop-down list helps avoid variations in spelling and wording.

The code below adds a department list to C8:

CellRange rangeList =
        sheet.getCellRange("C8");

// Define the available choices
rangeList.getDataValidation().setValues(
        new String[]{
                "Development",
                "Testing",
                "Marketing",
                "Finance"
        }
);

// Show the drop-down arrow
rangeList.getDataValidation()
        .isSuppressDropDownArrow(false);

// Show an input prompt
rangeList.getDataValidation()
        .setInputMessage("Select a department from the list");

rangeList.getCellStyle()
        .setKnownColor(ExcelColors.Gray25Percent);

For a short, stable list, defining the values directly in code is usually sufficient.

If the list changes frequently, it is better to keep the values in a worksheet range and use that range as the validation source.

Time Validation

C10 can be restricted to times between 9:00 and 18:00:

CellRange rangeTime =
        sheet.getCellRange("C10");

// Allow time values only
rangeTime.getDataValidation()
        .setAllowType(CellDataType.Time);

// Restrict the value to a time range
rangeTime.getDataValidation()
        .setCompareOperator(
                ValidationComparisonOperator.Between
        );

rangeTime.getDataValidation()
        .setFormula1("9:00");

rangeTime.getDataValidation()
        .setFormula2("18:00");

// Show an input prompt
rangeTime.getDataValidation()
        .setInputMessage(
                "Enter a time between 9:00 and 18:00"
        );

rangeTime.getCellStyle()
        .setKnownColor(ExcelColors.Gray25Percent);

This can be useful for appointment times, work shifts, or any field that should stay within defined working hours.

Step 3: Adjust the Worksheet Layout

A little formatting makes the generated sheet easier to use:

// Auto-fit column B
sheet.autoFitColumn(2);

// Set the width of column C
sheet.setColumnWidth(3, 20);

Step 4: Save the Workbook

Save the finished workbook:

workbook.saveToFile(
        "DataValidation.xlsx",
        ExcelVersion.Version2016
);

workbook.dispose();

The generated worksheet now contains five different validation rules:

C2 accepts whole numbers from 1 to 100.
C4 accepts dates within 2026.
C6 accepts up to 10 characters.
C8 provides a department drop-down list.
C10 accepts times between 9:00 and 18:00.

These rules stay with the workbook, so the same input restrictions apply whenever the file is reused as a template.

How to Extract Tables from Word Documents with Python

Dheeraj Malik — Tue, 15 Sep 2026 03:41:03 +0000

Word documents often use tables to store structured information such as inventory lists, inspection records, project data, and reports. Extracting one table manually is simple enough, but it quickly becomes tedious when a document contains several tables or when many Word files need to be processed.

With Python, you can read the rows and cells of a Word table and convert the content into a structure that is easier to reuse or export.

This guide covers how to read a table from a Word document, extract all tables to CSV files, and process multiple Word files in a folder.

Environment Setup

To run the examples below, install the required Python module for Word processing:

pip install Spire.Doc

Read a Table from a Word Document

A Word table can be accessed through its section and then read row by row.

The example below reads the first table in the first section and stores its content in a two-dimensional Python list:

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

input_file = "input.docx"

document = Document()
document.LoadFromFile(input_file)

section = document.Sections.get_Item(0)
table = section.Tables.get_Item(0)

table_data = []

for r in range(table.Rows.Count):
    row = table.Rows.get_Item(r)
    row_data = []

    for c in range(row.Cells.Count):
        cell = row.Cells.get_Item(c)

        paragraphs = []

        for p in range(cell.Paragraphs.Count):
            text = cell.Paragraphs.get_Item(p).Text.strip()

            if text:
                paragraphs.append(text)

        row_data.append(" ".join(paragraphs))

    table_data.append(row_data)

for row in table_data:
    print(row)

document.Close()

A table cell may contain more than one paragraph, so the code reads all paragraphs in the cell instead of assuming that only one exists.

The extracted data may look like this:

[
    ["Name", "Department", "Position"],
    ["John Smith", "Development", "Software Engineer"],
    ["Emma Lee", "Testing", "QA Engineer"]
]

If the original paragraph breaks need to be preserved, replace:

" ".join(paragraphs)

with:

"\n".join(paragraphs)

Extract All Tables from Word to CSV

A Word document may contain tables in more than one section. To extract all of them, iterate through every section and its Tables collection.

The following code saves each table as a separate CSV file:

import csv
import os
from spire.doc import *
from spire.doc.common import *

input_file = "input.docx"
output_folder = "ExtractedTables"

os.makedirs(output_folder, exist_ok=True)

document = Document()
document.LoadFromFile(input_file)

table_number = 0

for s in range(document.Sections.Count):
    section = document.Sections.get_Item(s)

    for t in range(section.Tables.Count):
        table = section.Tables.get_Item(t)
        table_number += 1

        output_file = os.path.join(
            output_folder,
            f"table_{table_number}.csv"
        )

        with open(
            output_file,
            "w",
            newline="",
            encoding="utf-8-sig"
        ) as csv_file:

            writer = csv.writer(csv_file)

            for r in range(table.Rows.Count):
                row = table.Rows.get_Item(r)
                row_data = []

                for c in range(row.Cells.Count):
                    cell = row.Cells.get_Item(c)

                    paragraphs = []

                    for p in range(cell.Paragraphs.Count):
                        text = cell.Paragraphs.get_Item(p).Text.strip()

                        if text:
                            paragraphs.append(text)

                    row_data.append(" ".join(paragraphs))

                writer.writerow(row_data)

document.Close()

print(f"Extracted {table_number} tables.")

If the document contains three tables, the output folder will look like this:

ExtractedTables/
├── table_1.csv
├── table_2.csv
└── table_3.csv

The CSV files use utf-8-sig, which helps avoid encoding problems when text containing non-ASCII characters is opened directly in spreadsheet applications such as Excel.

Batch Extract Tables from Multiple Word Files

For multiple documents, it is cleaner to move the extraction logic into a reusable function instead of repeating the same code for every file.

import csv
import os
from spire.doc import *
from spire.doc.common import *


def extract_tables(word_file, output_folder):
    os.makedirs(output_folder, exist_ok=True)

    document = Document()
    document.LoadFromFile(word_file)

    table_number = 0

    for s in range(document.Sections.Count):
        section = document.Sections.get_Item(s)

        for t in range(section.Tables.Count):
            table = section.Tables.get_Item(t)
            table_number += 1

            output_file = os.path.join(
                output_folder,
                f"table_{table_number}.csv"
            )

            with open(
                output_file,
                "w",
                newline="",
                encoding="utf-8-sig"
            ) as csv_file:

                writer = csv.writer(csv_file)

                for r in range(table.Rows.Count):
                    row = table.Rows.get_Item(r)
                    row_data = []

                    for c in range(row.Cells.Count):
                        cell = row.Cells.get_Item(c)

                        text = " ".join(
                            cell.Paragraphs.get_Item(p).Text.strip()
                            for p in range(cell.Paragraphs.Count)
                            if cell.Paragraphs.get_Item(p).Text.strip()
                        )

                        row_data.append(text)

                    writer.writerow(row_data)

    document.Close()

    return table_number


input_folder = "WordFiles"
output_folder = "ExtractedTables"

for file_name in os.listdir(input_folder):

    if not file_name.lower().endswith((".doc", ".docx")):
        continue

    input_file = os.path.join(input_folder, file_name)

    document_name = os.path.splitext(file_name)[0]

    document_output = os.path.join(
        output_folder,
        document_name
    )

    count = extract_tables(
        input_file,
        document_output
    )

    print(f"{file_name}: extracted {count} tables")

Each document gets its own output folder, so tables from different files do not overwrite one another:

ExtractedTables/
├── report/
│   ├── table_1.csv
│   └── table_2.csv
├── inventory/
│   └── table_1.csv
└── records/
    ├── table_1.csv
    └── table_2.csv

A Note on Merged Cells

Merged cells need extra attention when exporting Word tables to CSV.

Word supports both horizontal and vertical cell merging, while CSV only stores rows and columns and has no concept of merged cells. As a result, a complex Word table may not map cleanly to a flat CSV structure.

If the extracted data will be imported into a database or used for analysis, it is worth checking tables with merged headers or grouped rows and normalizing them as needed after extraction.