PDF security API

This guide explains how to secure PDF documents with password protection and control user permissions for viewing, printing, copying, and editing.

PDF passwords

PDF files can be protected with passwords to control who can access, modify, and print the contents of a document.

PDFs are protected with two types of passwords: the owner password and the user password.

Owner password — This password enables the owner of a PDF file to modify the file and change its permissions. The owner can change the user password, as well as set or modify the user permissions that control what users can do with the file.
User password — This password enables a user to open a PDF file with a set of permissions defined by the owner of the file. These permissions control what the user can do with the file, such as view, print, copy, or modify the contents. The user password can be used to protect the PDF file from unauthorized access by preventing users from viewing or modifying the file without the password.

PDF permissions

Specify what users can do to a password-protected document with the user_permissions parameter. The value of this parameter is an array, where each element is one of the following:

annotations_and_forms enables users to add or modify text annotations and fill in interactive form fields.
assemble enables users to insert, rotate, or delete pages and create document outline items or thumbnail images.
extract enables users to copy or otherwise extract text and graphics from the document.
extract_accessibility enables users to copy or otherwise extract text and graphics from the document using accessibility options.
fill_forms enables users to fill in existing interactive form fields (including signature fields).
modification enables users to modify the document in any way not covered by the other permissions settings.
print_high_quality enables users to print the document in high quality.
printing enables users to print the document.

Disable document printing:

curl -X POST https://api.nutrient.io/build \
  -H "Authorization: Bearer your_api_key_here" \
  -o result.pdf \
  --fail \
  -F document=@document.pdf \
  -F instructions='{
      "parts": [
        {
          "file": "document"
        }
      ],
      "output": {
        "type": "pdf",
        "owner_password": "owner-password",
        "user_password": "user-password",
        "user_permissions": [
          "modification",
          "extract",
          "annotations_and_forms",
          "fill_forms",
          "extract_accessibility",
          "assemble"
        ]
      }
    }'

curl -X POST https://api.nutrient.io/build ^
  -H "Authorization: Bearer your_api_key_here" ^
  -o result.pdf ^
  --fail ^
  -F document=@document.pdf ^
  -F instructions="{\"parts\": [{\"file\": \"document\"}], \"output\": {\"type\": \"pdf\", \"owner_password\": \"owner-password\", \"user_password\": \"user-password\", \"user_permissions\": [\"modification\", \"extract\", \"annotations_and_forms\", \"fill_forms\", \"extract_accessibility\", \"assemble\"]}}"

package com.example.pspdfkit;

import java.io.File;
import java.io.IOException;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.StandardCopyOption;

import org.json.JSONArray;
import org.json.JSONObject;

import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

public final class PspdfkitApiExample {
  public static void main(final String[] args) throws IOException {
    final RequestBody body = new MultipartBody.Builder()
      .setType(MultipartBody.FORM)
      .addFormDataPart(
        "document",
        "document.pdf",
        RequestBody.create(
          MediaType.parse("application/pdf"),
          new File("document.pdf")
        )
      )
      .addFormDataPart(
        "instructions",
        new JSONObject()
          .put("parts", new JSONArray()
            .put(new JSONObject()
              .put("file", "document")
            )
          )
          .put("output", new JSONObject()
            .put("type", "pdf")
            .put("owner_password", "owner-password")
            .put("user_password", "user-password")
            .put("user_permissions", new JSONArray()
              .put("modification")
              .put("extract")
              .put("annotations_and_forms")
              .put("fill_forms")
              .put("extract_accessibility")
              .put("assemble")
            )
          ).toString()
      )
      .build();

    final Request request = new Request.Builder()
      .url("https://api.nutrient.io/build")
      .method("POST", body)
      .addHeader("Authorization", "Bearer your_api_key_here")
      .build();

    final OkHttpClient client = new OkHttpClient()
      .newBuilder()
      .build();

    final Response response = client.newCall(request).execute();

    if (response.isSuccessful()) {
      Files.copy(
        response.body().byteStream(),
        FileSystems.getDefault().getPath("result.pdf"),
        StandardCopyOption.REPLACE_EXISTING
      );
    } else {
      // Handle the error.
      throw new IOException(response.body().string());
    }
  }
}

using System;
using System.IO;
using System.Net;
using RestSharp;

