Sanitize PDFs

This is sample code for using Apryse SDK to remove hidden, non-visual content within PDF documents. Using pdftron.PDF.Sanitizer ensures that if metadata, form data, bookmarks, hidden layers, markup annotations, JavaScript, or file attachments are present in a document, that content is permanently destroyed and is not simply disabled or obscured. Sample code is provided in Python, C++, C#, Java, Node.js (JavaScript), PHP, Ruby, and VB.

Implementation steps

To sanitize files with Apryse Server SDK:

Step 1: Follow get started with Server SDK in your preferred language or framework. Step 2: Add the sample code provided in this guide.

Learn more about Apryse Server SDK.

C#

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2026 by Apryse Software Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------

using System;
using System.IO;
using System.Collections;

using pdftron;
using pdftron.Common;
using pdftron.Filters;
using pdftron.SDF;
using pdftron.PDF;

using NUnit.Framework;

//------------------------------------------------------------------------------
// PDFNet's Sanitizer is a security-focused feature that permanently removes
// hidden, sensitive, or potentially unsafe content from a PDF document.
// While redaction targets visible page content such as text or graphics,
// sanitization focuses on non-visual elements and embedded structures.
//
// PDFNet Sanitizer ensures hidden or inactive content is destroyed,
// not merely obscured or disabled. This prevents leakage of sensitive
// data such as authoring details, editing history, private identifiers,
// and residual form entries, and neutralizes scripts or attachments.
//
// Sanitization is recommended prior to external sharing with clients,
// partners, or regulatory bodies. It helps align with privacy policies
// and compliance requirements by permanently removing non-visual data.
//------------------------------------------------------------------------------

namespace MiscellaneousSamples
{

	[TestFixture]
	public class PDFSanitizeTest
	{

		[Test]
		public static void Sample()
		{
			const string input_path =  "TestFiles/";


            // The following example illustrates how to retrieve the existing
            // sanitizable content categories within a document.
			try
			{
         	    using (PDFDoc doc = new PDFDoc(Utils.GetAssetTempFile(input_path + "numbered.pdf")))
    		    {
		            doc.InitSecurityHandler();

			        SanitizeOptions opts = Sanitizer.GetSanitizableContent(doc);
			        if (opts.GetMetadata())
    			    {
	    			    Console.WriteLine("Document has metadata.");
	    		    }
			        if (opts.GetMarkups())
			        {
				        Console.WriteLine("Document has markups.");
			        }
			        if (opts.GetHiddenLayers())
			        {
				        Console.WriteLine("Document has hidden layers.");
			        }
                    Console.WriteLine("Done...");
			    }
			}
			catch (PDFNetException e)
			{
				Console.WriteLine(e.Message);
				Assert.True(false);
			}


    	    // The following example illustrates how to sanitize a document with default options,
    	    // which will remove all sanitizable content present within a document.
    		try
    		{
         	    using (PDFDoc doc = new PDFDoc(Utils.GetAssetTempFile(input_path + "financial.pdf")))
        	    {
    		        doc.InitSecurityHandler();

			        Sanitizer.SanitizeDocument(doc);
    				doc.Save(Utils.CreateExternalFile("financial_sanitized.pdf"), SDFDoc.SaveOptions.e_linearized);
                    Console.WriteLine("Done...");
    			}
    		}
    		catch (PDFNetException e)
    		{
    			Console.WriteLine(e.Message);
    			Assert.True(false);
    		}


	        // The following example illustrates how to sanitize a document with custom set options,
	        // which will only remove the content categories specified by the options object.
    		try
    		{
         	    using (PDFDoc doc = new PDFDoc(Utils.GetAssetTempFile(input_path + "form1.pdf")))
        	    {
    		        doc.InitSecurityHandler();

    		        SanitizeOptions opts = new SanitizeOptions();
		            opts.SetMetadata(true);
        		    opts.SetFormData(true);
        		    opts.SetBookmarks(true);

			        Sanitizer.SanitizeDocument(doc, opts);
    				doc.Save(Utils.CreateExternalFile("form1_sanitized.pdf"), SDFDoc.SaveOptions.e_linearized);
                    Console.WriteLine("Done...");
    			}
    		}
    		catch (PDFNetException e)
    		{
    			Console.WriteLine(e.Message);
    			Assert.True(false);
    		}

		}
	}
}

