Feature-Rich JavaScript PDF API Library for Total Document Control

Create PDFs from Scratch

Document Solutions for PDF JS (DsPdfJS) is a JavaScript library that enables developers to programmatically generate, modify, and export PDF documents directly within modern web applications. Built on a high-performance WebAssembly-based API, developers can initialize new documents using the PdfDocument class and configure settings such as page size, PDF/A compliance, and font embedding through the PdfDocumentOptions interface. This flexible setup allows applications to create standards-compliant PDFs tailored to specific document requirements.

The library also provides comprehensive APIs for building and managing document content. Developers can add images, attach embedded files, or combine dynamically generated pages with existing PDFs using PdfDocument.load(). These capabilities support common workflows such as automated report generation, document assembly, and dynamic contract creation.

Once the document is complete, the PdfDocument.savePdf() method exports the final PDF as a binary array that can be downloaded, stored, or sent to a backend service. Output options such as linearized PDF support help optimize documents for fast web viewing. With these features, DsPdfJS enables powerful PDF generation and processing entirely in the browser.

• View Demo and Code
• Create and Save Documentation

Generate Multi-Page PDFs – Paginated Text

Managing pagination for large amounts of text can be complex, but Document Solutions for PDF JS (DsPdfJS) simplifies this process with flexible page management APIs. Developers can create and manage pages programmatically using the PdfPage and PdfPageCollection class, dynamically adding pages with methods like doc.newPageContext() to automatically distribute content across multiple pages.

The API also provides precise control over document layout and structure. Developers can access individual pages with methods like doc.pages.getAt(), render content through each page’s drawing context, and reorganize documents using page operations such as doc.pages.clone(), doc.pages.move(), and doc.pages.remove() This makes it easy to maintain consistent formatting across complex, multi-page documents.

With these capabilities, developers can efficiently generate professional PDFs, such as reports, proposals, eBooks, and documentation, while automatically managing pagination and preserving layout quality across the entire document.

• Pages Documentation

Advanced Text Rendering

Document Solutions for PDF JS (DsPdfJS) provides a flexible text rendering model for JavaScript developers, with two main approaches: drawText() for direct text output at a specified position, and drawLayout() for more advanced text composition. This makes it well suited for both simple labels and more complex document content such as wrapped paragraphs, aligned text blocks, and multi-run formatted text. Together, these APIs give developers precise control over how text is placed and rendered in PDF documents.

For formatting, DsPdfJS uses the Format class for character-level styling and the Layout class for paragraph-level control. With Format, developers can define fonts, font size, colors, outline and fill effects, and special styling such as subscript and superscript. With Layout, they can manage alignment, indentation, paragraph spacing, wrapping, and overflow behavior, making it easier to build polished report content, forms, and document layouts directly in JavaScript.

DsPdfJS also supports more advanced text scenarios such as text alignment, wrapping and trimming, rotated text, vertical text, and text measurement and splitting. Developers can measure content before rendering, truncate overflow when needed, or split text across columns and pages using layout-based APIs. These capabilities make DsPdfJS a strong foundation for rendering rich, layout-aware PDF text, from straightforward captions to multilingual, highly formatted document content.

• View Demo and Code
• Text Rendering Documentation

Text Formatting

Document Solutions for PDF JS (DsPdfJS) provides flexible text formatting capabilities that help JavaScript developers create polished, professional PDF documents with precise control over how text appears. Using the Format class, developers can define core text styling such as custom fonts, font size, colors, and text appearance, making it easy to match brand requirements, improve readability, and produce more visually refined document output.

Beyond basic styling, DsPdfJS supports more advanced formatting effects such as outline text, filled text, and combinations of fill and stroke styling for more decorative or emphasized typography. It also supports subscript and superscript, which are especially useful for rendering formulas, equations, scientific notation, and other specialized content. Because formatting can be applied at the text-run level, developers can combine different styles within the same line or paragraph for greater flexibility.

These formatting capabilities work seamlessly with DsPdfJS text rendering APIs such as drawText() and drawLayout(), allowing developers to apply rich styling in both simple and more structured text scenarios. Whether generating reports, forms, contracts, or branded business documents, DsPdfJS gives developers the tools to control text presentation with the level of precision needed for high-quality PDF output.

• View Demo and Code
• Text Formatting Documentation

Add Headers, Footers, & Page Numbers

Document Solutions for PDF JS (DsPdfJS) allows developers to add headers, footers, and page numbers to PDF documents by drawing text directly onto each page with the page context. Using the Format class for text styling and the Layout class for positioning, developers can create consistent header and footer regions across all pages and include dynamic content such as titles, timestamps, and page numbering. This approach gives JavaScript developers a practical way to add professional finishing elements to generated or loaded PDFs while maintaining full control over placement and appearance.

The layout system makes it easy to control both horizontal alignment and vertical placement for header and footer content. textAlignment is used to position text at the leading edge, center, or trailing edge of the page, while paragraphAlignment determines whether the text is rendered near the top or bottom of the page. By looping through all pages in the document and drawing the desired elements on each one, developers can build reusable header and footer logic that supports page counts, dates, custom labels, and other document-level metadata for a polished final result.

• View Demo and Code
• Setting Header and Footer Documentation

Embed Audio & Videos

