Get started with the Apryse Server SDK Node.js PDF library integration

In this guide, you'll explore sample PDFNet projects to understand the types of PDF outputs you can create with the Apryse Server SDK. You'll also create a simple Node.js application, add the Apryse Server SDK, and learn how to generate files programmatically.

Node.jsAWS Lambda Functions

Prerequisites

Before you start:

• Install Visual Studio Code or another code editor to develop and debug your code.
• Install Node.js and npm for your runtime environment. Use the latest active LTS version of Node.js within the supported range (Node.js 10.x–24.x).
• Get your Apryse trial key.

License Key

Apryse collects some data regarding your usage of the SDK for product improvement.

The data that Apryse collects include:

• The names and number of API calls
• The number of pages in a document
• The version of the SDK
• The language of the SDK

For clarity, no other data is collected by the SDK and Apryse has no access to the contents of your documents.

If you wish to continue without data collection, contact us and we will email you a no-tracking trial key for you to get started.

Run Apryse SDK in production.

A commercial license key is required for use in a production environment. Contact sales to purchase a commercial license key.

Keep your commercial license key confidential.

License keys are uniquely generated and strictly confidential. Don't publish or store them in any public location, including public GitHub repositories.

1. Convert DOCX to PDF

In this section, you’ll use the OfficeToPDFTest sample to convert a DOCX file to PDF using the Microsoft Office conversion API. You can use this sample to understand how document conversion works and as a reference for your own implementations.

Info

Apryse Node.js libraries include native binaries. During installation, the correct distribution for your system is installed automatically.

1. Open your Linux terminal and install the Apryse Node.js PDF library:

Bash

1npm i @pdftron/pdfnet-node

Report Invalid Code

Copy

For Alpine Linux, include a target platform specifier to install the correct binaries:

Bash

1npm i @pdftron/pdfnet-node --target_platform=alpine

Report Invalid Code

Copy

Info

If your OS or Node.js version isn't supported, the installation will fail.

2. Install the pdfnet-node-samples library, which contains a collection of sample projects:

Bash

1npm i @pdftron/pdfnet-node-samples

Report Invalid Code

Copy

3. To add your license key, navigate to this file and double-click to open:

Text

1/Home/node_modules/@pdftron/pdfnet-node-samples/LicenseKey/LicenseKey.js

Report Invalid Code

Copy

4. Go to the const LicenseKey = ‘YOUR_PDFTRON_LICENSE_KEY’; line and replace the quoted text with your trial license key. Don't change any other information in this file. Save your changes.

JavaScript

LicenseKey.js

1// Add your trial license key here
2const LicenseKey = 'YOUR_PDFTRON_LICENSE_KEY';
3
4if(LicenseKey == 'YOUR_PDFTRON_LICENSE_KEY'){
5    throw ('Please enter your license key by replacing \'YOUR_PDFTRON_LICENSE_KEY\' that is assigned to the LicenseKey variable in Samples/LicenseKey/LicenseKey.js. If you do not have a license key, please go to https://www.pdftron.com/pws/get-key to obtain a demo license or https://www.pdftron.com/form/contact-sales to obtain a production key.');
6}
7
8exports.Key = LicenseKey;

Report Invalid Code

Copy

5. Navigate to this location, right-click, and select Open in Terminal:

Text

1/Home/node_modules/@pdftron/pdfnet-node-samples/OfficeToPDFTest

Report Invalid Code

Copy

6. In the terminal, add this command to run the sample:

Bash

1node OfficeToPDFTest.js

Report Invalid Code

Copy

When you run the node OfficeToPDFTest.js command, the sample loads a Microsoft Office document, converts it to PDF, saves the PDF, and outputs the following status messages to the console. For more details, review the OfficeToPDF sample code and the Convert MS Office (Word, Excel, PowerPoint) to PDF overview.

Bash

1PDFNet is running in demo mode.
2PackageV2: base
3PackageV2: office_conversion
4Saved Fishermen.pdf
5Saved the_rime_of_the_ancient_mariner.pdf
6Saved factsheet_Arabic.pdf
7Done.