Go

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2026 by Apryse Software Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------

package main
import (
    "fmt"
    "testing"
    "flag"
    . "github.com/pdftron/pdftron-go/v2"
)

var licenseKey string
var modulePath string

func init() {
    flag.StringVar(&licenseKey, "license", "", "License key for Apryse SDK")
    flag.StringVar(&modulePath, "modulePath", "", "Module path for Apryse SDK")
}

//------------------------------------------------------------------------------
// PDFNet's Sanitizer is a security-focused feature that permanently removes
// hidden, sensitive, or potentially unsafe content from a PDF document.
// While redaction targets visible page content such as text or graphics,
// sanitization focuses on non-visual elements and embedded structures.
//
// PDFNet Sanitizer ensures hidden or inactive content is destroyed,
// not merely obscured or disabled. This prevents leakage of sensitive
// data such as authoring details, editing history, private identifiers,
// and residual form entries, and neutralizes scripts or attachments.
//
// Sanitization is recommended prior to external sharing with clients,
// partners, or regulatory bodies. It helps align with privacy policies
// and compliance requirements by permanently removing non-visual data.
//------------------------------------------------------------------------------

func TestPDFSanitize(t *testing.T){

    // Relative path to the folder containing the test files.
    inputPath := "../TestFiles/"
    outputPath := "../TestFiles/Output/"

    PDFNetInitialize(licenseKey)

	// The following example illustrates how to retrieve the existing
	// sanitizable content categories within a document.
	{
		doc := NewPDFDoc(inputPath + "numbered.pdf")
		doc.InitSecurityHandler()
		opts := SanitizerGetSanitizableContent(doc)
		if opts.GetMetadata() {
			fmt.Println("Document has metadata.")
		}
		if opts.GetMarkups() {
			fmt.Println("Document has markups.")
		}
		if opts.GetHiddenLayers() {
			fmt.Println("Document has hidden layers.")
		}
		fmt.Println("Done...")
	}

	// The following example illustrates how to sanitize a document with default options,
	// which will remove all sanitizable content present within a document.
	{
		doc := NewPDFDoc(inputPath + "financial.pdf")
		doc.InitSecurityHandler()
		SanitizerSanitizeDocument(doc, NewSanitizeOptions())
		doc.Save(outputPath+"financial_sanitized.pdf", uint(SDFDocE_linearized))
		fmt.Println("Done...")
	}

	// The following example illustrates how to sanitize a document with custom set options,
	// which will only remove the content categories specified by the options object.
	{
		options := NewSanitizeOptions()
		options.SetMetadata(true)
		options.SetFormData(true)
		options.SetBookmarks(true)

		doc := NewPDFDoc(inputPath + "form1.pdf")
		doc.InitSecurityHandler()
		SanitizerSanitizeDocument(doc, options)
		doc.Save(outputPath+"form1_sanitized.pdf", uint(SDFDocE_linearized))
		fmt.Println("Done...")
	}

    PDFNetTerminate()
}

Java

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2026 by Apryse Software Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------

import java.lang.*;
import java.awt.*;

import com.pdftron.pdf.*;
import com.pdftron.sdf.SDFDoc;

//------------------------------------------------------------------------------
// PDFNet's Sanitizer is a security-focused feature that permanently removes
// hidden, sensitive, or potentially unsafe content from a PDF document.
// While redaction targets visible page content such as text or graphics,
// sanitization focuses on non-visual elements and embedded structures.
//
// PDFNet Sanitizer ensures hidden or inactive content is destroyed,
// not merely obscured or disabled. This prevents leakage of sensitive
// data such as authoring details, editing history, private identifiers,
// and residual form entries, and neutralizes scripts or attachments.
//
// Sanitization is recommended prior to external sharing with clients,
// partners, or regulatory bodies. It helps align with privacy policies
// and compliance requirements by permanently removing non-visual data.
//------------------------------------------------------------------------------
public class PDFSanitizeTest {

