In-Person E-Signature on One Kiosk or Tablet

How do you collect e-signatures in person on one device?

Put one kiosk or tablet at the counter and let every signer sign the same document, in order, while they are in the room. With TurboSign embedded signing, your app creates the document once, shows the first signer their signing page inside your own kiosk screen, and loads the next signer the moment the previous one finishes. TurboSign enforces the order on its servers and records how each signer was verified.

Key takeaways

• One tablet, one document, every signer. Each person signs in turn on the same screen, and no signing link lands in anyone’s inbox.
• Signing order is enforced by TurboSign itself, not just by your screen, so nobody can sign out of turn.
• You choose how each signer proves who they are: an email passcode, a text message passcode, or an identity check your own system already ran.
• Everyone still leaves with a record. Each signer gets the completed copy, and the certificate shows how they were verified.

How does a TurboSign kiosk flow work?

1. 1

   An admin turns on embedded signing and allows your kiosk app

   In the E-Signature settings, an organization admin enables embedded signing and adds the origin of your kiosk or tablet app to Allowed embedding domains. The list is deny by default, so until your origin is on it, no site can frame the signing page.

2. 2

   Your backend creates the document once, with every signer in order

   One call to createEmbeddedSignature in the TypeScript SDK (@turbodocx/sdk) creates the request with each signer and their signing order. The first signer comes back ready with a signing URL; later signers come back pending with no URL yet. No signing-link emails go out.

3. 3

   The kiosk shows the current signer their signing page

   Your app frames the signing URL in an iframe, or drops it into the TurboSignForm component from @turbodocx/embed. If that signer verifies with a passcode, they enter it on the signing page, then review and sign the document without leaving the device.

4. 4

   When a signer finishes, the kiosk loads the next one

   The signing page posts a completion message to your app. Your backend then calls createSigningUrl for the next signer and the kiosk loads it in the same frame. Repeat until every signer is done, then confirm the whole document with the completed webhook.

How are signers verified on a shared device?

The verification method is set per signer, so one document can mix them. Your organization’s verification policy still applies to signers you leave unset.

Compare the methods in detail on the e-signature identity verification page. If your system already checked the signer, see bring your own identity verification. TurboSign also has an override mode that skips verification, but it exists for development and testing, not for a production kiosk.

What does the kiosk backend look like in code?

Two calls in the TypeScript SDK (@turbodocx/sdk 0.8.0). Other languages use the same signing-URL endpoint, POST /turbosign/documents/:documentId/signing-url.

import { TurboSign } from '@turbodocx/sdk';

// 1. At the counter: create the document once, every signer in order.
const { documentId, recipients } = await TurboSign.createEmbeddedSignature({
  file: agreementPdf,
  documentName: 'Purchase Agreement',
  recipients: [
    { name: 'Alex Rivera', email: 'alex@example.com',
      auth: { emailOtp: true }, fields: { signature: '{signature1}' } },
    { name: 'Sam Chen', email: 'sam@example.com',
      auth: { emailOtp: true }, fields: { signature: '{signature2}' } },
  ],
});
// recipients[0].status is 'ready': frame recipients[0].embedUrl now.
// recipients[1].status is 'pending': no URL until it is Sam's turn.

// 2. After the kiosk receives Alex's completion message:
const { url } = await TurboSign.createSigningUrl(documentId, {
  recipientId: recipients[1].recipientId,
});
// Load url in the same frame. Asked too early, TurboSign answers 409 RecipientNotInTurn.

The backend moves the turn forward a moment after a signer completes, so a short retry on the next createSigningUrl call keeps the hand-off smooth. On the front end, the React e-signature component frames each URL and reports completion; your app swaps in the next URL.

What stays under IT’s control?

Where is the full implementation guide?

This page covers the outcome. The step-by-step setup, every error code, and the request and response shapes live in the TurboSign documentation, and the sample app runs the kiosk flow end to end.

Frequently asked questions