Verify XLSX metadata cleanup with Python

Wendy — Sun, 08 Nov 2026 08:50:55 +0000

An XLSX cleanup report can tell you which fields it changed. For a regression check, I also want to inspect the downloaded file itself. Did the chosen author and company fields become empty or disappear? Did the sheets, formulas, and other package parts keep the same bytes?

This example uses a small demo workbook with fictional names, a custom ProjectCode, a formula, and a hidden sheet. The script uses Python's standard library. It reads two workbook copies and reports exactly which checks passed.

AI assisted with drafting and editing this English article. The code and reported results were checked against the demo files.

What to compare inside the workbook

An XLSX file is a ZIP package. In the sample, the author and last editor are in docProps/core.xml, the company name is in docProps/app.xml, and ProjectCode is in docProps/custom.xml. The sheet XML and the workbook definition sit under xl/.

Open a small workbook you control, save a working copy, and keep the original beside it. The example below uses a local browser cleanup as the source of the second copy. The same comparison works with another cleanup workflow that follows the same rule about which package parts it may change.

The input is the demo workbook. Keep this copy for the comparison.

Record the fields you expect the cleaner to remove. If you use a different custom property name, change the ProjectCode filter in the script.

Check the property values and hash the other parts

The script parses the three property XML parts and compares SHA-256 hashes of the uncompressed bytes for every other file in the archive. It flags any added or removed part outside the three allowed property paths. Duplicate member names and unexpected property XML roots are treated as errors.

Save the following as verify_xlsx_cleanup.py.

"""Read-only regression check for this article's small XLSX fixture."""

import argparse
import hashlib
import json
from collections import Counter
from xml.etree import ElementTree as ET
from zipfile import BadZipFile, ZipFile

PROPERTY_PARTS = {"docProps/core.xml", "docProps/app.xml", "docProps/custom.xml"}
DC = "http://purl.org/dc/elements/1.1/"
CP = "http://schemas.openxmlformats.org/package/2006/metadata/core-properties"
APP = "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties"
CUSTOM = "http://schemas.openxmlformats.org/officeDocument/2006/custom-properties"
ROOTS = {
    "docProps/core.xml": f"{{{CP}}}coreProperties",
    "docProps/app.xml": f"{{{APP}}}Properties",
    "docProps/custom.xml": f"{{{CUSTOM}}}Properties",
}


def xml_part(archive, path):
    if path not in archive.namelist():
        return None
    root = ET.fromstring(archive.read(path))
    if root.tag != ROOTS[path]:
        raise ValueError("Unexpected property XML root: " + path)
    return root


def text_at(root, name):
    node = None if root is None else root.find(name)
    return "" if node is None else "".join(node.itertext()).strip()


def snapshot(path):
    with ZipFile(path) as archive:
        names = [item.filename for item in archive.infolist() if not item.is_dir()]
        if any(count > 1 for count in Counter(names).values()):
            raise ValueError("Duplicate ZIP member names")
        if "xl/workbook.xml" not in names:
            raise ValueError("Missing xl/workbook.xml")
        core = xml_part(archive, "docProps/core.xml")
        app = xml_part(archive, "docProps/app.xml")
        custom = xml_part(archive, "docProps/custom.xml")
        project_codes = [] if custom is None else [
            "".join(node.itertext()).strip()
            for node in custom.findall(f"{{{CUSTOM}}}property")
            if node.get("name") == "ProjectCode"
        ]
        properties = {
            "creator": text_at(core, f"{{{DC}}}creator"),
            "lastModifiedBy": text_at(core, f"{{{CP}}}lastModifiedBy"),
            "company": text_at(app, f"{{{APP}}}Company"),
            "ProjectCode": project_codes,
        }
        other_parts = {
            name: hashlib.sha256(archive.read(name)).hexdigest()
            for name in names if name not in PROPERTY_PARTS
        }
        return properties, other_parts


def compare(before_path, after_path):
    before, old_parts = snapshot(before_path)
    after, new_parts = snapshot(after_path)
    changed = sorted(
        name for name in old_parts.keys() | new_parts.keys()
        if old_parts.get(name) != new_parts.get(name)
    )
    remaining = sorted(key for key, value in after.items() if value)
    print("Before properties:", json.dumps(before, ensure_ascii=False))
    print("After properties:", json.dumps(after, ensure_ascii=False))
    print("Remaining checked properties:", remaining)
    print("Changed/added/removed other parts:", changed)
    print("Other parts in output:", len(new_parts))
    if remaining or changed:
        print("REVIEW: one or more checks failed.")
        return 1
    print("OK: checked properties empty/absent; other part hashes match.")
    return 0


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("before")
    parser.add_argument("after")
    args = parser.parse_args()
    try:
        return compare(args.before, args.after)
    except (BadZipFile, ET.ParseError, OSError, RuntimeError, ValueError) as error:
        print("ERROR:", error)
        return 2


if __name__ == "__main__":
    raise SystemExit(main())

Run it with the original workbook first and the cleaned copy second.

python3 verify_xlsx_cleanup.py excel-metadata-demo.xlsx excel-metadata-demo-clean.xlsx

Read the result

In the demo, the original contained Sample Author, Sample Editor, Example Company, and DEMO-XLSX-001. The saved cleanup report listed ten removed metadata items. The independent script checked the four selected properties and found identical hashes for the other six parts.

The tool report counts metadata items. The Python check below counts ZIP parts outside the three allowed property paths.

Remaining checked properties: []
Changed/added/removed other parts: []
Other parts in output: 6
OK: checked properties empty/absent; other part hashes match.

Try the original as both arguments and the script exits with 1, listing the four remaining properties. A test copy with a changed cell also exits with 1 and identifies xl/worksheets/sheet1.xml. An added ZIP member is listed by name. An empty ProjectCode element still counts as a remaining property.

This comparison applies to small, trusted Transitional OOXML workbooks and the four chosen properties. A cleanup that intentionally rewrites other package parts will trigger review. Workbook rendering, recalculation, package relationships, and signatures each need their own checks. Review any sensitive values in cells, comments, hidden sheets, or external connections before sharing the final copy.

Source

The demo was produced by the AI MetaClean project. The project also documents the general workbook sharing workflow and Excel's built-in inspection steps. Excel metadata cleanup guide

DEV Community: AI MetaClean

Verify XLSX metadata cleanup with Python

What to compare inside the workbook

Check the property values and hash the other parts

Read the result

Source