    public static void main(String[] args) {
        // Relative paths to folders containing test files.
        String input_path = "../../TestFiles/";
        String output_path = "../../TestFiles/Output/";

        PDFNet.initialize(PDFTronLicense.Key());


        // The following example illustrates how to retrieve the existing
        // sanitizable content categories within a document.
        try (PDFDoc doc = new PDFDoc(input_path + "numbered.pdf")) {
            doc.initSecurityHandler();

            SanitizeOptions opts = Sanitizer.getSanitizableContent(doc);
            if (opts.getMetadata())
            {
                System.out.println("Document has metadata.");
            }
            if (opts.getMarkups())
            {
                System.out.println("Document has markups.");
            }
            if (opts.getHiddenLayers())
            {
                System.out.println("Document has hidden layers.");
            }
            System.out.println("Done...");
        } catch (Exception e) {
            e.printStackTrace();
        }


	    // The following example illustrates how to sanitize a document with default options,
	    // which will remove all sanitizable content present within a document.
        try (PDFDoc doc = new PDFDoc(input_path + "financial.pdf")) {
            doc.initSecurityHandler();

            Sanitizer.sanitizeDocument(doc);
            doc.save(output_path + "financial_sanitized.pdf", SDFDoc.SaveMode.LINEARIZED, null);
            System.out.println("Done...");
        } catch (Exception e) {
            e.printStackTrace();
        }


	    // The following example illustrates how to sanitize a document with custom set options,
	    // which will only remove the content categories specified by the options object.
        try (PDFDoc doc = new PDFDoc(input_path + "form1.pdf")) {
            doc.initSecurityHandler();

            SanitizeOptions options = new SanitizeOptions();
            options.setMetadata(true);
            options.setFormData(true);
            options.setBookmarks(true);

            Sanitizer.sanitizeDocument(doc, options);
            doc.save(output_path + "form1_sanitized.pdf", SDFDoc.SaveMode.LINEARIZED, null);
            System.out.println("Done...");
        } catch (Exception e) {
            e.printStackTrace();
        }

        PDFNet.terminate();
    }
}

C++

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2026 by Apryse Software Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------

#include <PDF/PDFNet.h>
#include <PDF/PDFDoc.h>
#include <PDF/Sanitizer.h>
#include <PDF/SanitizeOptions.h>
#include <iostream>

#include "../../LicenseKey/CPP/LicenseKey.h"


using namespace std;

using namespace pdftron;
using namespace Common;
using namespace SDF;
using namespace PDF;


//------------------------------------------------------------------------------
// PDFNet's Sanitizer is a security-focused feature that permanently removes
// hidden, sensitive, or potentially unsafe content from a PDF document.
// While redaction targets visible page content such as text or graphics,
// sanitization focuses on non-visual elements and embedded structures.
//
// PDFNet Sanitizer ensures hidden or inactive content is destroyed,
// not merely obscured or disabled. This prevents leakage of sensitive
// data such as authoring details, editing history, private identifiers,
// and residual form entries, and neutralizes scripts or attachments.
//
// Sanitization is recommended prior to external sharing with clients,
// partners, or regulatory bodies. It helps align with privacy policies
// and compliance requirements by permanently removing non-visual data.
//------------------------------------------------------------------------------

