@turbodocx/sdk

Official JavaScript/TypeScript SDK for TurboDocx

The most developer-friendly DocuSign & PandaDoc alternative for e-signatures and document generation. Send documents for signature and automate document workflows programmatically.

Documentation • API Reference • Examples • Discord

⚡ Skip the boilerplate — let an agent scaffold it for you

Have an AI coding agent (Claude Code, Cursor, Copilot, Codex, Gemini CLI, OpenCode) install this SDK, configure your env, write working route handlers, and wire them into your app:

npx skills add TurboDocx/quickstart

Then run /turbodocx-sdk inside your agent — or one of the focused shortcuts:

| Shortcut | What it scaffolds | |---|---| | /turbodocx-sdk turbosign | Send documents for e-signature, check status, download signed PDF | | /turbodocx-sdk deliverable | Generate documents from templates with variable substitution | | /turbodocx-sdk turbopartner | Provision and manage customer organizations (partner accounts) | | /turbodocx-sdk turbowebhooks | Subscribe to signature.document.completed events + verify HMAC | | /turbodocx-sdk turboquote | Build and send sales quotes with line items, bundles, and price books |

The skill auto-detects your framework (Express, NestJS, Next.js, Fastify, …) and follows your existing project conventions. Source: github.com/TurboDocx/quickstart.

Why TurboDocx?

A modern, developer-first alternative to legacy e-signature platforms:

| Looking for... | TurboDocx offers | |----------------|------------------| | DocuSign API alternative | Simple REST API, transparent pricing | | PandaDoc alternative | Document generation + e-signatures in one SDK | | HelloSign/Dropbox Sign alternative | Full API access, modern DX | | Adobe Sign alternative | Quick integration, developer-friendly docs | | SignNow alternative | Predictable costs, responsive support | | Documint alternative | DOCX/PDF generation from templates | | WebMerge alternative | Data-driven document automation |

Other platforms we compare to: SignRequest, SignEasy, Zoho Sign, Eversign, SignWell, Formstack Documents

TurboDocx Ecosystem

| Package | Description | |---------|-------------| | @turbodocx/html-to-docx | Convert HTML to DOCX - fastest JS library | | @turbodocx/n8n-nodes-turbodocx | n8n community nodes for TurboDocx | | TurboDocx Writer | Microsoft Word add-in |

Features

• 🚀 Production-Ready — Battle-tested, processing thousands of documents daily
• 📝 Full TypeScript Support — Comprehensive type definitions with IntelliSense
• ⚡ Lightweight — Zero dependencies, tree-shakeable
• 🔄 Promise-based — Modern async/await API
• 🛡️ Type-safe — Catch errors at compile time, not runtime
• 🤖 100% n8n Parity — Same operations as our n8n community nodes

Installation

npm install @turbodocx/sdk

# Yarn
yarn add @turbodocx/sdk

# pnpm
pnpm add @turbodocx/sdk

# Bun
bun add @turbodocx/sdk

Install via AI Agent Skill

Let an AI coding agent set up this SDK for you with the TurboDocx Quickstart Agent Skill:

npx skills add TurboDocx/quickstart

Works with Claude Code, GitHub Copilot, Cursor, OpenCode, and other AI coding agents. The skill detects your language, installs the package, and generates working integration code.

Quick Start

import { TurboSign } from '@turbodocx/sdk';

// 1. Configure with your API key and sender information
TurboSign.configure({
  apiKey: process.env.TURBODOCX_API_KEY,
  orgId: process.env.TURBODOCX_ORG_ID,
  senderEmail: process.env.TURBODOCX_SENDER_EMAIL,  // REQUIRED
  senderName: process.env.TURBODOCX_SENDER_NAME     // OPTIONAL (but strongly recommended)
});

// 2. Send a document for signature
const result = await TurboSign.sendSignature({
  file: pdfBuffer,
  documentName: 'Partnership Agreement',
  recipients: [
    { name: 'John Doe', email: '[email protected]', signingOrder: 1 }
  ],
  fields: [
    {
      type: 'signature',
      recipientEmail: '[email protected]',
      template: { anchor: '{signature1}', placement: 'replace', size: { width: 100, height: 30 } }
    }
  ]
});

console.log('Document ID:', result.documentId);

Configuration

import { TurboSign } from '@turbodocx/sdk';

