Node Migration Guide

View as Markdown

Migrating the Node SDK from hellosign-sdk to @dropbox/sign

Welcome! Dropbox Sign's new Node SDK is generated from our officially maintained OpenAPI spec. In this release, we've made important updates that introduce new functionality and create feature parity between the Dropbox Sign API and the Node SDK. However, some of these changes are considered "breaking" in the sense that they'll require you to update your existing code in order to continue using the SDK.

In this migration guide, we'll cover core concepts in the new SDK, highlight differences from legacy versions, and provide example code showing how past implementations map to the new version's syntax. We'll link out to supporting documents that offer more context behind the breaking changes and why we made them. We apologize for any inconvenience these changes may cause, but are confident the new features will add value to your integration.

Remember that we are here to help if you have any questions or need assistance along the way. Thank you for using Dropbox Sign's Node SDK. We hope you enjoy the improvements!

Architecture and Tooling

As mentioned above, the new Node SDK (@dropbox/sign) is generated from our OpenAPI Spec. Some of the architectural changes impact the tools and locations you use to interact with the SDK.

SDK Resources

  • Download -- using this new npm repo. New Node SDK versions will now be published here.
  • Development -- active development against the Node SDK happens here: hellosign-openapi/sdks/node.
  • SDK GitHub Repo -- dropbox-sign-node is updated based on changes to hellosign-openapi/sdks/node, but no active development work happens there.
  • Reference Docs -- the automatically generated Reference Docs are a great way to explore the SDK.
  • Examples -- our full suite of ready to use examples will help you get started quickly.
  • Engagement -- use the OpenAPI repo to submit Issues or Pull Requests for the Node SDK.

Core Concepts and Patterns

This section contains the core concepts and patterns of the new SDK and highlights differences from the legacy SDK.

Installation

There are two methods for installing the new SDK:

Install from NPM

  1. Optionally, to scaffold your package.json first run:

    $npm init
  2. To install from NPM run:

    $npm install @dropbox/sign

Build from Source

  1. Clone the repo locally

    $git clone https://github.com/hellosign/dropbox-sign-node.git
  2. Run npm pack
  3. Move generated file (dropbox-sign-1.0.0.tgz or similar) to your project directory

  4. In the dependencies array of your package.json file, add

    1"@dropbox/sign": "file:dropbox-sign-1.0.0.tgz"
  5. Run npm install


Importing the SDK

The new Node SDK is packaged as an ES Module rather than CommonJS, which means you’ll bring it into your code base differently.

Legacy Node SDK

Use require statement to bring in the entire Dropbox Sign SDK.

New Node SDK

Use import statement to add the entire SDK or only the pieces you need.

1const sign_sdk = require('hellosign-sdk')({ key: "API_KEY" });

To support ES Modules and use import statements in your Node project, your package.json file must contain "type": "module".


Authentication

Rather than one big SDK with access to everything, the new Node SDK is organized into groups of similar endpoints.

Legacy Node SDK

Pass credentials once when instantiating the SDK.

New Node SDK

Pass credentials each time a new section of the SDK is instantiated (Signature Request, Template, Account, etc.)

1const sign_sdk = require('hellosign-sdk')({key: 'YOUR API KEY HERE'});

Endpoints Grouped into Classes

The new SDK divides endpoints across unique Classes:


Using Models to Pass Parameters

Models are used to define the structure and value of the parameters being passed. The fully assembled model is passed to the API endpoint method.

New SDK Using Models to Pass Parameters

1import * as DropboxSign from "@dropbox/sign";
2
3const fs = require('fs');
4
5const apiAppApi = new DropboxSign.ApiAppApi();
6
7apiAppApi.username = "YOUR_API_KEY";
8
9const oauth = {
10 callbackUrl: "https://example.com/oauth",
11 scopes: [
12 "basic_account_info",
13 "request_signature"
14 ]
15};
16
17const whiteLabelingOptions = {
18 primaryButtonColor: "#00b3e6",
19 primaryButtonTextColor: "#ffffff"
20};
21
22const data = {
23 name: "My Production App",
24 domains: ["example.com"],
25 customLogoFile: fs.createReadStream("CustomLogoFile.png"),
26 oauth,
27 whiteLabelingOptions
28};
29
30const result = apiAppApi.apiAppCreate(data);
31result.then(response => {
32 console.log(response.body);
33}).catch(error => {
34 console.log("Exception when calling Dropbox Sign API:");
35 console.log(error.body);
36});

Path and Query Parameters