Report Invalid Code

Copy

7. Go to this directory to verify that the output PDF files are present:

Text

1/Home/node_modules/@pdftron/pdfnet-node-samples/TestFiles/Output

Report Invalid Code

Copy

The folder structure looks similar to:

Text

1pdfnet-node-samples/TestFiles/Output/
2├── factsheet_Arabic.pdf
3├── Fishermen.pdf
4├── the_rime_of_the_ancient_mariner.pdf

Report Invalid Code

Copy

8. Open the PDF files to see the converted output. The original DOCX files are located in the pdfnet-node-samples/Samples/TestFiles folder.

Converted PDF file showing the output generated from a DOCX document

2. Create a Node.js PDF app

Create a simple Node.js application that uses the Apryse Server SDK and PDFNet library to generate a PDF programmatically. In this section, you’ll set up a minimal project, add the required code, and run a script that creates a blank PDF document. This example provides a practical foundation for building more advanced document‑generation workflows.

Set up your project

Set up your project by creating a folder and preparing your workspace for the application.

1. Go to your Documents folder and create a new NewApryseProject folder.
2. Right-click the NewApryseProject folder and select Open in Terminal.
3. In the terminal, initialize a new Node.js project and create a default package.json file:

Bash

1npm init -y

Report Invalid Code

Copy

A successful output looks similar to:

Bash

1Wrote to <project_directory>/package.json:
2
3{
4  "name": "<project_name>",
5  "version": "1.0.0",
6  "description": "",
7  "main": "index.js",
8  "scripts": {
9    "test": "echo \"Error: no test specified\" && exit 1"
10  },
11  "keywords": [],
12  "author": "",
13  "license": "ISC",
14  "type": "commonjs"
15}
16

Report Invalid Code

Copy

Add the SDK to your app

Next, integrate the Apryse Server SDK into your .NET application and add the code needed to generate a PDF.

1. Navigate to the Documents/NewApryseProject directory in your terminal, then install the Apryse SDK:

Bash

1npm i @pdftron/pdfnet-node

Report Invalid Code

Copy

2. In Visual Studio Code, go to File > New Text File.

3. Paste this code into the text editor, update your license key, and save the file in the Documents/NewApryseProject directory as index.js:

JavaScript

index.js

1console.log("Hello World from Node.js!");
2
3const { PDFNet } = require('@pdftron/pdfnet-node'); // you may need to set up NODE_PATH environment variable to make this work.
4
5const main = async () => {
6  const doc = await PDFNet.PDFDoc.create();
7  const page = await doc.pageCreate();
8  doc.pagePushBack(page);
9  doc.save('output.pdf', PDFNet.SDFDoc.SaveOptions.e_linearized);
10};
11
12// Add your own license key as the second parameter, e.g. in place of 'YOUR_LICENSE_KEY'.
13PDFNet.runWithCleanup(main, 'YOUR_LICENSE_KEY')
14  .catch((error)=> {
15    console.log('Error: ' + JSON.stringify(error));
16  })
17  .then(()=> {
18    PDFNet.shutdown();
19  });

Report Invalid Code

Copy

Info

If you're signed in with an Apryse account, your license key is automatically prepopulated in all code snippets.

With this code, you can:

• Log a startup message to confirm the application is running.
• Import the Apryse Node.js SDK.
• Define an asynchronous main function that creates a new PDF document, adds a blank page, and saves it as a linearized PDF.
• Use runWithCleanup to initialize the SDK, execute the main function, and handle cleanup automatically.
• Handle errors and shut down the PDFNet engine after execution to release resources.

Run and verify your setup

Finally, build and run your application to confirm that the Apryse Server SDK is working correctly. After the application runs successfully, it will generate a blank PDF file locally.

1. Navigate to the Documents > NewApryseProject folder, and right-click to select Open in Terminal.
2. In the terminal, build and launch the application:

