---
title: "How to add digital signatures to PDFs using React"
canonical_url: "https://www.nutrient.io/blog/how-to-add-digital-signature-to-pdf-using-react/"
md_url: "https://www.nutrient.io/blog/how-to-add-digital-signature-to-pdf-using-react.md"
last_updated: "2026-07-17T07:40:20.771Z"
description: "Learn how to add digital signatures to PDFs using React and Nutrient Web SDK (formerly PSPDFKit for Web), including certificate generation, PKCS#7 signing, and client-side workflows."
---

**TL;DR**

Use Nutrient Web SDK to add digital signatures to PDFs in your React app. This tutorial covers setting up a React project with Vite, integrating the Nutrient React PDF viewer, generating a self-signed certificate and private key, and applying a PKCS#7 digital signature to a PDF in the browser. [Start a free trial](https://www.nutrient.io/try/) or [launch the demo](https://www.nutrient.io/demo/).

## Nutrient React digital signature library

Nutrient supports creating and validating digital signatures with hand-drawn, scanned, or typed options. Signatures can be stored locally or remotely, and workflows can trigger based on signature actions. The UI is customizable, and client-side signing works without a dedicated server. The library also handles forms, annotations, and other PDF operations.

## Signature support

Nutrient offers two types of signatures: electronic signatures and digital signatures.