When passing parameters to the API methods in the legacy SDK it was standard to pass the parameters inside of an object to the API method. For example using the opts object below:

Legacy SDK - Path and Query Parameters

1const hellosign = require('hellosign-sdk')({ key: 'HelloSign_API_KEY' });
2
3const opts = {
4 page: 1,
5 account_id: 'all'
6}
7
8hellosign.signatureRequest.list(opts).then((res) => {
9 console.log(res);
10}).catch((err) => {
11 console.error(err);
12});

The new SDK no longer accepts objects when passing path or query parameters to endpoints. Instead you will need to pass the parameters as separate variables such as accountId and page below:

New SDK - Path and Query Parameters

1import * as DropboxSign from "@dropbox/sign";
2
3const signatureApi = new DropboxSign.SignatureRequestApi();
4signatureApi.username = "YOUR_API_KEY";
5
6const accountId = null;
7const page = 1;
8
9const result = signatureApi.signatureRequestList(accountId, page);
10result.then(response => {
11 console.log(response.body);
12}).catch(error => {
13 console.log("Exception when calling Dropbox Sign API:");
14 console.log(error.body);
15});

Endpoints that have both path or query parameters, and accept POST data, will have a mix of both styles:

1import * as DropboxSign from "@dropbox/sign";
2
3const signatureRequestApi = new DropboxSign.SignatureRequestApi();
4
5signatureRequestApi.username = "YOUR_API_KEY";
6
7const data = {
8 emailAddress: "john@example.com"
9};
10
11const signatureRequestId = "2f9781e1a8e2045224d808c153c2e1d3df6f8f2f";
12
13const result = signatureRequestApi.signatureRequestRemind(signatureRequestId, data);
14result.then(response => {
15 console.log(response.body);
16}).catch(error => {
17 console.log("Exception when calling Dropbox Sign API:");
18 console.log(error.body);
19});

Error Handling and Warnings

The New SDK handles errors and warnings differently.

Error Handling

Errors are an instance of HttpError with its body parameter being an instance of ErrorResponse class and should be handled using Try/Catch blocks.

New SDK - Error Handling
1import * as DropboxSign from "@dropbox/sign";
2
3const accountApi = new DropboxSign.AccountApi();
4
5accountApi.username = "YOUR_API_KEY";
6
7const data = {
8 emailAddress: "newuser@dropboxsign.com"
9};
10
11const result = accountApi.accountCreate(data);
12result.then(response => {
13 console.log(response.body);
14}).catch(error => {
15 // error is instance of HttpError
16 console.log("Exception when calling Dropbox Sign API:");
17 // error.body is instance of ErrorResponse
18 console.log(error.body);
19});

Warnings

Warnings are a list of WarningResponse.

New SDK - Warnings

1import * as DropboxSign from "@dropbox/sign";
2
3const accountApi = new DropboxSign.AccountApi();
4
5accountApi.username = "YOUR_API_KEY";
6
7const data = {
8 emailAddress: "newuser@dropboxsign.com"
9};
10
11const result = accountApi.accountCreate(data);
12result.then(response => {
13 console.log(response.body);
14
15 // warning loop
16 response.body.warnings.forEach(warning => {
17 console.log(`Warning Name: ${warning.warningName}`);
18 console.log(`Warning Message: ${warning.warningMsg}`);
19 });
20}).catch(error => {
21 // error is instance of HttpError
22 console.log("Exception when calling Dropbox Sign API:");
23 // error.body is instance of ErrorResponse
24 console.log(error.body);
25});

Instantiating Objects From Data

There are two ways to instantiate an object.

  • You can instantiate a class directly and use setters to set your data
  • You can use an object literal that matches expected type definitions
1const signer1 = new DropboxSign.SubSignatureRequestSigner();
2signer1.name = "George";
3signer1.emailAddress = "george@example.com";
4
5const attachment1 = new DropboxSign.SubAttachment();
6attachment1.name = "Attachment 1";
7attachment1.instructions = "Please download this file";
8attachment1.signerIndex = 0;
9attachment1.required = true;

Event Callback Helper

A callback helper class is included in the New SDK repo to assist in verifying callbacks. The helper simplifies:

  1. Checking event authenticity with built in event hash check
  2. Displaying event types (account callback vs. app callback)
  3. Displaying event messages

The EventCallbackHelper and EventCallbackRequest classes facilitate parsing of event data and assist in validating that a callback originated from Dropbox Sign.

