Convert to PDF/UA

Requirements

These packages are required to use these features in production. Trial keys have unlimited access to all features

Server SDKPackage: AccessibilityModule: Data ExtractionLive demo

Sample code for using Apryse SDK to programmatically convert generic PDF documents into ISO-compliant, VeraPDF-valid PDF/UA files. Supports PDF/UA-1. Sample code provided in Python, C++, C#, Java, Node.js (JavaScript), PHP, Ruby and VB.

Implementation steps

To convert to PDF/UA with Apryse Server SDK:

Step 1: Follow get started with Server SDK in your preferred language or framework Step 2: Download the Data Extraction Module Step 3: Add the sample code provided in this guide

To use this feature in production, your license key will need the Accessibility Package. Trial keys already include all packages.

Learn more about our Server SDK and PDF/UA Library.

C#

//
// Copyright (c) 2001-2024 by Apryse Software Inc. All Rights Reserved.
//

using System;
using pdftron;
using pdftron.SDF;
using pdftron.PDF;
using pdftron.PDF.PDFUA;

//---------------------------------------------------------------------------------------
// The following sample illustrates how to make sure a file meets the PDF/UA standard, using the PDFUAConformance class object.
// Note: this feature is currently experimental and subject to change
//
// DataExtractionModule is required (Mac users can use StructuredOutputModule instead)
// https://docs.apryse.com/documentation/core/info/modules/#data-extraction-module
// https://docs.apryse.com/documentation/core/info/modules/#structured-output-module (Mac)
//---------------------------------------------------------------------------------------
namespace PDFUATestCS
{
	class PDFUATest
	{
		private static pdftron.PDFNetLoader pdfNetLoader = pdftron.PDFNetLoader.Instance();
		static PDFUATest() {}
		
		// Relative path to the folder containing test files.
		static string input_path =  "../../../../TestFiles/";
		static string output_path = "../../../../TestFiles/Output/";

		// DataExtraction library location, replace if desired, should point to a folder that includes the contents of <DataExtractionModuleRoot>/Lib.
		// If using default, unzip the DataExtraction zip to the parent folder of Samples, and merge with existing "Lib" folder
		static string extraction_module_path = "../../../../../Lib/";


		/// <summary>
		/// The main entry point for the application.
		/// </summary>
		[STAThread]
		static void Main(string[] args)
		{
			try {
				PDFNet.Initialize(PDFTronLicense.Key);

				String input_file1 = input_path + "autotag_input.pdf";
				String input_file2 = input_path + "table.pdf";
				String output_file1 = output_path + "autotag_pdfua.pdf";
				String output_file2 = output_path + "table_pdfua_linearized.pdf";

				//-----------------------------------------------------------
				// Example: PDF/UA Conversion
				//-----------------------------------------------------------
				Console.WriteLine("AutoConverting...");

				PDFNet.AddResourceSearchPath(extraction_module_path);
				if(!DataExtractionModule.IsModuleAvailable(DataExtractionModule.DataExtractionEngine.e_doc_structure))
				{
					Console.Error.WriteLine("Unable to run PDFUATest: Apryse SDK Data Extraction module not available.");
					Console.Error.WriteLine("---------------------------------------------------------------");
					Console.Error.WriteLine("The Data Extraction module is an optional add-on, available for download");
					Console.Error.WriteLine("at https://apryse.com/. If you have already downloaded this");
					Console.Error.WriteLine("module, ensure that the SDK is able to find the required files");
					Console.Error.WriteLine("using the PDFNet::AddResourceSearchPath() function.");
					Console.Error.WriteLine("");
					return;
				}

				PDFUAConformance pdf_ua = new PDFUAConformance();

				Console.WriteLine("Simple Conversion...");
				{
					// Perform conversion using default options
					pdf_ua.AutoConvert(input_file1, output_file1);
				}

				Console.WriteLine("Converting With Options...");
				{
					PDFUAOptions pdf_ua_opts = new PDFUAOptions();
					pdf_ua_opts.SetSaveLinearized(true); // Linearize when saving output
					// Note: if file is password protected, you can use pdf_ua_opts.setPassword()

					// Perform conversion using the options we specify
					pdf_ua.AutoConvert(input_file2, output_file2, pdf_ua_opts);
				}

			}
			catch (pdftron.Common.PDFNetException e)
			{
				Console.Error.WriteLine(e.GetMessage());
				Environment.Exit(-1);
			}
			finally
			{
				PDFNet.Terminate();
				Console.WriteLine("PDFUAConformance test completed.");
			}
		}
	}
}