1. [Electronic signatures](https://www.nutrient.io/sdk/solutions/signing/) let users create signatures with ink drawings, bitmap images, or text. The [Electronic Signatures](https://www.nutrient.io/sdk/electronic-signatures/) component supports draw, image, and type modes, and it stores signatures for reuse.

2. [Digital signatures](https://www.nutrient.io/guides/web/signatures/digital-signatures/overview.md) use certificates to prove a document’s origin and detect unauthorized changes. Both signature types can be used together.

## Nutrient’s React PDF library

We offer a commercial [React.js PDF viewer library](https://www.nutrient.io/guides/web/viewer.md) that integrates into web applications. It includes 30+ features for viewing, annotating, editing, and signing documents in the browser. The UI can be extended or simplified based on your needs.

- A prebuilt UI

- 15+ annotation tools for document collaboration

- Client-side [PDF](https://www.nutrient.io/guides/web.md), MS Office, and image viewing

- Engineering support for integration

## Why use Nutrient for React PDF digital signatures?

There are a few ways to add digital signatures to PDFs in a React application:

- **Roll your own signing flow** with low-level crypto libraries and a basic PDF renderer.

- **Call a server-side signing service** you build yourself on top of libraries like OpenSSL.

- **Embed a complete React PDF signing component** that handles viewing, form fields, certificates, and validation end to end.

Nutrient takes the third approach. Instead of wiring up a PDF renderer, form fields, certificate handling, and PKCS#7 signing manually, you embed a React PDF viewer with built-in signing. This provides:

- A React PDF viewer with annotations, forms, and a signing UI.

- Client-side signing using X.509 certificates and PKCS#7, keeping documents in the browser.

- Support for electronic signatures (drawn, typed, and image) and digital signatures (certificate-backed).

- A path to advanced scenarios like CAdES-style signatures and long-term validation as requirements grow.

## Requirements

You need:

- [Node.js](https://nodejs.org/en/) (latest version).

- A package manager compatible with npm. The examples below use [Yarn](https://yarnpkg.com/) and [npm](https://docs.npmjs.com/cli/v7/commands/npm) (installed with Node.js by default).

## Creating a new React project with Vite

1. Create a new React app using [Vite](https://vite.dev/):

   ```txt

   yarn create vite nutrient-react-example --template react
   ```

   ```txt

   npm create vite@latest nutrient-react-example -- --template react
   ```

2. Change to the created project directory `cd nutrient-react-example`.

## Adding Nutrient to your project

1. Add the Nutrient dependency:

   ```txt

   yarn add @nutrient-sdk/viewer
   ```

   ```txt

   npm install @nutrient-sdk/viewer
   ```

2. Self-hosting assets (recommended) — Copy the Nutrient library assets to your `public` folder:

```bash

cp -R node_modules/@nutrient-sdk/viewer/dist/nutrient-viewer-lib public/

```

By default, the SDK loads assets from the Nutrient CDN when no `baseUrl` is provided. For production use or offline scenarios, self-hosting is recommended. See the [self-hosting](https://www.nutrient.io/guides/web/self-host-assets.md) guide for more details.

## Displaying a PDF

1. Add the PDF document you want to display to the `public` directory. You can use our [demo document](https://www.nutrient.io/example.pdf) as an example.

2. Update `src/index.css` to ensure the viewer displays correctly. Remove or modify the default Vite styles:

   ```css

   :root {
     font-family: system-ui, Avenir, Helvetica, Arial, sans-serif;
     line-height: 1.5;
     font-weight: 400;
   }

   body {
     margin: 0;
     min-width: 320px;
     min-height: 100vh;
   }

   #root {

     width: 100%;
     height: 100vh;
   }
   ```

3. Add a component wrapper for the Nutrient library and save it as `components/PdfViewerComponent.jsx`:

   ```js

   import { useEffect, useRef } from 'react';

     export default function PdfViewerComponent(props) {
         const containerRef = useRef(null);

         useEffect(() => {
             const container = containerRef.current;
             let NutrientViewer = null;

             (async () => {
                 NutrientViewer = (await import('@nutrient-sdk/viewer')).default;

                 NutrientViewer.unload(container); // Ensure there's only one Nutrient instance.

                 if (container && NutrientViewer) {
                     await NutrientViewer.load({
                         container,
                         document: props.document,
                         // Required when self-hosting assets.
                         baseUrl: `${window.location.protocol}//${window.location.host}/`,
                     });
                 }
             })();

             return () => {
                 if (NutrientViewer) {
                     NutrientViewer.unload(container);
                 }
             };
         }, [props.document]);

         return (
             <div
                 ref={containerRef}
                 style={{ width: '100%', height: '100vh' }}
             />
         );
     }
   ```

   Note: If using the CDN (not self-hosting), you can omit the `baseUrl` option.

4. Include the newly created component in `App.jsx`:

   ```js

   // src/App.jsx

   import PdfViewerComponent from "./components/PdfViewerComponent";

   function App() {
     return (
       <div className="App" style={{ width: "100vw" }}>
         <div className="PDF-viewer">
           <PdfViewerComponent document={"document.pdf"} />
         </div>
       </div>
     );
   }

   export default App;
   ```

5. Your project structure should now look like this:

   ```

   nutrient-react-example
   ├── public
   │   ├── document.pdf
   │   └── nutrient-viewer-lib/   # Only if self-hosting

   ├── src
   │   ├── components
   │   |   └── PdfViewerComponent.jsx
   |   └── App.jsx
   ├── package.json
   └── yarn.lock
   ```

6. Start the app and run it in your default browser:

   ```txt

   yarn dev
   ```

   ```txt

   npm run dev
   ```

## Adding a digital signature to a PDF using Nutrient

Nutrient requires an [X.509 certificate](https://en.wikipedia.org/wiki/X.509) and a private key pair for adding a digital signature to a PDF document. To do this, follow the steps in the next section.

### Step 1: Generating a self-signed certificate and private key

Generate a self-signed certificate and private key using [OpenSSL](https://www.openssl.org/):

1. Open your terminal in the project directory.

2. Run the following OpenSSL command to generate a self-signed certificate and private key:

```bash

openssl req -x509 -sha256 -nodes -newkey rsa:2048 -keyout private-key.pem -out cert.pem

```

- `-x509` — Tells OpenSSL to create a self-signed certificate.

- `-sha256` — Specifies the hash function to use for the certificate.

- `-nodes` — Prevents encryption of the private key. You can remove this option for production keys if encryption is desired.

- `-newkey rsa:2048` — Generates a new RSA private key with a key size of 2,048 bits.

- `-keyout private-key.pem` — Specifies the name of the private key file.

- `-out cert.pem` — Specifies the name of the certificate file.

Follow the prompts to provide information for the certificate, such as the Common Name (CN), organization, and location. These details will be embedded in the certificate.

### Step 2: Verifying your certificate

After generating the certificate and private key, you can verify if the certificate is correctly PEM-encoded using the following command:

```bash

openssl x509 -noout -text -in public/cert.pem

```

This command will display certificate details and shouldn’t produce any errors. It confirms that `cert.pem` is a PEM-encoded X.509 certificate.

Store these files securely. Never commit private keys to version control.

For more information on adding a digital signature to a PDF using Nutrient, refer to our [digital signatures](https://www.nutrient.io/guides/web/signatures/digital-signatures/signature-lifecycle/sign-a-pdf-document.md) guide.

## Signing a PDF document using Nutrient

To add a digital signature to your PDF document using Nutrient, follow the steps below.

### Step 1: Installing the Forge library

Install the [Forge](https://www.npmjs.com/package/node-forge) library using npm. Open your terminal, navigate to the project directory, and run the following command:

```bash

yarn add node-forge

```

```bash

npm install node-forge

```

### Step 2: Importing dependencies

Update the imports in your `PdfViewerComponent.jsx` file to include the Forge library and the `useCallback` hook:

```jsx

import { useEffect, useRef, useCallback } from "react";
import forge from "node-forge";

```

### Step 3: Generating the PKCS#7 signature

Nutrient utilizes the cryptographic Distinguished Encoding Rules (DER) [PKCS#7](https://www.ietf.org/rfc/rfc2315.html) format for digital signatures. You’ll need to create a valid PKCS#7 signature containing your certificate and other relevant information.

Define a function, `generatePKCS7`, to generate the digital signature for your PDF. This function will perform the necessary cryptographic operations:

```jsx

export default function PdfViewerComponent(props) {
  const containerRef = useRef(null);

  const generatePKCS7 = useCallback(({ fileContents }) => {
    const certificatePromise = fetch("cert.pem").then((response) =>
      response.text(),
    );
    const privateKeyPromise = fetch("private-key.pem").then((response) =>
      response.text(),
    );
    return new Promise((resolve, reject) => {
      Promise.all([certificatePromise, privateKeyPromise]).then(([certificatePem, privateKeyPem]) => {
          const certificate = forge.pki.certificateFromPem(certificatePem);
          const privateKey = forge.pki.privateKeyFromPem(privateKeyPem);

          const p7 = forge.pkcs7.createSignedData();
          p7.content = new forge.util.ByteBuffer(fileContents);
          p7.addCertificate(certificate);
          p7.addSigner({
            key: privateKey,
            certificate,
            digestAlgorithm: forge.pki.oids.sha256,
            authenticatedAttributes: [
              {
                type: forge.pki.oids.contentType,
                value: forge.pki.oids.data,
              },
              {
                type: forge.pki.oids.messageDigest,
              },
              {
                type: forge.pki.oids.signingTime,
                value: new Date(),
              },
            ],
          });

          p7.sign({ detached: true });
          const result = stringToArrayBuffer(
            forge.asn1.toDer(p7.toAsn1()).getBytes(),
          );
          resolve(result);
        }).catch(reject);
    });
  }, []);

  // Rest of the component...
}

```

This function fetches your certificate and private key, and then it uses Forge to create a PKCS#7 signed data structure.

### Step 4: Converting a string to an array buffer

You’ll need a utility function, `stringToArrayBuffer`, to convert a binary string into an `ArrayBuffer`. Add this function inside your component:

```jsx

function stringToArrayBuffer(binaryString) {
  const buffer = new ArrayBuffer(binaryString.length);
  let bufferView = new Uint8Array(buffer);
  for (let i = 0, len = binaryString.length; i < len; i++) {
    bufferView[i] = binaryString.charCodeAt(i);
  }
  return buffer;
}

```

### Step 5: Initializing Nutrient and signing the document

Now you can initialize Nutrient and invoke the [`signDocument`](https://www.nutrient.io/api/web/NutrientViewer.Instance.html#signDocument) method. This method takes two arguments:

- **Argument 1** — An object to fine-tune the signing process by providing data such as certificates and private keys. If you don’t have specific signing requirements, pass `null`.

- **Argument 2** — A callback function that Nutrient calls with an object containing `fileContents` (an `ArrayBuffer` of the document’s content). Your callback must return a promise that resolves to the PKCS#7 signature as an `ArrayBuffer`.

```jsx

useEffect(() => {
  const container = containerRef.current;
  let NutrientViewer = null;

  (async () => {
    try {
      NutrientViewer = (await import("@nutrient-sdk/viewer")).default;

      NutrientViewer.unload(container); // Ensure there's only one Nutrient instance.

      const instance = await NutrientViewer.load({
        container,
        document: props.document,
        baseUrl: `${window.location.protocol}//${window.location.host}/`,
      });

      console.log("PDF loaded successfully.");

      // Only attempt signing if `enableSigning prop` is `true`.
      if (props.enableSigning) {
        try {
          await instance.signDocument(null, generatePKCS7);
          console.log("Document signed.");
        } catch (signError) {
          console.warn("Could not sign document:", signError.message);
        }
      }
    } catch (error) {
      console.error("Failed to load PDF:", error);
    }
  })();

  return () => {
    if (NutrientViewer) {
      NutrientViewer.unload(container);
    }
  };
}, [generatePKCS7, props.document, props.enableSigning]);

```

On success, the console logs “PDF loaded successfully.” followed by “Document signed.” Errors are logged if loading or signing fails.

### Step 6: Enabling digital signing in App.jsx

Update `src/App.jsx` to enable signing by passing the `enableSigning` prop:

```jsx

import PdfViewerComponent from "./components/PdfViewerComponent";

function App() {
  return (
    <div className="App" style={{ width: "100vw" }}>
      <div className="PDF-viewer">
        <PdfViewerComponent document={"document.pdf"} enableSigning={true} />
      </div>
    </div>
  );
}

export default App;

```

### Complete PdfViewerComponent code

Here’s the complete code for the `PdfViewerComponent`:

```jsx

import { useEffect, useRef, useCallback } from "react";
import forge from "node-forge";

export default function PdfViewerComponent(props) {
  const containerRef = useRef(null);

  const generatePKCS7 = useCallback(({ fileContents }) => {
    const certificatePromise = fetch("cert.pem").then((response) =>
      response.text(),
    );
    const privateKeyPromise = fetch("private-key.pem").then((response) =>
      response.text(),
    );
    return new Promise((resolve, reject) => {
      Promise.all([certificatePromise, privateKeyPromise]).then(([certificatePem, privateKeyPem]) => {
          const certificate = forge.pki.certificateFromPem(certificatePem);
          const privateKey = forge.pki.privateKeyFromPem(privateKeyPem);

          const p7 = forge.pkcs7.createSignedData();
          p7.content = new forge.util.ByteBuffer(fileContents);
          p7.addCertificate(certificate);
          p7.addSigner({
            key: privateKey,
            certificate,
            digestAlgorithm: forge.pki.oids.sha256,
            authenticatedAttributes: [
              {
                type: forge.pki.oids.contentType,
                value: forge.pki.oids.data,
              },
              {
                type: forge.pki.oids.messageDigest,
              },
              {
                type: forge.pki.oids.signingTime,
                value: new Date(),
              },
            ],
          });

          p7.sign({ detached: true });
          const result = stringToArrayBuffer(
            forge.asn1.toDer(p7.toAsn1()).getBytes(),
          );
          resolve(result);
        }).catch(reject);
    });
  }, []);

  function stringToArrayBuffer(binaryString) {
    const buffer = new ArrayBuffer(binaryString.length);
    let bufferView = new Uint8Array(buffer);
    for (let i = 0, len = binaryString.length; i < len; i++) {
      bufferView[i] = binaryString.charCodeAt(i);
    }
    return buffer;
  }

  useEffect(() => {
    const container = containerRef.current;
    let NutrientViewer = null;

    (async () => {
      try {
        NutrientViewer = (await import("@nutrient-sdk/viewer")).default;

        NutrientViewer.unload(container); // Ensure there's only one Nutrient instance.

        const instance = await NutrientViewer.load({
          container,
          document: props.document,
          baseUrl: `${window.location.protocol}//${window.location.host}/`,
        });

        console.log("PDF loaded successfully.");

        // Only attempt signing if `enableSigning` prop is `true`.
        if (props.enableSigning) {
          try {
            await instance.signDocument(null, generatePKCS7);
            console.log("Document signed.");
          } catch (signError) {
            console.warn("Could not sign document:", signError.message);
          }
        }
      } catch (error) {
        console.error("Failed to load PDF:", error);
      }
    })();

    return () => {
      if (NutrientViewer) {
        NutrientViewer.unload(container);
      }
    };
  }, [generatePKCS7, props.document, props.enableSigning]);

  return <div ref={containerRef} style={{ width: "100%", height: "100vh" }} />;
}

```

### Final project structure

Your project structure should now look like this:

```

nutrient-react-example
├── public
│   ├── cert.pem
│   ├── document.pdf
│   ├── nutrient-viewer-lib/
│   └── private-key.pem
├── src
│   ├── components
│   │   └── PdfViewerComponent.jsx
│   ├── App.jsx
│   └── index.css
├── package.json
└── yarn.lock

```

After building, the signing process runs automatically when `enableSigning={true}` and the document reloads with the digital signature.

> We recently added support for [CAdES](https://en.wikipedia.org/wiki/CAdES_\(computing\)) signatures, which are advanced digital signatures. To learn more about CAdES signatures, refer to our [digital signatures](https://www.nutrient.io/guides/web/signatures/digital-signatures/signature-lifecycle/sign-a-pdf-document.md) guide.

## Conclusion

This tutorial covered adding digital signatures to PDF documents using React and Nutrient Web SDK — from project setup to certificate generation and PKCS#7 signing in the browser. To test this in your own project, request a [free trial](https://www.nutrient.io/try/) or visit the [demo page](https://www.nutrient.io/demo/).

## FAQ

#### How do I add a digital signature to a PDF in React?

Embed Nutrient Web SDK’s React PDF viewer, provide an X.509 certificate and private key, and use the SDK’s signing API to apply a PKCS#7 signature. This tutorial covers Vite setup, viewer integration, certificate generation with OpenSSL, and signing from a React component.

#### What’s the difference between electronic and digital signatures in Nutrient?

Electronic signatures include drawn, typed, or image-based signatures that capture intent to sign. Digital signatures use certificates and public-key cryptography (X.509 and PKCS#7) to prove origin and detect tampering. Both can be used together, such as a visible electronic signature backed by a cryptographic digital signature.

#### Can I use Nutrient as a React PDF signature library only?

Yes. Embed the viewer, hide features you don’t need, and expose only signing tools. Annotations, forms, and other PDF features remain available if you expand your workflow later.

#### Do I need a backend server to sign PDFs with Nutrient in React?

No. Nutrient supports client-side signing in the browser. Load your certificate and private key in the React app, generate a PKCS#7 signature with `node-forge`, and pass it to the signing API. For strict security or compliance needs, you can also integrate with an HSM or backend signing service.

#### Is Nutrient suitable for production React eSignature workflows?

Yes. Nutrient is used in finance, healthcare, and government. It supports certificate-based digital signatures, CAdES-style advanced signatures, access control, and PDF rendering, with commercial support available.

#### How do I get started with Nutrient in my React app?

Install the `@nutrient-sdk/viewer` npm package and mount the viewer in a React component. From there, load any PDF, enable signing, and customize the UI. Start a [free trial](https://www.nutrient.io/try/) or explore the [online demo](https://www.nutrient.io/demo/).
---

## Related pages

- [The business case for accessibility: Five ways it drives enterprise value](/blog/5-ways-accessibility-drives-enterprise-value.md)
- [Accessibility Untangled Why It Matters Guide](/blog/accessibility-untangled-why-it-matters-guide.md)
- [Advanced Techniques For React Native Ui Components](/blog/advanced-techniques-for-react-native-ui-components.md)
- [`vector_store` holds your indexed documents (see the multimodal RAG post](/blog/agentic-rag.md)
- [Ai Document Automation Extraction To Action](/blog/ai-document-automation-extraction-to-action.md)
- [Ai Legal Assistant Document Authoring](/blog/ai-legal-assistant-document-authoring.md)
- [Angular File Viewer Pdf Image Office Files](/blog/angular-file-viewer-pdf-image-office-files.md)
- [Auto Tagging And Document Accessibility In Dotnet Sdk](/blog/auto-tagging-and-document-accessibility-in-dotnet-sdk.md)
- [Best Document Viewers](/blog/best-document-viewers.md)
- [The CEO’s AI playbook: Why decision architecture beats model selection](/blog/ceo-ai-playbook-decision-architecture.md)
- [1. Extract and chunk the PDF.](/blog/chat-with-pdf.md)
- [Complete Guide To Pdfjs](/blog/complete-guide-to-pdfjs.md)
- [Construction Document Data Extraction](/blog/construction-document-data-extraction.md)
- [Convert One Drive Files To Pdf In Sharepoint](/blog/convert-one-drive-files-to-pdf-in-sharepoint.md)
- [Create And Edit Pdfs In Flutter](/blog/create-and-edit-pdfs-in-flutter.md)
- [Create Pdfs With React](/blog/create-pdfs-with-react.md)
- [Creating A Document Scanner With Ocr In Python](/blog/creating-a-document-scanner-with-ocr-in-python.md)
- [Creating And Filling Pdf Forms Programmatically In Javascript](/blog/creating-and-filling-pdf-forms-programmatically-in-javascript.md)
- [The CTO’s AI playbook: Why accountability architecture beats orchestration](/blog/cto-ai-playbook-accountability-architecture.md)
- [Digital Signatures](/blog/digital-signatures.md)
- [Digital Workflow Automation](/blog/digital-workflow-automation.md)
- [Document Ai Vs Ocr](/blog/document-ai-vs-ocr.md)
- [Document Viewer](/blog/document-viewer.md)
- [Document Watermarking](/blog/document-watermarking.md)
- [Emerging threats: Your logging system may be an agentic threat vector](/blog/emerging-threats-your-logging-system.md)
- [app.py](/blog/extract-text-from-pdf-using-python.md)
- [Fillable Pdf](/blog/fillable-pdf.md)
- [How To Build A Dotnet Maui Pdf Viewer](/blog/how-to-build-a-dotnet-maui-pdf-viewer.md)
- [How To Build A Flutter Pdf Viewer](/blog/how-to-build-a-flutter-pdf-viewer.md)
- [or](/blog/how-to-build-a-javascript-pdf-viewer-with-pdfjs.md)
- [How To Build A Javascript Pdf Viewer](/blog/how-to-build-a-javascript-pdf-viewer.md)
- [or](/blog/how-to-build-a-nextjs-pdf-viewer.md)
- [How To Build A Powerpoint Viewer Using Javascript](/blog/how-to-build-a-powerpoint-viewer-using-javascript.md)
- [Using Yarn](/blog/how-to-build-a-react-excel-viewer.md)
- [How To Build A React Native Pdf Viewer](/blog/how-to-build-a-react-native-pdf-viewer.md)
- [How To Build A React Powerpoint Viewer](/blog/how-to-build-a-react-powerpoint-viewer.md)
- [How To Build A Reactjs File Viewer](/blog/how-to-build-a-reactjs-file-viewer.md)
- [or](/blog/how-to-build-a-reactjs-pdf-viewer-with-react-pdf.md)
- [or](/blog/how-to-build-a-reactjs-pdf-viewer.md)
- [How To Build A Reactjs Viewer With Pdfjs](/blog/how-to-build-a-reactjs-viewer-with-pdfjs.md)
- [How To Build A Vuejs Pdf Viewer With Pdfjs](/blog/how-to-build-a-vuejs-pdf-viewer-with-pdfjs.md)
- [How To Build A Vuejs Pdf Viewer](/blog/how-to-build-a-vuejs-pdf-viewer.md)
- [How To Build An Android Pdf Viewer](/blog/how-to-build-an-android-pdf-viewer.md)
- [How To Build An Angular Pdf Viewer With Ng2 Pdf Viewer](/blog/how-to-build-an-angular-pdf-viewer-with-ng2-pdf-viewer.md)
- [How To Build An Angular Pdf Viewer With Pdfjs](/blog/how-to-build-an-angular-pdf-viewer-with-pdfjs.md)
- [How To Convert Docx To Pdf Using Javascript](/blog/how-to-convert-docx-to-pdf-using-javascript.md)
- [How To Convert Docx To Pdf Using Python](/blog/how-to-convert-docx-to-pdf-using-python.md)
- [How To Convert Html To Pdf Using Html2pdf](/blog/how-to-convert-html-to-pdf-using-html2pdf.md)
- [or](/blog/how-to-convert-html-to-pdf-using-react.md)
- [or](/blog/how-to-convert-html-to-pdf-using-wkhtmltopdf-and-python.md)
- [How To Convert Word To Pdf In Nodejs](/blog/how-to-convert-word-to-pdf-in-nodejs.md)
- [or](/blog/how-to-create-a-react-js-signature-pad.md)
- [How To Create Pdfs With React To Pdf](/blog/how-to-create-pdfs-with-react-to-pdf.md)
- [How To Edit Pdfs Using Ios Pdf Library](/blog/how-to-edit-pdfs-using-ios-pdf-library.md)
- [How To Embed A Pdf Viewer In Your Website](/blog/how-to-embed-a-pdf-viewer-in-your-website.md)
- [How To Extract Tables From Pdf And Images](/blog/how-to-extract-tables-from-pdf-and-images.md)
- [How To Generate Pdf From Html With Nodejs](/blog/how-to-generate-pdf-from-html-with-nodejs.md)
- [base_url tells WeasyPrint where to resolve relative asset paths](/blog/how-to-generate-pdf-reports-from-html-in-python.md)
- [Open an image.](/blog/how-to-use-tesseract-ocr-in-python.md)
- [From an HTML string.](/blog/html-in-pdf-format.md)
- [Javascript Pdf Libraries](/blog/javascript-pdf-libraries.md)
- [Linearized Pdf](/blog/linearized-pdf.md)
- [Swift Package Manager](/blog/mobile-pdf-sdk.md)
- [`elements` come from your document parser — each has a type and content.](/blog/multimodal-rag.md)
- [Nutrient Vs Conga Composer](/blog/nutrient-vs-conga-composer.md)
- [Online Document Viewer](/blog/online-document-viewer.md)
- [Open Pdf In Your Web App](/blog/open-pdf-in-your-web-app.md)
- [Pdf Extraction Benchmark Opendataloader Bench](/blog/pdf-extraction-benchmark-opendataloader-bench.md)
- [Pdf Page Labels](/blog/pdf-page-labels.md)
- [Pdf Sdk Compliance Security Checklist](/blog/pdf-sdk-compliance-security-checklist.md)
- [Pdf Sdk Performance Benchmark](/blog/pdf-sdk-performance-benchmark.md)
- [Pdf Ua Compliance Guide](/blog/pdf-ua-compliance-guide.md)
- [Pdfjs Annotation Editor Layer](/blog/pdfjs-annotation-editor-layer.md)
- [Pdfjs Area Annotations Canvas Capture](/blog/pdfjs-area-annotations-canvas-capture.md)
- [Pdfjs Coordinate Systems Pdf To Screen](/blog/pdfjs-coordinate-systems-pdf-to-screen.md)
- [Pdfjs Eventbus Guide](/blog/pdfjs-eventbus-guide.md)
- [Pdfjs Limitations Commercial Upgrade](/blog/pdfjs-limitations-commercial-upgrade.md)
- [Pdfjs Native Annotation Layer Forms](/blog/pdfjs-native-annotation-layer-forms.md)
- [Pdfjs Navigation Zoom Rotation](/blog/pdfjs-navigation-zoom-rotation.md)
- [Pdfjs Pdf Page Manipulation Pdf Lib](/blog/pdfjs-pdf-page-manipulation-pdf-lib.md)
- [Pdfjs React Viewer Setup](/blog/pdfjs-react-viewer-setup.md)
- [Pdfjs Rendering Overlays React Portals](/blog/pdfjs-rendering-overlays-react-portals.md)
- [Pdfjs Server Side Text Extraction](/blog/pdfjs-server-side-text-extraction.md)
- [Pdfjs Sticky Note Annotations](/blog/pdfjs-sticky-note-annotations.md)
- [Pdfjs Text Highlight Annotations](/blog/pdfjs-text-highlight-annotations.md)
- [Pdfjs Text Search Pdffindcontroller](/blog/pdfjs-text-search-pdffindcontroller.md)
- [Pdfjs Thumbnail Sidebar](/blog/pdfjs-thumbnail-sidebar.md)
- [Process Flows](/blog/process-flows.md)
- [React Native Pdf Annotation](/blog/react-native-pdf-annotation.md)
- [or](/blog/sample-blog-updated.md)
- [Add DWS MCP Server to your Claude Code project.](/blog/teaching-llms-to-read-pdfs.md)
- [Open an image file.](/blog/tesseract-python-guide.md)
- [Top 5 Javascript Pdf Viewers](/blog/top-5-javascript-pdf-viewers.md)
- [Convert an HTML file to PDF.](/blog/top-ten-ways-to-convert-html-to-pdf.md)
- [Vector Pdf](/blog/vector-pdf.md)
- [Wcag2 Accessibility Requirements Documents](/blog/wcag2-accessibility-requirements-documents.md)
- [Web Sdk Is Now Headless](/blog/web-sdk-is-now-headless.md)
- [What Are Annotations](/blog/what-are-annotations.md)
- [What Is A Vpat](/blog/what-is-a-vpat.md)
- [What Is Pdf Ua](/blog/what-is-pdf-ua.md)
- [Why Pdfium Is A Trusted Platform For Pdf Rendering](/blog/why-pdfium-is-a-trusted-platform-for-pdf-rendering.md)
- [Why Your Ai Agent Hallucinates Pdf Table Data](/blog/why-your-ai-agent-hallucinates-pdf-table-data.md)