// Basic configuration (REQUIRED)
TurboSign.configure({
  apiKey: 'your-api-key',           // REQUIRED
  orgId: 'your-org-id',             // REQUIRED
  senderEmail: '[email protected]',   // REQUIRED - reply-to address for signature requests
  senderName: 'Your Company'        // OPTIONAL but strongly recommended
});

// With custom options
TurboSign.configure({
  apiKey: 'your-api-key',
  orgId: 'your-org-id',
  senderEmail: '[email protected]',
  senderName: 'Your Company',
  baseUrl: 'https://custom-api.example.com',  // Optional: custom API endpoint
});

Important: senderEmail is REQUIRED. This email will be used as the reply-to address for signature request emails. Without it, emails will default to "API Service User via TurboSign". The senderName is optional but strongly recommended for a professional appearance.

Environment Variables

We recommend using environment variables for your configuration:

# .env
TURBODOCX_API_KEY=your-api-key
TURBODOCX_ORG_ID=your-org-id
[email protected]
TURBODOCX_SENDER_NAME=Your Company Name

TurboSign.configure({
  apiKey: process.env.TURBODOCX_API_KEY,
  orgId: process.env.TURBODOCX_ORG_ID,
  senderEmail: process.env.TURBODOCX_SENDER_EMAIL,
  senderName: process.env.TURBODOCX_SENDER_NAME
});

API Reference

TurboSign

createSignatureReviewLink(options)

Upload a document for review without sending signature emails. Returns a preview URL.

const result = await TurboSign.createSignatureReviewLink({
  fileLink: 'https://example.com/contract.pdf',
  recipients: [
    { name: 'John Doe', email: '[email protected]', order: 1 }
  ],
  fields: [
    { type: 'signature', page: 1, x: 100, y: 500, width: 200, height: 50, recipientOrder: 1 }
  ],
  documentName: 'Service Agreement',        // Optional
  documentDescription: 'Q4 Contract',       // Optional
  senderName: 'Acme Corp',                  // Optional
  senderEmail: '[email protected]',        // Optional
  ccEmails: ['[email protected]']              // Optional
});

console.log('Preview URL:', result.previewUrl);
console.log('Document ID:', result.documentId);

sendSignature(options)

Upload a document and immediately send signature request emails.

const result = await TurboSign.sendSignature({
  fileLink: 'https://example.com/contract.pdf',
  recipients: [
    { name: 'Alice', email: '[email protected]', order: 1 },
    { name: 'Bob', email: '[email protected]', order: 2 }  // Signs after Alice
  ],
  fields: [
    { type: 'signature', page: 1, x: 100, y: 500, width: 200, height: 50, recipientOrder: 1 },
    { type: 'signature', page: 1, x: 100, y: 600, width: 200, height: 50, recipientOrder: 2 }
  ]
});

// Each recipient gets a unique signing URL
result.recipients.forEach(r => {
  console.log(`${r.name}: ${r.signUrl}`);
});

getStatus(documentId)

Check the current status of a document.

const status = await TurboSign.getStatus('doc-uuid-here');

console.log('Document Status:', status.status);  // 'pending' | 'completed' | 'voided'
console.log('Recipients:', status.recipients);

// Check individual recipient status
status.recipients.forEach(r => {
  console.log(`${r.name}: ${r.status}`);  // 'pending' | 'signed' | 'declined'
});

download(documentId)

Download the signed document as a Buffer/Blob.

const signedPdf = await TurboSign.download('doc-uuid-here');

// Node.js: Save to file
import { writeFileSync } from 'fs';
writeFileSync('signed-contract.pdf', signedPdf);

// Browser: Trigger download
const blob = new Blob([signedPdf], { type: 'application/pdf' });
const url = URL.createObjectURL(blob);
window.open(url);

void(documentId, reason)

Cancel a signature request.

await TurboSign.void('doc-uuid-here', 'Contract terms changed');

resend(documentId, recipientIds)

Resend signature request emails to specific recipients.

await TurboSign.resend('doc-uuid-here', ['recipient-uuid-1', 'recipient-uuid-2']);

getAuditTrail(documentId)

Get the complete audit trail for a document, including all events and timestamps.

const audit = await TurboSign.getAuditTrail('doc-uuid-here');

console.log('Document:', audit.document.name);

for (const entry of audit.auditTrail) {
  console.log(`${entry.actionType} - ${entry.timestamp}`);
  if (entry.user) {
    console.log(`  By: ${entry.user.name} (${entry.user.email})`);
  }
  if (entry.recipient) {
    console.log(`  Recipient: ${entry.recipient.name}`);
  }
}