Go

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2024 by Apryse Software Inc. All Rights Reserved.
// Consult LICENSE.txt regarding 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")
}

//---------------------------------------------------------------------------------------
// The following sample illustrates how to make sure a file meets the PDF/UA standard, using the PDFUAConformance class object.
// Note: this feature is currently experimental and subject to change
//
// DataExtractionModule is required (Mac users can use StructuredOutputModule instead)
// https://docs.apryse.com/documentation/core/info/modules/#data-extraction-module
// https://docs.apryse.com/documentation/core/info/modules/#structured-output-module (Mac)
//---------------------------------------------------------------------------------------

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

func TestPDFUA(t *testing.T) {

	inputFile1 := inputPath + "autotag_input.pdf"
	inputFile2 := inputPath + "table.pdf"
	outputFile1 := outputPath + "autotag_pdfua.pdf"
	outputFile2 := outputPath + "table_pdfua_linearized.pdf"

	PDFNetInitialize(licenseKey)

	fmt.Println("AutoConverting...")

	PDFNetAddResourceSearchPath(modulePath)

	if !DataExtractionModuleIsModuleAvailable(DataExtractionModuleE_DocStructure) {
		fmt.Println("")
		fmt.Println("Unable to run Data Extraction: PDFTron SDK Structured Output module not available.")
		fmt.Println("-----------------------------------------------------------------------------")
		fmt.Println("The Data Extraction suite is an optional add-on, available for download")
		fmt.Println("at https://docs.apryse.com/documentation/core/info/modules/. If you have already")
		fmt.Println("downloaded this module, ensure that the SDK is able to find the required files")
		fmt.Println("using the PDFNetAddResourceSearchPath() function.")
		fmt.Println("")
		PDFNetTerminate()
		return
	}

	pdfua := NewPDFUAConformance()

	fmt.Println("Simple Conversion...")

	// Perform conversion using default options
	pdfua.AutoConvert(inputFile1, outputFile1)

	fmt.Println("Converting With Options...")

	pdfuaOpts := NewPDFUAOptions()
	pdfuaOpts.SetSaveLinearized(true) // Linearize when saving output
	// Note: if file is password protected, you can use pdfuaOpts.SetPassword()

	// Perform conversion using the options we specify
	pdfua.AutoConvert(inputFile2, outputFile2, pdfuaOpts)

	PDFNetTerminate()
	fmt.Println("PDFUAConformance test completed.")
}

Java

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

import com.pdftron.common.PDFNetException;
import com.pdftron.pdf.*;
import com.pdftron.pdf.pdfua.*;

//---------------------------------------------------------------------------------------
// The following sample illustrates how to make sure a file meets the PDF/UA standard, using the PDFUAConformance class object.
// Note: this feature is currently experimental and subject to change
//
// DataExtractionModule is required (Mac users can use StructuredOutputModule instead)
// https://docs.apryse.com/documentation/core/info/modules/#data-extraction-module
// https://docs.apryse.com/documentation/core/info/modules/#structured-output-module (Mac)
//---------------------------------------------------------------------------------------
public class PDFUATest {

    // Relative path to the folder containing test files.
    public static final String input_path = "../../TestFiles/";
    public static final String output_path = "../../TestFiles/Output/";

    // DataExtraction library location, replace if desired, should point to a folder that includes the contents of <DataExtractionModuleRoot>/Lib.
    // If using default, unzip the DataExtraction zip to the parent folder of Samples, and merge with existing "Lib" folder
    public static final String extraction_module_path = "../../../Lib/";