int main(int argc, char *argv[])
{
	int ret = 0;
	PDFNet::Initialize(LicenseKey);

	// Relative paths to folders containing test files.
	string input_path =  "../../TestFiles/";
	string output_path = "../../TestFiles/Output/";

	// The following example illustrates how to retrieve the existing
	// sanitizable content categories within a document.
	try
	{
		PDFDoc doc(input_path + "numbered.pdf");
		doc.InitSecurityHandler();

		SanitizeOptions opts = Sanitizer::GetSanitizableContent(doc);
		if (opts.GetMetadata())
		{
			cout << "Document has metadata." << endl;
		}
		if (opts.GetMarkups())
		{
			cout << "Document has markups." << endl;
		}
		if (opts.GetHiddenLayers())
		{
			cout << "Document has hidden layers." << endl;
		}
		cout << "Done..." << endl;
	}
	catch(Common::Exception& e)
	{
		cout << e << endl;
		ret = 1;
	}
	catch(...)
	{
		cout << "Unknown Exception" << endl;
		ret = 1;
	}


	// The following example illustrates how to sanitize a document with default options,
	// which will remove all sanitizable content present within a document.
	try
	{
		PDFDoc doc(input_path + "financial.pdf");
		doc.InitSecurityHandler();

		Sanitizer::SanitizeDocument(doc, 0);
		doc.Save(output_path + "financial_sanitized.pdf", SDFDoc::e_linearized, 0);
		cout << "Done..." << endl;
	}
	catch(Common::Exception& e)
	{
		cout << e << endl;
		ret = 1;
	}
	catch(...)
	{
		cout << "Unknown Exception" << endl;
		ret = 1;
	}


	// The following example illustrates how to sanitize a document with custom set options,
	// which will only remove the content categories specified by the options object.
	try
	{
		SanitizeOptions options;
		options.SetMetadata(true);
		options.SetFormData(true);
		options.SetBookmarks(true);

		PDFDoc doc(input_path + "form1.pdf");
		doc.InitSecurityHandler();

		Sanitizer::SanitizeDocument(doc, &options);
		doc.Save(output_path  + "form1_sanitized.pdf", SDFDoc::e_linearized, 0);
		cout << "Done..." << endl;
	}
	catch(Common::Exception& e)
	{
		cout << e << endl;
		ret = 1;
	}
	catch(...)
	{
		cout << "Unknown Exception" << endl;
		ret = 1;
	}

	PDFNet::Terminate();
	return ret;
}

JavaScript

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2026 by Apryse Software Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------

//------------------------------------------------------------------------------
// PDFNet's Sanitizer is a security-focused feature that permanently removes
// hidden, sensitive, or potentially unsafe content from a PDF document.
// While redaction targets visible page content such as text or graphics,
// sanitization focuses on non-visual elements and embedded structures.
//
// PDFNet Sanitizer ensures hidden or inactive content is destroyed,
// not merely obscured or disabled. This prevents leakage of sensitive
// data such as authoring details, editing history, private identifiers,
// and residual form entries, and neutralizes scripts or attachments.
//
// Sanitization is recommended prior to external sharing with clients,
// partners, or regulatory bodies. It helps align with privacy policies
// and compliance requirements by permanently removing non-visual data.
//------------------------------------------------------------------------------

const { PDFNet } = require('../../lib/pdfnet.js');
const PDFTronLicense = require('../../LicenseKey/NODEJS/LicenseKey');

((exports) => {

    exports.runPDFSanitizeTest = () => {

        const main = async() => {
            // Relative path to the folder containing test files.
            const inputPath = '../TestFiles/';
            const outputPath = '../TestFiles/Output/';

            // The following example illustrates how to retrieve the existing
            // sanitizable content categories within a document.
            try {
                const doc = await PDFNet.PDFDoc.createFromFilePath(inputPath + 'numbered.pdf');
                if (await doc.initSecurityHandler()) {
                    const opts = await PDFNet.Sanitizer.getSanitizableContent(doc);
                    if (opts.getMetadata()) {
                        console.log('Document has metadata.');
                    }
                    if (opts.getMarkups()) {
                        console.log('Document has markups.');
                    }
                    if (opts.getHiddenLayers()) {
                        console.log('Document has hidden layers.');
                    }
                }
                console.log('Done...');
            } catch (err) {
                console.log(err.stack);
            }

            // The following example illustrates how to sanitize a document with default options,
            // which will remove all sanitizable content present within a document.
            try {
                const doc = await PDFNet.PDFDoc.createFromFilePath(inputPath + 'financial.pdf');
                if (await doc.initSecurityHandler()) {
                    await PDFNet.Sanitizer.sanitizeDocument(doc);
                    await doc.save(outputPath + 'financial_sanitized.pdf', PDFNet.SDFDoc.SaveOptions.e_linearized);
                }
                console.log('Done...');
            } catch (err) {
                console.log(err.stack);
            }

            // The following example illustrates how to sanitize a document with custom set options,
            // which will only remove the content categories specified by the options object.
            try {
                const options = new PDFNet.Sanitizer.SanitizeOptions();
                options.setMetadata(true);
                options.setFormData(true);
                options.setBookmarks(true);

                const doc = await PDFNet.PDFDoc.createFromFilePath(inputPath + 'form1.pdf');
                if (await doc.initSecurityHandler()) {
                    await PDFNet.Sanitizer.sanitizeDocument(doc, options);
                    await doc.save(outputPath + 'form1_sanitized.pdf', PDFNet.SDFDoc.SaveOptions.e_linearized);
                }
                console.log('Done...');
            } catch (err) {
                console.log(err.stack);
            }
        };
        PDFNet.runWithCleanup(main, PDFTronLicense.Key).catch(function(error){console.log('Error: ' + JSON.stringify(error));}).then(function(){return PDFNet.shutdown();});
    };
    exports.runPDFSanitizeTest();
})(exports);
// eslint-disable-next-line spaced-comment
//# sourceURL=PDFSanitizeTest.js