The Document Solutions for PDF JS library supports embedded rich media in PDF documents through the RichMediaAnnotation class. This allows developers to add media content such as audio and video to a PdfPage, where it appears as a rectangular region with playback controls. Media resources can be attached using methods such as setVideo(), setAudio(), or setContent(), and embedded content can also be retrieved later with getContent().

DsPdfJS also provides control over how that media is presented and when it is activated. Properties such as presentationStyle determine whether the media appears embedded on the page or in a separate window, while activationCondition and deactivationCondition control when playback starts or stops based on page visibility or user interaction. Developers can position the annotation on the page using properties such as rect, making it possible to place embedded media precisely within the document layout.

Overall, this feature allows developers to create PDFs that include playable multimedia content instead of only static text and graphics. By combining RichMediaAnnotation with programmatic PDF generation, DsPdfJS can be used to build more interactive PDF documents that include embedded audio or video alongside the rest of the document content.

• View Demo and Code
• RichMedia Annotation Documentation

Insert & Adjust Images

The Document Solutions for PDF JS Library makes it easy to insert and adjust images in PDF documents by combining straightforward image loading with flexible drawing controls. Developers can load image data with Image.load(), which creates an Image object from a byte array, and then place that image on the page with drawImage() through the page’s PdfContext. The API supports JPEG and PNG image formats, and loaded images can also be converted to Bitmap objects with toBitmap(), giving developers additional flexibility for image-based workflows before rendering them into the PDF.

Once an image is loaded, drawImage() allows developers to control exactly how it appears on the page by specifying the destination position and size. This makes it possible to add logos, photos, screenshots, and other visual content to generated PDFs with predictable placement and scaling. The method also accepts DrawImageOptions, which provide more refined control over image presentation. For example, developers can preserve proportions with keepAspectRatio, adjust visibility with opacity, and define a visible subregion of the image with clipBounds when only part of the image should be shown.

These capabilities make DsPdfJS well suited for document-generation scenarios that require more than simply dropping in an image at a fixed size. Developers can use the same core API to insert full images, resize them to fit page layouts, preserve their aspect ratio, or crop them to highlight a specific area. Together, Image.load(), toBitmap(), drawImage(), and DrawImageOptions provide a practical and flexible foundation for working with images in JavaScript-generated PDF documents.

• View Demo and Code
• Add Images Documentation

Draw Graphics & Shapes

The Document Solutions for PDF JS Library provides a rich set of drawing capabilities that allow developers to programmatically create shapes and graphics within PDF documents. Using the DrawingContext API, such as PdfContext, SvgContext, or BmpContext, developers can render lines, rectangles, ellipses, polygons, and custom paths directly onto a page. Methods like drawRect(), drawEllipse(), drawLine(), drawPolygon(), and drawPath() provide precise control over position, size, stroke width, fill color, and other visual properties, enabling developers to build detailed visual elements directly within a PDF.

For more advanced graphics, the API also supports creating custom vector paths using createPath() and rendering them with drawPath() to produce complex shapes and diagrams. Developers can combine these drawing operations with transformation methods such as rotate(), scale(), and translate() to control how graphics appear within the document layout. With these capabilities built into this powerful JavaScript PDF API library, developers can easily add diagrams, visual highlights, branding elements, and decorative graphics to dynamically generated PDFs created in browser-based or server-side JavaScript applications.

• View Demo and Code
• Create an Image Documentation

Unicode Fonts for International Languages

DsPdfJS supports Unicode-capable fonts for international languages, making it possible to generate multilingual PDF documents with characters beyond the limited glyph sets of the standard PDF fonts. By loading external fonts through the Font class, developers can render text from a wide range of writing systems, including accented Latin characters, non-Latin scripts, and other language-specific glyphs. Supported font formats include TrueType (.ttf), TrueType Collections (.ttc), OpenType (.otf), and WOFF (.woff), giving developers flexible options for working with modern font files in JavaScript.

For broader font management, DsPdfJS provides the FontCollection class, which can be used to register fonts and supply them to rendering operations by family name. It also supports fallback fonts through methods such as addFallbackFont(), allowing developers to provide additional fonts when the primary font does not contain all required glyphs. This is especially useful for multilingual documents that combine multiple languages or character sets in the same PDF.

DsPdfJS also supports font embedding, which helps preserve correct text rendering across different PDF viewers and systems. External fonts are embedded as subsets by default to reduce file size, and developers can switch to full embedding with PdfDocument.fontEmbedMode when needed. Together, external font loading, fallback font support, and embedding make DsPdfJS a strong option for creating globally compatible PDF documents with reliable international text rendering.

• View Demo and Code
• Fonts Documentation

Right-to-Left Text Support

DsPdfJS provides support for right-to-left and vertical text rendering, making it easier to generate PDF documents for multilingual and region-specific publishing scenarios. Support for right-to-left scripts such as Arabic and Hebrew is built directly into the text rendering engine, so developers do not need to enable a separate property or call a special method to activate it. When the appropriate font and text content are used, DsPdfJS handles right-to-left rendering automatically as part of its normal text drawing workflow.

For vertical text, DsPdfJS uses the Layout class and its flowDirection property, which can be set to values such as FlowDirection.VerticalLeftToRight or FlowDirection.VerticalRightToLeft to control how text is arranged on the page. Additional formatting options in the Format class allow developers to fine-tune vertical text behavior, including uprightInVerticalText for keeping short Latin words or numbers upright within East Asian vertical text, and useVerticalLineGapForSideways for controlling spacing in sideways text runs. This gives developers the flexibility to create more natural vertical layouts for Japanese, Chinese, and Korean text while still supporting mixed-language content.