Bash

1node index.js

Report Invalid Code

Copy

A successful output looks similar to:

Bash

1Hello World from Node.js!
2
3PDFNet is running in demo mode.
4PackageV2: base

Report Invalid Code

Copy

3. Navigate to the Documents > NewApryseProject folder.

4. Verify the blank output.pdf file was generated programmatically using the Apryse Server SDK:

Text

1NewApryseProject/
2├── node_modules/
3├── index.js
4├── output.pdf
5├── package.json
6└── package-lock.json

Report Invalid Code

Copy

Now that you've successfully run an OfficeToPDFTest sample and integrated the Apryse Server SDK Node.js PDF library into your application, you can try out 50+ samples depending on your needs.

You can try over fifty samples for Apryse Server SDK.

To try additional samples, go to section 1. Convert DOCX to PDF, then choose another sample to run.

Prerequisites

• A version of Node.js supported by AWS Lambda (up to v24)
• An active AWS account
• Docker (optional)

Initial Setup

In this particular guide, we will demonstrate how to set up an AWS Lambda function to use the Apryse SDK with Node.js.

First, you will have to prepare a deployment package with the pdfnet-node module and your Lambda function code (typically named index.js) within it. From the command line:

sh

1mkdir YOUR_FUNCTION_FOLDER
2cd YOUR_FUNCTION_FOLDER
3npm init -y
4npm install @pdftron/pdfnet-node

Report Invalid Code

Copy

Now, copy your lambda function code to YOUR_FUNCTION_FOLDER.

It's at this point that it is important to note that the pdfnet-node module must be installed using the same operating system that AWS Lambda will use for its runtime. This is dependent on on the version of Node.js you are using. To see which operating system is required, look here.

We recommend that you use a Docker container to simulate this runtime and have included a Dockerfile to do just that. Create a Dockerfile with the contents below.

Dockerfile

Dockerfile

1# Declare the build argument
2ARG NODE_VERSION=18
3
4# Stage #1: Build the Lambda function deployment package
5FROM public.ecr.aws/lambda/nodejs:$NODE_VERSION AS build-stage
6
7# Set the working directory
8WORKDIR /app
9
10# Copy package.json and package-lock.json for caching dependencies
11COPY package.json ./
12COPY package-lock.json ./
13
14# Install node dependencies for production
15RUN npm ci --omit=dev
16
17# Copy Lambda function code into the working directory
18COPY index.js ./
19
20# Stage #2: Package the Lambda function deployment package into a .zip file
21FROM alpine
22
23# Set the working directory
24WORKDIR /app
25
26# Install packaging dependencies and make output directory
27RUN apk add --no-cache zip && \
28    mkdir /output
29
30# Copy Lambda function code file and node_modules from build stage into working directory
31COPY --from=build-stage /app/index.js ./
32COPY --from=build-stage /app/node_modules/ ./node_modules/
33
34# Create a deployment package (a .zip file) that will be uploaded to AWS Lambda when the container is made
35CMD ["zip", "-r", "/output/deploymentpackage.zip", "./"]

Report Invalid Code

Copy

Next, run the following docker commands to generate a deployment package to upload to AWS Lambda. Replace YOUR_IMAGE_NAME_HERE with the image name of your choice, as well as YOUR_NODE_VERSION_HERE as the Node version of your choice. YOUR_NODE_VERSION_HERE as the Node version of your choice. Note that this Dockerfile requires that your AWS Lambda function code file be named index.js, and that it uses your project's package.json and package-lock.json to install dependencies such as the pdfnet-node module you installed in the last step.

sh

1docker build -t YOUR_IMAGE_NAME_HERE --build-arg NODE_VERSION=YOUR_NODE_IMAGE_HERE .
2docker run --rm -v $(pwd)/output:/output YOUR_IMAGE_NAME_HERE

Report Invalid Code

Copy

After running this Docker container, you should have your deployment package within the ./output directory and can now upload it to AWS Lambda.