Python

#---------------------------------------------------------------------------------------
# Copyright (c) 2001-2026 by Apryse Software Inc. All Rights Reserved.
# Consult legal.txt regarding legal and license information.
#---------------------------------------------------------------------------------------

import site
site.addsitedir("../../../PDFNetC/Lib")
import sys
from PDFNetPython import *

sys.path.append("../../LicenseKey/PYTHON")
from LicenseKey import *

#------------------------------------------------------------------------------
# PDFNet's Sanitizer is a security-focused feature that permanently removes
# hidden, sensitive, or potentially unsafe content from a PDF document.
# While redaction targets visible page content such as text or graphics,
# sanitization focuses on non-visual elements and embedded structures.
#
# PDFNet Sanitizer ensures hidden or inactive content is destroyed,
# not merely obscured or disabled. This prevents leakage of sensitive
# data such as authoring details, editing history, private identifiers,
# and residual form entries, and neutralizes scripts or attachments.
#
# Sanitization is recommended prior to external sharing with clients,
# partners, or regulatory bodies. It helps align with privacy policies
# and compliance requirements by permanently removing non-visual data.
#------------------------------------------------------------------------------

def main():
    # Relative paths to folders containing test files.
    input_path = "../../TestFiles/"
    output_path = "../../TestFiles/Output/"

    PDFNet.Initialize(LicenseKey)

    # The following example illustrates how to retrieve the existing
    # sanitizable content categories within a document.
    try:
        doc = PDFDoc(input_path + "numbered.pdf")
        doc.InitSecurityHandler()

        opts = Sanitizer.GetSanitizableContent(doc)
        if opts.GetMetadata():
            print("Document has metadata.")
        if opts.GetMarkups():
            print("Document has markups.")
        if opts.GetHiddenLayers():
            print("Document has hidden layers.")
        print("Done...")
    except Exception as e:
        print(e)

    # The following example illustrates how to sanitize a document with default options,
    # which will remove all sanitizable content present within a document.
    try:
        doc = PDFDoc(input_path + "financial.pdf")
        doc.InitSecurityHandler()

        Sanitizer.SanitizeDocument(doc, None)
        doc.Save(output_path + "financial_sanitized.pdf", SDFDoc.e_linearized)
        print("Done...")
    except Exception as e:
        print(e)

    # The following example illustrates how to sanitize a document with custom set options,
    # which will only remove the content categories specified by the options object.
    try:
        options = SanitizeOptions()
        options.SetMetadata(True)
        options.SetFormData(True)
        options.SetBookmarks(True)

        doc = PDFDoc(input_path + "form1.pdf")
        doc.InitSecurityHandler()

        Sanitizer.SanitizeDocument(doc, options)
        doc.Save(output_path + "form1_sanitized.pdf", SDFDoc.e_linearized)
        print("Done...")
    except Exception as e:
        print(e)

    PDFNet.Terminate()

if __name__ == '__main__':
    main()

PHP

<?php
//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2026 by Apryse Software Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------
if(file_exists("../../../PDFNetC/Lib/PDFNetPHP.php"))
include("../../../PDFNetC/Lib/PDFNetPHP.php");
include("../../LicenseKey/PHP/LicenseKey.php");

