NODE.JS

Node.js SDK for Secure eSignature Integration

Integrate legally binding e-signatures into your Node.js applications in minutes with a production-ready SDK and clear developer documentation.

View documentation

Create free Sandbox

				
					import { TemplateApi, Role, SendForSignFromTemplateForm  } from "boldsign";
 
// Create an instance of the Template API
const api = new TemplateApi();
 
// Set your BoldSign API key for authentication
api.setApiKey("YOUR_API_KEY");
 
// Create and configure the signer role
const role = new Role();
role.roleIndex = 1;
role.signerName = "Signer Name";
role.signerEmail = "signer@example.com";
 
// Create the request and assign signer roles
const req = new SendForSignFromTemplateForm();
req.roles = [role];
 
// Send the document for signing using the template
const documentCreated = api.sendUsingTemplate("YOUR_TEMPLATE_ID", req);

				
					npm install boldsign

Built for Secure Node.js eSignature Workflows

Build secure, compliant e‑signature workflows for production Node.js services and APIs.

Secure Signer Authentication

Set Access codes, email OTP, SMS OTP, or identity verification directly via Node.js SDK calls.

Event-Driven Webhooks

Receive real-time document and signing events with reliable delivery retries for up to 8 hours.

Templates & Text Tags

Create reusable templates and auto‑place fields using text tags to simplify document preparation.

Embedded Sending & Signing

Embed end‑to‑end document sending and signing flows directly into your Node.js applications.

SaaS & Multi-Tenant Ready

Send documents on behalf of users, manage teams, branding, and scale across tenants.

Enterprise-Grade Compliance

ESIGN, UETA, and eIDAS compliance with encryption, audit trails, and reliable webhooks.

Explore eSignature API

Code Examples

				
					import { DocumentApi, DocumentSigner, FormField, Rectangle, SendForSign } from "boldsign";
import * as fs from 'fs';

// Create an instance of the Document API
const documentApi = new DocumentApi();

// Set your BoldSign API key for authentication
documentApi.setApiKey("YOUR_API_KEY");

const bounds = new Rectangle();
bounds.x = 100;
bounds.y = 50;
bounds.width = 100;
bounds.height = 100;

// Create a form field for the signature
const formField = new FormField();
formField.fieldType = FormField.FieldTypeEnum.Signature;
formField.pageNumber = 1;
formField.bounds = bounds;

// Create a signer for the document
const documentSigner = new DocumentSigner();
documentSigner.name = "Signer Name";
documentSigner.emailAddress = "signer@example.com";
documentSigner.signerType = DocumentSigner.SignerTypeEnum.Signer;
documentSigner.formFields = [formField];

const files = fs.createReadStream("YOUR_FILE_PATH");

// Create a SendForSign request
const sendForSign = new SendForSign();
sendForSign.title = "Agreement";
sendForSign.signers = [documentSigner];
sendForSign.files = [files];

// Send the document for signing
const documentCreated = documentApi.sendDocument(sendForSign);

				
					import { DocumentApi, DocumentSigner, EmbeddedDocumentRequest, FormField, Rectangle } from "boldsign";
import * as fs from 'fs';

// Create Document API instance
const documentApi = new DocumentApi();

// Set BoldSign API key
documentApi.setApiKey("YOUR_API_KEY");

const bounds = new Rectangle();
bounds.x = 100;
bounds.y = 50;
bounds.width = 100;
bounds.height = 100;

// Create a signature form field
const formField = new FormField();
formField.fieldType = FormField.FieldTypeEnum.Signature;
formField.pageNumber = 1;
formField.bounds = bounds;

// Configure the signer
const documentSigner = new DocumentSigner();
documentSigner.name = "Signer Name";
documentSigner.emailAddress = "signer@example.com";
documentSigner.signerType = DocumentSigner.SignerTypeEnum.Signer;
documentSigner.formFields = [formField];

const files = fs.createReadStream("YOUR_FILE_PATH");