    public static void main(String[] args) {
        try {
            PDFNet.initialize(PDFTronLicense.Key());

            String input_file1 = input_path + "autotag_input.pdf";
            String input_file2 = input_path + "table.pdf";
            String output_file1 = output_path + "autotag_pdfua.pdf";
            String output_file2 = output_path + "table_pdfua_linearized.pdf";

            //-----------------------------------------------------------
            // Example: PDF/UA Conversion
            //-----------------------------------------------------------
            System.out.println("AutoConverting...");

            PDFNet.addResourceSearchPath(extraction_module_path);
            if(!DataExtractionModule.isModuleAvailable(DataExtractionModule.DataExtractionEngine.e_doc_structure))
            {
                System.out.println("Unable to run PDFUATest: Apryse SDK Data Extraction module not available.");
                System.out.println("---------------------------------------------------------------");
                System.out.println("The Data Extraction module is an optional add-on, available for download");
                System.out.println("at https://apryse.com/. If you have already downloaded this");
                System.out.println("module, ensure that the SDK is able to find the required files");
                System.out.println("using the PDFNet::AddResourceSearchPath() function.");
                System.out.println("");
                return;
            }

            PDFUAConformance pdf_ua = new PDFUAConformance();

            System.out.println("Simple Conversion...");
            {
                // Perform conversion using default options
                pdf_ua.autoConvert(input_file1, output_file1);
            }

            System.out.println("Converting With Options...");
            {
                PDFUAOptions pdf_ua_opts = new PDFUAOptions();
                pdf_ua_opts.setSaveLinearized(true); // Linearize when saving output
                // Note: if file is password protected, you can use pdf_ua_opts.setPassword()

                // Perform conversion using the options we specify
                pdf_ua.autoConvert(input_file2, output_file2, pdf_ua_opts);
            }

        } catch (PDFNetException e) {
            System.out.println(e.getMessage());
        } finally {
            PDFNet.terminate();
            System.out.println("PDFUAConformance test completed.");
        }
    }

}

C++

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2024 by Apryse Software Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------
#include <iostream>
#include <PDF/PDFNet.h>
#include <PDF/DataExtractionModule.h>
#include "../../LicenseKey/CPP/LicenseKey.h"
#include <PDF/PDFUA/PDFUAConformance.h>
#include <PDF/PDFUA/PDFUAOptions.h>
using namespace std;
using namespace pdftron;
using namespace pdftron::PDF;
using namespace pdftron::PDF::PDFUA;
//---------------------------------------------------------------------------------------
// The following sample illustrates how to make sure a file meets the PDF/UA standard, using the PDFUAConformance class object.
// Note: this feature is currently experimental and subject to change
//
// DataExtractionModule is required (Mac users can use StructuredOutputModule instead)
// https://docs.apryse.com/documentation/core/info/modules/#data-extraction-module
// https://docs.apryse.com/documentation/core/info/modules/#structured-output-module (Mac)
//---------------------------------------------------------------------------------------
int main(int argc, char *argv[])
{
	// Relative path to the folder containing test files.
	static UString input_path("../../TestFiles/");
	static UString output_path("../../TestFiles/Output/");
	// DataExtraction library location, replace if desired, should point to a folder that includes the contents of <DataExtractionModuleRoot>/Lib.
	// If using default, unzip the DataExtraction zip to the parent folder of Samples, and merge with existing "Lib" folder.
	static UString extraction_module_path("../../../Lib/");
	UString input_file1 = input_path + "autotag_input.pdf";
	UString input_file2 = input_path + "table.pdf";
	UString output_file1 = output_path + "autotag_pdfua.pdf";
	UString output_file2 = output_path + "table_pdfua_linearized.pdf";
	int ret = 0;
	try
	{
		PDFNet::Initialize(LicenseKey);
		cout << "AutoConverting..." << endl;
		PDFNet::AddResourceSearchPath(extraction_module_path);
		if (!DataExtractionModule::IsModuleAvailable(DataExtractionModule::e_DocStructure))
		{
			cout << endl;
			cout << "Unable to run PDFUATest: Apryse SDK Data Extraction module not available." << endl;
			cout << "---------------------------------------------------------------" << endl;
			cout << "The Data Extraction module is an optional add-on, available for download" << endl;
			cout << "at https://apryse.com/. If you have already downloaded this" << endl;
			cout << "module, ensure that the SDK is able to find the required files" << endl;
			cout << "using the PDFNet::AddResourceSearchPath() function." << endl << endl;
			return 1;
		}
		PDFUAConformance pdf_ua;
		cout << "Simple Conversion..." << endl;
		{
			// Perform conversion using default options
			pdf_ua.AutoConvert(input_file1, output_file1);
		}
		cout << "Converting With Options..." << endl;
		{
			PDFUAOptions pdf_ua_opts;
			pdf_ua_opts.SetSaveLinearized(true); // Linearize when saving output
			// Note: if file is password protected, you can use pdf_ua_opts.SetPassword()
			// Perform conversion using the options we specify
			pdf_ua.AutoConvert(input_file2, output_file2, pdf_ua_opts);
		}
	}
	catch (Common::Exception& e)
	{
		cout << e << endl;
		ret = 1;
	}
	catch (...) {
		cout << "Unknown Exception" << endl;
		ret = 1;
	}
	cout << "PDFUAConformance test completed." << endl;
	PDFNet::Terminate();
	return ret;
}