Second, create a Lambda function in your AWS account and upload the deployment package:

• Lambda > Functions > Create function > Author from scratch > Function name [YOUR_FUNCTION_NAME] > Runtime (matching your Node version) > choose Create Function
• Upload from .zip file > Upload [your deployment package] > Save
• Add trigger > API Gateway > Create an API > REST > Security [Open]
• Configuration > General configuration > Edit > memory [Choose 10240MB]

Integrate Into Your Application

Once you have followed the initial setup instructions, you can begin calling Apryse SDK APIs in your Lambda function code. For example:

JavaScript

1const { PDFNet } = require('@pdftron/pdfnet-node');
2exports.handler = async (event) => {
3  let response = null;
4  if (event.httpMethod != 'POST') {
5    response = {
6      statusCode: 200,
7      body: JSON.stringify('Hello, your AWS lambda function is working!'),
8    };
9  } else {
10    const main = async () => {
11      // parsing
12      let body = JSON.parse(event.body);
13      // your AWS lambda function goes here
14      response = {
15        statusCode: 200,
16        body: JSON.stringify('your AWS lambda function response.'),
17      };
18    };
19    await PDFNet.runWithCleanup(main, 'YOUR_PDFTRON_LICENSE_KEY_HERE').catch(
20      function (error) {
21        console.log('Error: ' + JSON.stringify(error));
22        response = {
23          statusCode: 500,
24          body: JSON.stringify(error),
25        };
26      }
27    );
28  }
29  return response;
30};

Report Invalid Code

Copy

Run Sample Code

You can update the Node.js script of your AWS Lambda function with the following code or download the source code from our GitHub repository. This snippet shows how to process a request sent from a client, convert an office document to a PDF, and send the output to client.

JavaScript

1// This example shows how to create AWS Lambda functions using Apryse SDK.
2// A REST API request was posted with base64 encoded data by the client.
3// The request would be processed by the server and a response with base64 encoded data of OfficeToPDF output would be sent to the client.
4const { PDFNet } = require('@pdftron/pdfnet-node');
5exports.handler = async (event) => {
6  let response = null;
7  if (event.httpMethod != 'POST') {
8    response = {
9      statusCode: 200,
10      body: JSON.stringify(
11        'Hello, please send base64 doc to use this Lambda function!'
12      ),
13    };
14  } else {
15    const main = async () => {
16      // parsing
17      let body = JSON.parse(event.body);
18      let base64str = body.file.data;
19      let filename = body.file.filename;
20      let base64_bytes = Buffer.from(base64str, 'base64');
21      // save input doc to /tmp
22      const outputPath = '/tmp/';
23      const path = require('path');
24      const inputFilename = path.parse(filename).name + '.docx';
25      const fs = require('fs');
26      fs.writeFileSync(outputPath + inputFilename, base64_bytes);
27      // perform the conversion with no optional parameters
28      const pdfdoc = await PDFNet.Convert.officeToPdfWithPath(
29        outputPath + inputFilename
30      );
31      // save the result
32      const outputFilename = path.parse(filename).name + '.pdf';
33      await pdfdoc.save(
34        outputPath + outputFilename,
35        PDFNet.SDFDoc.SaveOptions.e_linearized
36      );
37      console.log('Saved ' + outputFilename);
38      // sending data
39      let buff = fs.readFileSync(outputPath + outputFilename);
40      let base64_string = buff.toString('base64');
41      response = {
42        statusCode: 200,
43        body: JSON.stringify(base64_string),
44      };
45    };
46    await PDFNet.runWithCleanup(main, 'YOUR_PDFTRON_LICENSE_KEY_HERE').catch(
47      function (error) {
48        console.log('Error: ' + JSON.stringify(error));
49        response = {
50          statusCode: 500,
51          body: JSON.stringify(error),
52        };
53      }
54    );
55  }
56  return response;
57};

Report Invalid Code

Copy

Testing

After you have uploaded your deployment package to AWS Lambda and set its API endpoint in Configuration > Triggers, you can now do a simple test using a REST API.