Together, these capabilities make DsPdfJS well suited for advanced global text rendering scenarios. Developers can combine automatic right-to-left support with vertical text layout, multilingual fonts, and layout-based text composition to build documents that preserve intended reading direction and presentation across a wide variety of languages and writing systems. This is especially valuable for applications that need to generate professional PDFs for international audiences without relying on separate rendering tools or complex manual text handling.

• View Demo and Code
• Vertical Text Documentation

Load a Font from a Font File

Load and use custom TrueType or OpenType fonts in your documents with the Document Solutions for PDF JS API library. By creating a Font instance from a font file, developers can ensure consistent typography, branding, and character rendering when generating PDFs programmatically.

Fonts can be loaded directly from binary font data using Font.load() or Font.loadCollection(), allowing applications to create Font objects from .ttf, .otf, or font collection files. Once loaded, the font can be embedded into the PDF so that text renders correctly across different systems and PDF viewers.

The Font class provides extensive information about the loaded typeface, including the font family name, PostScript name, weight class, and whether the font is bold, italic, or monospaced. Developers can also verify whether a font can be embedded using properties like canEmbed and permissionToEmbedGranted, helping ensure proper licensing compliance when generating documents. Together, these capabilities allow developers to integrate custom typography into generated PDFs while maintaining accurate rendering and full control over document appearance.

• View Demo and Code
• Font from File Documentation

Load a Font from a Font File

Document Solutions for PDF empowers enterprise developers to enhance document design by importing custom fonts directly from font files, ensuring complete control over typography. Using the Font classes FromFile method, you can easily embed custom typefaces, including TrueType and OpenType formats, into your PDFs. This feature enables seamless integration of brand-specific fonts or unique styles, maintaining consistent branding and design throughout your documents.

With support for font fallback, you can also define linked fonts to handle missing glyphs for complex scripts or multilingual content, ensuring comprehensive character coverage. This is particularly valuable when working with documents that require a mix of custom and standard fonts across different languages. Whether you're creating polished marketing materials, professional reports, or visually distinct documents, custom fonts enhance the visual appeal, ensure accuracy, and align with your design vision across all platforms.

• View Demo and Code
• Using Font from File Documentation 

Add Embedded Fonts

Ensure consistent and reliable text rendering across all devices by embedding fonts directly within your PDF documents using the Document Solutions for PDF JS API library. By embedding fonts, developers can guarantee that text appears exactly as intended regardless of whether the viewing system has the required fonts installed.

Fonts can be loaded into the document using the Font class and created from font file data with methods such as Font.load() or Font.loadCollection(). Once loaded, these fonts can be embedded in the generated PDF so that all necessary glyphs and typographic information travel with the document. The API also provides properties such as canEmbed and permissionToEmbedGranted to help verify whether a font is permitted to be embedded, supporting proper licensing and distribution practices.

To optimize file size while maintaining visual accuracy, the library can subset fonts so that only the glyphs used in the document are embedded. Using properties like canSubset, developers can efficiently include the required characters without embedding the entire font file. This approach allows applications to produce PDFs with consistent typography, smaller file sizes, and reliable cross-platform display.

• Font Embedding Documentation

PDF to Image (JPEG and PNG)

The Document Solutions for PDF JS API Library makes it easy to convert PDF pages into image formats for display, export, preview generation, and downstream processing. Using the PdfPage class, developers can render an individual page directly as a PNG with PdfPage.saveAsPng() or as an in-memory image object with PdfPage.saveAsPngImage(). Export behavior can be controlled through the optional SaveAsImageOptions parameter, while helpers such as PdfPage.getRenderSize() make it easier to determine the output dimensions needed for a particular DPI or display target.

Beyond direct image export, PdfPage also supports page rendering through PdfPage.draw(), which can draw the page onto a supplied DrawingContext within a specified rectangle or bounds. Properties such as width, height, mediaBox, cropBox, and rotation help define how the page is sized and displayed before conversion, ensuring accurate output even when page geometry or orientation varies. This combination of direct export and drawable rendering gives developers a reliable way to turn PDF pages into image assets for thumbnails, web previews, archived snapshots, or visual reuse in other applications.

• Export Page Documentation

PDF to SVG

The Document Solutions for PDF JS API Library provides built-in support for converting PDF pages into scalable SVG output, making it easy to preserve visual quality across different screen sizes and zoom levels. Using the PdfPage class, developers can export a page as UTF-8 SVG data with PdfPage.saveAsSvg(), generate a structured SVG object with PdfPage.saveAsSvgDocument(), or create compressed output with PdfPage.saveAsSvgGz(). Each of these methods accepts optional SaveAsImageOptions, allowing developers to control page export behavior while producing lightweight, web-friendly vector graphics from PDF content.

In addition to direct SVG export, PdfPage.draw() can render page content onto a target DrawingContext, including SVG-based contexts, for more customized rendering workflows. Supporting properties such as width, height, mediaBox, cropBox, and rotation help ensure the SVG output accurately reflects the page’s true dimensions and orientation, while getRenderSize() can be used when calculating appropriate output sizing. Together, these APIs give developers flexible options for transforming PDF pages into high-quality SVG assets for browser display, responsive previews, document reuse, and scalable visual rendering.

