Data Sanitization

Documents are rarely "just documents." By the time a DOCX or PDF leaves your system, it often contains much more than what is visible on the screen, including form field values, metadata, internal comments, and complete revision histories.

In document pipelines, especially those involving automation, collaboration, or AI, this hidden data can be a liability. This article explains why sanitizing documents is essential and how the sample project on GitHub demonstrates effective data sanitization using TX Text Control in C# .NET.

The Real Problem: Hidden Data Travels with Your Documents As a document is edited, reviewed, and passed along, it accumulates context. For example, a contract template is filled with personal data. Multiple reviewers add comments and tracked changes. Systems embed metadata such as the author, timestamps, and environmental details.

None of this information is necessarily visible in the final version, but it remains part of the file. This becomes problematic the moment a document leaves your control.

For example, a legal team might send a "clean" contract to opposing counsel, only to reveal its negotiation strategy through leftover comments. A healthcare provider might forward a report containing patient identifiers in hidden fields. A government submission might include metadata that exposes internal systems or authorship.

Legal and Compliance Risks It's not just about being tidy; it's about compliance, liability, and control.

Government agencies often require documents to be stripped of metadata and embedded logic prior to submission. Documents containing hidden data may be rejected or flagged.

In legal workflows, documents move between multiple parties, including clients, opposing counsel, courts, and regulators. If tracked changes or annotations are not removed, they can reveal deleted clauses, internal discussions, or negotiation strategies.

Healthcare adds another layer. Documents often contain Protected Health Information (PHI), so even a single leftover form field or comment could result in the unintentional sharing of sensitive patient data.

Moreover, documents are increasingly processed by AI systems. Sending raw documents to external services without sanitizing them means potentially exposing personal or confidential data far beyond your control.

A Practical Example: The Sample Application The sample project uses TX Text Control .NET Server to demonstrate an important yet simple idea: sanitization should be a controlled, two-step process.

Rather than immediately modifying a document, the application first analyzes it and only removes sensitive data if necessary.

The workflow in Program.cs looks like this:

The document is loaded into a ServerTextControl instance The application scans the document and creates a report of all sensitive elements Only if such data exists, the sanitization step is executed The cleaned document is saved and reported again This distinction between detection and removal is crucial. The first step acts as a dry run. It inspects metadata, populated form fields, comments, tracked changes, and embedded content and generates a structured report. Nothing is changed at this stage. The second step performs the actual cleanup. It clears metadata, resets all form field values, removes comments and tracked changes, and removes additional embedded information. The result is a document that is visually clean and free of hidden data.

It's important to note that the same report structure is used before and after sanitization. This makes the process transparent and auditable and allows you to verify that all sensitive data has been removed.

How the Sample Application Works in Code The sample application is built around a simple yet practical idea: Inspect the document first, and only sanitize it if necessary. In Program.cs , the document is loaded, analyzed, optionally sanitized, saved, and reported again. This compact flow clearly separates detection from removal.

The following screenshot shows the report output for the sample application. The first report displays the document's state prior to sanitization and includes metadata, form field values, comments, and tracked changes. The second report confirms that all sensitive data was removed after sanitization.

The entry point looks like this:

using TXTextControl; using TxSanitization.Sanitization;

using var textControl = new ServerTextControl(); textControl.Create(); textControl.Load("pre_sanitizing.tx", StreamType.InternalUnicodeFormat);

// Check for sanitizable data and print the report before sanitization var checkReport = DocumentSanitizer.CheckForSanitizableData(textControl); SanitizationReportPrinter.Print(checkReport, "Exists");

// Sanitize the document if needed, then print the report after sanitization var report = checkReport.HasSanitizableData ? DocumentSanitizer.SanitizeBeforeExport(textControl) : checkReport;

// Save the sanitized document textControl.Save("post_sanitizing.tx", StreamType.InternalUnicodeFormat);

// Print the sanitization report after sanitization SanitizationReportPrinter.Print(report, "Removed"); This is the two-step process in its simplest form. First, the application identifies any sensitive data. Second, it removes that data before exporting the document. This design is useful in document pipelines because it provides control and traceability. You can see what was in the file before making any changes, and you can log what was removed before the document leaves your system.

CheckForSanitizableData

This function performs an inspection pass. It does not modify the document. Instead, it validates the input and calls the Analyze method, which generates a SanitizationReport .