// Create embedded document request
const embeddedDocumentRequest = new EmbeddedDocumentRequest();
embeddedDocumentRequest.title = "Sent from API Node SDK";
embeddedDocumentRequest.showToolbar = true;
embeddedDocumentRequest.sendViewOption = EmbeddedDocumentRequest.SendViewOptionEnum.FillingPage;
embeddedDocumentRequest.files = [files];
embeddedDocumentRequest.signers = [documentSigner];

const embeddedSendCreated = documentApi.createEmbeddedRequestUrlDocument(embeddedDocumentRequest);

				
					import { DocumentApi } from "boldsign";

// Create an instance of the Document API
const documentApi = new DocumentApi();

// Set your BoldSign API key
documentApi.setApiKey("YOUR_API_KEY");

const documentId = "YOUR_DOCUMENT_ID";
const signerEmail = "signer@example.com";

// Generate embedded signing URL
const embeddedSigningLink = documentApi.getEmbeddedSignLink(documentId, signerEmail);

				
					import { TemplateApi, CreateTemplateRequest, TemplateRole, Rectangle, FormField } from "boldsign";
import * as fs from 'fs';

const templateApi = new TemplateApi();

// Set BoldSign API key
templateApi.setApiKey("YOUR_API_KEY");

const bounds = new Rectangle();
bounds.x = 100;
bounds.y = 50;
bounds.width = 100;
bounds.height = 100;

// Create a signature form field
const formField = new FormField();
formField.fieldType = FormField.FieldTypeEnum.Signature;
formField.pageNumber = 1;
formField.bounds = bounds;

// Configure template role
const role = new TemplateRole();
role.index = 1;
role.name = "Signer";
role.defaultSignerEmail = "signer@example.com";
role.defaultSignerName = "Signer Name";
role.signerType = TemplateRole.SignerTypeEnum.Signer;
role.formFields = [formField];

const file = fs.createReadStream("YOUR_FILE_PATH");

// Create template request
const createTemplateRequest = new CreateTemplateRequest();
createTemplateRequest.title = "Testing node sdk";
createTemplateRequest.documentTitle = "Node sdk test case";
createTemplateRequest.roles = [role];
createTemplateRequest.files = [file];

const templateCreated = templateApi.createTemplate(createTemplateRequest);

				
					import { DocumentApi, DocumentSigner, FormField, Rectangle, SendForSign, IdentityVerificationSettings } from "boldsign";
import * as fs from 'fs';

const documentApi = new DocumentApi();

// Set your BoldSign API key for authentication
documentApi.setApiKey("YOUR_API_KEY");

const rect = new Rectangle();
rect.x = 100;
rect.y = 100;
rect.width = 100;
rect.height = 50;

const field = new FormField();
field.id = "Signature1";
field.fieldType = FormField.FieldTypeEnum.Signature;
field.pageNumber = 1;
field.bounds = rect;

// Configure identity verification settings for the signer
const idVerification = new IdentityVerificationSettings();
idVerification.type = IdentityVerificationSettings.TypeEnum.EveryAccess;
idVerification.maximumRetryCount = 10;
idVerification.requireLiveCapture = true;
idVerification.requireMatchingSelfie = true;
idVerification.nameMatcher = IdentityVerificationSettings.NameMatcherEnum.Strict;
idVerification.allowedDocumentTypes = [
    IdentityVerificationSettings.AllowedDocumentTypesEnum.Passport,
    IdentityVerificationSettings.AllowedDocumentTypesEnum.IdCard,
    IdentityVerificationSettings.AllowedDocumentTypesEnum.DriverLicense
];

// Create a signer and assign identity verification
const signer = new DocumentSigner();
signer.name = "Signer Name";
signer.emailAddress = "signer@example.com";
signer.signerType = DocumentSigner.SignerTypeEnum.Signer;
signer.authenticationType = DocumentSigner.AuthenticationTypeEnum.IdVerification;
signer.identityVerificationSettings = idVerification;
signer.formFields = [field];