• Export Pages Documentation

Create Interactive Form Fields – AcroForms

The Document Solutions for PDF JS API Library supports interactive PDF form creation through the AcroForm class, which defines and manages the AcroForm structure within a PdfDocument. Through AcroForm.fields, developers can access the document’s FieldCollection and add or manage the form fields that make up an interactive PDF form experience. This provides the foundation for building fillable PDFs with user-editable controls while keeping the form structure tied directly to the owning document through the AcroForm.doc property.

For more advanced form behavior, AcroForm.calculationorder makes it possible to control the sequence in which fields are recalculated whenever field values change. Because this property is based on each Field.calculationindex, developers can define reliable calculation logic for forms that contain dependent values, totals, or other computed results. Together,  AcroForm.fields and AcroForm.calculationOrder give developers the core tools needed to create, organize, and manage interactive AcroForms in PDF documents.

• View Demo and Code
• Add AcroForm Fields Documentation

Import & Extract PDF Form Data

The Document Solutions for PDF JS API Library supports importing and extracting PDF form data through form submission actions that operate on selected fields, making it easier to move AcroForm data into external workflows. The ActionFieldsBase class provides the shared field-selection behavior used by ActionSubmitForm, allowing developers to target specific fields through the fields property or invert the selection with excludeSpecifiedFields. Because entries in fields can be either field names or Field objects, developers have flexible control over exactly which parts of the form are included when data is processed, while an empty list means all fields are included by default.

For extraction and submission scenarios, ActionSubmitForm adds the configuration needed to send form data to a server-defined endpoint through uri, with the submission format controlled by submitFormat. Developers can further refine the exported data using fdfFormat, htmlFormFormat, or pdfFormat, depending on the chosen submission type, and can include empty fields with includeFieldsWithNoValue or normalize date values with canonicalDateFormat. When using FDF-based workflows, FDFFormatFlags provides additional control, including options such as IncludeAnnotations, ExclNonUserAnnots, IncludeAppendSaves, ExclFKey, and EmbedForm, allowing submitted form data to include annotations, incremental changes, or even an embedded copy of the source PDF. Together, these APIs provide a flexible mechanism for extracting, packaging, and submitting PDF form data in structured formats.

• View Demo and Code
• Import or Export Form Data Documentation

Customize Form Appearance & Field Properties

The Document Solutions for PDF JS API Library allows developers to customize both the appearance and behavior of interactive form fields by working with the document’s AcroForm and its fields collection. Through AcroForm.fields, you can access and manage the FieldCollection that contains the form fields in the PDF, making it possible to configure how each field is presented and how it behaves within the form. At the document level, AcroForm.calculationOrder also helps define how dependent fields update when values change, which is especially useful when field properties and displayed values are tied to calculations or other dynamic form logic.

For visual and behavioral refinement, field-related configuration can be combined with annotation-level control through WidgetAnnotation, which is one of the annotation types built on the PDF annotation system and is used for interactive form controls. Common annotation properties such as rect or pdfRect can define field placement, while flags, locked, lockedContents, contents, and name help manage field state, metadata, and editability. This combination of AcroForm, FieldCollection, calculation settings, and widget-based annotation control gives developers a flexible foundation for tailoring how PDF form fields look, where they appear, and how users interact with them.

• Modify AcroForm Fields Documentation

Action Sound Support

The Document Solutions for PDF JS API Library supports sound-enabled PDF experiences through the SoundObject and SoundAnnotation classes, allowing developers to embed and configure audio content directly inside a document. A SoundObject can be created from raw properties or from audio data in supported formats, and its playback content can be managed with setAudioData() and getAudioData(). Developers can also define important audio characteristics such as samplingRate, soundChannels, bitsPerSample, and encodingFormat, which control how the embedded sound data is stored and interpreted. Once created, that audio can be assigned to a SoundAnnotation through the sound property so the PDF contains an annotation that plays embedded audio when activated.

SoundAnnotation also provides the markup and appearance controls needed to present audio interactions clearly within the document. Developers can choose an icon through icon, position the annotation with rect or pdfRect, and supply descriptive metadata using properties such as contents, subjects, userName, creationDate, and modifiedDate. As a subclass of MarkupAnnotation, it also supports popup, richText, color, opacity, flags, locked, and lockedContents, making it suitable for review, collaboration, or media-rich workflows. For scripted sound-related interactions, ActionJavaScript can be used to attach custom JavaScript behavior through its JavaScript property, enabling document actions that respond dynamically when PDF viewers support JavaScript execution.

• View Demo and Code
• Sound Annotation Documentation

Fill & Flatten PDF Forms

DsPdfJS allows developers to fill PDF forms programmatically by loading a document, accessing the form through the acroForm class, and updating field values in the document’s fields collection. Individual fields can be retrieved with methods such as getAt(), then modified by changing properties like value, name, or calculationIndex. This makes it easy to populate existing PDF forms with application data, automate form completion workflows, or prepare documents for downstream processing without manual entry.