The audit trail includes a cryptographic hash chain for tamper-evidence verification.

TurboPartner (Partner API)

The TurboPartner module provides partner portal operations for managing organizations, users, API keys, and audit logs.

Configuration

import { TurboPartner } from '@turbodocx/sdk';

TurboPartner.configure({
  partnerApiKey: process.env.TURBODOCX_PARTNER_API_KEY,  // Must start with TDXP-
  partnerId: process.env.TURBODOCX_PARTNER_ID,           // UUID format
});

Environment Variables:

# .env
TURBODOCX_PARTNER_API_KEY=TDXP-your-partner-api-key
TURBODOCX_PARTNER_ID=your-partner-uuid

Organization Management

// Create an organization
const org = await TurboPartner.createOrganization({
  name: 'Acme Corp',
  metadata: { industry: 'Technology' },
  features: { maxUsers: 50, hasTDAI: true },
});
console.log('Org ID:', org.data.id);

// List organizations
const orgs = await TurboPartner.listOrganizations({ limit: 10, search: 'acme' });

// Get organization details (includes features and tracking)
const details = await TurboPartner.getOrganizationDetails('org-uuid');
console.log('Features:', details.data.features);
console.log('Tracking:', details.data.tracking);

// Update organization name
await TurboPartner.updateOrganizationInfo('org-uuid', { name: 'New Name' });

// Delete an organization
await TurboPartner.deleteOrganization('org-uuid');

// Update organization entitlements
await TurboPartner.updateOrganizationEntitlements('org-uuid', {
  features: { maxUsers: 100, hasTDAI: true },
});

Organization User Management

// List users in an organization
const users = await TurboPartner.listOrganizationUsers('org-uuid', { limit: 25 });

// Add a user to an organization
const user = await TurboPartner.addUserToOrganization('org-uuid', {
  email: '[email protected]',
  role: 'contributor',  // 'admin' | 'contributor' | 'user' | 'viewer'
});

// Update a user's role
await TurboPartner.updateOrganizationUserRole('org-uuid', 'user-uuid', {
  role: 'admin',
});

// Remove a user from an organization
await TurboPartner.removeUserFromOrganization('org-uuid', 'user-uuid');

// Resend invitation email
await TurboPartner.resendOrganizationInvitationToUser('org-uuid', 'user-uuid');

Organization API Key Management

// List API keys
const keys = await TurboPartner.listOrganizationApiKeys('org-uuid');

// Create an API key (full key value is only returned on creation)
const key = await TurboPartner.createOrganizationApiKey('org-uuid', {
  name: 'Production Key',
  role: 'admin',
});
console.log('Key:', key.data.key);

// Update an API key
await TurboPartner.updateOrganizationApiKey('org-uuid', 'key-uuid', {
  name: 'Updated Key Name',
});

// Revoke an API key
await TurboPartner.revokeOrganizationApiKey('org-uuid', 'key-uuid');

Partner API Key Management

// List partner API keys
const partnerKeys = await TurboPartner.listPartnerApiKeys();

// Create a partner API key with scopes
const partnerKey = await TurboPartner.createPartnerApiKey({
  name: 'CI/CD Key',
  scopes: ['org:create', 'org:read', 'org:update'],
  description: 'Key for automated deployments',
});

// Update a partner API key
await TurboPartner.updatePartnerApiKey('key-uuid', {
  name: 'Updated Name',
  scopes: ['org:create', 'org:read'],
});

// Revoke a partner API key
await TurboPartner.revokePartnerApiKey('key-uuid');

Partner User Management

// List partner portal users
const partnerUsers = await TurboPartner.listPartnerPortalUsers();

// Add a user to the partner portal
const partnerUser = await TurboPartner.addUserToPartnerPortal({
  email: '[email protected]',
  role: 'admin',  // 'admin' | 'member' | 'viewer'
  permissions: {
    canManageOrgs: true,
    canManageOrgUsers: true,
    canManagePartnerUsers: false,
    canManageOrgAPIKeys: true,
    canManagePartnerAPIKeys: false,
    canUpdateEntitlements: true,
    canViewAuditLogs: true,
  },
});

// Update partner user permissions
await TurboPartner.updatePartnerUserPermissions('user-uuid', {
  role: 'member',
  permissions: { canManageOrgs: false },
});

// Remove a partner user
await TurboPartner.removeUserFromPartnerPortal('user-uuid');