In order to use the function to convert an office document to PDF, the client needs to POST a REST API request to the server. The request must include JSON data structured as in the code below.

Python

1json_data = {
2  "file": {
3    "encoding": "base64",
4    "data": base64_string_of_your_office_document,
5    "filename": filename,
6    "content-type": "application/pdf"
7  }
8}

Report Invalid Code

Copy

Upon receiving a client's request, a response will be sent back to the client including the base64 encoded PDF output using the same JSON structure. All the client needs to do now is decode the encoded data into a PDF. That's it!
Please review the sample python code. After cloning the repository and installing necessary packages, please refer to /client/README.txt for detailed instructions. Navigate to the client folder, run the following command, see the response to client's request in the console, and check the output in the output folder:

Python

1python AWSLambdaExample.py --url <YOUR PUBLISHED FUNCTION URL>

Report Invalid Code

Copy

The client will send a REST API request to convert /input/simple-word_2007.docx to a PDF and the server will send back the encoded data, which will then be saved as PDF in the output folder.

You can experiment with your own office document by putting it inside input folder:

Python

1python AWSLambdaExample.py --url <YOUR PUBLISHED FUNCTION URL> --filename <YOUR OFFICE FILENAME>

Report Invalid Code

Copy

In this article, we have shown how to set up an AWS Lambda function using the Apryse SDK. You can now experiment making your own functions, URLs, and can fully utilize the Apryse SDK using AWS Lambda. If your have any questions, please don't hesitate to contact us!

You'll get started with our samples to see the output you can create when you integrate the Apryse Server SDK into your Node.js projects. You'll also create a project and integrate the Server SDK into your Node.js projects, using the macOS platform.

Before you start:

• Install Visual Studio Code (or your preferred application) to write, edit, and debug source code.
• Install Node.js and npm on macOS to use as your runtime environment and package manager. We recommend using the latest Active LTS version of Node.js.
• Get your Apryse trial key.

In this section, you can download and run the OfficeToPDFTest PDFNet sample module, which demonstrates the SDK's document-conversion capabilities. Upon successful completion, you can convert a DOCX document to a PDF file while leveraging the MS Office-to-PDF conversion API. You can use this module as a reference implementation when integrating similar document-conversion functionality into your own applications. By running the sample, you can quickly:

• Verify the capabilities.
• Understand how to interact with the MS Office to Conversion PDF API.
• Use it as a reference for integrating similar functionality into your own application.