To produce a final, non-editable version of a filled form, DsPdfJS can render each source page into a new PDF while drawing both annotations and form fields as part of the page content. This can be done with the draw() method using options such as drawAnnotations: true and drawFormFields: true, effectively turning the interactive form appearance into static page content in the output document. This approach is useful for secure distribution, archiving, and finalized business documents where form values should remain visible but no longer be editable by the recipient.

• View Demo and Code
• Forms Documentation

Extract PDF Text

DsPdfJS provides support for extracting and locating text in PDF documents through its built-in text search functionality, making it easier for JavaScript developers to find specific content across an entire document. Using the findText() method on PdfDocument, developers can search for a target string and retrieve every occurrence found in the PDF, even when the matched text spans multiple rendered lines. This makes the feature useful for content inspection, indexing, validation, and other search-driven document workflows.

Search behavior can be refined with FindTextParams, which includes options such as matchCase for case-sensitive matching and wholeWord for restricting results to complete-word matches. Each search result includes useful details such as the page index and the bounds of the matched text, allowing developers to do more than just locate text. For example, the returned positions can be used to highlight found content visually on the page or serve as input for downstream operations such as replacement, deletion, or review workflows.

Together, these capabilities make DsPdfJS’s text extraction and search support a practical foundation for working with PDF text programmatically. Whether the goal is to identify keywords, inspect structured content, or prepare text for additional editing or highlighting, DsPdfJS gives developers a straightforward way to retrieve and work with text content directly in JavaScript.

• View Demo and Code
• Text Search Documentation

Extract Metadata & Document Properties

The Document Solutions for PDF JS API Library provides two complementary ways to extract metadata and document properties from PDF files through the Metadata and DocumentInfo classes. DocumentInfo exposes the traditional document information dictionary, making it easy to read values such as author, title, subject, keywords, creator, producer, createDate, and modifyDate. For richer standards-based metadata, the Metadata class gives access to XMP data and related document descriptors, including title, description, creators, contributors, publishers, languages, identifier, copyright, coverage, source, relations, types, producer, creatorTool, createDate, modifyDate, and metadataDate. Together, these APIs allow applications to inspect both basic document properties and more detailed metadata stored in the PDF.

Beyond standard descriptive fields, Metadata also supports compliance and custom-property scenarios through properties such as pdfA, pdfUa, readOnly, and userProps. Developers can work with existing custom metadata through userProps or add new metadata entries with addProperty(), making it possible to extract not only built-in document information but also organization-specific XMP values. This combination of DocumentInfo and Metadata gives developers a complete approach to reading PDF properties for indexing, auditing, search, compliance, and document management workflows.

• View Demo and Code
• Get Document Properties Documentation

Merge Multiple PDFs into One

The Document Solutions for PDF JS API Library makes it easy to combine multiple PDF files into a single document with PdfDocument.mergeWithDocument(). Developers can load existing files with PdfDocument.load(), then merge one source PdfDocument into another while controlling the process with MergeDocumentOptions. This includes inserting merged pages at a specific position with index, limiting the imported pages with range, and deciding whether related document content such as copyFields, copyOptionalContent, copyArticleThreads, copyAssociatedFiles, copyNamedDestinations, and copyDocumentLevelEmbeddedFiles should also be brought into the destination PDF.

For more advanced merge workflows, MergeDocumentOptions also includes settings such as mergeStructTree for structure tree handling, outlineMergeMode for controlling how outlines are combined, and forceDirectCopy for copying referenced objects without parsing content streams. Because PdfDocument.mergeWithDocument() works directly on loaded PdfDocument instances, it gives developers a flexible way to assemble larger PDFs from smaller source files while preserving selected interactive, structural, and navigational elements as needed.

• View Demo and Code
• Merge PDFs Documentation

Split a PDF

DsPdfJS allows developers to split PDF documents by extracting selected pages into new PDF files. Rather than relying on a separate dedicated split command, this workflow is handled by creating a new PdfDocument and copying the desired page or page range from the source document into it. This makes it easy to break larger PDFs into smaller files for archiving, distribution, page-level processing, or workflow automation.

The main API used for this process is mergeWithDocument(), which can copy pages from one document into another using the range option. To split a PDF, developers first load the source file, then create a new PdfDocument for each page or page range they want to extract. By calling mergeWithDocument() with a specific fromPage and toPage range, they can build separate output files containing only the needed content. Each resulting document can then be saved independently with savePdf().

This approach gives developers flexible control over how documents are divided, whether the goal is to save every page as its own file or extract larger page groups into multiple PDFs. Because the same page-copying mechanism can also be used for merging and rearranging content, DsPdfJS provides a consistent and practical model for page-level document manipulation in JavaScript.

• Split PDFs Documentation

Add Attachments

The Document Solutions for PDF JS API Library supports adding file attachments to PDFs through the FileAttachmentAnnotation class, which represents a reference to a file that is typically embedded in the document. Developers can associate a file with the annotation by setting the file property to a FileSpecification or FileSpecificationProperties object, then place the attachment icon on a page using page, rect, or pdfRect. The annotation can also be customized with icon, which supports standard attachment icons such as "Paperclip", "PushPin", "Tag", and "Graph", making it easy to present attached content in a clear and recognizable way within the PDF.