JavaScript

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2024 by Apryse Software Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------
const { PDFNet } = require('../../lib/pdfnet.js');
const PDFTronLicense = require('../../LicenseKey/NODEJS/LicenseKey');
((exports) => {
	'use strict';
	exports.runPDFUATest = () => {
		//---------------------------------------------------------------------------------------
		// The following sample illustrates how to make sure a file meets the PDF/UA standard, using the PDFUAConformance class object.
		// Note: this feature is currently experimental and subject to change
		//
		// DataExtractionModule is required (Mac users can use StructuredOutputModule instead)
		// https://docs.apryse.com/documentation/core/info/modules/#data-extraction-module
		// https://docs.apryse.com/documentation/core/info/modules/#structured-output-module (Mac)
		//---------------------------------------------------------------------------------------
		const main = async () => {
			// Relative path to the folder containing test files.
			const input_path = '../TestFiles/';
			const output_path = '../TestFiles/Output/';
			// DataExtraction library location, replace if desired, should point to a folder that includes the contents of <DataExtractionModuleRoot>/Lib.
			// If using default, unzip the DataExtraction zip to the parent folder of Samples, and merge with existing "Lib" folder
			const extraction_module_path = '../../lib/';
			const input_file1 = input_path + 'autotag_input.pdf';
			const input_file2 = input_path + 'table.pdf';
			const output_file1 = output_path + 'autotag_pdfua.pdf';
			const output_file2 = output_path + 'table_pdfua_linearized.pdf';
			try {
				//-----------------------------------------------------------
				// Example: PDF/UA Conversion
				//-----------------------------------------------------------
				console.log('AutoConverting...');
				await PDFNet.addResourceSearchPath(extraction_module_path);
				if (!await PDFNet.DataExtractionModule.isModuleAvailable(PDFNet.DataExtractionModule.DataExtractionEngine.e_DocStructure)) {
					console.log('');
					console.log('Unable to run PDFUATest: Apryse SDK Data Extraction module not available.');
					console.log('---------------------------------------------------------------');
					console.log('The Data Extraction module is an optional add-on, available for download');
					console.log('at https://apryse.com/. If you have already downloaded this');
					console.log('module, ensure that the SDK is able to find the required files');
					console.log('using the PDFNet.addResourceSearchPath() function.');
					console.log('');
					return;
				}
				const pdf_ua = await PDFNet.PDFUAConformance.create();
				console.log('Simple Conversion...');
				{
					// Perform conversion using default options
					await pdf_ua.autoConvert(input_file1, output_file1);
				}
				console.log('Converting With Options...');
				{
					const pdf_ua_opts = await PDFNet.PDFUAConformance.createPDFUAOptions();
					pdf_ua_opts.setSaveLinearized(true); // Linearize when saving output
					// Note: if file is password protected, you can use pdf_ua_opts.setPassword()
					// Perform conversion using the options we specify
					await pdf_ua.autoConvert(input_file2, output_file2, pdf_ua_opts);
				}
			} catch (err) {
				console.log(err);
			}
			console.log('PDFUAConformance test completed.');
		}
		PDFNet.runWithCleanup(main, PDFTronLicense.Key).catch(function (error) {
			console.log('Error: ' + JSON.stringify(error));
		}).then(function () { return PDFNet.shutdown(); });
	};
	exports.runPDFUATest();
})(exports);
// eslint-disable-next-line spaced-comment
//# sourceURL=PDFUATest.js

PHP