We will send event callback payloads to you as a multipart/form-data request with a single json formfield that contains your event callback as a JSON string.

Example Event Callback Request From US to YOU

$curl -X POST 'https://example.com/YOUR_EVENT_CALLBACK_URL' \
> -F 'json={"event":{"event_type":"account_confirmed","event_time":"1669926463","event_hash":"ff8b03439122f9160500c3fb855bdee5a9ccba5fff27d3b258745d8f3074832f","event_metadata":{"related_signature_id":null,"reported_for_account_id":"6421d70b9bd45059fa207d03ab8d1b96515b472c","reported_for_app_id":null,"event_message":null}}}'

Example JSON Payload

1{
2 "event": {
3 "event_type": "account_confirmed",
4 "event_time": "1669926463",
5 "event_hash": "ff8b03439122f9160500c3fb855bdee5a9ccba5fff27d3b258745d8f3074832f",
6 "event_metadata": {
7 "related_signature_id": null,
8 "reported_for_account_id": "6421d70b9bd45059fa207d03ab8d1b96515b472c",
9 "reported_for_app_id": null,
10 "event_message": null
11 }
12 }
13}

How to use the EventCallbackHelper

1import { EventCallbackRequest, EventCallbackHelper } from "@dropbox/sign";
2
3// use your API key
4const api_key = '324e3b0840f065eb51f3fd63231d0d33daa35d4ed10d27718839e81737065782';
5
6// callback_data represents data we send to you
7const callback_data = JSON.parse(req.body.json);
8
9const callback_event = EventCallbackRequest.init(callback_data);
10
11// verify that a callback came from HelloSign.com
12if (EventCallbackHelper.isValid(api_key, callback_event)) {
13 // one of "account_callback" or "api_app_callback"
14 const callback_type = EventCallbackHelper.getCallbackType(callback_event);
15
16 // do your magic below!
17}

Native TypeScript Support

The new SDK is written in TypeScript and comes fully typed for the best possible developer experience.

If you do not use TypeScript you can still use the new SDK as normal.


Differences from Legacy SDK

This section highlights larger changes to be aware of when migrating to the new SDK.

Form Fields Per Document

The Form Fields per Document parameter has changed from a two dimensional array, to a one dimensional array—allowing you to designate which file you to add the field to using documentIndex. You can learn more about this change here: Form Fields per Document.

1const hellosign = require('hellosign-sdk')({ key: process.env.HelloSign_API_KEY });
2
3module.exports = {
4send_signature_request: function () {
5 const opts = {
6 test_mode: 1,
7 files: ['Demo-Mutual-Non-Disclosure-Agreement.pdf'],
8 title: 'NDA with Acme Co.',
9 subject: 'The NDA we talked about',
10 message: 'Please sign this NDA and then we can discuss more.',
11 signers: [
12 {
13 name: 'Jill',
14 email_address: 'jill@example.com'
15 }
16 ],
17 form_fields_per_document: [[{
18 "api_id": "abcd",
19 "name": "signer_signature",
20 "type": "signature",
21 "x": 200,
22 "y": 300,
23 "page": 1,
24 "width": 280,
25 "height": 72,
26 "required": true,
27 "signer": 0
28 }]]
29};
30
31 hellosign.signatureRequest.send(opts).then((res) => {
32 console.log(res)
33 }).catch((err) => {
34 console.log(err)
35 });
36 }
37}

Instantiating the Correct Field Class

There are several different types of form fields you can define, identified by the value of the type field and a few ways to instantiate the correct object when making an API request.

The different classes for each type are:

You can use a literal object definition with no typing:

1const data = {
2 testMode: true,
3 files: [ yourFile ],
4 title: "NDA with Acme Co.",
5 subject: "The NDA we talked about",
6 message: "Please sign this NDA and then we can discuss more. Let me know if you have any questions.",
7 signers: [ signer1 ],
8 formFieldsPerDocument: [
9 {
10 type: "signature",
11 documentIndex: 0,
12 apiId: "abcd",
13 name: "field_1",
14 x: 200,
15 y: 300,
16 page: 1,
17 width: 280,
18 height: 72,
19 required: true,
20 signer: "0"
21 }
22 ]
23};

You can also instantiate an instance of the correct class. In this scenario the type field is automatically set to the correct value for you:

1// type is automatically set to "signature"
2const formField1 = new DropboxSign.SubFormFieldsPerDocumentSignature();
3formField1.documentIndex = 0;
4formField1.apiId = "abcd";
5formField1.name = "signer_signature";
6formField1.x = 200;
7formField1.y = 300;
8formField1.page = 1;
9formField1.width = 280;
10formField1.height = 72;
11formField1.required = true;
12formField1.signer = "0";
13
14const data = {
15 testMode: true,
16 files: [ yourFile ],
17 title: "NDA with Acme Co.",
18 subject: "The NDA we talked about",
19 message: "Please sign this NDA and then we can discuss more. Let me know if you have any questions.",
20 signers: [ signer1 ],
21 formFieldsPerDocument: [ formField1 ]
22};

If you are using TypeScript you can use a literal object definition with typehint on the object itself. If you use a typehint any invalid or missing data will be highlighted on the object itself in your IDE.

If you use TypeScript but do not typehint the object, you will see the error when passing the data to the API endpoint.

1// TS2741: Property '"type"' is missing in type [...]
2const formField1: DropboxSign.SubFormFieldsPerDocumentSignature = {
3 documentIndex: 0,
4 apiId: "abcd",
5 name: "field_1",
6 x: 200,
7 y: 300,
8 page: 1,
9 width: 280,
10 height: 72,
11 required: true,
12 signer: "0"
13}
14
15const data = {
16 testMode: true,
17 files: [ yourFile ],
18 title: "NDA with Acme Co.",
19 subject: "The NDA we talked about",
20 message: "Please sign this NDA and then we can discuss more. Let me know if you have any questions.",
21 signers: [ signer1 ],
22 formFieldsPerDocument: [ formField1 ]
23};
24
25const result = signatureApi.signatureRequestSend(data);
26result.then(response => {
27 console.log(response.body);
28}).catch(error => {
29 console.log("Exception when calling Dropbox Sign API:");
30 console.log(error.body);
31});

”role” Value in signers Object

In the Legacy SDK when making a Signature Request using a Template the signers property was an object with the role name as the key. In the new SDK the role value has been moved into the signer object itself.

For example for the /signature_request/send_with_template endpoint the signers property could be represented as:

1{
2 "signers": {
3 "Client": {
4 "name": "George",
5 "email_address": "george@example.com"
6 },
7 "Manager": {
8 "name": "Bob",
9 "email_address": "bob@example.com"
10 }
11 }
12}

Using the new SDK you would now send this data as follows:

1import * as DropboxSign from "@dropbox/sign";
2
3const signatureRequestApi = new DropboxSign.SignatureRequestApi();
4
5signatureRequestApi.username = "YOUR_API_KEY";
6
7const data = {
8 templateIds: ["c26b8a16784a872da37ea946b9ddec7c1e11dff6"],
9 subject: "Purchase Order",
10 message: "Glad we could come to an agreement.",
11 signers: [
12 {
13 "role": "Client",
14 "name": "George",
15 "emailAddress": "george@example.com"
16 },
17 {
18 "role": "Manager",
19 "name": "Bob",
20 "emailAddress": "bob@example.com"
21 }
22 ]
23};
24
25const result = signatureRequestApi.signatureRequestSendWithTemplate(data);
26result.then(response => {
27 console.log(response.body);
28}).catch(error => {
29 console.log("Exception when calling Dropbox Sign API:");
30 console.log(error.body);
31});

“role” Value in ccs Property

In the Legacy SDK when making a Signature Request using a Template the ccs property was an object with the role name as the key. In the new SDK the role value has been moved into the cc object itself, alongside a new email_address property.

For example for the /signature_request/send_with_template endpoint the ccs property could be represented as:

1{
2 "ccs": {
3 "Client": "george@example.com",
4 "Manager": "bob@example.com"
5 }
6}

Using the new SDK you would now send this data as follows:

1import * as DropboxSign from "@dropbox/sign";
2
3const signatureRequestApi = new DropboxSign.SignatureRequestApi();
4
5signatureRequestApi.username = "YOUR_API_KEY";
6
7const data = {
8 templateIds: ["c26b8a16784a872da37ea946b9ddec7c1e11dff6"],
9 subject: "Purchase Order",
10 message: "Glad we could come to an agreement.",
11 signers: [
12 {
13 role: "Client",
14 name: "George",
15 emailAddress: "george@example.com"
16 },
17 {
18 role: "Manager",
19 name: "Bob",
20 emailAddress: "bob@example.com"
21 }
22 ],
23 ccs: [
24 {
25 role: "Client",
26 emailAddress: "george@example.com"
27 },
28 {
29 role: "Manager",
30 emailAddress: "bob@example.com"
31 }
32 ]
33};
34
35const result = signatureRequestApi.signatureRequestSendWithTemplate(data);
36result.then(response => {
37 console.log(response.body);
38}).catch(error => {
39 console.log("Exception when calling Dropbox Sign API:");
40 console.log(error.body);
41});