As a subclass of MarkupAnnotation, FileAttachmentAnnotation also includes a wide range of properties for metadata, appearance, and user interaction. Developers can provide descriptive details with contents, subject, userName, name, creationDate, and modifiedDate, while visual behavior can be refined through color, opacity, flags, locked, and lockedContents. The annotation can also use popup and richText for note-style interaction, and appearance streams can be managed with resetAppearance() and removeAppearance(). This makes FileAttachmentAnnotation a flexible way to embed or reference supplemental files directly inside a PDF while keeping them discoverable and interactive for end users.

• View Demo and Code
• Attachment Documentation

Outlines & Bookmarks

The Document Solutions for PDF JavaScript API Library provides full support for creating and managing PDF outlines and bookmarks through the OutlineNode and OutlineNodeCollection classes. An OutlineNode represents an individual bookmark entry and can be initialized with a title, a destination through dest, or an action through action, allowing developers to create navigational items that jump to a location in the document or trigger a defined behavior. Each node can also be expanded or collapsed with expanded, styled with textColor and textStyle, and organized into a hierarchy through its children collection, parent, and owner relationships. This makes it possible to build simple bookmark lists or deeply nested outline structures for complex documents.

The OutlineNodeCollection class manages groups of bookmark nodes and provides the collection operations needed to build and maintain an outline tree. Developers can add bookmarks with add(), insert them at specific positions with insert(), retrieve them with getAt(), update them with setAt(), and remove them with remove() or removeAt(). Collection-level properties such as count, last, and doc help manage the overall outline structure, while clear() makes it easy to reset the collection entirely. Together, OutlineNode and OutlineNodeCollection give developers a flexible way to create bookmark-based navigation that improves PDF usability and helps users move quickly through long or structured documents.

• View Demo and Code
• Outline Documentation

Set & Modify PDF Metadata

The Document Solutions for PDF JS API Library provides comprehensive control over PDF metadata through the Metadata and DocumentInfo classes, allowing developers to both set and update standard document properties and richer XMP metadata. With DocumentInfo, you can define or modify familiar PDF properties such as author, title, subject, keywords, creator, producer, createDate, and modifyDate, and you can reset those values with DocumentInfo.reset() when needed. For XMP-based metadata, the Metadata class exposes a broader set of properties including title, description, creators, contributors, publishers, languages, identifier, copyright, coverage, source, relations, types, producer, creatorTool, createDate, modifyDate, and metadataDate, making it possible to manage both basic and standards-oriented document metadata in one workflow.

The Metadata class also supports advanced metadata scenarios such as compliance tagging and custom properties. Developers can set pdfA and pdfUa to reflect conformance information, control editability with readOnly, and manage custom metadata entries through userProps or by adding individual values with addProperty(). Because PdfDocument.documentInfo and PdfDocument.metadata expose these objects directly on the document, applications can efficiently modify metadata for indexing, compliance, search, archival, and document management use cases without changing the visible page content.

• View Demo and Code
• Get Document Properties Documentation

Text Search, Replace, & Delete

DsPdfJS provides built-in support for text search, replace, and delete operations, making it easier for JavaScript developers to inspect and modify PDF content directly in code. Using the findText() method on PdfDocument, developers can search for specific strings across the document and retrieve all matching occurrences, even when the text spans multiple rendered lines. Search behavior can be refined with FindTextParams, including options such as matchCase and wholeWord, and the returned results include information such as page index and text bounds. This makes the feature useful not only for locating content, but also for follow-up workflows such as highlighting, validation, redaction preparation, or targeted editing.

For content updates, DsPdfJS supports replaceText(), which allows developers to find matching text and replace it with new text throughout the document. Replacement can be driven by the same FindTextParams search criteria, and developers can optionally control the appearance of the replacement text by specifying a font and font size. This makes it practical to update names, titles, labels, dates, or other repeated content in existing PDFs while preserving a clean, automated workflow. Because the search results also expose positional information, developers can combine search with page drawing logic to highlight matched regions visually before or after replacement.

DsPdfJS also supports deleteText() for removing matched text from a PDF. Deletion behavior is controlled through DeleteTextMode, allowing developers to choose whether surrounding content should shift to fill the removed text area or whether the removed content’s space should remain blank. This gives flexibility for different cleanup scenarios, from deleting unwanted labels or text fragments to preparing documents for final distribution. Together, findText(), replaceText(), and deleteText() give DsPdfJS a strong set of text-editing capabilities for search-driven PDF automation in JavaScript.

• View Demo and Code
• Text Search, Replace and Delete Documentation

Redact PDF Content

The Document Solutions for PDF JS API Library makes it possible to permanently remove sensitive information from PDFs by using the RedactAnnotation class to mark content for removal and then applying those marks with PdfDocument.redact(). A RedactAnnotation can target content with either RedactAnnotation.area or RedactAnnotation.pdfArea for quadrilateral-based regions, or with RedactAnnotation.rect or RedactAnnotation.pdfRect when a rectangular region is sufficient. This gives developers precise control over what will be erased, while the annotation itself can still carry useful metadata through inherited properties such as contents, subject, userName, creationDate, and modifiedDate.

Beyond simply removing content, the RedactAnnotation class also provides strong control over how redacted regions appear after redaction is applied. Developers can define replacement visuals with overlayFillColor, add replacement labels with overlayText, control repeated text behavior through overlayTextRepeat, and format that text using overlayAppearance and justification. The annotation’s visible markup before application can also be customized with markFillColor, markBorderColor, color, and opacity, while methods such as resetAppearance() and removeAppearance() help manage annotation rendering. This combination allows developers to build redaction workflows that are both secure and presentation-ready, ensuring sensitive PDF content is truly removed rather than merely hidden.