<?php
//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2024 by Apryse Software Inc. All Rights Reserved.
// Consult LICENSE.txt regarding license information.
//---------------------------------------------------------------------------------------
if(file_exists("../../../PDFNetC/Lib/PDFNetPHP.php"))
include("../../../PDFNetC/Lib/PDFNetPHP.php");
include("../../LicenseKey/PHP/LicenseKey.php");
//---------------------------------------------------------------------------------------
// The following sample illustrates how to make sure a file meets the PDF/UA standard, using the PDFUAConformance class object.
// Note: this feature is currently experimental and subject to change
//
// DataExtractionModule is required (Mac users can use StructuredOutputModule instead)
// https://docs.apryse.com/documentation/core/info/modules/#data-extraction-module
// https://docs.apryse.com/documentation/core/info/modules/#structured-output-module (Mac)
//---------------------------------------------------------------------------------------
function main()
{
	// Relative path to the folder containing the test files.
	$input_path = "../../TestFiles/";
	$output_path = "../../TestFiles/Output/";
	// DataExtraction library location, replace if desired, should point to a folder that includes the contents of <DataExtractionModuleRoot>/Lib.
	// If using default, unzip the DataExtraction zip to the parent folder of Samples, and merge with existing "Lib" folder.
	$extraction_module_path = "../../../PDFNetC/Lib/";
	$input_file1 = $input_path."autotag_input.pdf";
	$input_file2 = $input_path."table.pdf";
	$output_file1 = $output_path."autotag_pdfua.pdf";
	$output_file2 = $output_path."table_pdfua_linearized.pdf";
	global $LicenseKey;
	PDFNet::Initialize($LicenseKey);
	PDFNet::GetSystemFontList();
	echo(nl2br("AutoConverting...\n"));
	PDFNet::AddResourceSearchPath($extraction_module_path);
	if (!DataExtractionModule::IsModuleAvailable(DataExtractionModule::e_DocStructure)) {
		echo(nl2br("\n"));
		echo(nl2br("Unable to run Data Extraction: PDFTron SDK Structured Output module not available.\n"));
		echo(nl2br("-----------------------------------------------------------------------------\n"));
		echo(nl2br("The Data Extraction suite is an optional add-on, available for download\n"));
		echo(nl2br("at https://docs.apryse.com/documentation/core/info/modules/. If you have already\n"));
		echo(nl2br("downloaded this module, ensure that the SDK is able to find the required files\n"));
		echo(nl2br("using the PDFNet::AddResourceSearchPath() function.\n"));
		echo(nl2br("\n"));
		PDFNet::Terminate();
		return;
	}
	try {
		$pdf_ua = new PDFUAConformance();
		echo(nl2br("Simple Conversion...\n"));
		// Perform conversion using default options
		$pdf_ua->AutoConvert($input_file1, $output_file1);
		echo(nl2br("Converting With Options...\n"));
		$pdf_ua_opts = new PDFUAOptions();
		$pdf_ua_opts->SetSaveLinearized(true); // Linearize when saving output
		// Note: if file is password protected, you can use $pdf_ua_opts->SetPassword()
		// Perform conversion using the options we specify
		$pdf_ua->AutoConvert($input_file2, $output_file2, $pdf_ua_opts);
	}
	catch(Exception $e) {
		echo(nl2br($e->getMessage()));
	}
	PDFNet::Terminate();
	echo(nl2br("PDFUAConformance test completed.\n"));
}
main();
?>

Python