“name” Value in custom_fields Property

In the Legacy SDK when making a Signature Request with the custom_fields property it was an object with the name as the key. In the new SDK the name value has been moved into the custom_field object itself.

For example for the /signature_request/send_with_template endpoint the custom_fields property could be represented as:

1{
2 "custom_fields": {
3 "company": {
4 "value": "ABC Corp",
5 "required": true
6 }
7 }
8}

Using the new SDK you would now send this data as follows:

1import * as DropboxSign from "@dropbox/sign";
2
3const signatureRequestApi = new DropboxSign.SignatureRequestApi();
4
5signatureRequestApi.username = "YOUR_API_KEY";
6
7const data = {
8 templateIds: ["c26b8a16784a872da37ea946b9ddec7c1e11dff6"],
9 subject: "Purchase Order",
10 message: "Glad we could come to an agreement.",
11 signers: [
12 {
13 role: "Client",
14 name: "George",
15 emailAddress: "george@example.com"
16 },
17 {
18 role: "Manager",
19 name: "Bob",
20 emailAddress: "bob@example.com"
21 }
22 ],
23 customFields: [
24 {
25 name: "company",
26 value: "ABC Corp",
27 required: true
28 }
29 ]
30};
31
32const result = signatureRequestApi.signatureRequestSendWithTemplate(data);
33result.then(response => {
34 console.log(response.body);
35}).catch(error => {
36 console.log("Exception when calling Dropbox Sign API:");
37 console.log(error.body);
38});

template_id to template_ids

The template_id parameter has been removed. You must now use template_ids.

Legacy SDK versionNew SDK Version
Template ID (template_id) is passed as a singular string:

template_id : “1234567890”
Template ID is passed as an array of strings (templateIds):

templateIds: [“1234567890”]

file to files

The file parameter has been renamed to files. Usage remains the same.


file_url to file_urls

The file_url parameter has been renamed to file_urls. Usage remains the same.


snake_case to camelCase

The variables, properties, and functions in the Legacy SDK were written in snake_case. The New SDK now uses camelCase instead, as this is what is standard practice for Node.

$test_mode
$template_id
$custom_fields
$form_fields_per_document
$signing_options

Interacting with Files

The new SDK version introduces some new patterns around uploading and downloading files. You can read about them more in depth here: Interacting with Files.

Uploading Files

Passing a file with with your API request using the files parameter is different:

Legacy SDK versionNew SDK Version
Accepts a file binary or a path to a local fileOnly accepts a file binary
1const hellosign = require('hellosign-sdk')({ key: process.env.HelloSign_API_KEY });
2
3module.exports = {
4send_signature_request: function () {
5 const opts = {
6 test_mode: 1,
7 files: ['Demo-Mutual-Non-Disclosure-Agreement.pdf'],
8 title: 'NDA with Acme Co.',
9 subject: 'The NDA we talked about',
10 message: 'Please sign this NDA and then we can discuss more.',
11 signers: [
12 {
13 name: 'Jill',
14 email_address: 'jill@example.com'
15 }
16 ]
17 };
18
19 hellosign.signatureRequest.send(opts).then((res) => {
20 console.log(res)
21 }).catch((err) => {
22 console.log(err)
23 });
24 }
25}

Downloading Files

Download functionality is now spread across multiple endpoints.

Legacy SDK VersionNew SDK version
Download Files is a single endpoint and the return is configured by parameters.Download Files spread across three endpoints
1var signature_request_id = 'SIGNATURE_REQUEST_ID'
2
3hellosign.signatureRequest.download(signature_request_id, {file_type: 'zip'}, function(err, response) {
4var file = fs.createWriteStream("files.zip");
5response.pipe(file);
6 file.on('finish', function() {
7 file.close();
8 });
9});
1var signature_request_id = 'SIGNATURE_REQUEST_ID'
2
3hellosign.signatureRequest.download('SIGNATURE_REQUEST_ID', { get_data_uri: true }, (err, res) => {
4 console.log(res)
5});
1var signature_request_id = 'SIGNATURE_REQUEST_ID'
2
3hellosign.signatureRequest.download('SIGNATURE_REQUEST_ID', { get_url: true }, (err, res) => {
4 console.log(res)
5});

