---
title: "How to Require Signer Authentication for eSignature Requests via API"
description: "Learn how to enhance security for eSignature requests by mandating signer authentication through API integration using BoldSign."
url: "https://boldsign.com/blogs/mandate-signer-authentication-for-esignature-requests-via-api/"
---

1. [Blog](https://boldsign.com/blogs.md)
2. [API](https://boldsign.com/category/api.md)

# How to Mandate Signer Authentication for eSignature Requests via API

[Gopinath Kannusamy](https://boldsign.com/author/gopinath-kannusamy/) July 8, 2024 Updated August 21, 2026 6 min read

Signer authentication is the process of verifying the identity of a user, adding an additional layer of security to the document signing process. BoldSign supports multiple signer authentication methods, including email OTP, SMS OTP, access code authentication, and identity verification, to verify the signers. In this blog post, we will explore how to mandate signer authentication for eSignature requests via API using BoldSign. We will delve into the various signer authentication methods, their importance, and step-by-step guides with code snippets for implementation.

## Understanding Signer Authentication Methods

Before beginning the implementation, let’s first understand the different signer authentication methods provided by BoldSign:

- **Access Code**\
  An access code is a set of alphanumeric characters specified by the sender for accessing the document. The sender needs to provide the code directly to the recipient. This method is simple yet effective for ensuring that only the intended recipient can access the document.
- **Email OTP**\
  An email OTP (one-time password) is a system-generated password delivered to the recipient’s inbox. This OTP is required to access the document. Email OTP adds an extra layer of security by ensuring that the signer has access to the email account associated with the intended recipient.
- **SMS OTP**\
  An SMS OTP is a system-generated one-time password delivered to the recipient’s phone number. This OTP is required to access the document. SMS OTP provides an additional level of security by verifying the recipient’s phone number.
- **Identity Verification**\
  Identity verification is another process to confirm the signer’s identity. This can include providing a passport or driver’s license. Identity verification provides the highest level of security by thoroughly verifying the signer’s identity.
- **Knowledge-Based Authentication (KBA)**\
  KBA helps verify a signer’s identity using dynamically generated security questions based on public record information associated with that individual. Before accessing the document, the signer must provide identity information and correctly answer the required verification questions. KBA adds an additional layer of identity assurance without requiring the signer to upload an identity document and is available for U.S.-based recipients.

## Importance of Signer Authentication in eSignatures

Signer authentication for documents requiring eSignatures is essential for several reasons:

- **Security:** Signer authentication ensures that only the intended recipient can access and sign the document, preventing unauthorized access.
- **Compliance:** Many industries have regulations that require verified signatures. Signer authentication helps meet these legal and regulatory requirements.
- **Trust:** Signer authentication builds trust between parties by ensuring that the signer is who they claim to be.

## Sending a Document with SMS Authentication

Now that we understand the importance of signer authentication, let’s look at how to send a document with SMS authentication using BoldSign’s API. Use the following example code to prepare your API request for sending a document with SMS OTP authentication.

```
curl -X 'POST' \
  'https://api.boldsign.com/v1/document/send' \
  -H 'accept: application/json' \
  -H 'X-API-KEY: {your API key}' \
  -H 'Content-Type: multipart/form-data' \
  -F 'Signers={
  "name": "hanky",
  "emailAddress": "hankyWhites@boldsign.dev",
  "signerType": "Signer",
  "authenticationType": "SMSOTP",
  "phoneNumber": {
    "countryCode": "{Signer country code}",
    "number": "{Signer phone number}"
  },
  "formFields": [
    {
      "id": "signature",
      "name": "signature",
      "fieldType": "Signature",
      "pageNumber": 1,
      "bounds": {
        "x": 100,
        "y": 100,
        "width": 200,
        "height": 25
      },
      "isRequired": true
    }
  ],
  "locale": "EN"
}' \
  -F 'Files=@{your file path}' \
  -F 'Title={title}'
```

In the previous example, set the **authenticationType** value to **SMSOTP**, and provide values for the **countryCode** and **number** with the signer’s country code and phone number. Then, make the API request.

## Sending a Document with Access Code Authentication

Next, let’s send a document with access code authentication. Use the following example code to prepare your API request for sending a document with access code authentication.

```
curl -X 'POST' \
  'https://api.boldsign.com/v1/document/send' \
  -H 'accept: application/json' \
  -H 'X-API-KEY: {your API key}' \
  -H 'Content-Type: multipart/form-data' \
  -F 'Title="Sample Document"' \
  -F 'Signers={
  "name": "hanky",
  "emailAddress": "hankyWhites@boldsign.dev",
  "signerType": "Signer",
  "authenticationType": "AccessCode",
  "authenticationCode": "1234",
  "formFields": [
    {
      "id": "signature",
      "name": "signature",
      "fieldType": "Signature",
      "pageNumber": 1,
      "bounds": {
        "x": 100,
        "y": 100,
        "width": 200,
        "height": 25
      },
      "isRequired": true
    }
  ],
  "locale": "EN"
}' \
  -F 'Files=@{your file path}'
```

In the previous example, set the **authenticationType** to **AccessCode** and provide a unique access code (e.g., “1234”) in the **authenticationCode** property. Then make the API request.

## Sending a Document with Email OTP Authentication

Let’s look at how to send a document with email OTP authentication. Use the following code snippet to prepare your API request for sending a document with email OTP authentication.

```
curl -X 'POST' \
  'https://api.boldsign.com/v1/document/send' \
  -H 'accept: application/json' \
  -H 'X-API-KEY: {your API key}' \
  -H 'Content-Type: multipart/form-data' \
  -F 'Signers={
  "name": "hanky",
  "emailAddress": "hankyWhites@boldsign.dev",
  "signerType": "Signer",
  "authenticationType": "EmailOTP",
  "formFields": [
    {
      "id": " signature ",
      "fieldType": "Signature",
      "pageNumber": 1,
      "bounds": {
        "x": 50,
        "y": 100,
        "width": 200,
        "height": 25
      },
      "isRequired": true
    }
  ]
}' \
  -F 'Title="Sample Document"' \
  -F 'Files=@{your file path}'
```

In the previous example, set the **authenticationType** value to **EmailOTP** and then make the API request.

## Sending a Document with Identity Verification

Finally, let’s look at how to send a document with identity verification. Use the following code snippet to prepare your API request for sending a document with identity verification.

```
curl -X 'POST' \
  'https://api.boldsign.com/v1/document/send' \
  -H 'accept: application/json' \
  -H 'X-API-KEY: {Your API Key}' \
  -H 'Content-Type: multipart/form-data' \
  -F 'Files=@{Your file path}' \
  -F 'Title=Sample Document' \
  -F 'Signers={
  "name": "hanky",
  "emailAddress": "hankyWhites@boldsign.dev",
  "authenticationType": "IdVerification",
  "identityVerificationSettings": {
    "type": "EveryAccess",
    "maximumRetryCount": 10,
    "requireLiveCapture": true,
    "requireMatchingSelfie": true,
    "nameMatcher": "Strict"
  },
  "signerType": "Signer",
  "formFields": [
    {
      "id": "signature",
      "fieldType": "Signature",
      "pageNumber": 1,
      "bounds": {
        "x": 100,
        "y": 100,
        "width": 200,
        "height": 25
      },
      "isRequired": true
    }
  ]
}'
```

In this example, configure the **authenticationType** as **IdVerification** and proceed to customize the settings within the **IdentityVerificationSettings** section. These configurations involve defining the authentication frequency using **type**, specifying the maximum number of retry attempts with **maximumRetryCount**, enabling selfie and live capture by setting **requireLiveCapture** and **requireMatchingSelfie** to true, respectively, and configuring the **nameMatcher**. For comprehensive details on setting up identity verification settings, refer to the [documentation](https://developers.boldsign.com/identity-verification/introduction/?region=us).

## Sending a Document with Knowledge-Based Authentication (KBA)

Let’s look at how to send a document with Knowledge-Based Authentication (KBA). Use the following code snippet to prepare your API request for sending a document with KBA authentication.

```
curl -X POST \
  'https://api.boldsign.com/v1/document/send' \
  -H 'accept: application/json' \
  -H 'X-API-KEY: {your API key}' \
  -H 'Content-Type: multipart/form-data' \
  -F 'Signers={
  "name": "hanky",
  "emailAddress": "hankyWhites@boldsign.dev",
  "signerType": "Signer",
  "authenticationType": "KBA",
  "kbaSettings": {
    "type": "EveryAccess",
    "maximumRetryCount": 3,
    "nameMatcher": "Strict"
  },
  "formFields": [
    {
      "id": "signature",
      "fieldType": "Signature",
      "pageNumber": 1,
      "bounds": {
        "x": 50,
        "y": 100,
        "width": 200,
        "height": 25
      },
      "isRequired": true
    }
  ]
}' \
  -F 'Title=Sample Document' \
  -F 'Files=@{your file path}'
```

In this example, configure the **authenticationType** as **KBA** and proceed to customize the settings within the **kbaSettings** object. These configurations involve defining the authentication frequency using **type**, specifying the maximum number of retry attempts with **maximumRetryCount**, and configuring the **nameMatcher** setting. When the recipient opens the document, they must successfully complete the KBA verification process before they can access and sign the document.For comprehensive details on configuring KBA settings, refer to the [KBA documentation](https://developers.boldsign.com/knowledge-based-authentication/introduction/?region=us).

## Conclusion

Adding signer authentication to your eSignature requests using BoldSign’s API enhances security and ensures that the signer is properly verified. By following the examples provided, you can implement whichever signer authentication method best suits your situation to secure your documents and streamline your eSignature process.

If you are not yet a BoldSign customer, begin your [30-day free trial](https://account.boldsign.com/signup?planId=1020\&utm_source=boldsignblogs\&utm_medium=redirect\&utm_campaign=boldsign) to discover its benefits. Feel free to leave a comment below; we appreciate your feedback. If you would like to learn more about our services or require assistance, please [schedule a demo](https://boldsign.com/request-demo.md) or contact our support staff through our [support portal](https://support.boldsign.com/support/tickets/create).

Topics [API integration](https://boldsign.com/blogs/tag/api-integration.md)[Identity verification](https://boldsign.com/blogs/tag/identity-verification.md)[Signer experience](https://boldsign.com/blogs/tag/signer-experience.md)

## Sign documents 3x faster

Send, sign and manage documents securely and efficiently.

[Try it today](https://account.boldsign.com/signup?planId=1018\&utm_source=boldsignblogs\&utm_medium=redirect\&utm_campaign=boldsign)

## Gopinath Kannusamy

Gopinath is a passionate software developer with 2 years of experience at BoldSign. He is an avid writer and enjoys sharing his insights on technology and development. In his free time, he enjoys exploring new technologies and learning new things. Connect with him on [LinkedIn](https://www.linkedin.com/in/gopinath-kannusamy-b7b84517a/).

[More posts by Gopinath Kannusamy](https://boldsign.com/author/gopinath-kannusamy/)

## Related posts

- [API](https://boldsign.com/category/api.md) July 10, 2024 8 min read

  ## [Mandating Signer Authentication After Sending Documents via API](https://boldsign.com/blogs/mandating-signer-authentication-after-sending-documents-via-api.md)

  BoldSign API supports verifying eSignatures via email, SMS, or access code, providing an additional layer of security after document delivery.

- [API](https://boldsign.com/category/api.md) September 21, 2026 7 min read

  ## [How to Detect Email and SMS Delivery Failure in eSignature Code](https://boldsign.com/blogs/email-sms-delivery-failure-esignature-webhooks.md)

  Detect email and SMS delivery failure in eSignature workflows before it stalls a signature. Learn the root causes, and how to catch failures with webhooks.

- [API](https://boldsign.com/category/api.md) June 9, 2026 9 min read

  ## [Eliminate Approval Delays in Multi-Signer Workflows with Group Signers](https://boldsign.com/blogs/group-signers-api.md)

  Discover how BoldSign Group Signers help teams avoid approval delays by allowing any authorized member to securely sign documents via the API. Try now!

Get started

## Sign up for your free trial today!

[Start free trial](https://account.boldsign.com/signup?planId=1018)

- 30-day free trial
- No credit card required

*Picture: A completed employment contract: signed by John Doe on 11/03/2026, all parties have signed*
