---
title: "Knowledge-Based Authentication for eSignatures | BoldSign"
description: "Use Knowledge-Based Authentication (KBA) in BoldSign to verify signers with identity questions pulled from public records before they can sign documents."
url: "https://boldsign.com/electronic-signature-features/knowledge-based-authentication/"
---

Signer authentication

# Make sure the right person opens and signs, with knowledge-based authentication

BoldSign asks each US signer a few questions drawn from public records before the document opens. Signers upload no ID and take no selfie.

[Start free trial](https://account.boldsign.com/signup?planId=1018)[Book a walkthrough](https://boldsign.com/request-demo.md)

Example with sample data.

*Picture: The page a signer sees before a document protected by knowledge-based authentication opens: Verify your identity to sign this document, the agreement to the KBA identity check, and the Begin verification button*

Trusted by 100,000+ organizations worldwide

![Samsonite](https://boldsign.com/assets/landing/trustbar/samsonite.svg)

![Ryanair](https://boldsign.com/assets/landing/trustbar/ryanair.svg)

![Hyatt](https://boldsign.com/assets/landing/trustbar/hyatt.svg)

![Sony](https://boldsign.com/assets/landing/trustbar/sony.svg)

![Crumbl Cookies](https://boldsign.com/assets/landing/trustbar/crumbl.svg)

![Payroc](https://boldsign.com/assets/landing/trustbar/payroc.svg)

![Cost Plus](https://boldsign.com/assets/landing/trustbar/costplus.svg)

Why it matters

## When do teams add KBA to a signing request?

KBA suits US signers who must prove who they are without a photo ID.

- *Picture: A Form 8879 signature request sent to taxpayer\@cubeflakes.com, opened with Review and Sign, the sender line outlined in red with the note Is this the taxpayer?*

  ### Tax forms signed remotely

  IRS guidance names knowledge-based questions for Forms 8878 and 8879 signed remotely.

  [See how KBA attempt limits solve it](#bs-kba-settings)

- *Picture: A loan agreement’s signature request forwarded from Jane Smith to steve\@cubeflakes.com, whose hand presses Review and Sign, with the note Not the borrower*

  ### Loan and account documents

  An impostor signing a loan or account form could cause financial loss.

  [See how KBA solves it](#bs-kba-steps)

- *Picture: A claim consent form asking the signer to upload a photo of a passport or driver’s license, the upload outlined in red with the note More than this form needs*

  ### Insurance and patient forms

  Some signers would rather not upload a government ID for a consent or claims form.

  [See how ID-free checks solve it](#bs-kba-vs-id)

- *Picture: A purchase agreement signed remotely by the buyer, Steve Smith, the signature outlined in red with the note Never met in person*

  ### Real estate paperwork signed remotely

  Buyers and sellers who never meet in person still need to show who signed.

  [See how KBA solves it](#bs-kba-steps)

The signer’s side

## What does a signer do to pass KBA?

A BoldSign signer passes KBA in 3 steps in the browser, before the document opens.

- *Picture: Personal information: Jane Smith’s name, street address, ZIP code and the last 4 of her SSN entered, and Generate questions pressed*

  ### Agree and enter legal details

  The signer enters their legal name, address, and last four SSN digits.

- *Picture: Identity verification questions with the timer, 5 of 5 answered and Ready to submit, and question 5 answered*

  ### Answer questions from public records

  They answer questions from public records.

- *Picture: The loan agreement open for signing after the check: Required fields left, Start signing and the Sign Here field*

  ### Open and sign the document

  Correct answers open the document.

BoldSign keeps only the check’s status, a provider reference and each attempt’s time, not the address or SSN digits.

KBA features

## What else can KBA do?

KBA also works on a phone, allows retries, and lets you reset checks or set account defaults.

- *Picture: Identity verification questions in the mobile app: 0 of 5 answered and the timer at 01:58*

  01 · Verify

  ### Answer on a phone

  The mobile app shows the same timed questions.

- *Picture: Session expired, with the Verify again button*

  02 · Verify

  ### A timed session

  If the timer runs out, Verify again starts a new session.

- *Picture: Verification failed: some answers did not match the records, with Verify again and 2 attempts left out of 3*

  03 · Recover

  ### Another try, within your limit

  Retry while attempts remain.

- *Picture: An NDA document’s recipient Steve Smith with KBA failed, and the menu with Reset verification and Remove authentication*

  04 · Recover

  ### Failed checks don't cancel the document

  A failed KBA does not cancel the document. Reset it and the signer carries on from the same link.

- *Picture: Business Profile, Knowledge-based authentication (KBA): frequency Every Access, 3 retry attempts and name match None*

  05 · Manage

  ### Defaults for the whole account

  Admins set default frequency, retries and name matching.

- *Picture: Add Recipients with Jane Smith and Steve Smith, each with Knowledge-Based as their authentication*

  06 · Verify

  ### A check for each signer

  Each signer on a request answers their own questions.

Settings

## KBA settings you control for each signer

Senders set how often KBA repeats, how many tries a signer gets, and how close the name must match. Admins set account defaults.

**How often the signer verifies Every access, every access until signed, or once per document.**

*Picture: KBA authentication settings: KBA frequency set to Every access*

**How many tries a signer gets Set the retries before a signer is locked out.**

*Picture: KBA authentication settings: Number of retry attempts set to 3*

**How closely the name must match None, Lenient, Moderate, or Strict.**

*Picture: KBA authentication settings: Name-match tolerance level set to None*

**A different check for each signer KBA for one signer, another check or none for the rest.**

*Picture: A recipient’s Settings with Authentication on and Knowledge-Based picked, marked BETA*

Choosing a check

## Should you use KBA or ID verification?

Use KBA for US signers when no photo ID is needed. Use ID verification to match a government ID to a live selfie. Prices are in USD.

| What differs | Knowledge-based authentication | ID verification |
| - | - | - |
| What the signer provides | Legal name, address, and last four SSN digits, then answers to questions | A photo of a passport or driver’s license, and a live selfie |
| Who it works for | Signers in the US | Signers with a supported photo ID |
| What the sender can review | The result of each attempt | The uploaded ID, to approve or reject |
| Price on the Business plan | $1.50 per attempt | $2 per completed attempt, pass or fail |
| Attempts you can allow | 1 to 3 | 1 to 10 |

Security

## How are documents signed with KBA kept secure?

BoldSign encrypts every signed document twice with AES-256, and its controls are audited for SOC 2 Type 2.

IT and procurement teams can read the [data processing agreement](https://boldsign.com/dpa.md) and the [subprocessor list](https://boldsign.com/subprocessors.md) online, and [request the SOC 2 Type 2 report](https://boldsign.com/compliance-request-form.md).

[View security policy](https://boldsign.com/security-policy.md)

Compared

## Which eSignature tools offer knowledge-based authentication?

A KBA attempt costs $1.50 on BoldSign Business and $2 on PandaDoc Business. Docusign (Enhanced plans) and Adobe (enterprise plans) publish no KBA rate. Swipe sideways to see all five vendors. Not published: the vendor’s own pages do not state it. Spotted something outdated? Tell us through the [contact page](https://boldsign.com/contact-us.md).

| Capability | BoldSign | Docusign | Adobe Acrobat Sign | PandaDoc | Dropbox Sign |
| - | - | - | - | - | - |
| Plan that includes KBA | Business plan$15 per user a month | Enhanced plansContact sales. Not on Personal, Standard, or Business Pro | Enterprise plansNot published | Business and Enterprise plansBusiness is $49 per seat a month | Not publishedHelp pages list only SMS and access codes |
| Price per KBA attempt | $1.50 per attemptPass or fail, pay as you go | Not publishedThe identity add-on starts at $2.40 per ID verification attempt | Not publishedTransactions bought through a sales rep, one per recipient, not per attempt | $2 per attemptEvery attempt is deducted from a prepaid balance | Not published |
| KBA for several signers on one request | Yes, set per recipient | Yes, set per recipient | Yes, set per recipient | Yes, set per recipient | Not published |
| After a signer’s last failed attempt | Document is not canceledYou reset KBA and the signer uses the same link | Envelope is locked by defaultThe signer contacts the sender to unlock it | Agreement is cancelled by defaultA new agreement is needed | Signer contacts the sender | Not published |

What it costs

## Limits and costs to know before you add KBA with BoldSign

KBA checks who opens a document, not a government ID. Prices are in USD.

- $1.50 per KBA attempt Charged when questions are generated, pass or fail.
- $15 Business plan, per user a month Billed yearly. KBA cannot be added to the Essential or Growth plans ([pricing](https://boldsign.com/electronic-signature-pricing/?plan=webapp)).

### Before your first KBA send

- 3 attempts at most Then the document locks until you reset KBA.
- US signers only KBA works only for recipients based in the US.

* KBA cannot be combined with an access code, email OTP, SMS OTP, or ID verification for the same signer.
* KBA cannot be used for signing groups or in-person signers.
* Trial plans include no KBA credits.

Switching

## Switching from another eSignature tool

Docusign templates import into BoldSign at no charge with BoldSign’s import tool, and BoldSign support helps teams make the switch.

- Guide

  ### Import your Docusign templates

  Step-by-step help for moving Docusign templates into BoldSign.

  [Read the import guide](https://support.boldsign.com/kb/article/16442/how-to-import-docusign-templates-into-boldsign)

- Comparison

  ### BoldSign compared with Docusign

  Features and prices side by side, for teams moving from Docusign.

  [See the Docusign comparison](https://boldsign.com/docusign-alternative.md)

- Comparison

  ### BoldSign compared with Dropbox Sign

  For teams moving from Dropbox Sign, formerly HelloSign.

  [See the Dropbox Sign comparison](https://boldsign.com/alternatives/hellosign-dropbox-sign.md)

- Comparison

  ### BoldSign compared with Adobe Acrobat Sign

  For teams moving from Adobe Acrobat Sign.

  [See the Adobe comparison](https://boldsign.com/alternatives/adobesign.md)

- Comparison

  ### BoldSign compared with PandaDoc

  For teams moving from PandaDoc.

  [See the PandaDoc comparison](https://boldsign.com/alternatives/pandadoc-alternative.md)

- Comparison

  ### SignNow and other tools

  Every eSignature tool BoldSign is compared with.

  [See all comparisons](https://boldsign.com/alternatives.md)

For developers

## Can developers add KBA with an API?

Yes. Set a signer’s authenticationType to KBA, with kbaSettings for frequency, attempts and name matching, even after sending.

These samples come from the developer guide [How to send a document with KBA using BoldSign API](https://developers.boldsign.com/how-to-guides/send-document-with-kba/).

[Read the developer docs](https://developers.boldsign.com/how-to-guides/send-document-with-kba/)

**cURL**

cURL

```
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};type=application/pdf' \
  -F 'Title=Agreement' \
  -F 'Signers={
  "name": "Alex Gayle",
  "emailAddress": "alexgayle@cubeflakes.com",
  "authenticationType": "KBA",
  "kbaSettings": {
    "type": "EveryAccess",
    "maximumRetryCount": 3,
    "nameMatcher": "Strict"
  },
  "signerType": "Signer",
  "formFields": [
    {
      "id": "signature1",
      "name": "signature1",
      "fieldType": "Signature",
      "pageNumber": 1,
      "bounds": {
        "x": 100,
        "y": 100,
        "width": 100,
        "height": 50
      },
      "isRequired": true
    }
  ]
}'
```

**C#**

C#

```
using BoldSign.Api;
using BoldSign.Api.Model;
using BoldSign.Api.Model.Kba;
using BoldSign.Model;
var apiClient = new ApiClient("https://api.boldsign.com", "{Your API Key}");
var documentClient = new DocumentClient(apiClient);
var documentFilePath = new DocumentFilePath
{
    ContentType = "application/pdf",
    FilePath = "{Your File Path}",
};
var filesToUpload = new List<IDocumentFile>
{
    documentFilePath,
};
var signatureField = new FormField(
    id: "signature1",
    isRequired: true,
    type: FieldType.Signature,
    pageNumber: 1,
    bounds: new Rectangle(x: 100, y: 100, width: 100, height: 50));
var kbaSettings = new KbaSettings
{
    Type = AuthenticationFrequency.EveryAccess,
    MaximumRetryCount = 3,
    NameMatcher = KbaNameMatchLevel.Strict,
};
var signer = new DocumentSigner(
    signerName: "Alex Gayle",
    signerType: SignerType.Signer,
    signerEmail: "alexgayle@cubeflakes.com",
    authenticationType: AuthenticationType.KBA,
    formFields: new List<FormField> { signatureField },
    locale: Locales.EN)
{
    KbaSettings = kbaSettings,
};
var sendForSign = new SendForSign
{
    Title = "Agreement",
    Signers = new List<DocumentSigner> { signer },
    Files = filesToUpload,
};
var documentCreated = documentClient.SendDocument(sendForSign);
Console.WriteLine(documentCreated.DocumentId);
```

**Python**

Python

```
import boldsign
configuration = boldsign.Configuration(host = "https://api.boldsign.com", api_key="YOUR_API_KEY")
with boldsign.ApiClient(configuration) as api_client:
    document_api = boldsign.DocumentApi(api_client)
    send_for_sign = boldsign.SendForSign(
        title="Agreement",
        files=["YOUR_FILE_PATH"],
        signers=[
            boldsign.DocumentSigner(
                name="Alex Gayle",
                emailAddress="alexgayle@cubeflakes.com",
                signerType="Signer",
                authenticationType="KBA",
                kbaSettings=boldsign.KbaSettings(
                    type="EveryAccess",
                    maximumRetryCount=3,
                    nameMatcher="Strict"
                ),
                formFields=[
                    boldsign.FormField(
                        name="signature1",
                        fieldType="Signature",
                        pageNumber=1,
                        isRequired=True,
                        bounds=boldsign.Rectangle(x=100, y=100, width=100, height=50)
                    )
                ],
                locale="EN"
            )
        ]
    )
    document_created = document_api.send_document(send_for_sign)
    print(document_created.document_id)
```

**PHP**

PHP

```
<?php require_once "vendor/autoload.php";
use BoldSign\Configuration;
use BoldSign\Api\DocumentApi;
use BoldSign\Model\FormField;
use BoldSign\Model\Rectangle;
use BoldSign\Model\DocumentSigner;
use BoldSign\Model\KbaSettings;
use BoldSign\Model\SendForSign;
$config = new Configuration();
$config->setHost('https://api.boldsign.com');
$config->setApiKey('YOUR_API_KEY');
$document_api = new DocumentApi($config);
$form_field = new FormField();
$form_field->setName('signature1');
$form_field->setFieldType('Signature');
$form_field->setPageNumber(1);
$form_field->setIsRequired(true);
$bounds = new Rectangle([100, 100, 100, 50]);
$form_field->setBounds($bounds);
$kba_settings = new KbaSettings();
$kba_settings->setType('EveryAccess');
$kba_settings->setMaximumRetryCount(3);
$kba_settings->setNameMatcher('Strict');
$document_signer = new DocumentSigner();
$document_signer->setName('Alex Gayle');
$document_signer->setEmailAddress('alexgayle@cubeflakes.com');
$document_signer->setSignerType('Signer');
$document_signer->setAuthenticationType('KBA');
$document_signer->setLocale('EN');
$document_signer->setFormFields([$form_field]);
$document_signer->setKbaSettings($kba_settings);
$send_for_sign = new SendForSign();
$send_for_sign->setTitle('Agreement');
$send_for_sign->setFiles(['YOUR_FILE_PATH']);
$send_for_sign->setSigners([$document_signer]);
$document_created = $document_api->sendDocument($send_for_sign);
```

**Java**

Java

```
import com.boldsign.ApiClient;
import com.boldsign.Configuration;
import com.boldsign.api.DocumentApi;
import com.boldsign.model.DocumentCreated;
import com.boldsign.model.DocumentSigner;
import com.boldsign.model.FormField;
import com.boldsign.model.KbaSettings;
import com.boldsign.model.Rectangle;
import com.boldsign.model.SendForSign;
import java.io.File;
import java.util.Arrays;
ApiClient client = Configuration.getDefaultApiClient();
client.setBasePath("https://api.boldsign.com");
client.setApiKey("YOUR_API_KEY");
DocumentApi documentApi = new DocumentApi(client);
FormField formField = new FormField();
formField.setName("signature1");
formField.setFieldType(FormField.FieldTypeEnum.SIGNATURE);
formField.setPageNumber(1);
formField.setIsRequired(true);
Rectangle bounds = new Rectangle().x(100f).y(100f).width(100f).height(50f);
formField.setBounds(bounds);
KbaSettings kbaSettings = new KbaSettings();
kbaSettings.setType(KbaSettings.TypeEnum.EVERY_ACCESS);
kbaSettings.setMaximumRetryCount(3);
kbaSettings.setNameMatcher(KbaSettings.NameMatcherEnum.STRICT);
DocumentSigner signer = new DocumentSigner();
signer.setName("Alex Gayle");
signer.setEmailAddress("alexgayle@cubeflakes.com");
signer.setSignerType(DocumentSigner.SignerTypeEnum.SIGNER);
signer.setAuthenticationType(DocumentSigner.AuthenticationTypeEnum.KBA);
signer.setLocale(DocumentSigner.LocaleEnum.EN);
signer.setFormFields(Arrays.asList(formField));
signer.setKbaSettings(kbaSettings);
SendForSign sendForSign = new SendForSign();
File file = new File("YOUR_FILE_PATH");
sendForSign.setFiles(Arrays.asList(file));
sendForSign.setSigners(Arrays.asList(signer));
sendForSign.setTitle("Agreement");
DocumentCreated documentCreated = documentApi.sendDocument(sendForSign);
```

**Node.js**

Node.js

```
import { DocumentApi, DocumentSigner, FormField, Rectangle, SendForSign, KbaSettings } from "boldsign";
import * as fs from 'fs';
const baseUrl:string = "https://api.boldsign.com";
const documentApi = new DocumentApi(baseUrl);
documentApi.setApiKey("YOUR_API_KEY");
const bounds = new Rectangle();
bounds.x = 100;
bounds.y = 100;
bounds.width = 100;
bounds.height = 50;
const formField = new FormField();
formField.name = "signature1";
formField.fieldType = FormField.FieldTypeEnum.Signature;
formField.pageNumber = 1;
formField.isRequired = true;
formField.bounds = bounds;
const kbaSettings = new KbaSettings();
kbaSettings.type = KbaSettings.TypeEnum.EveryAccess;
kbaSettings.maximumRetryCount = 3;
kbaSettings.nameMatcher = KbaSettings.NameMatcherEnum.Strict;
const documentSigner = new DocumentSigner();
documentSigner.name = "Alex Gayle";
documentSigner.emailAddress = "alexgayle@cubeflakes.com";
documentSigner.signerType = DocumentSigner.SignerTypeEnum.Signer;
documentSigner.authenticationType = DocumentSigner.AuthenticationTypeEnum.Kba;
documentSigner.locale = DocumentSigner.LocaleEnum.En;
documentSigner.formFields = [formField];
documentSigner.kbaSettings = kbaSettings;
const files = fs.createReadStream("YOUR_FILE_PATH");
const sendForSign = new SendForSign();
sendForSign.title = "Agreement";
sendForSign.signers = [documentSigner];
sendForSign.files = [files];
const documentCreated = await documentApi.sendDocument(sendForSign);
```

Common questions

## Questions about knowledge-based authentication

Related pages

- [What KBA is and when to use it](https://boldsign.com/blogs/knowledge-based-authentication-signer-verification.md)
- [Signer authentication methods](https://boldsign.com/electronic-signature-features/signer-authentication.md)
- [KBA in the help centre](https://support.boldsign.com/kb/article/24138/knowledge-based-authentication-in-boldsign)

### Is a document signed after KBA legally binding?

Yes. BoldSign complies with the ESIGN Act, UETA, and eIDAS, so its signatures are secure and [legally binding](https://boldsign.com/electronic-signature-legality.md). KBA adds an identity check before the signer opens the document.

### What happens if a signer fails KBA?

A failed KBA does not cancel the document. The signer can retry while attempts remain; after the last one it locks until you reset or remove KBA. A reset keeps the same link, and the next attempt is charged.

### Can KBA be added to a document that was already sent?

Yes. Add KBA to a signer from the document’s overview page; they complete it the next time they open the same link.

### Is KBA charged if the signer never opens the document?

No. KBA is charged only when the signer starts the check and the questions are generated. Adding or resetting it costs nothing.

### Do signers need a BoldSign account to complete KBA?

No. BoldSign signers open the signing link and complete KBA in their browser, without an account.

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*

Last updated: October 15, 2026. Disclaimer: This page contains product comparisons based on publicly available information as of October 2026 and may change.
