---
title: "Electronic Signature Identity Verification | BoldSign"
description: "Electronic signature identity verification: BoldSign checks each signer's government ID and selfie before the document opens, with proof in the audit trail."
url: "https://boldsign.com/electronic-signature-features/signer-identity-verification/"
---

Signer identity verification

# Prove who signed, with signer identity verification

BoldSign checks each signer’s passport, driver’s license, or national ID, and can match it to a biometric selfie, before the document opens. The audit trail keeps the proof.

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

Example with sample data.

Verify your identity to sign this document

Verify your identity

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

## What goes wrong when you only know the signer’s email?

An email address proves who opened the link, not who signed.

- *Picture: A signature request for a loan agreement forwarded from Jane Smith to steve\@cubeflakes.com, whose hand presses Review and Sign, with the note Steve is not the signer*

  ### A forwarded link can sign

  Anyone the request email reaches can open the document and sign in the signer’s name.

  [See how ID verification solves it](#bs-idv-how)

- *Picture: An audit trail with only jane\@cubeflakes.com and an IP address behind Viewed and Signed, and no identity check, outlined in red with the note It was not me, now what?*

  ### No proof when a signature is denied

  If a signer says it was not them, an email and an IP address do not prove who signed.

  [See how the audit trail solves it](#bs-idv-audit)

- *Picture: A reply from Jane Smith with passport_scan.jpg attached, outlined in red, with the note An ID copy, in your inbox*

  ### ID copies in your inbox

  Asking signers to email a passport photo spreads ID copies across inboxes and still does not prove who signed.

  [See how Stripe ID checks solve it](#bs-idv-settings)

How it works

## How does signer identity verification work?

BoldSign has the signer photograph a government ID and take a selfie, then matches the two before the document opens.

- *Picture: A recipient’s Settings in Prepare document for signing: Authentication on and Identity Verification picked*

  ### You turn it on per signer

  Choose Identity Verification in recipient settings.

- *Picture: The signature request email from John Doe via Cubeflakes, with the Review and Sign button in the brand’s blue*

  ### The signer opens the request

  The signer selects Review and sign.

- *Picture: Get ready to scan your ID: You must scan your driver’s license or passport, and I’m ready pressed*

  ### The signer captures their ID and a selfie

  They photograph their ID and any required selfie, or switch to their phone by QR code.

- *Picture: Identity Verification Successful: the signer is redirected to the document signing page*

  ### The signer is verified

  Once the ID matches, they can sign.

ID verification features

## What else can ID verification do?

It can also cover several signers, move to the phone, and recover a failed check.

- *Picture: Verify your identity to sign this document, with the Verify your identity button, powered by Stripe*

  01 · Verify

  ### Stops impersonation before access

  The document stays locked until the signer matches their ID and selfie.

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

  02 · Verify

  ### Checks for several signers on one request

  Two signers on one loan each verify with their own ID.

- *Picture: Continue on your mobile device: a QR code to scan, and Other options*

  03 · Verify

  ### Scan with the phone’s camera

  Scan a QR code to take the ID photo and selfie on a phone.

- *Picture: Identity Verification Failed, with Retry verification and 1 of 3 retries remaining*

  04 · Recover

  ### Another try, within your limit

  A failed check can retry, up to your limit, before the document locks.

- *Picture: Manual Verification of Steve Smith’s failed check: the ID type Passport, the country US, and the Mark as verified button*

  05 · Recover

  ### A failed check does not cancel the document

  Review and approve the uploaded ID, or reset their attempts.

- *Picture: A document’s recipients: Steve Smith with ID Verification failed, and the menu with Manual Verification, Reset Verification, Remove authentication and Download verification data*

  06 · Recover

  ### Reset, remove or download

  Reset attempts, remove the check, or download the data.

Audit trail

## Every check is recorded in the audit trail

The certificate of completion logs who verified, the provider, the session ID and the time.

- **Holds up when a signature is disputed.** If a signer denies signing, you can show a matched ID and selfie.

*Picture: The certificate of completion’s audit trail: John Doe sent the document to Jane Smith, Jane Smith completed identity verification through Stripe Identity, then signed the document*

Settings

## What can you control in ID verification settings?

Each signer gets their own ID verification setting, for this document only.

**Choose who verifies and how often Turn it on per signer or reviewer, and pick how often they verify.**

*Picture: Business Profile, ID Verification: ID Verification Frequency set to Every access*

**Selfie and name match Selfie check and live capture are on by default; name matching is Strict.**

*Picture: Business Profile, ID Verification: Name-match tolerance level Strict, and Require selfie check on*

**Attempts and reports Allow 1 to 10 tries before the document locks.**

*Picture: Business Profile, ID Verification: Number of verification attempts set to 3*

**Allowed IDs and countries Pick accepted ID types and limit issuing countries.**

*Picture: Business Profile, ID Verification: Allowed ID Documents Driver’s License and 2 more, and Allowed Countries United Kingdom and United States*

Security

## How are documents signed with ID verification kept secure?

BoldSign encrypts every 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)

Cost

## What does ID verification cost?

BoldSign charges $2 per completed attempt, pass or fail, on top of the plan seat. Each retry and re-verification costs $2 too.

| Scenario | Verifications | Cost |
| - | - | - |
| 3 signers on a loan agreement, each verified once | 3 | $6 |
| 1 signer set to verify on every access, who opens the document 3 times | 3 | $6 |
| 40 lease agreements a month, one tenant each, verified once | 40 | $80 |

What it costs

## Limits and costs to know before you verify signer IDs with BoldSign

BoldSign checks a government ID and selfie, not background or credit. Prices are in USD.

- $2 per completed attempt Pass or fail. Each retry is charged.
- $15 Business plan, per user a month Billed yearly. ID verification cannot be added to the Essential or Growth plans ([pricing](https://boldsign.com/electronic-signature-pricing/?plan=webapp)).
- $30 Enterprise API plan, a month Needed for live documents through the API, with 40 envelopes included.

### Before your first ID check

- 10 attempts at most Per signer, 3 by default, then the document locks.

* BoldSign does not read ID details written in Arabic, Chinese, Cyrillic, Greek, Hebrew, Japanese, Korean, Tamil, or Thai script ([identity verification settings](https://support.boldsign.com/kb/article/15466/identity-verification-settings-in-boldsign)).
* National ID cards are available by invitation only ([supported documents](https://support.boldsign.com/kb/article/15463/supported-documents-for-identity-verification)).
* Trial plans include no ID verification credits.

Compared

## Which digital signature tools include identity verification?

BoldSign Business is $15 per user a month, against $30 for Docusign eSignature Standard and $49 for PandaDoc Business. Adobe and Dropbox Sign publish no price.

| Capability | BoldSign | Docusign | Adobe Acrobat Sign | PandaDoc | Dropbox Sign |
| - | - | - | - | - | - |
| Base plan that covers ID checks | Business plan$15 per user a month | eSignature Standard plan$30 per user a month, $360 billed yearly | Enterprise plan (ETLA)Not published | Business plan$49 per seat a month | API Premium planNot published |
| Price per ID check | $2 per verification attemptPass or fail, pay as you go | From $2.40 per attemptAdded to the plan | Not publishedPrepaid through Adobe sales | $2 per successful checkPrepaid packs of 10 or more | Not publishedThrough an account manager |
| ID checks for several signers on one request | Yes, set per recipient | Yes, set per recipient | Yes | Yes, set per recipient | No, ID checks go to one signer per request |
| After a signer’s last failed attempt | Document stays openYou review the ID, or reset their attempts | Signer can ask the sender for a new envelope | Agreement is cancelled by defaultA new agreement is needed | Not published | Not published |

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).

### Another way to verify signers in the US

For signers in the United States, BoldSign also offers knowledge-based authentication (KBA). Instead of photographing an ID, the signer answers security questions drawn from public records.

| Compare | ID verification | Knowledge-based authentication |
| - | - | - |
| The signer | Photographs a government ID | Enters identity details and answers security questions |
| Device | A computer or phone with a camera | Any device, no camera |
| Who can use it | Signers in the US and other supported countries | Signers in the US only |

[Learn about knowledge-based authentication](https://boldsign.com/electronic-signature-features/knowledge-based-authentication.md)

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 you add identity verification through the API?

Yes. Set a signer’s authenticationType to IdVerification, and test it free in the sandbox first.

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

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

**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 name};type=application/pdf' \
  -F 'Title={Title}' \
  -F 'Signers={
  "name": "Test",
  "emailAddress": "alexgayle@cubeflakes.com",
  "authenticationType": "IdVerification",
  "deliveryMode": "Email",
  "identityVerificationSettings": {
    "type": "EveryAccess",
    "maximumRetryCount": 10,
    "requireLiveCapture": true,
    "requireMatchingSelfie": true,
    "nameMatcher": "Strict",
    "allowedDocumentTypes": [
      "Passport",
      "IDCard",
      "DriverLicense"
    ]
  },
  "signerType": "Signer",
  "allowFieldConfiguration": true,
  "formFields": [
    {
      "id": "signature1",
      "name": "signature1",
      "fieldType": "Signature",
      "pageNumber": 1,
      "bounds": {
        "x": 160,
        "y": 150,
        "width": 51,
        "height": 21
      },
      "isRequired": true
    }
  ]
}'
```

**C#**

C#

```
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: "sign",
    isRequired: true,
    type: FieldType.Signature,
    pageNumber: 1,
    bounds: new Rectangle(x: 100, y: 100, width: 100, height: 50));
var formFieldCollections = new List<FormField>()
{
    signatureField
};
var idSettings = new IdentityVerificationSettings
{
    Type = Model.IdVerification.IdVerificationType.EveryAccess,
    MaximumRetryCount = 10,
    RequireLiveCapture = true,
    RequireMatchingSelfie = true,
    NameMatcher = Model.IdVerification.NameVariation.Strict,
    AllowedDocumentTypes = new List<Model.IdVerification.AllowedDocumentType>()
    {
      Model.IdVerification.AllowedDocumentType.Passport,
      Model.IdVerification.AllowedDocumentType.IDCard,
      Model.IdVerification.AllowedDocumentType.DriverLicense,
    },
};
var signer = new DocumentSigner(
    signerName: "Signer Name",
    signerType: SignerType.Signer,
    signerEmail: "alexgayle@cubeflakes.com",
    authenticationType: AuthenticationType.IdVerification,
    identityVerificationSettings: idSettings,
    formFields: formFieldCollections,
    locale: Locales.EN);
var documentSigners = new List<DocumentSigner>()
{
    signer
};	
var sendForSign = new SendForSign()
{
    Title = "Agreement",
    Signers = documentSigners,
    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 = "Document SDK API",
        document_title = "SDK Document Test case",
        description = "Testing document from SDK integration test case", 
        files = ["YOUR_FILE_PATH"],
        signers = [
            boldsign.DocumentSigner(
                name = "Hanky",
                emailAddress = "hankyWhites@cubeflakes.com",
                signerOrder = 1,
                signerType = "Signer",
                formFields = [
                    boldsign.FormField(
                        name = "Sign",
                        fieldType = "Signature",
                        font = "Helvetica",
                        pageNumber = 1,
                        isRequired = True,
                        bounds = boldsign.Rectangle(x = 50, y = 50, width = 100, height = 150)
                    )
                ],
                privateMessage = "This is private message for signer",
                authenticationType = "IdVerification",
                identityVerificationSettings = boldsign.IdentityVerificationSettings(
                    type = "EveryAccess",
                    maximumRetryCount = 10,
                    requireLiveCapture = True,
                    requireMatchingSelfie = True,
                    nameMatcher = "Strict"
                )
            )
        ],
    )
    
    document_created = document_api.send_document(send_for_sign)
```

**PHP**

PHP

```
<?php require_once "vendor/autoload.php";
$config = new BoldSign\Configuration();
$config->setHost('https://api.boldsign.com');
$config->setApiKey('YOUR_API_KEY');
$documentApi = new BoldSign\Api\DocumentApi($config);
$idSettings = new BoldSign\Model\IdentityVerificationSettings();
$idSettings->setType('EveryAccess');
$idSettings->setMaximumRetryCount(10);
$idSettings->setRequireLiveCapture(true);
$idSettings->setRequireMatchingSelfie(true);
$idSettings->setNameMatcher('Strict');
$bounds = new BoldSign\Model\Rectangle();
$bounds->setX(100);
$bounds->setY(150);
$bounds->setWidth(200);
$bounds->setHeight(50);
$signatureFieldSettings = new BoldSign\Model\FormField();
$signatureFieldSettings->setFieldType('Signature');
$signatureFieldSettings->setId('signatureField1');
$signatureFieldSettings->setPageNumber(1);
$signatureFieldSettings->setBounds($bounds);

$signer = new BoldSign\Model\DocumentSigner();
$signer->setName('Signer Name');
$signer->setEmailAddress('signer@example.com');
$signer->setAuthenticationType('IdVerification');
$signer->setFormFields([$signatureFieldSettings]);
$signer->setIdentityVerificationSettings($idSettings);
$sendForSign = new BoldSign\Model\SendForSign();
$sendForSign->setTitle('Document Title');
$sendForSign->setFiles(['YOUR_FILE_PATH']);
$sendForSign->setSigners([$signer]);
$documentCreated = $documentApi->sendDocument($sendForSign);
```

**Java**

Java

```
import java.io.File;
import java.util.Arrays;
import com.boldsign.ApiClient;
import com.boldsign.ApiException;
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.IdentityVerificationSettings;
import com.boldsign.model.Rectangle;
import com.boldsign.model.SendForSign;
ApiClient client = Configuration.getDefaultApiClient();
client.setBasePath("https://api.boldsign.com");
client.setApiKey("YOUR_API_KEY");
DocumentApi documentApi = new DocumentApi(client);
IdentityVerificationSettings identityVerificationSettings = new IdentityVerificationSettings();
identityVerificationSettings.setType(IdentityVerificationSettings.TypeEnum.EVERY_ACCESS);
identityVerificationSettings.setMaximumRetryCount(10);
identityVerificationSettings.setRequireLiveCapture(true);
identityVerificationSettings.setRequireMatchingSelfie(true);
identityVerificationSettings.setNameMatcher(IdentityVerificationSettings.NameMatcherEnum.STRICT);
FormField formField = new FormField();
formField.setFieldType(FormField.FieldTypeEnum.SIGNATURE);
formField.setPageNumber(1);
formField.setId("Signature1");
Rectangle bounds = new Rectangle().x(100f).y(100f).width(100f).height(50f);
formField.setBounds(bounds);
DocumentSigner signer = new DocumentSigner();
signer.setName("David");
signer.setEmailAddress("david@cubeflakes.com");
signer.setFormFields(Arrays.asList(formField));
signer.setAuthenticationType(DocumentSigner.AuthenticationTypeEnum.ID_VERIFICATION);
signer.setIdentityVerificationSettings(identityVerificationSettings);
SendForSign sendForSign = new SendForSign();
sendForSign.setTitle("Document title");
sendForSign.setSigners(Arrays.asList(signer));
sendForSign.setFiles(Arrays.asList(new File("YOUR_FILE_PATH")));
DocumentCreated created = documentApi.sendDocument(sendForSign);
```

**Node.js**

Node.js

```
import { DocumentApi, IdentityVerificationSettings, FormField, Rectangle, DocumentSigner, SendForSign } from "boldsign";
import * as fs from 'fs';
const documentApi = new DocumentApi("https://api.boldsign.com");
documentApi.setApiKey('YOUR_API_KEY');
const idSettings = new IdentityVerificationSettings();
idSettings.type = IdentityVerificationSettings.TypeEnum.EveryAccess;
idSettings.maximumRetryCount = 10;
idSettings.requireLiveCapture = true;
idSettings.requireMatchingSelfie = true;
idSettings.nameMatcher = IdentityVerificationSettings.NameMatcherEnum.Strict;
const signatureField = new FormField();
signatureField.id = 'signature';
signatureField.fieldType = FormField.FieldTypeEnum.Signature;
signatureField.pageNumber = 1;
signatureField.bounds = new Rectangle();
signatureField.bounds.x = 100;
signatureField.bounds.y = 100;
signatureField.bounds.width = 200;
signatureField.bounds.height = 50;
signatureField.isRequired = true;
const signer = new DocumentSigner();
signer.name = 'Name';
signer.emailAddress = 'alexgayle@cubeflakes.com';
signer.signerType = DocumentSigner.SignerTypeEnum.Signer;
signer.authenticationType = DocumentSigner.AuthenticationTypeEnum.IdVerification;
signer.identityVerificationSettings = idSettings;
signer.formFields = [signatureField];
const sendForSign = new SendForSign();
sendForSign.title = '{title}';
sendForSign.files = [fs.createReadStream("YOUR_FILE_PATH")];
sendForSign.signers = [signer];
documentApi.sendDocument(sendForSign);
```

Common questions

## Frequently asked questions

Related pages

- [ID verification for rental applications](https://boldsign.com/blogs/id-verification-for-rental-applications.md)
- [Identity verification for remote HR onboarding](https://boldsign.com/blogs/hr-remote-onboarding-identity-verification.md)
- [Signer authentication](https://boldsign.com/electronic-signature-features/signer-authentication.md)
- [BoldSign pricing calculator](https://boldsign.com/esignature-pricing-calculator.md)
- [eSignature ROI calculator](https://boldsign.com/esignature-roi-calculator.md)

### Which BoldSign plans include ID verification?

ID verification is an add-on on the [Business plan](https://boldsign.com/electronic-signature-pricing/?plan=webapp), $15 per user a month billed yearly, and on Premium and Enterprise API. Each verification costs $2. It is not on the Essential or Growth plans.

### What happens if a signer fails verification?

A failed check does not cancel the document. After the attempts you set, it locks for that signer, and you can approve their uploaded ID or reset their attempts.

### Which ID documents can signers use?

Passports and driver’s licenses, plus national ID cards once enabled for your account. Accepted documents vary by issuing country ([list by country](https://support.boldsign.com/kb/article/15463/supported-documents-for-identity-verification)).

### Do signers need a BoldSign account or app to verify?

No. Signers verify in their browser from the signing link, on any device, or scan a QR code to continue on their phone.

### How is the signer’s ID data protected?

Stripe Identity runs each check and stores the ID data; BoldSign keeps none on its servers. Documents are encrypted with AES-256, and BoldSign holds a [SOC 2 Type 2](https://boldsign.com/soc2-overview.md) report.

### What other ways can I confirm who is signing?

BoldSign also offers access codes, one-time codes by email or SMS, and knowledge-based authentication (KBA) for signers in the United States. Compare them on the [signer authentication page](https://boldsign.com/electronic-signature-features/signer-authentication.md).

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.