#---------------------------------------------------------------------------------------
# Copyright (c) 2001-2024 by Apryse Software Inc. All Rights Reserved.
# Consult LICENSE.txt regarding license information.
#---------------------------------------------------------------------------------------
import site
site.addsitedir("../../../PDFNetC/Lib")
import sys
from PDFNetPython import *
sys.path.append("../../LicenseKey/PYTHON")
from LicenseKey import *
#---------------------------------------------------------------------------------------
# The following sample illustrates how to make sure a file meets the PDF/UA standard, using the PDFUAConformance class object.
# Note: this feature is currently experimental and subject to change
#
# DataExtractionModule is required (Mac users can use StructuredOutputModule instead)
# https://docs.apryse.com/documentation/core/info/modules/#data-extraction-module
# https://docs.apryse.com/documentation/core/info/modules/#structured-output-module (Mac)
#---------------------------------------------------------------------------------------
# Relative path to the folder containing the test files.
input_path = "../../TestFiles/"
output_path = "../../TestFiles/Output/"
# DataExtraction library location, replace if desired, should point to a folder that includes the contents of <DataExtractionModuleRoot>/Lib.
# If using default, unzip the DataExtraction zip to the parent folder of Samples, and merge with existing "Lib" folder.
extraction_module_path = "../../../PDFNetC/Lib/"
def main():
    input_file1 = input_path + "autotag_input.pdf"
    input_file2 = input_path + "table.pdf"
    output_file1 = output_path + "autotag_pdfua.pdf"
    output_file2 = output_path + "table_pdfua_linearized.pdf"
    PDFNet.Initialize(LicenseKey)
    print("AutoConverting...")
    PDFNet.AddResourceSearchPath(extraction_module_path)
    if not DataExtractionModule.IsModuleAvailable(DataExtractionModule.e_DocStructure):
        print("")
        print("Unable to run Data Extraction: PDFTron SDK Structured Output module not available.")
        print("-----------------------------------------------------------------------------")
        print("The Data Extraction suite is an optional add-on, available for download")
        print("at https://docs.apryse.com/documentation/core/info/modules/. If you have already")
        print("downloaded this module, ensure that the SDK is able to find the required files")
        print("using the PDFNet.AddResourceSearchPath() function.")
        print("")
        PDFNet.Terminate()
        return
    try:
        pdf_ua = PDFUAConformance()
        print("Simple Conversion...")
        # Perform conversion using default options
        pdf_ua.AutoConvert(input_file1, output_file1)
        print("Converting With Options...")
        pdf_ua_opts = PDFUAOptions()
        pdf_ua_opts.SetSaveLinearized(True)  # Linearize when saving output
        # Note: if file is password protected, you can use pdf_ua_opts.SetPassword()
        # Perform conversion using the options we specify
        pdf_ua.AutoConvert(input_file2, output_file2, pdf_ua_opts)
    except Exception as e:
        print(str(e))
    PDFNet.Terminate()
    print("PDFUAConformance test completed.")
if __name__ == '__main__':
    main()

Ruby

#---------------------------------------------------------------------------------------
# Copyright (c) 2001-2024 by Apryse Software Inc. All Rights Reserved.
# Consult LICENSE.txt regarding license information.
#---------------------------------------------------------------------------------------
require '../../../PDFNetC/Lib/PDFNetRuby'
include PDFNetRuby
require '../../LicenseKey/RUBY/LicenseKey'
$stdout.sync = true
#---------------------------------------------------------------------------------------
# The following sample illustrates how to make sure a file meets the PDF/UA standard, using the PDFUAConformance class object.
# Note: this feature is currently experimental and subject to change
#
# DataExtractionModule is required (Mac users can use StructuredOutputModule instead)
# https://docs.apryse.com/documentation/core/info/modules/#data-extraction-module
# https://docs.apryse.com/documentation/core/info/modules/#structured-output-module (Mac)
#---------------------------------------------------------------------------------------
# Relative path to the folder containing the test files.
$input_path = "../../TestFiles/"
$output_path = "../../TestFiles/Output/"
# DataExtraction library location, replace if desired, should point to a folder that includes the contents of <DataExtractionModuleRoot>/Lib.
# If using default, unzip the DataExtraction zip to the parent folder of Samples, and merge with existing "Lib" folder.
$extraction_module_path = "../../../PDFNetC/Lib/"
def main()
	input_file1 = $input_path + "autotag_input.pdf"
	input_file2 = $input_path + "table.pdf"
	output_file1 = $output_path + "autotag_pdfua.pdf"
	output_file2 = $output_path + "table_pdfua_linearized.pdf"
	PDFNet.Initialize(PDFTronLicense.Key)
	puts "AutoConverting..."
	PDFNet.AddResourceSearchPath($extraction_module_path)
	if !DataExtractionModule.IsModuleAvailable(DataExtractionModule::E_DocStructure) then
		puts ""
		puts "Unable to run Data Extraction: PDFTron SDK Structured Output module not available."
		puts "-----------------------------------------------------------------------------"
		puts "The Data Extraction suite is an optional add-on, available for download"
		puts "at https://docs.apryse.com/documentation/core/info/modules/. If you have already"
		puts "downloaded this module, ensure that the SDK is able to find the required files"
		puts "using the PDFNet.AddResourceSearchPath() function."
		puts ""
		PDFNet.Terminate
		return
	end
	begin
		pdf_ua = PDFUAConformance.new()
		puts "Simple Conversion..."
		# Perform conversion using default options
		pdf_ua.AutoConvert(input_file1, output_file1)
		puts "Converting With Options..."
		pdf_ua_opts = PDFUAOptions.new()
		pdf_ua_opts.SetSaveLinearized(true) # Linearize when saving output
		# Note: if file is password protected, you can use pdf_ua_opts.SetPassword()
		# Perform conversion using the options we specify
		pdf_ua.AutoConvert(input_file2, output_file2, pdf_ua_opts)
	rescue => error
		puts error.message
	end
	PDFNet.Terminate
	puts "PDFUAConformance test completed."
