Skip to content
  1. Blog
  2. API

How to Add In-Person Signing to Documents with the BoldSign API

TL;DR: Send the document with POST /v1/document/send, set the signer’s signerType to InPersonSigner, and add a hostEmail for the team member who runs the session. The host must belong to your organization and use a different email from the signer. Our in-person signing page shows what the session looks like.

A loan officer has a client at the desk with a contract ready to sign. Your app already sends documents by email, but the client is right here. Waiting for an email to arrive slows the meeting down.

In-person signing solves that. The client signs on your team member’s device, and the signed copy lands in your account like any other.

What is in-person signing?

In-person signing lets someone sign on a device you hold rather than from an emailed link. A member of your team, called the host, stays with the signer during the session.

Think of a pen handed across a counter at a bank. The clerk stays, watches you sign, and keeps the form. The same idea works on a phone, tablet or computer.

How does a document API with signature integration handle in-person signing?

A document API with signature integration lets your app send documents for signature in code. For in-person signing, you add two values to the signer: a signer type and a host email.

Our guide to send a document with in-person signing covers the same request. Here is what each value does:

  • signerType: set it to InPersonSigner. The other values are Signer and Reviewer.
  • hostEmail: the email of the team member who runs the session.
  • formFields: the fields the signer fills in, such as a signature.

What rules apply to the host email?

The host must be a user in your own organization. The host email must also differ from every recipient email on the document.

Those two rules keep the roles apart. The person who runs the session is never the person who signs.

What happens during an in-person signing session?

The host opens the session from the email we send, then selects Start session to hand over the device. The signer fills in the fields with the host beside them.

When the signer finishes, they select Transfer control to give the device back. We save the completed document in your account, and the signer receives a copy by email.

The audit trail names the host along with each recipient. You can download it from My Documents once everyone has signed.

How do you send a document with an in-person signer?

Send a POST request to https://api.boldsign.com/v1/document/send. Add the file, a title and the signer with their form fields.

  1. Create an API key in your BoldSign account.
  2. Add the signer’s name and email, and set signerType to InPersonSigner.
  3. Add the host’s email in hostEmail.
  4. Place a signature field on the page with bounds.
  5. Send the request and keep the document ID from the response.

Each sample below sends one document to Alex as the in-person signer, with Sam as the host.

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 'Message=' \
  -F 'Signers={
  "name": "Alex",
  "emailAddress": "alex@example.com",
  "signerType": "InPersonSigner",
  "hostEmail": "sam@example.com",
  "deliveryMode": "Email",
  "formFields": [
    {
      "id": "signature1",
      "name": "signature1",
      "fieldType": "Signature",
      "pageNumber": 1,
      "bounds": {
        "x": 80,
        "y": 50,
        "width": 31,
        "height": 21
      },
      "isRequired": true
    }
  ],
  "locale": "EN"
}' \
  -F 'Files=@{FILE_PATH}' \
  -F 'Title=Title'
var apiClient = new ApiClient("https://api.boldsign.com", "{YOUR_API_KEY}");
var documentClient = new DocumentClient(apiClient);

