Announcing the TypeScript SDK for Nutrient DWS Processor API

Today we’re launching the TypeScript client library for the Nutrient Document Web Services (DWS) Processor API! This SDK makes document processing integration straightforward with type safety, intelligent tooling, and workflow builder patterns.

Why we built this SDK

The Nutrient DWS Processor API offers powerful document processing capabilities — converting, merging, watermarking, OCR, redaction, and digital signing. But working directly with REST APIs can be cumbersome:

• Manual handling of multipart requests and binary data
• No type safety or autocompletion in your IDE
• Repetitive error handling and authentication code
• Complex workflow orchestration for multistep operations

Our new TypeScript SDK solves these challenges by providing:

• Type-safe interfaces with comprehensive TypeScript definitions
• Simplified authentication supporting both API keys and async token providers
• Intelligent error handling with structured error types and detailed context
• Workflow builders for chaining complex document operations
• AI-native development with built-in support for popular coding tools

Key features and benefits

The TypeScript SDK is built to provide developers with a type-safe, modern, and streamlined approach to handling complex document tasks. The following sections highlight its key capabilities.

Complete API coverage

The TypeScript SDK provides 100 percent mapping to the Nutrient DWS Processor API with more than 35 document processing operations:

• Document conversion — PDF, PDF/A, PDF/UA, DOCX, XLSX, PPTX, PNG, JPG, WEBP, Markdown, and HTML
• Editing operations — Watermark, rotate, flatten, redact, merge, split
• Digital signing — PAdES standards-compliant signatures
• Data extraction — Text, tables, key-value pairs, structured content
• OCR processing — Multi-language image and scan recognition
• Security features — Redaction presets, password protection, permissions
• Optimization — Compress files without quality loss

Type safety and developer experience

The TypeScript SDK provides complete type definitions that give you confidence in your code:

import { NutrientClient } from "@nutrient-sdk/dws-client-typescript";

const client = new NutrientClient({
  apiKey: process.env.NUTRIENT_API_KEY,
});

// Type-safe method calls with IntelliSense.
const result = await client.convert("document.docx", "pdf");
const text = await client.extractText("document.pdf");

Convenience methods with smart defaults

While you can access the full power of the API, we’ve also provided convenience methods for common operations:

// Simple conversion with smart defaults.
const pdf = await client.convert("document.docx", "pdf");

// Or customize every aspect via workflow.
const pdf = await client
  .workflow()
  .addFilePart("document.docx")
  .outputPdfA({
    conformance: "pdfa-2b",
    optimize: {
      mrcCompression: true,
      imageOptimizationQuality: 3,
    },
  })
  .execute();

Workflow builder pattern

For complex document processing tasks, the SDK offers a fluent workflow builder with a staged interface that guides you through the process:

const result = await client
  .workflow()
  // Stage 1: Combine multiple documents into one workflow.
  .addFilePart("contract.pdf")
  .addFilePart("appendix.pdf")

  // Stage 2: Apply actions — process the combined documents.
  .applyAction(
    BuildActions.watermarkText("CONFIDENTIAL", {
      opacity: 0.5,
      fontSize: 48,
    }),
  )
  .applyAction(BuildActions.createRedactionsPreset("email-address"))

  // Stage 3: Set output format — specify final document properties.
  .outputPdf({
    optimize: {
      mrcCompression: true,
      imageOptimizationQuality: 2,
    },
  })

  // Stage 4: Execute — run the entire workflow and get results.
  .execute();

AI-native development experience

The TypeScript SDK is designed to work in collaboration with AI coding assistants. We provide first-class support for popular AI tools, including Claude Code, GitHub Copilot, JetBrains Junie, Cursor, and Windsurf.

After installation, run one command to download the complete package documentation directly to your AI agent’s rule sets:

npx dws-add-claude-code-rule
npx dws-add-github-copilot-rule
npx dws-add-junie-rule
npx dws-add-cursor-rule
npx dws-add-windsurf-rule