// Create the send-for-sign request
const sendForSign = new SendForSign();
sendForSign.title = "DOCUMENT_TITLE";
sendForSign.signers = [signer];
sendForSign.files = [fs.createReadStream('YOUR_FILE_PATH')];

// Send the document for signing with identity verification enabled
const documentCreated = await documentApi.sendDocument(sendForSign);

Common Workflows

Built for teams that need fast, secure, and automated e‑signature workflows across Node.js services and APIs.

Sales & Legal Documents

Automate contract delivery, signer tracking, and completion using Node.js SDK calls and webhook‑based updates.

Hiring & Onboarding

Add signing to Node.js‑powered onboarding flows for offer letters, employment agreements, and internal policies.

Consent & Authorization Management

Handle consent and authorization use cases with API‑driven signing, audit trails, and secure data handling.

Banking & Compliance Workflows

Streamline agreement and regulatory documents using secure signing and real‑time status notifications.

Property & Leasing Workflows

Manage property‑related documents end‑to‑end by programmatically sending and tracking files from your app.

Customer-Facing SaaS Platforms

Embed e‑signature capabilities directly into your Node.js product and enable signing workflows for your customers at scale.

Key stats

Why BoldSign?

25+

Years in business

120+

Countries

50,000+

Customers

99.999%

Uptime reliability

Ready to Get Started?

Start building secure e‑signature workflows in your Node.js applications using the BoldSign Node.js SDK, designed for production use and built to scale.

Install Node.js SDK

Read Documentation

Articles

Explore more articles on this topic

Discover additional articles, implementation guides, and best practices related to the BoldSign Node.js SDK.

Blog Post

Introducing BoldSign Node.js SDK for effortless E-Signature integration

Effortlessly add e‑signatures into your applications with the BoldSign Node.js SDK.

Blog Post

Integrate eSignatures into Node.js Application with BoldSign

Embed eSignatures into your Node.js application and manage all signing tasks directly within your app.

Frequently asked questions

How do I send a document for signature using the Node.js SDK?

You can send a document by creating a SendForSign request, adding signers and files, and calling the sendDocument method from the Document API. The SDK handles document delivery, signer notifications, and status tracking.

Does the Node.js SDK support embedded signing?

Yes. You can generate embedded signing links using the SDK and integrate the signing experience directly into your application using an iFrame or custom UI.

Can I automate workflows using webhooks?

Yes. The SDK works with BoldSign webhooks to notify your application in real time when events occur, such as document sent, viewed, signed, or completed.

Is the BoldSign Node.js SDK secure and compliant?

Yes. BoldSign supports ESIGN, UETA, and eIDAS compliance, along with encryption, audit trails, and secure signer authentication methods such as OTP and identity verification. For more, refer to this guide on Compliance.

How do I authenticate API requests in the Node.js SDK?

You can authenticate using your BoldSign API key or OAuth2.0 by setting it in the SDK configuration. This allows secure communication between your application and BoldSign APIs.

Does the SDK support multi-tenant SaaS applications?

Yes. You can send documents on behalf of users, manage teams, and implement tenant-level branding, making it suitable for SaaS platforms. For more details, refer to this guide: Integrate eSignature Capabilities into Your SaaS Applications.

Can I use templates to simplify document workflows?

Yes. You can create reusable templates and use them to send documents quickly without redefining fields and signer details each time.

What file formats are supported for signing?

BoldSign supports commonly used formats such as PDF, JPG, PNG, DOCX, and Excel (.xlsx) for document signing workflows. For more, refer to this guide on supported file formats and file sizes.

How reliable are webhook deliveries?

Webhook events are retried automatically for up to several hours to ensure your application receives important updates even if there are temporary failures.

Where can I find complete API documentation and examples?

You can access detailed documentation, SDK references, and additional examples in the BoldSign developer documentation.

Sign up for your free trial today!

30-day free trial
No credit card required

30-day free trial

No credit card required