namespace PspdfkitApiDemo
{
  class Program
  {
    static void Main(string[] args)
    {
      var client = new RestClient("https://api.nutrient.io/build");

      var request = new RestRequest(Method.POST)
        .AddHeader("Authorization", "Bearer your_api_key_here")
        .AddFile("document", "document.pdf")
        .AddParameter("instructions", new JsonObject
        {
          ["parts"] = new JsonArray
          {
            new JsonObject
            {
              ["file"] = "document"
            }
          },
          ["output"] = new JsonObject
          {
            ["type"] = "pdf",
            ["owner_password"] = "owner-password",
            ["user_password"] = "user-password",
            ["user_permissions"] = new JsonArray
            {
              "modification",
              "extract",
              "annotations_and_forms",
              "fill_forms",
              "extract_accessibility",
              "assemble"
            }
          }
        }.ToString());

      request.AdvancedResponseWriter = (responseStream, response) =>
      {
        if (response.StatusCode == HttpStatusCode.OK)
        {
          using (responseStream)
          {
            using var outputFileWriter = File.OpenWrite("result.pdf");
            responseStream.CopyTo(outputFileWriter);
          }
        }
        else
        {
          var responseStreamReader = new StreamReader(responseStream);
          Console.Write(responseStreamReader.ReadToEnd());
        }
      };

      client.Execute(request);
    }
  }
}

// This code requires Node.js. Do not run this code directly in a web browser.

const axios = require('axios')
const FormData = require('form-data')
const fs = require('fs')

const formData = new FormData()
formData.append('instructions', JSON.stringify({
  parts: [
    {
      file: "document"
    }
  ],
  output: {
    type: "pdf",
    owner_password: "owner-password",
    user_password: "user-password",
    user_permissions: [
      "modification",
      "extract",
      "annotations_and_forms",
      "fill_forms",
      "extract_accessibility",
      "assemble"
    ]
  }
}))
formData.append('document', fs.createReadStream('document.pdf'))

;(async () => {
  try {
    const response = await axios.post('https://api.nutrient.io/build', formData, {
      headers: formData.getHeaders({
        'Authorization': 'Bearer your_api_key_here'
      }),
      responseType: "stream"
    })

    response.data.pipe(fs.createWriteStream("result.pdf"))
  } catch (e) {
    const errorString = await streamToString(e.response.data)
    console.log(errorString)
  }
})()

function streamToString(stream) {
  const chunks = []
  return new Promise((resolve, reject) => {
    stream.on("data", (chunk) => chunks.push(Buffer.from(chunk)))
    stream.on("error", (err) => reject(err))
    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")))
  })
}

import requests
import json

response = requests.request(
  'POST',
  'https://api.nutrient.io/build',
  headers = {
    'Authorization': 'Bearer your_api_key_here'
  },
  files = {
    'document': open('document.pdf', 'rb')
  },
  data = {
    'instructions': json.dumps({
      'parts': [
        {
          'file': 'document'
        }
      ],
      'output': {
        'type': 'pdf',
        'owner_password': 'owner-password',
        'user_password': 'user-password',
        'user_permissions': [
          'modification',
          'extract',
          'annotations_and_forms',
          'fill_forms',
          'extract_accessibility',
          'assemble'
        ]
      }
    })
  },
  stream = True
)

if response.ok:
  with open('result.pdf', 'wb') as fd:
    for chunk in response.iter_content(chunk_size=8096):
      fd.write(chunk)
else:
  print(response.text)
  exit()

<?php

$FileHandle = fopen('result.pdf', 'w+');

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => 'https://api.nutrient.io/build',
  CURLOPT_CUSTOMREQUEST => 'POST',
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_POSTFIELDS => array(
    'instructions' => '{
      "parts": [
        {
          "file": "document"
        }
      ],
      "output": {
        "type": "pdf",
        "owner_password": "owner-password",
        "user_password": "user-password",
        "user_permissions": [
          "modification",
          "extract",
          "annotations_and_forms",
          "fill_forms",
          "extract_accessibility",
          "assemble"
        ]
      }
    }',
    'document' => new CURLFILE('document.pdf')
  ),
  CURLOPT_HTTPHEADER => array(
    'Authorization: Bearer your_api_key_here'
  ),
  CURLOPT_FILE => $FileHandle,
));

$response = curl_exec($curl);

curl_close($curl);

fclose($FileHandle);

POST https://api.nutrient.io/build HTTP/1.1
Content-Type: multipart/form-data; boundary=--customboundary
Authorization: Bearer your_api_key_here

--customboundary
Content-Disposition: form-data; name="instructions"
Content-Type: application/json

{
  "parts": [
    {
      "file": "document"
    }
  ],
  "output": {
    "type": "pdf",
    "owner_password": "owner-password",
    "user_password": "user-password",
    "user_permissions": [
      "modification",
      "extract",
      "annotations_and_forms",
      "fill_forms",
      "extract_accessibility",
      "assemble"
    ]
  }
}
--customboundary
Content-Disposition: form-data; name="document"; filename="document.pdf"
Content-Type: application/pdf

(document data)
--customboundary--

PDF security API

PDF passwords

PDF permissions

Was this helpful?

Help us improve

Thank you for your feedback!

Something went wrong. Please try again or let us know.