// Resend partner portal invitation
await TurboPartner.resendPartnerPortalInvitationToUser('user-uuid');

Audit Logs

// Get audit logs with filters
const logs = await TurboPartner.getPartnerAuditLogs({
  action: 'org.created',
  startDate: '2025-01-01',
  endDate: '2025-12-31',
  limit: 100,
});

for (const entry of logs.data.results) {
  console.log(`${entry.action} - ${entry.resourceType} - ${entry.createdOn}`);
}

TurboWebhooks (Signature Webhook)

The TurboWebhooks module manages your organization's signature webhook — a single subscription to TurboDocx signature events (signature.document.completed, signature.document.voided). It also exposes a verifyWebhookSignature helper for incoming webhook receivers.

One webhook per org. The SDK manages a single fixed-name webhook (signature) per org so SDK-managed and UI-managed webhooks stay in sync — what you create here also appears in the dashboard's Signature Webhooks settings page. To manage multiple webhooks per org, call the REST API directly.

Requires administrator role. All webhook routes require an admin TDX- API key.

Configuration

import { TurboWebhooks } from '@turbodocx/sdk';

TurboWebhooks.configure({
  apiKey: process.env.TURBODOCX_API_KEY,
  orgId: process.env.TURBODOCX_ORG_ID,
  // baseUrl: 'http://localhost:3000',  // optional, defaults to https://api.turbodocx.com
});

TurboWebhooks does not require senderEmail (unlike TurboSign) — webhook routes don't send signature emails.

Create the signature webhook (save the secret immediately)

const created = await TurboWebhooks.createWebhook({
  urls: ['https://your-server.example.com/webhooks/turbodocx'], // HTTPS only
  events: ['signature.document.completed', 'signature.document.voided'],
});

// `secret` is shown ONCE here — store it securely. It cannot be retrieved later.
console.log(`Save this secret: ${created.secret}`);

If the signature webhook already exists, createWebhook returns 400 ValidationError. Either update the existing one with updateWebhook or deleteWebhook first.

Get, update, delete

const webhook = await TurboWebhooks.getWebhook();
// `webhook.deliveryStats` and `webhook.availableEvents` are included

await TurboWebhooks.updateWebhook({ isActive: false });
await TurboWebhooks.deleteWebhook();

Test deliveries and replay

const tested = await TurboWebhooks.testWebhook({
  eventType: 'signature.document.completed',
  payload: { documentId: 'doc-xyz', status: 'completed' },
});
console.log(tested.summary); // { total, successful, failed }

const deliveries = await TurboWebhooks.listWebhookDeliveries({ limit: 10 });

// Retry a specific past delivery
const replayed = await TurboWebhooks.replayWebhookDelivery(deliveries.results[0].id);

Rotate the secret

const rotated = await TurboWebhooks.regenerateWebhookSecret();
// `rotated.secret` is the new secret. Old signatures will fail from this moment on.

Aggregate stats

const stats = await TurboWebhooks.getWebhookStats({ days: 30 });
console.log(stats.summary.successRate, stats.eventBreakdown);

Verify incoming webhook signatures

Webhook deliveries from TurboDocx are signed with HMAC-SHA256 over ${timestamp}.${rawBody} using your webhook secret. Use the verifyWebhookSignature helper to verify them in your receiver:

import express from 'express';
import { verifyWebhookSignature } from '@turbodocx/sdk';

const app = express();

// CRITICAL: use raw body parser on the webhook route, NOT express.json().
// The signature is over the exact bytes — re-stringifying breaks verification.
app.post(
  '/webhooks/turbodocx',
  express.raw({ type: 'application/json' }),
  (req, res) => {
    const signature = req.header('X-TurboDocx-Signature') ?? '';
    const timestamp = req.header('X-TurboDocx-Timestamp') ?? '';
    const secret = process.env.TURBODOCX_WEBHOOK_SECRET!;

    if (!verifyWebhookSignature(req.body, signature, timestamp, secret)) {
      return res.status(401).send('invalid signature');
    }

    const event = JSON.parse(req.body.toString('utf8'));
    // ... process event ...
    res.status(200).send('ok');
  },
);

By default the helper enforces a 300-second timestamp tolerance to prevent replay attacks. Override with { toleranceSeconds: N } (0 disables the check — not recommended in production).

TurboQuote (Sales Quoting)

The TurboQuote module provides end-to-end sales quoting: build quote templates, manage your product catalog, assemble quotes with line items, and send them to customers.

