The BoldSign mobile app is now available. Visitthis link for more details and give it a try!

The BoldSign mobile app is now available. Visitthis link for more details and give it a try!

Request Demo
BoldSign Logo Small


Explore the BoldSign features that make eSigning easier.


Integrate Electronic Signature Capabilities into Your SaaS Applications

Electronic signatures have grown in popularity over the past decade and have become the standard for getting contracts signed online. The initial adoption of eSignatures mainly involved importing your documents from various sources into web-based eSignature applications like BoldSign and then sending signature requests from there.
However, manually importing documents into electronic signature applications can feel a bit cumbersome when dealing with higher volumes. Ideally, users should be able to send eSignature requests from their existing applications without having to export documents into another application. BoldSign provides a comprehensive suite of APIs for integrating electronic signature capabilities into your existing applications.

Challenges of integrating electronic signatures into multitenant SaaS applications

Many SaaS applications on the market can benefit from embedding eSignature capabilities. However, many SaaS applications are multitenant, which introduces additional challenges when integrating eSignature capabilities.
A multitenant application is an application where there are at least two hierarchies of customers. For example, consider a recruitment software SaaS company, Cubeflakes. Cubeflakes’s customer is Bytesplash, a recruitment company that needs to get contracts signed by their customers who are job seekers
The challenge arises when Bytesplash needs to send contracts to job seekers under their identity. Typically, this would require Bytesplash to sign up for an account with the eSignature software provider, and that causes a couple of problems:
  • Cubeflakes must send their customers to the eSignature software provider’s website to create an account. This makes the eSignature onboarding process a bit awkward for Cubeflakes’s customers.
  • Cubeflakes must pay an additional licensing fee for each tenant that would need to send out contracts for signature.
These reasons make integrating eSignature capabilities into multitenant SaaS applications cumbersome and expensive using most of the existing solutions available on the market today.
BoldSign provides a unique solution to this problem through a Signer Identity feature that makes onboarding seamless and comes at no additional cost. The cost difference between integrating BoldSign’s APIs versus any other solution in the market for a typical multitenant SaaS application would run into hundreds of thousands of dollars

Integrate eSignature capabilities into your SaaS applications

The complete process of integrating BoldSign’s APIs into a multitenant SaaS application is explained in detail in this part of the blog. All examples shown are from the perspective of the fictional recruitment SaaS company called Cubeflakes.


If you want to follow along, you’ll need a BoldSign account and an API key. The API key is located in the API Key—BoldSign page.

Create a brand identity through API

Let’s assume that Bytesplash is Cubeflakes’s new customer who needs to have eSignature capabilities enabled for their new account.
The first step would be to create a new brand identity for Bytesplash, since the contracts will be sent under their identity. A brand identity includes several customization elements including brand colors and logo. Cubeflakes, the company that licenses BoldSign, would use BoldSign’s API to add a brand identity for Bytesplash under their account.
curl -X 'POST' \
    '' \
    -H 'X-API-KEY: {your API key}'\
    -F 'BrandName="Bytesplash"' \
    -F 'BrandLogo=@"/Users/Bytesplash.png"'

BoldSign API customers are allowed to create an unlimited number of brands so they can create a brand for each of their tenants. Your customers will be happy that their branding will be reflected when they send out any contracts.
In our example scenario, all documents will be sent under the Bytesplash branding and Bytesplash’s customers will not have any knowledge of Cubeflakes at all. This customization greatly increases confidence about the origin of the document.
The following is a screenshot of the branding that Bytesplash’s customers would see on the signing page

API for creating templates

The next step would be to let Bytesplash customize its own document templates. Templates in BoldSign are useful for saving time and effort. We configure a document once with various form and signature fields and then reuse that document anytime we need to get the same contract signed by a different set of recipients. Most companies have set of documents that will be signed repeatedly by many of their customers, so using templates will save a lot of time.
In a multitenant SaaS app scenario, each of the tenants would need to upload their own templates and place various form fields like text boxes, checkboxes, radio buttons, and signature fields. In our example scenario, we are going to let Bytesplash’s users create a template for an offer letter within the Cubeflakes application.
curl -X 'POST' \
    '' \
    -H 'accept: application/json' \
    -H 'X-API-KEY: {your API key}' \
    -F 'ShowToolbar="true"' \
    -F 'Title="Embedded Offer Letter"' \
    -F 'Roles[0][Name]="HR"' \
    -F 'Roles[0][Index]="1"' \
    -F 'Roles[0][SignerOrder]="1"' \
    -F 'Roles[1][Name]="Employee"' \
    -F 'Roles[1][Index]="2"' \
    -F 'DocumentInfo[0][Title]="Embedded Offer Letter"' \
    -F 'DocumentInfo[0][Language]="1"' \
    -F 'Files=@"/Users/Employment-Offer-Letter.pdf"'

The entire template configuration experience can be embedded within your application. In this case, Bytesplash will be able to drag form fields onto the document within the Cubeflakes app and then visually configure it as needed.

Get consent to send documents on behalf of tenants

For legal compliance reasons, BoldSign only permits sending signature requests from verified identities. So, in our example scenario, Bytesplash’s identity needs to be verified by BoldSign before contracts can be sent out under its name. This verification is done through a simple email-based approval process. Use the following code snippet to send an approval request.
curl -X 'POST' \
    '' \
    -H 'accept: */*' \
    -H 'X-API-KEY: {your API key}' \
    -H 'Content-Type: application/json;odata.metadata=minimal;odata.streaming=true' \
    -d '{
      "name": "George Livingston",
      "email": ""

In our example scenario, Bytesplash will receive an email like the following one.
Approve Request
When the Bytesplash’s user clicks on the approve request link in the email, a confirmation pop-up will be displayed.
Verify Identity
Once the tenant approves the request, Cubeflakes can send documents on behalf of its tenants.

Send document for signing on behalf of tenant

Everything is set. Cubeflakes can send the document for signing on behalf of Bytesplash. Cubeflakes will use the created brand ID and template ID . Refer to the following code.
curl -X 'POST' \
    '' \
    -H 'accept: application/json' \
    -H 'X-API-KEY: {your API key}' \
    -H 'Content-Type: application/json;odata.metadata=minimal;odata.streaming=true' \
    -d '{
    "title": "Employment Offer Letter",
    "roles": [
        "roleIndex": 1,
        "signerName": "George Livingston",
        "signerEmail": ""
        "roleIndex": 2,
        "signerName": "John Smith",
        "signerEmail": ""
    "brandId": "9b374346-8d95-48a7-a1fe-f7ba7522b0e8",
    "hideDocumentId": true,
    "onBehalfOf": "",

Once the document is sent, your tenant’s user will receive an email like the following one, requesting them to sign the document. Now, the user will be confident about the origin of the document and the identity of the signature requester, and they can sign the document with confidence.
That’s it, we have successfully integrated electronic signature capabilities into a multitenant SaaS application. The code samples that we have seen so far only showcase the signature request process. However, BoldSign also provides several other APIs to track the status of signature requests and even download the final signed document.
You can get started today and integrate BoldSign into your multitenant SaaS application. The complete integration can be done using the 30-day free trial.

To learn more about BoldSign APIs, visit our API documentation. Live API demos are also available for testing. Sample code in popular programming languages is available in the GitHub repo.

If you have questions, you can contact us through our support portal. We are always happy to assist you!

Share this blog

Subscribe RSS feed

Leave a Reply

Your email address will not be published. Required fields are marked *