public static SanitizationReport CheckForSanitizableData(ServerTextControl textControl) { ArgumentNullException.ThrowIfNull(textControl); return Analyze(textControl); } This makes it ideal for a pre-export validation step. For instance, in a legal workflow, you could perform this check before sending a contract to opposing counsel. If the report shows comments, tracked changes, or prefilled form values, the system can automatically block the export or sanitize the file. The same applies in healthcare, where hidden form data or annotations may contain PHI, as well as in public-sector workflows, where metadata or embedded content may be prohibited in official submissions.

SanitizeBeforeExport

This is the actual cleanup function. It begins by reanalyzing the document and immediately returns if there is nothing to sanitize. If there is sanitizable content, the function clears the metadata, resets the form fields, and removes the comments and tracked changes.

public static SanitizationReport SanitizeBeforeExport(ServerTextControl textControl) { ArgumentNullException.ThrowIfNull(textControl);

var report = Analyze(textControl); if (!report.HasSanitizableData) { return report; }

var documentSettings = textControl.DocumentSettings; documentSettings.Author = string.Empty; documentSettings.CreationDate = DateTime.MinValue; documentSettings.CreatorApplication = string.Empty; documentSettings.DocumentBasePath = string.Empty; documentSettings.DocumentKeywords = Array.Empty(); documentSettings.DocumentSubject = string.Empty; documentSettings.DocumentTitle = string.Empty; documentSettings.UserDefinedDocumentProperties = null; documentSettings.EmbeddedFiles = null;

foreach (FormField formField in textControl.FormFields) { switch (formField) { case TextFormField textFormField: textFormField.Text = string.Empty; break; case CheckFormField checkFormField: checkFormField.Checked = false; break; case SelectionFormField selectionFormField: selectionFormField.SelectedIndex = -1; selectionFormField.Text = string.Empty; break; case DateFormField dateFormField: dateFormField.Date = null; break; } }

foreach (IFormattedText textPart in textControl.TextParts) { while (textPart.Comments.Count > 0) { textPart.Comments.Remove(textPart.Comments[1]); }

while (textPart.TrackedChanges.Count > 0) { textPart.TrackedChanges.Remove(textPart.TrackedChanges[1], true); } }

return report; } This function makes the sample especially relevant for real-world pipelines. It removes more than just visible review artifacts. It also removes metadata, including author, creation date, creator application, base path, keywords, subject, title, and user-defined document properties. Embedded files are also removed. Then, it resets different form field types according to their behavior. Text fields are emptied, check boxes are unchecked, selection fields are reset, and date fields are cleared. Finally, all comments and tracked changes are removed from the document's text parts.

This sample is strong not just because it removes comments or clears form fields. It also provides document pipelines with a repeatable structure.

CheckForSanitizableData determines whether the document is safe to leave the system in its current state. SanitizeBeforeExport applies a deterministic cleanup if it is not safe. SanitizationReport makes the result measurable and SanitizationReportPrinter makes it visible. Together, these functions transform sanitization from a manual cleanup task into a proper pipeline step.

For legal teams, this means that contracts can be checked for hidden comments and revision history before disclosure. In healthcare, documents can be stripped of prefilled patient data and internal notes before being sent to insurers or regulators. For government submissions, metadata and embedded content can be removed before documents are passed through official channels. For AI workflows, only the information intended for downstream processing is allowed to leave the organization.

Conclusion In document processing pipelines, sanitization is not just a best practice. It's a necessity. Hidden data traveling with documents can pose significant risks, including legal liabilities, compliance issues, and data breaches. Implementing a structured approach to sanitization, as demonstrated in the sample application, allows organizations to maintain control over their documents and ensure that only the intended information is shared.

The principles of detection and removal outlined in this article can help you safeguard your data and maintain the integrity of your document workflows, whether you're a legal team preparing contracts, a healthcare provider handling sensitive reports, or a government agency submitting official documents.

TX Text Control .NET Server

DS Server

Server & Web

Windows Forms

WPF

ActiveX

Core Technologies

Blog

Core Technologies

Blog

Authors

Latest Posts

Support Resources

Documentation

Support

Getting Started

Other Resources

About Us

Industry events

Company

Contact

Newsletter

Legal

Sign in

Create account

Text Control Account

Data Sanitization

Post tagged with Data Sanitization in 2026

Server & Web

Windows Forms

WPF

ActiveX

Core Technologies

​

Latest Posts

​

Support

Getting Started

​

Other Resources

Company

Contact

Newsletter

Legal

Text Control Account

​

​

Data Sanitization

Post tagged with Data Sanitization in 2026 ​

April 2026

Post tagged with Data Sanitization in 2026