//------------------------------------------------------------------------------
// PDFNet's Sanitizer is a security-focused feature that permanently removes
// hidden, sensitive, or potentially unsafe content from a PDF document.
// While redaction targets visible page content such as text or graphics,
// sanitization focuses on non-visual elements and embedded structures.
//
// PDFNet Sanitizer ensures hidden or inactive content is destroyed,
// not merely obscured or disabled. This prevents leakage of sensitive
// data such as authoring details, editing history, private identifiers,
// and residual form entries, and neutralizes scripts or attachments.
//
// Sanitization is recommended prior to external sharing with clients,
// partners, or regulatory bodies. It helps align with privacy policies
// and compliance requirements by permanently removing non-visual data.
//------------------------------------------------------------------------------

	global $LicenseKey;
	PDFNet::Initialize($LicenseKey);
	PDFNet::GetSystemFontList();    // Wait for fonts to be loaded if they haven't already. This is done because PHP can run into errors when shutting down if font loading is still in progress.

	// Relative paths to folders containing test files.
	$input_path = getcwd()."/../../TestFiles/";
	$output_path = $input_path."Output/";

	// The following example illustrates how to retrieve the existing
	// sanitizable content categories within a document.
	try
	{
		$doc = new PDFDoc($input_path."numbered.pdf");
		$doc->InitSecurityHandler();

		$opts = Sanitizer::GetSanitizableContent($doc);
		if ($opts->GetMetadata())
		{
			echo(nl2br("Document has metadata.\n"));
		}
		if ($opts->GetMarkups())
		{
			echo(nl2br("Document has markups.\n"));
		}
		if ($opts->GetHiddenLayers())
		{
			echo(nl2br("Document has hidden layers.\n"));
		}
		echo(nl2br("Done...\n"));
	}
	catch(Exception $e)
	{
		echo(nl2br($e->getMessage()."\n"));
	}

	// The following example illustrates how to sanitize a document with default options,
	// which will remove all sanitizable content present within a document.
	try
	{
		$doc = new PDFDoc($input_path."financial.pdf");
		$doc->InitSecurityHandler();

		Sanitizer::SanitizeDocument($doc, null);
		$doc->Save($output_path."financial_sanitized.pdf", SDFDoc::e_linearized);
		echo(nl2br("Done...\n"));
	}
	catch(Exception $e)
	{
		echo(nl2br($e->getMessage()."\n"));
	}

	// The following example illustrates how to sanitize a document with custom set options,
	// which will only remove the content categories specified by the options object.
	try
	{
		$options = new SanitizeOptions();
		$options->SetMetadata(true);
		$options->SetFormData(true);
		$options->SetBookmarks(true);

		$doc = new PDFDoc($input_path."form1.pdf");
		$doc->InitSecurityHandler();

		Sanitizer::SanitizeDocument($doc, $options);
		$doc->Save($output_path."form1_sanitized.pdf", SDFDoc::e_linearized);
		echo(nl2br("Done...\n"));
	}
	catch(Exception $e)
	{
		echo(nl2br($e->getMessage()."\n"));
	}

	PDFNet::Terminate();
?>

Ruby

#---------------------------------------------------------------------------------------
# Copyright (c) 2001-2026 by Apryse Software Inc. All Rights Reserved.
# Consult legal.txt regarding legal and license information.
#---------------------------------------------------------------------------------------

require '../../../PDFNetC/Lib/PDFNetRuby'
include PDFNetRuby
require '../../LicenseKey/RUBY/LicenseKey'

$stdout.sync = true