Downloading Templates

1import * as DropboxSign from "@dropbox/sign";
2import * as fs from 'fs';
3
4const templateApi = new DropboxSign.TemplateApi();
5
6// Configure HTTP basic authorization: api_key
7templateApi.username = "YOUR_API_KEY";
8
9// or, configure Bearer authorization: oauth2
10// templateApi.accessToken = "YOUR_ACCESS_TOKEN";
11
12const templateId = "5de8179668f2033afac48da1868d0093bf133266";
13const fileType = "pdf";
14
15const result = templateApi.templateFiles(templateId, fileType);
16result.then(response => {
17 fs.createWriteStream('file_response.pdf').write(response.body);
18}).catch(error => {
19 console.log("Exception when calling Dropbox Sign API:");
20 console.log(error.body);
21});

Endpoint Mapping

This section shows you how endpoints in the legacy SDK map to the new SDK. It doesn’t cover all endpoints, but gives you an idea of mapping implementations between the two SDKs. Please reach out if you think we’re missing an important example.

Get Account

1const hellosign = require('hellosign-sdk')({ key: process.env.HelloSign_API_KEY });
2
3hellosign.account.get().then((res) => {
4 console.log(res)
5}).catch((err) => {
6 console.log(err)
7});

Get Signature Request

1const hellosign = require('hellosign-sdk')({ key: 'HelloSign_API_KEY' });
2
3hellosign.signatureRequest.get(SIGNATURE_REQUEST_ID).then((res) => {
4 console.log(res)
5}).catch((err) => {
6 console.log(err)
7});

Send Signature Request

1const hellosign = require('hellosign-sdk')({ key: 'HelloSign_API_KEY' });
2
3var signers = [
4 {
5 email_address : 'jack@example.com',
6 name : 'Jack',
7 order : 0,
8 },
9 {
10 email_address : 'jill@example.com',
11 name : 'Jill',
12 order : 1,
13 }
14]
15
16var options = {
17 test_mode : 1,
18 title : 'NDA with Acme Co.',
19 subject : 'The NDA we talked about',
20 message : 'Please sign this NDA and then we can discuss more. Let me know if you have any questions.',
21 signers : signers,
22 cc_email_addresses : ['lawyer@example.com', 'lawyer2@example.com'],
23 files : ['./Demo-Mutual-Non-Disclosure-Agreement.pdf'],
24 metadata : {
25 clientId : '1234',
26 custom_text : 'NDA #9'
27 }
28};
29
30hellosign.signatureRequest.send(options)
31.then(function(res){
32 console.log(res.signature_request);
33});

Create Embedded with Template

1const hellosign = require('hellosign-sdk')({ key: 'HelloSign_API_KEY' });
2
3var options = {
4 test_mode : 1,
5 clientId : 'CLIENT_ID',
6 template_id : 'TEMPLATE_ID',
7 subject : 'Purchase Order',
8 message : 'Glad we could come to an agreement.',
9 signers : [
10 {
11 role : 'Client',
12 email_address : 'george@example.com',
13 name : 'George',
14 }
15 ]
16};
17
18hellosign.signatureRequest.createEmbeddedWithTemplate(options);
19.then(function(res){
20 console.log(res.signature_request);
21});

Update API App

1const opts = {
2 name: 'My Cool App',
3 white_labeling_options: '{"primary_button_color":"#ff0000","primary_button_text_color":"#000000"}'
4};
5
6hellosign.apiApp.update('CLIENT_ID', opts).then((res) => {
7 console.log(res)
8}).catch((err) => {
9 console.log(err)
10});

Supporting Legacy SDKs

Following the official release of the new SDK version, we'll be preparing to deprecate all legacy versions of the Node SDK for one year after launch. That means, once fully launched, we'll only support critical vulnerabilities and bug fixes for legacy SDK versions 2.1.0 for 12 months. After that, legacy versions are considered officially deprecated and are no longer supported. You can find more information in our SDK Versioning Policy.

We encourage you to start migrating (or planning to migrate) to the new SDK as soon as possible. Please don't hesitate to reach out if you have questions or need assistance.


Feedback and Assistance

We know that dealing with "breaking" changes is inconvenient for those of you currently using the legacy SDK, but believe the new SDK offers a better experience while providing access to more features. If you need help or get stuck, please reach out to API support: Submit a Ticket

We warmly welcome your feedback, feature requests, and bug reports in our OpenAPI repo. All of the engineering work on the Node SDK happens in the Node folder of the repo.