Configuration

import { TurboQuote } from '@turbodocx/sdk';

TurboQuote.configure({
  apiKey: process.env.TURBODOCX_API_KEY,  // REQUIRED (or accessToken)
  orgId: process.env.TURBODOCX_ORG_ID,   // REQUIRED
  // baseUrl: 'https://api.turbodocx.com' // optional
});

TurboQuote does not require senderEmail — use apiKey + orgId only.

Methods

| Group | Methods | |---|---| | Configuration | configure() | | Quotes | createQuote(), getQuote(), listQuotes(), updateQuote(), deleteQuote() | | Quote status transitions | sendQuote(), sendQuoteWithDeliverable(), declineQuote(), voidQuote(), handleExpiredQuote(), duplicateQuote() | | Quote downloads | downloadQuotePdf() | | Line items | addLineItems(), addBundleLineItems(), listLineItems(), updateLineItem(), removeLineItem() | | Products | createProduct(), getProduct(), listProducts(), updateProduct(), deleteProduct(), duplicateProduct(), getProductPrimaryImages() | | Bundles | createBundle(), getBundle(), listBundles(), updateBundle(), deleteBundle(), duplicateBundle() | | Price books | createPriceBook(), getPriceBook(), listPriceBooks(), updatePriceBook(), deletePriceBook(), duplicatePriceBook(), applyPriceBook(), removePriceBook(), listPriceBookProducts() | | Quote template | getTemplate(), getTemplateById(), listTemplates(), createTemplate(), updateTemplate(), deleteTemplate() | | Types / categories | createType(), listTypes(), updateType(), deleteType() | | Companies | createCompany(), getCompany(), listCompanies(), updateCompany(), deleteCompany() | | Contacts | createContact(), listCompanyContacts(), updateContact(), deleteContact() |

Create a quote, add line items, and send

// 1. Create the quote
const quote = await TurboQuote.createQuote({
  name: 'Professional Services — Q3 2026',
  companyId: 'company-uuid',
  contactId: 'contact-uuid',
  currency: 'USD',
  validUntil: '2026-09-30',
});
console.log('Quote number:', quote.quoteNumber);

// 2. Add a product line item
const items = await TurboQuote.addLineItems(quote.id, {
  productId: 'product-uuid',
  productName: 'Consulting Service',
  unitPrice: 500,
  billingFrequency: 'monthly',
  quantity: 3,
  discountType: 'percent',
  discountPercent: 10,
});
console.log('Line item ID:', items[0].id);

// 3. Send the quote to the customer
const sent = await TurboQuote.sendQuote(quote.id);
console.log(sent.message);

Download a quote as PDF

import { writeFileSync } from 'fs';

const pdf = await TurboQuote.downloadQuotePdf(quote.id);  // returns ArrayBuffer
writeFileSync('quote.pdf', Buffer.from(pdf));

Field Types

| Type | Description | |:-----|:------------| | signature | Signature field (draw or type) | | initials | Initials field | | text | Free-form text input | | date | Date stamp | | checkbox | Checkbox / agreement | | full_name | Full name | | first_name | First name | | last_name | Last name | | email | Email address | | title | Job title | | company | Company name |

Field Positioning

{
  type: 'signature',
  page: 1,              // Page number (1-indexed)
  x: 100,               // X position from left (pixels)
  y: 500,               // Y position from top (pixels)
  width: 200,           // Field width (pixels)
  height: 50,           // Field height (pixels)
  recipientOrder: 1,    // Which recipient this field belongs to
  required: true        // Optional: default true for signature/initials
}

Examples

For complete, working examples including template anchors, advanced field types, and various workflows, see the examples/ directory:

• turbosign-send-simple.ts - Send document directly with template anchors
• turbosign-basic.ts - Create review link first, then send manually
• turbosign-advanced.ts - Advanced field types (checkbox, readonly, multiline text, etc.)

Sequential Signing (Multiple Recipients)