end
main()

VB

'---------------------------------------------------------------------------------------
' Copyright (c) 2001-2024 by Apryse Software Inc. All Rights Reserved.
' Consult legal.txt regarding legal and license information.     
'---------------------------------------------------------------------------------------
Imports System

Imports pdftron
Imports pdftron.PDF
Imports PDFTRON.PDF.PDFUA

'//---------------------------------------------------------------------------------------
'// The following sample illustrates how to make sure a file meets the PDF/UA standard, using the PDFUAConformance class object.
'// Note: this feature is currently experimental and subject to change
'//
'// DataExtractionModule is required (Mac users can use StructuredOutputModule instead)
'// https://docs.apryse.com/documentation/core/info/modules/#data-extraction-module
'// https://docs.apryse.com/documentation/core/info/modules/#structured-output-module (Mac)
'//---------------------------------------------------------------------------------------

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

    '// Relative path to the folder containing test files.
    Dim input_path As String =  "../../../../TestFiles/"
    Dim output_path As String = "../../../../TestFiles/Output/"

    '// DataExtraction library location, replace if desired, should point to a folder that includes the contents of <DataExtractionModuleRoot>/Lib.
    '// If using default, unzip the DataExtraction zip to the parent folder of Samples, and merge with existing "Lib" folder
    Dim extraction_module_path As String = "../../../../../Lib/"

    ' The main entry point for the application.
    Sub Main()

        PDFNet.Initialize(PDFTronLicense.Key)

        Try
            Dim input_file1 As String = input_path + "autotag_input.pdf"
            Dim input_file2 As String = input_path + "table.pdf"
            Dim output_file1 As String = output_path + "autotag_pdfua.pdf"
            Dim output_file2 As String = output_path + "table_pdfua_linearized.pdf"

            '//-----------------------------------------------------------
            '// Example: PDF/UA Conversion
            '//-----------------------------------------------------------
            Console.WriteLine("AutoConverting...")

            PDFNet.AddResourceSearchPath(extraction_module_path)
            If Not DataExtractionModule.IsModuleAvailable(DataExtractionModule.DataExtractionEngine.e_doc_structure) Then
                Console.WriteLine("Unable to run PDFUATest: Apryse SDK Data Extraction module not available.")
                Console.WriteLine("---------------------------------------------------------------")
                Console.WriteLine("The Data Extraction module is an optional add-on, available for download")
                Console.WriteLine("at https://apryse.com/. If you have already downloaded this")
                Console.WriteLine("module, ensure that the SDK is able to find the required files")
                Console.WriteLine("using the PDFNet::AddResourceSearchPath() function.")
                Console.WriteLine()
                Return
            End If

            Dim pdf_ua As PDFUAConformance = New PDFUAConformance()

            Console.WriteLine("Simple Conversion...")

            '// Perform conversion using default options
            pdf_ua.AutoConvert(input_file1, output_file1)


            Console.WriteLine("Converting With Options...")

            Dim pdf_ua_opts As PDFUAOptions = New PDFUAOptions()
            pdf_ua_opts.SetSaveLinearized(True) '// Linearize When saving output
            '// Note: if file is password protected, you can use pdf_ua_opts.setPassword()

            '// Perform conversion using the options we specify
            pdf_ua.AutoConvert(input_file2, output_file2, pdf_ua_opts)
        Catch e As PDFTRON.Common.PDFNetException
            Console.WriteLine(e.Message)
        End Try

        PDFNet.Terminate()
        Console.WriteLine("PDFUAConformance test completed.")
    End Sub

End Module