• View Demo and Code
• Redaction Annotation Documentation

Add Annotations

The Document Solutions for PDF JS API Library provides a broad annotation system built on the abstract AnnotationBase class, making it possible to add many different types of interactive and visual markup to a PDF. Through classes that extend AnnotationBase, developers can work with MarkupAnnotation for comment-style and review-oriented annotations, LinkAnnotation for clickable navigation or external links, PopupAnnotation for associated note windows, WatermarkAnnotation for fixed-position printed graphics, WidgetAnnotation for interactive form controls, RichMediaAnnotation for embedded rich content, and UnknownAnnotation for unsupported or unclassified annotation types that still need to be preserved or managed. Each annotation can be assigned to a PdfPage using AnnotationBase’s page property, referenced across pages through pages, and positioned with either rect or pdfRect depending on the coordinate system required.

Across all supported annotation types, AnnotationBase provides the common properties and methods needed to control annotation behavior and metadata. Developers can define descriptive text with contents, uniquely identify annotations with name, manage state through flags, locked, and lockedContents, and track changes with modifiedDate. The base API also includes resetAppearance() and removeAppearance() for managing annotation appearance streams, along with doc for access to the owning PdfDocument. This shared foundation makes it easier to build annotation-heavy PDF workflows while still taking advantage of the specific purpose of each available annotation class.

• View Demo and Code
• Annotations Documentation

Add Images

The Document Solutions for PDF JS API Library makes it easy to add images to PDF pages by drawing them directly onto a page’s PdfContext. Each PdfPage exposes its drawing surface through the PdfPage.context property, and developers can place image content with PdfContext.drawImage(), either by specifying x, y, width, and height values or by passing destination bounds. This allows precise placement and sizing of image assets such as logos, photos, watermarks, and other visual elements directly within the PDF page content stream.

Beyond basic placement, PdfContext also provides the tools needed to control how images appear and interact with surrounding content. Developers can adjust image positioning and scaling with transformation methods such as translate(), scale(), scaleXY(), rotate(), and applyTransform(), while pushClip() and pushLayer() can be used for clipped or transparent image rendering effects. Additional properties such as blendMode, matrix, transform, and resolution give further control over image composition, helping developers build richer PDF layouts when using PdfContext.drawImage() to insert visual content.

• View Demo and Code
• Images Documentation

Watermarking

Add fixed-position watermarks to PDF documents using the Document Solutions for PDF JS API library. Watermarks are commonly used to display document status indicators such as Draft, Confidential, or Internal Use Only, or to apply branding elements like company logos directly onto pages.

Watermarks can be created using the WatermarkAnnotation class, which defines graphics that remain at a consistent size and position regardless of the printed page dimensions. Developers can apply either text-based or image-based watermarks using the text or image properties, allowing for flexible visual overlays. The textFormat property can be used to define how watermark text appears, enabling customized formatting when the watermark’s appearance is generated.

Positioning and placement can be controlled through properties such as rect or pdfRect, while additional adjustments can be made using horzTranslate and vertTranslate to shift the watermark relative to the page’s width and height. Developers can also apply transformations through the matrix property to modify how the watermark is rendered. Watermark annotations can be assigned to specific pages using the page property and may include descriptive metadata through properties like contents, name, and modifiedDate. Together, these capabilities allow applications to programmatically add consistent document overlays for branding, document classification, or security marking while preserving the original PDF content underneath.

• Watermark Documentation

Incremental Update

Improve performance and efficiency when modifying existing PDFs by saving documents using incremental updates in the Document Solutions for PDF JS API library. Incremental updates allow changes to be appended to the end of a PDF file rather than rewriting the entire document, significantly reducing processing time and preserving the original document structure.

When saving a document, developers can specify the SavePdfOptions configuration and set the saveMode property to SaveMode.IncrementalUpdate. In this mode, only the modified objects and new content are written to the file, while the original data remains unchanged. This approach is especially useful when working with large documents or applying frequent updates such as adding annotations, form data, or metadata.

Incremental updates also help maintain document history and compatibility with workflows that rely on preserving prior revisions. Combined with additional save options such as pdfStreamHandling and useObjectStreams, developers can fine-tune how updated content is stored within the PDF. This allows applications to efficiently modify documents while minimizing file rewriting and improving overall performance.

• Incremental Update Documentation

Password Protected PDFs

The Document Solutions for PDF JS API Library supports password-protected PDFs through document encryption settings that control both access and allowed actions within the file. With PermissionOptions, developers can define an ownerPassword to secure permission changes and optionally restrict behavior such as copying through b, editing through editingPermissions, and printing through printingPermissions. When a document is opened with EncryptOptions.userPassword, these permission settings are enforced for users opening the file under that password, helping protect sensitive PDF content from unauthorized extraction, modification, or printing.

For existing secured files, the library also supports opening encrypted documents with PdfDocument.load(), using the optional decryption parameter to supply PdfDecryptionOptions such as a password. This allows applications to reliably load password-protected PDFs from binary data while enforcing access validation at open time. Together, PermissionOptions, EncryptOptions.userPassword, and PdfDocument.load() provide a complete workflow for securing PDFs, controlling what end users can do with them, and safely reopening protected documents when valid credentials are supplied.