What this means for your development experience:

• Improved AI assistance with comprehensive SDK documentation
• Reduced hallucination when generating code
• Built-in support for common questions
• Clean integration that doesn’t interfere with other tools

Using JetBrains Junie as an example, after installing our documentation rules, Junie could fluently generate code based on coding tasks.

Junie can also answer detailed questions about the package documentation, serving as a first line of support for developers.

Context7 MCP Server integration

Beyond individual AI assistants, we’re also making our documentation available through Context7(opens in a new tab) — a Model Context Protocol (MCP) server that provides AI agents access to documentation for popular packages like React, Next.js, and Tailwind CSS.

Our TypeScript package is available on Context7:

• Nutrient DWS TypeScript Client(opens in a new tab)

This allows any MCP-compatible AI agent to browse and fetch our documentation on demand, providing even more flexible integration options.

Get started today

Before getting started, you’ll need:

• A Nutrient DWS Processor API key
• Node.js 18+ for TypeScript development

Installation and basic usage

Install via npm or yarn:

npm install @nutrient-sdk/dws-client-typescript

Basic usage:

import { NutrientClient } from "@nutrient-sdk/dws-client-typescript";

const client = new NutrientClient({
  apiKey: "your_api_key",
});

// Convert documents.
const pdfResult = await client.convert("presentation.pptx", "pdf");

// Merge multiple PDFs.
const merged = await client.merge(["doc1.pdf", "doc2.pdf"]);

// Add watermarks.
const watermarked = await client.watermarkText("document.pdf", "DRAFT");

// Extract data.
const extractedText = await client.extractText("scanned.pdf");

Real-world use cases

The following sections outline some powerful workflows you can build with the TypeScript SDK.

Document automation pipeline

// Process contracts end to end.
const processContract = async (contractFile: string) => {
  // Stage 1: Combine, watermark, and archive documents in a single workflow.
  const combined = await client
    .workflow()
    .addFilePart(contractFile)
    .addFilePart("terms-and-conditions.pdf")
    .applyAction(BuildActions.watermarkText("CONFIDENTIAL"))
    .outputPdfA({
      conformance: "pdfa-2b",
      optimize: { mrcCompression: true },
    })
    .execute();

  // Stage 2: Apply digital signature for legal compliance.
  const signed = await client.sign(combined.buffer, {
    signatureType: "cades",
    cadesLevel: "b-lt",
  });

  return signed;
};

Batch document processing

// Extract data from multiple invoices and compile results.
const processInvoices = async (invoiceFiles: string[]) => {
  const results = [];

  for (const invoiceFile of invoiceFiles) {
    // OCR the invoice if it's a scanned image.
    const ocrResult = await client.ocr(invoiceFile, "english");

    // Extract key-value pairs from the OCR result.
    const kvpResult = await client.extractKeyValuePairs(ocrResult.buffer);

    results.push({
      file: invoiceFile,
      data: kvpResult.data,
    });
  }

  return results;
};

Advanced redaction workflow

// Multistep redaction with different strategies.
const redactSensitiveInfo = async (document: string) => {
  return await client
    .workflow()
    .addFilePart(document)
    .applyActions([
      // Strategy 1: Target specific known content with exact text matching.
      BuildActions.createRedactionsText("Account Number: 12345"),

      // Strategy 2: Use built-in patterns for common sensitive data types.
      BuildActions.createRedactionsPreset("email-address"),
      BuildActions.createRedactionsPreset("credit-card-number"),

      // Permanently remove all marked content.
      BuildActions.applyRedactions(),
    ])
    .outputPdf()
    .execute();
};

We want your feedback

This TypeScript SDK represents a significant step forward in making document processing more accessible to developers. We’d love to hear about your use cases, feature requests, and feedback:

• TypeScript SDK — GitHub issues(opens in a new tab)
• General questions — Contact our team

Try it out and let us know what you think — we’re excited to see what you’ll build!