var documentFilePath = new DocumentFilePath
{
    ContentType = "application/pdf",
    FilePath = "{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 formFieldCollections = new List<FormField>
{
    signatureField
};

var signer = new DocumentSigner(
    signerName: "Alex",
    signerType: SignerType.InPersonSigner,
    signerEmail: "alex@example.com",
    hostEmail: "sam@example.com",
    formFields: formFieldCollections,
    locale: Locales.EN);

var documentSigners = new List<DocumentSigner>
{
    signer
};

var sendForSign = new SendForSign
{
    Message = "please sign this",
    Title = "Agreement",
    Signers = documentSigners,
    Files = filesToUpload
};

var documentCreated = documentClient.SendDocument(sendForSign);
import boldsign

configuration = boldsign.Configuration(api_key="YOUR_API_KEY")

with boldsign.ApiClient(configuration) as api_client:
    document_api = boldsign.DocumentApi(api_client)

    signatureField = boldsign.FormField(
        fieldType="Signature",
        pageNumber=1,
        bounds=boldsign.Rectangle(x=100, y=100, width=100, height=50),
        isRequired=True,
    )

    signer = boldsign.DocumentSigner(
        name="Alex",
        emailAddress="alex@example.com",
        signerType="InPersonSigner",
        hostEmail="sam@example.com",
        formFields=[signatureField],
        locale="EN",
    )

    send_for_sign = boldsign.SendForSign(
        title="DOCUMENT_TITLE",
        signers=[signer],
        files=["FILE_PATH"],
    )

    document_created = document_api.send_document(send_for_sign=send_for_sign)
import { DocumentApi, DocumentSigner, FormField, Rectangle, SendForSign } from "boldsign";
import * as fs from "fs";

async function main() {
  const data = new SendForSign();
  const config = new DocumentApi();
  config.setApiKey("YOUR_API_KEY");

  const bounds = new Rectangle();
  bounds.x = 50;
  bounds.y = 50;
  bounds.width = 100;
  bounds.height = 20;

  const signatureField = new FormField();
  signatureField.fieldType = FormField.FieldTypeEnum.Signature;
  signatureField.pageNumber = 1;
  signatureField.bounds = bounds;
  signatureField.isRequired = true;

  const signer = new DocumentSigner();
  signer.name = "Alex";
  signer.emailAddress = "alex@example.com";
  signer.signerType = DocumentSigner.SignerTypeEnum.InPersonSigner;
  signer.hostEmail = "sam@example.com";
  signer.formFields = [signatureField];
  signer.locale = "EN";

  data.title = "DOCUMENT_TITLE";
  data.signers = [signer];
  data.files = [fs.createReadStream("FILE_PATH")];

  const response = await config.sendDocument(data);
}

main();
ApiClient client = Configuration.getDefaultApiClient();
client.setApiKey("YOUR_API_KEY");

DocumentApi documentApi = new DocumentApi(client);

FormField signatureField = new FormField();
signatureField.setFieldType(FieldTypeEnum.SIGNATURE);
signatureField.setPageNumber(1);

Rectangle bounds = new Rectangle().x(50f).y(50f).width(100f).height(20f);
signatureField.setBounds(bounds);
signatureField.setIsRequired(true);

List<FormField> formFields = new ArrayList<FormField>();
formFields.add(signatureField);

DocumentSigner signer = new DocumentSigner();
signer.setName("Alex");
signer.setEmailAddress("alex@example.com");
signer.setSignerType(DocumentSigner.SignerTypeEnum.IN_PERSON_SIGNER);
signer.setHostEmail("sam@example.com");
signer.setFormFields(formFields);
signer.setLocale(DocumentSigner.LocaleEnum.EN);

List<DocumentSigner> signers = new ArrayList<DocumentSigner>();
signers.add(signer);

File file = new File("FILE_PATH");
List<File> files = new ArrayList<File>();
files.add(file);

SendForSign sendForSign = new SendForSign();
sendForSign.setTitle("DOCUMENT_TITLE");
sendForSign.setSigners(signers);
sendForSign.setFiles(files);

DocumentCreated documentCreated = documentApi.sendDocument(sendForSign);
<?php

require_once "vendor/autoload.php";

$config = new BoldSign\Configuration();
$config->setApiKey('YOUR_API_KEY');

$document_api = new BoldSign\Api\DocumentApi($config);

$signatureField = new BoldSign\Model\FormField();
$signatureField->setFieldType('Signature');
$signatureField->setPageNumber(1);
$signatureField->setBounds(new BoldSign\Model\Rectangle([50, 50, 100, 20]));
$signatureField->setIsRequired(true);

$signer = new BoldSign\Model\DocumentSigner();
$signer->setName("Alex");
$signer->setEmailAddress("alex@example.com");
$signer->setSignerType("InPersonSigner");
$signer->setHostEmail("sam@example.com");
$signer->setFormFields([$signatureField]);
$signer->setLocale("EN");

$send_for_sign = new BoldSign\Model\SendForSign();
$send_for_sign->setTitle('DOCUMENT_TITLE');
$send_for_sign->setSigners([$signer]);
$send_for_sign->setFiles(['FILE_PATH']);

$documentCreated = $document_api->sendDocument($send_for_sign);

Swap the demo names and emails for your own. The send document API reference lists every signer property.

What should you check before you go live?

A few details cause most failed or confusing sends. Check these before your first real session.

  • The host is a user in your organization, not an outside email.
  • The host email differs from the signer email.
  • Every in-person signer has at least one signature field.
  • You tested in the sandbox first, since every live document counts toward your envelopes.

Which BoldSign plan do you need, and what does it cost?

Live API access comes with the Enterprise API plan, which starts at $30 a month with 40 envelopes. Extra envelopes cost $0.75 each.

You can build and test first in our free sandbox, with no credit card. Sandbox documents carry a test watermark and are deleted after 14 days. Prices are in USD, as listed on the BoldSign pricing page in November 2026.

You need the Growth plan or above to send in-person documents from the web app instead. Growth costs $5 per user a month, billed yearly.

Where do you go next with in-person signing?

Start with one signer and one host in the sandbox. Then add the fields your documents need.

Frequently asked questions

What is an in-person signer in BoldSign?

An in-person signer signs on a device that a member of your team holds, instead of from an emailed link. The team member who runs the session is the host.

Which field turns a signer into an in-person signer?

Set signerType to InPersonSigner on that signer in the send request. The other accepted values are Signer and Reviewer.

What does the hostEmail field do?

The hostEmail field names the team member who runs the signing session. It applies only when signerType is InPersonSigner.

Can the host and the signer use the same email address?

No. The host email must differ from every recipient email on the document, so the two roles stay separate in the record.

Who can act as the host?

Only a user in your own BoldSign organization can host an in-person session. Pick someone who will be with the signer when they sign.

Does the signer get a copy of the signed document?

Yes. The signer receives a copy of the signed document by email once the session ends.

Is an in-person electronic signature legally binding?

Yes, when the signer agrees to sign electronically and the signed record is kept. The audit trail names the host and each signer. Check the rules for your document type and country.

Can I test in-person signing through the API for free?

Yes. Our free API sandbox needs no credit card. Sandbox documents carry a test watermark and are deleted after 14 days.

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.

More posts by Gopinath Kannusamy
Get started

Sign up for your free trial today!

Start free trial
  • 30-day free trial
  • No credit card required