• Security Documentation

Encrypt & Decrypt PDFs

The Document Solutions for PDF JS API Library provides a complete workflow for encrypting and decrypting PDFs with modern password security through the StandardSecurityHandler class, which has 6 revisions that each use a different encryption method. The StandardSecurityHandlerRev6 security handler uses AES encryption with a 256-bit key, making it suitable for protecting sensitive documents while still allowing developers to define how the file can be accessed and used. You can create a handler with StandardSecurityHandlerRev6.create(), assign document-opening credentials through userPassword or userPasswordBytes, and define administrative control through ownerPassword or ownerPasswordBytes. The class also exposes permission-related properties such as copyContent, editingPermissions, printingPermissions, allowPrint, allowEditContent, and allowEditAnnotations, giving fine-grained control over what users can do after opening the encrypted PDF.

For decryption, the library supports loading secured files with PdfDocument.load() together with PdfDecryptionOptions, allowing applications to pass a password through password or passwordBytes when opening an encrypted document. Additional options such as throwExceptionIfInvalidPassword and throwExceptionIfUnsupportedSecurityOptions let developers decide whether invalid credentials or unsupported security definitions should immediately raise errors or allow a limited-load scenario. Once a document is loaded, StandardSecurityHandlerRev6.accessType and passwordMatches can help determine what level of access was granted and how the supplied password matched the document’s security settings. Together, StandardSecurityHandlerRev6 and PdfDecryptionOptions make it possible to both secure PDFs with strong encryption and reliably reopen protected documents in controlled JavaScript workflows.

• Encrypt PDF Documentation

Set Access Permissions

The Document Solutions for PDF JS API Library allows developers to set detailed access permissions on PDF files so users can be limited to only the actions you want to allow. Using PermissionOptions, you can define an ownerPassword to control permission changes, while properties such as copyContent, editingPermissions, and printingPermissions determine whether document content can be copied, edited, or printed. This makes it easy to protect sensitive PDF documents while still allowing controlled access for viewing or limited interaction.

For more advanced security workflows, the StandardSecurityHandlerRev6 class provides direct control over access rules alongside strong AES 256-bit encryption. Developers can configure userPassword or userPasswordBytes to require a password for opening the document, then apply permissions with properties from the class such as copyContent, allowPrint, allowEditContent, allowEditAnnotations, editingPermissions, and printingPermissions. When a secured file is later opened, properties like accessType and passwordMatches can help determine what level of access was granted, making it possible to build secure PDF experiences that both restrict user actions and clearly enforce document-level permissions.

• View Demo and Code
• Set Permissions Documentation

Open Encrypted PDFs Without Passwords

The Document Solutions for PDF JS API Library allows developers to open certain encrypted PDF documents without supplying a password by using PdfDocument.load() together with PdfDecryptionOptions. By setting PdfDecryptionOptions.throwExceptionIfInvalidPassword to false, the document can still be loaded even when no valid password or passwordBytes value is provided. In this state, the PDF is not fully decrypted, but the application may still be able to work with limited parts of the document model, making it possible to inspect or update some non-encrypted or non-string-based data without requiring full access credentials.

This approach is useful in scenarios where you need to interact with high-level document information or perform limited document updates on protected files without stopping the workflow because of a missing password. At the same time, the API makes the limitation clear: when an invalid password is allowed through throwExceptionIfInvalidPassword: false, many methods and properties may not work correctly until the document is reopened with valid PdfDecryptionOptions.password or PdfDecryptionOptions.passwordBytes. This gives developers a flexible way to handle secured PDFs gracefully while still preserving full functionality for cases where the correct password is available.

• Open Encrypted PDF Without Password Documentation

Standard PDF Viewer

Document Solutions for PDF JS includes a JavaScript PDF Viewer, called DsPdfViewer, that provides a seamless experience for viewing and interacting with PDFs directly in the browser. With its cross-platform support, DsPdfViewer enables users to access PDF documents effortlessly across Windows, macOS, Linux, iOS, and Android devices, while maintaining compatibility with major frameworks like Angular, React, Vue, and ASP.NET Core. A Standard license is included with a purchase of Document Solutions for PDF JavaScript and offers robust capabilities for navigating, zooming, and searching within documents, enhancing both accessibility and productivity.  

For users with advanced needs, the Professional license unlocks powerful editing features such as PDF form-filling, collaborative editing, and comprehensive document modification. These features are available through two flexible options: a server-based editing mode, which connects to a .NET server running the Document Solutions for PDF and SupportApi, and a client-only mode leveraging WebAssembly (Wasm) for fully local, software-independent PDF processing.

• View Demo and Code
• Document Solutions PDF Viewer Documentation
• Learn More About the JavaScript PDF Viewer

Print PDFs

Add seamless PDF print functionality to web applications with the help of the JavaScript PDF Viewer, DsPdfViewer. End users can print the currently loaded PDF using the built-in toolbar button, or developers can trigger the browser’s native print dialog programmatically using the API’s print method.

This feature provides a fast and intuitive way to generate hard copies of digital documents, ideal for applications that manage contracts, invoices, reports, and more. Compatible with all modern browsers, no third-party plugins or PDF software needed.

• View Demo and Code
• Print Documentation