const result = await TurboSign.sendSignature({
  fileLink: 'https://example.com/contract.pdf',
  recipients: [
    { name: 'Employee', email: '[email protected]', order: 1 },
    { name: 'Manager', email: '[email protected]', order: 2 },
    { name: 'HR', email: '[email protected]', order: 3 }
  ],
  fields: [
    // Employee signs first
    { type: 'signature', page: 1, x: 100, y: 400, width: 200, height: 50, recipientOrder: 1 },
    { type: 'date', page: 1, x: 320, y: 400, width: 100, height: 30, recipientOrder: 1 },
    // Manager signs second
    { type: 'signature', page: 1, x: 100, y: 500, width: 200, height: 50, recipientOrder: 2 },
    { type: 'date', page: 1, x: 320, y: 500, width: 100, height: 30, recipientOrder: 2 },
    // HR signs last
    { type: 'signature', page: 1, x: 100, y: 600, width: 200, height: 50, recipientOrder: 3 },
    { type: 'date', page: 1, x: 320, y: 600, width: 100, height: 30, recipientOrder: 3 }
  ]
});

Polling for Completion

async function waitForCompletion(documentId: string, maxAttempts = 60) {
  for (let i = 0; i < maxAttempts; i++) {
    const status = await TurboSign.getStatus(documentId);

    if (status.status === 'completed') {
      return await TurboSign.download(documentId);
    }

    if (status.status === 'voided') {
      throw new Error('Document was voided');
    }

    // Wait 30 seconds between checks
    await new Promise(r => setTimeout(r, 30000));
  }

  throw new Error('Timeout waiting for signatures');
}

With Express.js

import express from 'express';
import { TurboSign } from '@turbodocx/sdk';

const app = express();

TurboSign.configure({ apiKey: process.env.TURBODOCX_API_KEY });

app.post('/api/send-contract', async (req, res) => {
  try {
    const result = await TurboSign.sendSignature({
      fileLink: req.body.pdfUrl,
      recipients: req.body.recipients,
      fields: req.body.fields
    });

    res.json({ success: true, documentId: result.documentId });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

Local Testing

The SDK includes a comprehensive manual test script to verify all functionality locally.

Running Manual Tests

# Install dependencies
npm install

# Run the manual test script
npx tsx manual-test.ts

What It Tests

The manual-test.ts file tests all SDK methods:

• ✅ createSignatureReviewLink() - Document upload for review
• ✅ sendSignature() - Send for signature
• ✅ getStatus() - Check document status
• ✅ download() - Download signed document
• ✅ void() - Cancel signature request
• ✅ resend() - Resend signature emails

Configuration

Before running, update the hardcoded values in manual-test.ts:

• API_KEY - Your TurboDocx API key
• BASE_URL - API endpoint (default: http://localhost:3000)
• ORG_ID - Your organization UUID
• TEST_FILE_PATH - Path to a test PDF/DOCX file
• TEST_EMAIL - Email address for testing

Expected Output

The script will:

1. Upload a test document
2. Send it for signature
3. Check the status
4. Test void and resend operations
5. Print results for each operation

Error Handling

import { TurboSign, TurboDocxError } from '@turbodocx/sdk';

try {
  await TurboSign.getStatus('invalid-id');
} catch (error) {
  if (error instanceof TurboDocxError) {
    console.error('Status:', error.statusCode);   // HTTP status code
    console.error('Message:', error.message);     // Error message
    console.error('Code:', error.code);           // Error code (if available)
  } else {
    console.error('Unexpected error:', error);
  }
}

Common Error Codes

| Status | Meaning | |:-------|:--------| | 400 | Bad request — check your parameters | | 401 | Unauthorized — check your API key | | 404 | Document not found | | 429 | Rate limited — slow down requests | | 500 | Server error — retry with backoff |

TypeScript

Full TypeScript support with exported types:

import {
  TurboSign,
  SendSignatureRequest,
  CreateSignatureReviewLinkRequest,
  Recipient,
  Field,
  DocumentStatus,
  TurboDocxError
} from '@turbodocx/sdk';

// Type-safe options
const options: SendSignatureRequest = {
  fileLink: 'https://example.com/contract.pdf',
  recipients: [{ name: 'John', email: '[email protected]', signingOrder: 1 }],
  fields: [{ type: 'signature', page: 1, x: 100, y: 500, width: 200, height: 50, recipientEmail: '[email protected]' }]
};

const result = await TurboSign.sendSignature(options);

Requirements

• Node.js 16+
• TypeScript 4.7+ (if using TypeScript)

Related Packages

| Package | Description | |:--------|:------------| | @turbodocx/n8n-nodes-turbodocx | n8n community nodes | | turbodocx-sdk (Python) | Python SDK | | turbodocx (Go) | Go SDK |

Support

• 📖 Documentation
• 💬 Discord
• 🐛 GitHub Issues

License

MIT — see LICENSE