#------------------------------------------------------------------------------
# PDFNet's Sanitizer is a security-focused feature that permanently removes
# hidden, sensitive, or potentially unsafe content from a PDF document.
# While redaction targets visible page content such as text or graphics,
# sanitization focuses on non-visual elements and embedded structures.
#
# PDFNet Sanitizer ensures hidden or inactive content is destroyed,
# not merely obscured or disabled. This prevents leakage of sensitive
# data such as authoring details, editing history, private identifiers,
# and residual form entries, and neutralizes scripts or attachments.
#
# Sanitization is recommended prior to external sharing with clients,
# partners, or regulatory bodies. It helps align with privacy policies
# and compliance requirements by permanently removing non-visual data.
#------------------------------------------------------------------------------

	# Relative paths to folders containing test files.
	input_path = "../../TestFiles/"
	output_path = "../../TestFiles/Output/"

	PDFNet.Initialize(PDFTronLicense.Key)

	# The following example illustrates how to retrieve the existing
	# sanitizable content categories within a document.
	begin
		doc = PDFDoc.new(input_path + "numbered.pdf")
		doc.InitSecurityHandler

		opts = Sanitizer.GetSanitizableContent(doc)
		if opts.GetMetadata
			puts "Document has metadata."
		end
		if opts.GetMarkups
			puts "Document has markups."
		end
		if opts.GetHiddenLayers
			puts "Document has hidden layers."
		end
		puts "Done..."
	rescue Exception => e
		puts e
	end

	# The following example illustrates how to sanitize a document with default options,
	# which will remove all sanitizable content present within a document.
	begin
		doc = PDFDoc.new(input_path + "financial.pdf")
		doc.InitSecurityHandler

		Sanitizer.SanitizeDocument(doc, nil)
		doc.Save(output_path + "financial_sanitized.pdf", SDFDoc::E_linearized)
		puts "Done..."
	rescue Exception => e
		puts e
	end

	# The following example illustrates how to sanitize a document with custom set options,
	# which will only remove the content categories specified by the options object.
	begin
		options = SanitizeOptions.new
		options.SetMetadata(true)
		options.SetFormData(true)
		options.SetBookmarks(true)

		doc = PDFDoc.new(input_path + "form1.pdf")
		doc.InitSecurityHandler

		Sanitizer.SanitizeDocument(doc, options)
		doc.Save(output_path + "form1_sanitized.pdf", SDFDoc::E_linearized)
		puts "Done..."
	rescue Exception => e
		puts e
	end

	PDFNet.Terminate

VB

'
' Copyright (c) 2001-2026 by Apryse Software Inc. All Rights Reserved.
'

Imports System
Imports System.Collections

Imports pdftron
Imports pdftron.Common
Imports pdftron.Filters
Imports pdftron.SDF
Imports pdftron.PDF

Module PDFSanitizeTestVB
    Dim pdfNetLoader As PDFNetLoader
    Sub New()
        pdfNetLoader = pdftron.PDFNetLoader.Instance()
    End Sub

    ' PDFNet's Sanitizer is a security-focused feature that permanently removes
    ' hidden, sensitive, or potentially unsafe content from a PDF document.
    ' While redaction targets visible page content such as text or graphics,
    ' sanitization focuses on non-visual elements and embedded structures.
    '
    ' PDFNet Sanitizer ensures hidden or inactive content is destroyed,
    ' not merely obscured or disabled. This prevents leakage of sensitive
    ' data such as authoring details, editing history, private identifiers,
    ' and residual form entries, and neutralizes scripts or attachments.
    '
    ' Sanitization is recommended prior to external sharing with clients,
    ' partners, or regulatory bodies. It helps align with privacy policies
    ' and compliance requirements by permanently removing non-visual data.
    Sub Main()
        PDFNet.Initialize(PDFTronLicense.Key)

        Dim input_path As String = "../../../../TestFiles/"
        Dim output_path As String = "../../../../TestFiles/Output/"

        ' The following example illustrates how to retrieve the existing
        ' sanitizable content categories within a document.
        Try
            Using doc As PDFDoc = New PDFDoc(input_path + "numbered.pdf")
                doc.InitSecurityHandler()
                Dim opts As SanitizeOptions = Sanitizer.GetSanitizableContent(doc)
                If opts.GetMetadata() Then
                    Console.WriteLine("Document has metadata.")
                End If
                If opts.GetMarkups() Then
                    Console.WriteLine("Document has markups.")
                End If
                If opts.GetHiddenLayers() Then
                    Console.WriteLine("Document has hidden layers.")
                End If
            End Using
            Console.WriteLine("Done...")
        Catch ex As PDFNetException
            Console.WriteLine(ex.Message)
        Catch ex As Exception
            MsgBox(ex.Message)
        End Try

        ' The following example illustrates how to sanitize a document with default options,
        ' which will remove all sanitizable content present within a document.
        Try
            Using doc As PDFDoc = New PDFDoc(input_path + "financial.pdf")
                doc.InitSecurityHandler()
                Sanitizer.SanitizeDocument(doc)
                doc.Save(output_path + "financial_sanitized.pdf", SDFDoc.SaveOptions.e_linearized)
            End Using
            Console.WriteLine("Done...")
        Catch ex As PDFNetException
            Console.WriteLine(ex.Message)
        Catch ex As Exception
            MsgBox(ex.Message)
        End Try

        ' The following example illustrates how to sanitize a document with custom set options,
        ' which will only remove the content categories specified by the options object.
        Try
            Dim options As SanitizeOptions = New SanitizeOptions()
            options.SetMetadata(True)
            options.SetFormData(True)
            options.SetBookmarks(True)

            Using doc As PDFDoc = New PDFDoc(input_path + "form1.pdf")
                doc.InitSecurityHandler()
                Sanitizer.SanitizeDocument(doc, options)
                doc.Save(output_path + "form1_sanitized.pdf", SDFDoc.SaveOptions.e_linearized)
            End Using
            Console.WriteLine("Done...")
        Catch ex As PDFNetException
            Console.WriteLine(ex.Message)
        Catch ex As Exception
            MsgBox(ex.Message)
        End Try

        PDFNet.Terminate()
    End Sub