1. Open your macOS terminal and enter the following and press Enter to install the Apryse Node.js PDF library for macOS (for these steps we're installing to this location, but you can install the library to your project directory):

1npm i @pdftron/pdfnet-node

The packages are added:

Install the Node.js PDF library.

2. Enter the following and press Enter to install the pdfnet-node-samples (they are not included in the pdfnet-node package above and must be downloaded separately):

1npm i @pdftron/pdfnet-node-samples

The samples are installed:

Install the pdfnet-node-samples.

At the terminal, type exit and press Enter.

Before running the sample, you need to add your license key to the LicenseKey.cs file.

3. Navigate to: home/node_modules/@pdftron/pdfnet-node-samples/LicenseKey.js, right-click and select Open With > Visual Studio Code to open.

Open the LicenseKey.js file.

4. Scroll down to the line containing const LicenseKey = ‘YOUR_PDFTRON_LICENSE_KEY’; and replace the words in quotes with the copy of your trial license key you generated when you completed the Prerequisites instructions above. Do not change any other information in this file. Save your changes and close the file.

Add your license key.

5. Navigate to: home/node_modules/@pdftron/pdfnet-node-samples/OfficeToPDFTest, right-click, and select New Terminal at Folder. The macOS terminal opens.

Open the OfficeToPDFTest sample.

6. From the project directory, in the terminal, enter the following and press Enter to run the sample:

1node OfficeToPDFTest.js

The sample runs:

Run the OfficeToPDFTest sample.

When you run the node OfficeToPDFTest.js command, the sample code loads an Office document, converts the Office document to PDF, saves the resulting PDF, and outputs status messages to the console. For more details, you can look at additional OfficeToPDF sample code and the Convert MS Office (Word, Excel, PowerPoint) to PDF overview.

Once the sample has finished running, you will see Done in the terminal.

7. In the terminal, type exit, press Enter, and close the terminal window.

8. Navigate to: home/node_modules/@pdftron/pdfnet-node-samples/TestFiles/Output. You will see three output PDF files (Fishermen.pdf, the_rime_of_the_ancient_mariner.pdf, and the factsheet_Arabic.pdf):

Navigate to the Output folder.

9. Open the PDF files to see the converted output. You have successfully run the OfficeToPDFTest conversion sample!

Open the PDF files to view the converted output.

This section provides steps to create a simple Node.js project that uses the Apryse SDK and the PDFNet library to programmatically generate a blank PDF document. With these steps, you can learn how to set up your environment, import the required libraries, and run a script that produces a valid PDF file—all without manual intervention. This example provides a practical foundation for more advanced document‑generation workflows.

1. Navigate to the Documents folder and create a New Folder.
2. Enter the folder name, NewApryseProject.
3. Right-click on the NewApryseProject folder and select NewTerminal at Folder.
4. From the project directory, in the terminal, enter the following and press Enter to initialize a new Node.js project and create a package.json file with default values.

1npm init -y

A new package.json file is created:

Create a new Node.js project.

5. In the terminal, type exit, press Enter, and close the window.

1. Open Visual Studio Code, select File >Open Folder.. . Navigate to Documents > NewApryseProject and click Open.

Open Node.js folder.

2. From the File menu, select NewTextFile and name it index.js.

3. Copy the following code and paste it into the index.js file to create a blank PDF page.

1console.log("Hello World from Node.js!");
2
3const { PDFNet } = require('@pdftron/pdfnet-node'); // you may need to set up NODE_PATH environment variable to make this work.
4
5const main = async () => {
6  const doc = await PDFNet.PDFDoc.create();
7  const page = await doc.pageCreate();
8  doc.pagePushBack(page);
9  doc.save('blank.pdf', PDFNet.SDFDoc.SaveOptions.e_linearized);
10};
11
12// add your own license key as the second parameter, e.g. in place of 'YOUR_LICENSE_KEY.
13PDFNet.runWithCleanup(main, 'YOUR_LICENSE_KEY')
14  .catch((error)=> {
15    console.log('Error: ' + JSON.stringify(error));
16  })
17  .then(()=> {
18    PDFNet.shutdown();
19  });

Keep in mind the following about the code above:

• The system logs a startup message.
• The program imports the Node.js SDK.
• The script defines an async main function that builds the PDF.
• The PDFNet engine runs with cleanup and license initialization.
• The program logs any errors.
• The script releases PDFNet resources and shuts down the engine.

4. Scroll down to the line containing PDFNet.runWithCleanup(main, ‘YOUR_PDFTRON_LICENSE_KEY’) and replace the words in quotes with the copy of your trial license key.

Add your trial license key.

5. Save your changes and close the file.

6. You have successfully added the Apryse Server SDK to your Node.js project!

1. Navigate to the Documents folder. Select the NewApryseProject folder, right-click and select NewTerminal at Folder.
2. From the project directory, in the terminal, enter the following, then press Enter:

1node index.js

The sample code executes, creates a blank PDF page, and displays the message, “Hello World!”

The sample code runs.

3. Exit out of the terminal and navigate to the Documents > NewApryseProject folder.

4. Open the blank.pdf which you created by integrating the Apryse Server SDK!

Now that you have successfully run an OfficeToPDFTest sample and integrated the Apryse Server SDK Node.js PDF Library into your application, you can try out 50+ samples depending on your needs.

Try out additional samples.

5. To try additional samples, go to section 1. Run a sample > step5 above and choose another sample to run.