Build a Node.js PDF library app with Apryse Server SDK

This guide shows how to build a simple Node.js PDF application that uses the Apryse Server SDK and PDFNet library to generate a PDF programmatically. You’ll set up a minimal project, install the SDK, and add the required code to create a blank PDF document. This example provides a practical foundation for building more advanced document‑generation workflows.

To get started, choose your preferred platform from the tabs below.

Windows

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.

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.

1. Set up your project

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

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

npm init -y

A successful output looks similar to:

Wrote to <project_directory>/package.json:

{
  "name": "<project_name>",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "type": "commonjs"
}

2. Add the Apryse SDK

Next, integrate the Apryse Server SDK into your Node.js 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:

npm i @pdftron/pdfnet-node

1. In Visual Studio Code, go to File > New Text File.
2. Paste this code into the text editor, update your license key, and save the file in the Documents\NewApryseProject directory as index.js:

console.log("Hello World from Node.js!");

// You may need to set up NODE_PATH environment variable to make this work
const { PDFNet } = require('@pdftron/pdfnet-node');

const main = async () => {
  const doc = await PDFNet.PDFDoc.create();
  const page = await doc.pageCreate();
  doc.pagePushBack(page);
  doc.save('output.pdf', PDFNet.SDFDoc.SaveOptions.e_linearized);
};

// Add your own license key as the second parameter, e.g. in place of 'YOUR_LICENSE_KEY'
PDFNet.runWithCleanup(main, 'YOUR_LICENSE_KEY')
  .catch((error)=> {
    console.log('Error: ' + JSON.stringify(error));
  })
  .then(()=> {
    PDFNet.shutdown();
  });

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.

3. Verify your output

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. Go to the Documents > NewApryseProject folder, and right-click to select Open in Terminal.
2. In the terminal, build and launch the application:

node index.js

A successful output looks similar to:

Hello World from Node.js!

PDFNet is running in demo mode.
PackageV2: base

1. Go to the Documents > NewApryseProject folder using the file manager.
2. Verify the blank output.pdf file was generated programmatically using the Apryse Server SDK:

NewApryseProject/
├── node_modules/
├── index.js
├── output.pdf
├── package.json
└── package-lock.json

Linux

Node.js

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.

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. Set up your project

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

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

npm init -y

A successful output looks similar to:

Wrote to <project_directory>/package.json:

{
  "name": "<project_name>",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "type": "commonjs"
}

2. Add the Apryse SDK

Next, integrate the Apryse Server SDK into your Node.js 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:

npm i @pdftron/pdfnet-node

1. In Visual Studio Code, go to File > New Text File.
2. Paste this code into the text editor, update your license key, and save the file in the Documents/NewApryseProject directory as index.js:

console.log("Hello World from Node.js!");

// You may need to set up NODE_PATH environment variable to make this work
const { PDFNet } = require('@pdftron/pdfnet-node'); 

const main = async () => {
  const doc = await PDFNet.PDFDoc.create();
  const page = await doc.pageCreate();
  doc.pagePushBack(page);
  doc.save('output.pdf', PDFNet.SDFDoc.SaveOptions.e_linearized);
};

// Add your own license key as the second parameter, e.g. in place of 'YOUR_LICENSE_KEY'
PDFNet.runWithCleanup(main, 'YOUR_LICENSE_KEY')
  .catch((error)=> {
    console.log('Error: ' + JSON.stringify(error));
  })
  .then(()=> {
    PDFNet.shutdown();
  });

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.

3. Verify your output

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. Go to the Documents > NewApryseProject folder, and right-click to select Open in Terminal.
2. In the terminal, build and launch the application:

node index.js

A successful output looks similar to:

Hello World from Node.js!

PDFNet is running in demo mode.
PackageV2: base

1. Go to the Documents > NewApryseProject folder using the file manager.
2. Verify the blank output.pdf file was generated programmatically using the Apryse Server SDK:

NewApryseProject/
├── node_modules/
├── index.js
├── output.pdf
├── package.json
└── package-lock.json

AWS Lambda Functions

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:

mkdir YOUR_FUNCTION_FOLDER
cd YOUR_FUNCTION_FOLDER
npm init -y
npm install @pdftron/pdfnet-node

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

# Declare the build argument
ARG NODE_VERSION=18

# Stage #1: Build the Lambda function deployment package
FROM public.ecr.aws/lambda/nodejs:$NODE_VERSION AS build-stage

# Set the working directory
WORKDIR /app

# Copy package.json and package-lock.json for caching dependencies
COPY package.json ./
COPY package-lock.json ./

# Install node dependencies for production
RUN npm ci --omit=dev

# Copy Lambda function code into the working directory
COPY index.js ./

# Stage #2: Package the Lambda function deployment package into a .zip file
FROM alpine

# Set the working directory
WORKDIR /app

# Install packaging dependencies and make output directory
RUN apk add --no-cache zip && \
    mkdir /output

# Copy Lambda function code file and node_modules from build stage into working directory
COPY --from=build-stage /app/index.js ./
COPY --from=build-stage /app/node_modules/ ./node_modules/

# Create a deployment package (a .zip file) that will be uploaded to AWS Lambda when the container is made
CMD ["zip", "-r", "/output/deploymentpackage.zip", "./"]

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.

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

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:

const { PDFNet } = require('@pdftron/pdfnet-node');
exports.handler = async (event) => {
  let response = null;
  if (event.httpMethod != 'POST') {
    response = {
      statusCode: 200,
      body: JSON.stringify('Hello, your AWS lambda function is working!'),
    };
  } else {
    const main = async () => {
      // parsing
      let body = JSON.parse(event.body);
      // your AWS lambda function goes here
      response = {
        statusCode: 200,
        body: JSON.stringify('your AWS lambda function response.'),
      };
    };
    await PDFNet.runWithCleanup(main, 'YOUR_PDFTRON_LICENSE_KEY_HERE').catch(
      function (error) {
        console.log('Error: ' + JSON.stringify(error));
        response = {
          statusCode: 500,
          body: JSON.stringify(error),
        };
      }
    );
  }
  return response;
};

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.

// This example shows how to create AWS Lambda functions using Apryse SDK.
// A REST API request was posted with base64 encoded data by the client.
// The request would be processed by the server and a response with base64 encoded data of OfficeToPDF output would be sent to the client.
const { PDFNet } = require('@pdftron/pdfnet-node');
exports.handler = async (event) => {
  let response = null;
  if (event.httpMethod != 'POST') {
    response = {
      statusCode: 200,
      body: JSON.stringify(
        'Hello, please send base64 doc to use this Lambda function!'
      ),
    };
  } else {
    const main = async () => {
      // parsing
      let body = JSON.parse(event.body);
      let base64str = body.file.data;
      let filename = body.file.filename;
      let base64_bytes = Buffer.from(base64str, 'base64');
      // save input doc to /tmp
      const outputPath = '/tmp/';
      const path = require('path');
      const inputFilename = path.parse(filename).name + '.docx';
      const fs = require('fs');
      fs.writeFileSync(outputPath + inputFilename, base64_bytes);
      // perform the conversion with no optional parameters
      const pdfdoc = await PDFNet.Convert.officeToPdfWithPath(
        outputPath + inputFilename
      );
      // save the result
      const outputFilename = path.parse(filename).name + '.pdf';
      await pdfdoc.save(
        outputPath + outputFilename,
        PDFNet.SDFDoc.SaveOptions.e_linearized
      );
      console.log('Saved ' + outputFilename);
      // sending data
      let buff = fs.readFileSync(outputPath + outputFilename);
      let base64_string = buff.toString('base64');
      response = {
        statusCode: 200,
        body: JSON.stringify(base64_string),
      };
    };
    await PDFNet.runWithCleanup(main, 'YOUR_PDFTRON_LICENSE_KEY_HERE').catch(
      function (error) {
        console.log('Error: ' + JSON.stringify(error));
        response = {
          statusCode: 500,
          body: JSON.stringify(error),
        };
      }
    );
  }
  return response;
};

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.

json_data = {
  "file": {
    "encoding": "base64",
    "data": base64_string_of_your_office_document,
    "filename": filename,
    "content-type": "application/pdf"
  }
}

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 AWSLambdaExample.py --url <YOUR PUBLISHED FUNCTION URL>

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 AWSLambdaExample.py --url <YOUR PUBLISHED FUNCTION URL> --filename <YOUR OFFICE FILENAME>

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!

macOS

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.

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. Set up your project

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

1. In your file manager, create a Documents > NewApryseProject folder.
2. Right-click the NewApryseProject folder and select New Terminal at Folder.
3. In your terminal, initialize a new Node.js project to generate a default package.json file:

npm init -y

A successful output looks similar to:

Wrote to <project_directory>/package.json:

{
  "name": "<project_name>",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "type": "commonjs"
}

2. Add the Apryse SDK

Next, integrate the Apryse Server SDK into your Node.js 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:

npm i @pdftron/pdfnet-node

1. In Visual Studio Code, go to File > New Text File.
2. Paste this code into the text editor, update your license key, and save the file in the Documents/NewApryseProject directory as index.js:

console.log("Hello World from Node.js!");

// You may need to set up NODE_PATH environment variable to make this work
const { PDFNet } = require('@pdftron/pdfnet-node');

const main = async () => {
  const doc = await PDFNet.PDFDoc.create();
  const page = await doc.pageCreate();
  doc.pagePushBack(page);
  doc.save('output.pdf', PDFNet.SDFDoc.SaveOptions.e_linearized);
};

// Add your own license key as the second parameter, e.g. in place of 'YOUR_LICENSE_KEY'
PDFNet.runWithCleanup(main, 'YOUR_LICENSE_KEY')
  .catch((error)=> {
    console.log('Error: ' + JSON.stringify(error));
  })
  .then(()=> {
    PDFNet.shutdown();
  });

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.

3. Verify your output

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. Go to the Documents > NewApryseProject folder, and right-click to select New Terminal at Folder.
2. In the terminal, build and launch the application:

node index.js

A successful output looks similar to:

Hello World from Node.js!

PDFNet is running in demo mode.
PackageV2: base

1. Go to the Documents > NewApryseProject folder using the file manager.
2. Verify the blank output.pdf file was generated programmatically using the Apryse Server SDK. The folder structure looks similar to:

NewApryseProject/
├── node_modules/
├── index.js
├── output.pdf
├── package.json
└── package-lock.json

Get started video

Get started with the Apryse Server SDK and Node.js on the Windows platform by watching this 4-minute video.

Get started video for Apryse Server SDK and Node.js on Windows

Next Steps

UsageGuidesSamplesAPI docs