Integrate advanced document viewing, annotations, forms, signing, and editing into any JavaScript stack. Use the built-in UI, replace any component via the slot system, or run fully headless — every capability is reachable from code, ready for both human users and AI agents. Process client-side with WebAssembly, server-side, or in the cloud.
A JavaScript PDF viewer lets you embed PDF functionality directly in your web app. Our PDF SDK gives you everything you need to view, edit, and sign documents — all controlled through JavaScript APIs.
Pixel-perfect rendering with fast page streaming for large documents.
17+ annotation types, form creation and filling, plus electronic and digital signatures.
Replace any UI component via the slot system, or strip the chrome entirely with preset: 'minimal' and build your own interface on top.
Client-side processing with WebAssembly, or optional server-side rendering with Document Engine.
INTERACTIVE PLAYGROUND
CODE EXAMPLES
Drop in a viewer that’s fast, framework-friendly, and fully client-side — no server, no setup.
Basic Example
import NutrientViewer from "@nutrient-sdk/viewer";
const instance = await NutrientViewer.load({ container: "#nutrient-container", document: "<pdf-file-path>", licenseKey: "YOUR_LICENSE_KEY_GOES_HERE"});
console.log("Nutrient Web Viewer is ready!");console.log(instance);const NutrientViewer = require("@nutrient-sdk/viewer");
NutrientViewer.load({ container: "#nutrient-container", document: "<pdf-file-path>", licenseKey: "YOUR_LICENSE_KEY_GOES_HERE"}).then(function(instance) { console.log("Nutrient Web Viewer is ready!"); console.log(instance);})Headless UI (preset: minimal)
import NutrientViewer from "@nutrient-sdk/viewer";
// Strip all default UI — bare document canvas only.// Selectively restore components via slot overrides.const instance = await NutrientViewer.load({ container: "#nutrient-container", document: "<pdf-file-path>", licenseKey: "YOUR_LICENSE_KEY_GOES_HERE", ui: { preset: "minimal", // Replace any slot with your own implementation: search: (getInstance, id) => ({ render: () => { const div = document.createElement("div"); div.textContent = "Your custom search UI"; return div; }, }), },});
// Drive the viewer programmatically:instance.setViewState((v) => v.set("currentPageIndex", 2));Custom Toolbar
import NutrientViewer from "@nutrient-sdk/viewer";
const instance = await NutrientViewer.load({ container: "#nutrient-container", document: "<pdf-file-path>", licenseKey: "YOUR_LICENSE_KEY_GOES_HERE", toolbarItems: [...NutrientViewer.defaultToolbarItems, { type: "custom", id: "my-button", title: "My Button", onPress: event => { alert("hello from my button"); } }]});const NutrientViewer = require("@nutrient-sdk/viewer");
NutrientViewer.load({ container: "#nutrient-container", document: "<pdf-file-path>", licenseKey: "YOUR_LICENSE_KEY_GOES_HERE", toolbarItems: NutrientViewer.defaultToolbarItems.concat([{ type: "custom", id: "my-button", title: "My Button", onPress: function(event) { alert("hello from my button"); } }])});Create Annotation
import NutrientViewer from "@nutrient-sdk/viewer";
const instance = await NutrientViewer.load({ container: "#nutrient-container", document: "<pdf-file-path>", licenseKey: "YOUR_LICENSE_KEY_GOES_HERE"});
const annotation = new NutrientViewer.Annotations.LineAnnotation({ pageIndex: 0, startPoint: new NutrientViewer.Geometry.Point({ x: 95, y: 95}), endPoint: new NutrientViewer.Geometry.Point({ x: 195, y: 195}), boundingBox: new NutrientViewer.Geometry.Rect({ left: 90, top: 90, width: 200, height: 200, }),});
await instance.create(annotation);const NutrientViewer = require("@nutrient-sdk/viewer");
NutrientViewer.load({ container: "#nutrient-container", document: "<pdf-file-path>", licenseKey: "YOUR_LICENSE_KEY_GOES_HERE"}).then(async (instance) => { const annotation = new NutrientViewer.Annotations.LineAnnotation({ pageIndex: 0, startPoint: new NutrientViewer.Geometry.Point({ x: 95, y: 95}), endPoint: new NutrientViewer.Geometry.Point({ x: 195, y: 195}), boundingBox: new NutrientViewer.Geometry.Rect({ left: 90, top: 90, width: 200, height: 200, }), });
await instance.create(annotation);})Build faster with our JavaScript PDF viewer’s easy setup, detailed documentation, and plug-and-play code. Process PDFs client-side and offline, with server support for performance and security.
Save time and resources by choosing to build with our JavaScript PDF viewer. No more bugs and open source nightmares. Just performant document support without the headaches.
Every capability exposed by the built-in UI is equally reachable through the public API, with complete TypeScript declarations. Your code can drive annotations, page edits, signatures, and navigation without private methods or workarounds.
Deliver AI functionality with AI Assistant. Whether you’re looking to add AI summarization, translation, redaction, data extraction, or comparison, our web viewer is the simplest way to add intelligence to your documents.
Nutrient Web Viewer SDK is a modular JavaScript bundle you can drop into any stack today and extend tomorrow.
Render large PDFs instantly, layer on markups and threaded comments, and watch feedback appear live.
Add, reorder, or rewrite pages and build dynamic forms in a browser — zero desktop tools.
Apply tamper‑proof eSignatures, run pixel‑perfect diffs, and scrub sensitive data before release.
Ask a document anything, classify content, generate PDFs, and auto‑convert at scale with one endpoint.
Output long‑term PDF/A, enforce encryption, and breeze through audits with WCAG 2.2 AA compliance, high contrast themes, and enhanced screen reader support.
DOCUVIEWARE
We have an HTML5 viewer for that too. It offers a comparable feature set and is designed specifically for .NET applications.
VIEWER OPTIONS
Whether you’re building with JavaScript or .NET, Nutrient offers flexible viewer solutions tailored to your technology stack and deployment needs.
| Web Viewer SDK | Web Viewer SDK + Document Engine | DWS Viewer API | DocuVieware | |
|---|---|---|---|---|
| Technology stack | JavaScript | JavaScript + backend | JavaScript + Cloud backend | .NET (ASP.NET) |
| User interface | HTML5-based | HTML5-based | HTML5-based | HTML5-based |
| Deployment | Viewer: In-browser via WebAssembly |
Viewer: In-browser Rendering: Self-hosted (with Docker), or managed by Nutrient |
Viewer: In-browser Rendering: Hosted in the cloud by Nutrient | On-premises (.NET server) or cloud-based |
| Rendering | Client-side | Server-side | Server-side | Server-side (.NET) |
| Key notes |
|
|
|
|
| Documentation |
Nutrient SDKs and Cloud APIs add full document lifecycle support to any platform, tech stack, or infrastructure in minutes. The same technology meets Fortune 500 requirements while helping startups ship fast.
Clean documentation, drop-in code, and MCP hooks for both developers and AI agents. The public API is validated continuously for LLM discoverability through our agent experience (AX) evaluation framework — so agents can complete real document tasks without hallucinating methods.
Web, mobile, desktop, server, or Nutrient Cloud — with no lock-in.
SOC 2 Type 2 audited with WCAG 2.2 AA compliance. Features high contrast themes, enhanced screen reader support, and PDF/UA for fully accessible documents.
Built-in document AI with support for leading LLMs and their private implementations.
PROVEN AT SCALE
Renders multipage PDFs and signature tags with Nutrient, keeping 200 million users in 188 countries moving at the speed of eSignature.
Scales legal document workflows by 50 percent month over month using Nutrient Web SDK and Document Engine — without adding infrastructure or compromising enterprise compliance.
Construction ERP powering one‑quarter of ENR’s Top 400 contractors embeds Nutrient SDKs for mobile drawing management across iOS, Android, and Web, slashing developer time and fueling double‑digit growth.
For decades, software’s value lived in its interface. Agents change that: Take the UI away, and you’d better have an engine and an API that can do everything the UI could. Here’s how we made Nutrient Web SDK truly headless, in both senses of the word, and why it’s the foundation of an AI-first product.
Discover the top five JavaScript PDF viewers in 2026, including free and enterprise-grade options. Compare features, pricing, and use cases to find the best PDF viewer for your app.
Learn how to build a React file viewer that opens PDFs, images, and Office docs client side with Nutrient Web SDK. Full code, Vite setup, and demo.
FREE TRIAL
Start building with Web Viewer SDK in minutes — no payment information required.
A JavaScript PDF viewer is a developer toolkit that enables embedding powerful PDF features — like viewing, editing, annotating, and signing — directly into web applications using JavaScript. Nutrient’s web PDF SDK delivers high-performance rendering, a customizable UI, and built-in tools for collaboration, redaction, and compliance — all without relying on external apps.
When picking a JavaScript PDF viewer, developers should prioritize flexibility, performance, and ease of integration. Here’s what to consider:
Nutrient (formerly PSPDFKit) is built for developers who want control, speed, and flexibility without compromise — perfect for embedding rich PDF workflows directly into your browser-based app.
Nutrient Web Viewer SDK is the best in its category for being flexible, fast, and easy to use for developers. This is especially true when you want to use our full PDF functionality without giving control to other viewers.
Our web viewer is a JavaScript PDF viewer that developers can integrate to enable their users to view, annotate, edit, and sign PDF documents directly within their web applications. It supports high-fidelity rendering, form viewing and filling, redaction, text editing, text comparison, measurement tools, comments, and so much more.
Yes. Nutrient Web Viewer SDK is designed for seamless integration with all major JavaScript frameworks, including React, Angular, Vue, Svelte, and Next.js. It requires only a DOM container for appending the viewer, ensuring flexibility across different development environments.
Yes — Nutrient Web Viewer SDK ships with a complete slot system
that covers every UI component (every toolbar, modal, panel,
popup, and sidebar). Each slot supports three configuration
shapes: hidden (the component doesn’t render),
partial (replace a subregion while keeping the rest),
or full (replace the entire component with your own
implementation). Slot callbacks receive a live accessor to the SDK
instance, so your custom components have full access to SDK state
without touching private APIs. For teams that want a bare document
canvas with no SDK chrome at all, ui: { preset: 'minimal' } strips everything in one line, and then you selectively restore
the components you need. Refer to our UI customization and headless UI guides for the full reference.
Yes. Every capability available through the built-in UI is equally available through the public instance API — annotations, ink drawing, page editing, signature capture, bookmarks, and navigation are all reachable from code with nothing requiring private method access. The SDK ships complete TypeScript declarations, so an LLM agent given only the public type definitions and our guides can construct working implementations without hallucinating methods. We validate that property continuously through our internal agent experience (AX) evaluation framework, which runs LLM-generated code through TypeScript compilation, static API analysis, and end-to-end browser execution before new APIs ship. Refer to the Instance API reference for the full programmatic surface.
Yes. Nutrient Web Viewer SDK supports complete in-browser client-side PDF processing and rendering by leveraging the latest WebAssembly technology. This approach offloads processing to the browser, reducing server dependency, enabling offline processing, and providing the ability to integrate it into other low-code applications on major business platforms like Salesforce, SharePoint, Mendix, and more.
Nutrient Web Viewer SDK supports three flexible deployment
options to fit your technical needs:
1) A fully
client-side deployment that runs entirely in the browser,
powered by WebAssembly technology.
2) A paired
deployment with Document Engine for advanced control and
server-side performance.
3) Integration with our
cloud-hosted DWS Viewer API for backend-performant features
without any backend setup.
The variety of
deployment options gives you the freedom to choose the best
model for your application and use case needs.
Yes. Nutrient Web Viewer SDK ensures compatibility across all major web browsers, including Chrome, Firefox, Safari, Edge, and Firefox ESR. It also supports cross-platform applications, ensuring consistent performance on desktop and mobile and in cloud-based solutions.
Nutrient Web Viewer SDK supports features — including digital signatures, redaction, and encryption — that enable users to maintain document security and compliance with regulations such as GDPR, HIPAA, and more. Our client-side deployment inherently ensures data privacy by only processing documents on the client’s device. Nutrient is SOC 2 Type 2 audited and continuously monitors, maintains, audits, and updates internal security procedures, in addition to regularly engaging in third-party penetration testing of all software.
Yes. Nutrient Web Viewer SDK provides comprehensive accessibility support with WCAG 2.2 AA compliance. We offer high contrast themes (both light and dark), enhanced ARIA labels for improved screen reader compatibility, and better keyboard navigation. The SDK also supports PDF/UA for creating accessible documents. These features ensure your application meets Section 508 and EN 301 549 requirements, making your PDF viewer accessible to users with visual impairments and other disabilities.
Yes. Nutrient Web Viewer SDK includes experimental support for right-to-left (RTL) layout, enabling proper UI rendering for Arabic and Hebrew. This feature enables the entire viewer interface — including toolbars, menus, and panels — to mirror appropriately for RTL reading patterns. While still experimental, this capability helps you reach Middle Eastern and other RTL-language markets with a native user experience.