End Module

Obj-C

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2026 by Apryse Software Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------

#import <OBJC/PDFNetOBJC.h>
#import <Foundation/Foundation.h>

//------------------------------------------------------------------------------
// PDFNet's Sanitizer is a security-focused feature that permanently removes
// hidden, sensitive, or potentially unsafe content from a PDF document.
// While redaction targets visible page content such as text or graphics,
// sanitization focuses on non-visual elements and embedded structures.
//
// PDFNet Sanitizer ensures hidden or inactive content is destroyed,
// not merely obscured or disabled. This prevents leakage of sensitive
// data such as authoring details, editing history, private identifiers,
// and residual form entries, and neutralizes scripts or attachments.
//
// Sanitization is recommended prior to external sharing with clients,
// partners, or regulatory bodies. It helps align with privacy policies
// and compliance requirements by permanently removing non-visual data.
//------------------------------------------------------------------------------

int main(int argc, char *argv[])
{
    @autoreleasepool {

        int ret = 0;

        [PTPDFNet Initialize: 0];


        // The following example illustrates how to retrieve the existing
        // sanitizable content categories within a document.
        @try
        {
            PTPDFDoc *doc = [[PTPDFDoc alloc] initWithFilepath: @"../../TestFiles/numbered.pdf"];
            [doc InitSecurityHandler];
            PTSanitizeOptions *opts = [PTSanitizer GetSanitizableContent: doc];

            if ([opts GetMetadata]) {
                NSLog(@"Document has metadata.");
            }
            if ([opts GetMarkups]) {
                NSLog(@"Document has markups.");
            }
            if ([opts GetHiddenLayers]) {
                NSLog(@"Document has hidden layers.");
            }
            NSLog(@"Done...");
        }
        @catch(NSException *e)
        {
            NSLog(@"%@", e.reason);
            ret = 1;
        }


	    // The following example illustrates how to sanitize a document with default options,
	    // which will remove all sanitizable content present within a document.
        @try
        {
            PTPDFDoc *doc = [[PTPDFDoc alloc] initWithFilepath: @"../../TestFiles/financial.pdf"];
            [doc InitSecurityHandler];

            [PTSanitizer SanitizeDocument: doc options: nil];
            [doc SaveToFile: @"../../TestFiles/Output/financial_sanitized.pdf" flags: e_ptlinearized ];
            NSLog(@"Done...");
        }
        @catch(NSException *e)
        {
            NSLog(@"%@", e.reason);
            ret = 1;
        }


	    // The following example illustrates how to sanitize a document with custom set options,
	    // which will only remove the content categories specified by the options object.
        @try
        {
            PTSanitizeOptions *opts = [[PTSanitizeOptions alloc] init];
            [opts SetMetadata: YES];
            [opts SetFormData: YES];
            [opts SetBookmarks: YES];

            PTPDFDoc *doc = [[PTPDFDoc alloc] initWithFilepath: @"../../TestFiles/form1.pdf"];
            [doc InitSecurityHandler];

            [PTSanitizer SanitizeDocument: doc options: opts];
            [doc SaveToFile: @"../../TestFiles/Output/form1_sanitized.pdf" flags: e_ptlinearized ];
            NSLog(@"Done...");
        }
        @catch(NSException *e)
        {
            NSLog(@"%@", e.reason);
            ret = 1;
        }

        [PTPDFNet Terminate: 0];
        return ret;
    }
}