Clickwrap agreement in React Native
A React Native app shows its acceptance screen in a WebView that loads a page from your own domain, passes the client token in, and gets the record ID back over the message bridge before your server creates the account.
Free plan: 10 live signatures a month and a full test mode. No card required.
The working code: a WebView acceptance screen and its backend
The browser SDK observes real page elements, and a native view has no DOM for it to observe. So the acceptance screen is a small web page on your own domain, shown in react-native-webview. The screen, the page and a four-route Express server are below.
// server/routes/ceremony.ts import { randomUUID } from "node:crypto"; import { Router } from "express"; import { db, esc } from "../clients"; export const ceremony = Router(); // POST /api/signup/ceremony creates the session and returns only the client token. ceremony.post("/api/signup/ceremony", async (req, res) => { const { email, country, state } = req.body as { email: string; country: string; state?: string }; const signerId = randomUUID(); // your identifier for this person. Keep using it for them in later sessions. const region = country.toUpperCase() === "US" && state ? `US-${state.toUpperCase()}` : undefined; const { data: session, error } = await esc.sessions.create( { profile: process.env.ESIGNCOMPLY_PROFILE_ID!, signer: { external_id: signerId, email, class: "consumer", country: country.toUpperCase(), region }, documents: [ { document: process.env.ESIGNCOMPLY_TERMS_ID!, version: "current" }, { document: process.env.ESIGNCOMPLY_PRIVACY_ID!, version: "current" }, ], // The page the WebView loads. In live mode it must be inside your registered domain. context: { url: `${process.env.APP_ORIGIN}/mobile/accept`, locale: "en-US", purpose: "account_signup" }, }, { idempotencyKey: `signup-${signerId}` }, ); if (error) return res.status(502).json({ error: error.code }); // Server-owned state: the signer and the versions this session pinned. await db.query("insert into acceptances (signer_id, session_id, document_version_ids) values ($1, $2, $3)", [ signerId, session.id, session.documents.map((d) => d.version_id), ]); // Only these go to the app. Never the key, never the whole session. res.json({ ceremonyId: session.id, clientToken: session.client_token, apiUrl: session.api_url, documents: session.documents, }); });
<!-- server/public/accept.html, served at /mobile/accept on your own domain --> <!doctype html> <html lang="en"> <head> <meta charset="utf-8"> <meta name="viewport" content="width=device-width, initial-scale=1"> <title>Accept the terms</title> <style> body { font: 16px/1.5 system-ui, sans-serif; color: #111; margin: 24px; } #assent a { color: #2563eb; text-decoration: underline; } </style> </head> <body> <form id="accept"> <div id="assent"> <input id="agree" type="checkbox" disabled> <label for="agree"> By checking the box and clicking Create account, you agree to the <a id="tos-link" href="/legal/terms">Terms of Service</a> and acknowledge the <a id="privacy-link" href="/legal/privacy">Privacy Notice</a>. </label> <p><button id="create-account" type="submit" disabled>Create account</button></p> <p>Acme uses Esign Comply to record this event on its behalf. See Acme's Privacy Notice for purposes and roles.</p> </div> <p id="message" role="alert"></p> </form> <script src="https://esigncomply.com/sdk/v1/esigncomply.js"></script> <script type="module"> const agree = document.querySelector("#agree"); const submit = document.querySelector("#create-account"); const message = document.querySelector("#message"); const tosLink = document.querySelector("#tos-link"); const privacyLink = document.querySelector("#privacy-link"); const INCONCLUSIVE = "We could not confirm whether your acceptance was recorded. Please wait while we check."; // The bridge to the native screen: one JSON string per message. const toApp = (payload) => window.ReactNativeWebView.postMessage(JSON.stringify(payload)); let ceremony = null; // The native screen calls this with what your server returned for the session. window.startCeremony = async ({ clientToken, apiUrl, documents }) => { if (ceremony) ceremony.destroy(); agree.checked = false; // a new session must find the box unchecked agree.disabled = submit.disabled = true; try { ceremony = await EsignComply.attach({ clientToken, apiUrl }); ceremony.on("change", ({ remainingSteps }) => { submit.disabled = remainingSteps.some((step) => step !== "signature.applied"); }); ceremony.on("expired", () => toApp({ type: "expired" })); // the app asks your server for a new session // Point each link at the exact version this session pinned, then report it. const [terms, privacy] = documents; tosLink.search = "?v=" + terms.version_id; privacyLink.search = "?v=" + privacy.version_id; await ceremony.presentDocument({ versionId: terms.version_id, mode: "hyperlink", link: tosLink }); await ceremony.presentDocument({ versionId: privacy.version_id, mode: "hyperlink", link: privacyLink }); // The region holds the notice, the links, the checkbox and the button. await ceremony.observeAssent({ region: document.querySelector("#assent"), checkbox: agree, submit }); agree.disabled = false; // the box can be ticked only while the SDK is watching it } catch (error) { message.textContent = error.message; } }; document.querySelector("#accept").addEventListener("submit", async (event) => { event.preventDefault(); if (!ceremony) return; message.textContent = ""; try { const result = await ceremony.complete(); // the signing act: { recordId, receipt, verifyUrl, status } toApp({ type: "completed", recordId: result.recordId }); // the app sends it to your server to confirm } catch (error) { // A refusal carries a message and a fix: keep the form. Anything else is inconclusive. const refused = error instanceof EsignComply.EsignComplyError && error.code !== "network_error" && error.status < 500; message.textContent = refused ? error.message : INCONCLUSIVE; } }); toApp({ type: "ready" }); </script> </body> </html>
// app/screens/AcceptTermsScreen.tsx import { useRef, useState } from "react"; import { Linking, Text, View } from "react-native"; import { WebView, type WebViewMessageEvent } from "react-native-webview"; // Your verified domain. In development use http://localhost:3000, which test keys accept. const SITE = "https://app.example.com"; const ACCEPT_URL = `${SITE}/mobile/accept`; const INCONCLUSIVE = "We could not confirm whether your acceptance was recorded. Please wait while we check."; type Signup = { email: string; password: string; country: string; state?: string }; type Ceremony = { ceremonyId: string; clientToken: string; apiUrl: string; documents: Array<{ version_id: string }> }; export function AcceptTermsScreen({ signup, onDone }: { signup: Signup; onDone: () => void }) { const webview = useRef<WebView<object>>(null); const ceremony = useRef<Ceremony | null>(null); const [message, setMessage] = useState<string | null>(null); // Your server creates the session with the secret key. The app only ever holds the client token. async function startCeremony() { const response = await fetch(`${SITE}/api/signup/ceremony`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ email: signup.email, country: signup.country, state: signup.state }), }); if (!response.ok) return setMessage("We could not start the signup. Try again."); const started: Ceremony = await response.json(); ceremony.current = started; // Pass the client token into the page. It stays in memory there. const { clientToken, apiUrl, documents } = started; webview.current?.injectJavaScript(`window.startCeremony(${JSON.stringify({ clientToken, apiUrl, documents })}); true;`); } async function onMessage(event: WebViewMessageEvent) { const fromPage = JSON.parse(event.nativeEvent.data) as { type: string; recordId?: string }; if (fromPage.type === "ready" || fromPage.type === "expired") return startCeremony(); if (fromPage.type !== "completed" || !ceremony.current) return; // The record ID from the page is a claim. Your server checks it before the account exists. const response = await fetch(`${SITE}/api/signup/finish`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ ceremonyId: ceremony.current.ceremonyId, recordId: fromPage.recordId, email: signup.email, password: signup.password, }), }); if (response.ok) onDone(); else setMessage(INCONCLUSIVE); } return ( <View style={{ flex: 1 }}> <WebView ref={webview} source={{ uri: ACCEPT_URL }} onMessage={onMessage} // Document links open in the system browser, so the acceptance page stays loaded. onShouldStartLoadWithRequest={(request) => { if (request.url.startsWith(ACCEPT_URL)) return true; Linking.openURL(request.url); return false; }} /> {message ? <Text accessibilityRole="alert">{message}</Text> : null} </View> ); }
// server/routes/finish.ts import { Router } from "express"; import { db, esc } from "../clients"; import { createUser } from "../users"; // your own account creation export const finish = Router(); const SEALED = new Set(["recorded", "timestamped", "anchored"]); // POST /api/signup/finish confirms the record, then creates the account. finish.post("/api/signup/finish", async (req, res) => { const { ceremonyId, recordId, email, password } = req.body as Record<string, string | undefined>; if (!ceremonyId || !recordId || !email || !password) return res.status(400).json({ error: "invalid_request" }); const { rows } = await db.query( "select id, signer_id, document_version_ids from acceptances where session_id = $1 and user_id is null", [ceremonyId], ); const acceptance = rows[0]; if (!acceptance) return res.status(409).json({ error: "not_confirmed" }); // The record ID came from the app: a claim to check, with the secret key. const { data: record, error } = await esc.records.get(recordId); if (error) return res.status(409).json({ error: "not_confirmed" }); // a made-up ID returns not_found const actual = record.documents.map((d) => d.version_id).sort(); const expected = [...acceptance.document_version_ids].sort(); const confirmed = SEALED.has(record.status) && record.livemode === (process.env.NODE_ENV === "production") && record.signer.external_id === acceptance.signer_id && JSON.stringify(actual) === JSON.stringify(expected); if (!confirmed) return res.status(409).json({ error: "not_confirmed" }); // no account const user = await createUser({ email, password }); await db.query("update acceptances set user_id = $1, record_id = $2, receipt = $3, accepted_at = $4 where id = $5", [ user.id, record.id, record.receipt, record.signed_at, acceptance.id, ]); res.json({ ok: true }); });
-- server/migrations/001_acceptances.sql create table acceptances ( id bigint generated always as identity primary key, -- Written when the session is created. signer_id text not null, -- signer.external_id sent to Esign Comply session_id text not null unique, -- ses_... document_version_ids text[] not null, -- the versions the session pinned -- Filled in once the record is confirmed. user_id bigint references users (id), -- null until the account exists record_id text unique, -- rec_... receipt text, -- signed receipt (JWS, ES256) accepted_at timestamptz, -- the record's signed_at created_at timestamptz not null default now() );
// server/routes/legal.ts import { Router } from "express"; import { esc } from "../clients"; export const legal = Router(); const DOCUMENTS: Record<string, string | undefined> = { terms: process.env.ESIGNCOMPLY_TERMS_ID, privacy: process.env.ESIGNCOMPLY_PRIVACY_ID, }; // GET /legal/terms?v=dv_... serves one registered version, unmodified. legal.get("/legal/:slug", async (req, res) => { const documentId = DOCUMENTS[req.params.slug]; if (!documentId) return res.sendStatus(404); const version = typeof req.query.v === "string" ? req.query.v : "current"; const { data, error } = await esc.documents.versions.getContent(documentId, version); if (error || !data.html) return res.sendStatus(404); // The registered HTML and nothing else inside the article: the SDK hashes its text. res.type("html").send(`<!doctype html> <html lang="${data.language}"> <head> <meta charset="utf-8"> <meta name="viewport" content="width=device-width, initial-scale=1"> <title>Legal</title> </head> <body> <article data-esc-document="${data.version_id}">${data.html}</article> </body> </html>`); });
// server/routes/webhook.ts import express, { Router } from "express"; import { verifyWebhookSignature } from "esigncomply"; import { db, esc } from "../clients"; export const webhook = Router(); type Completed = { record_id: string; session_id: string; signer_external_id: string; documents: Array<{ version_id: string }> }; // POST /webhooks/esigncomply. express.raw keeps the body as bytes: the signature covers the bytes. webhook.post("/webhooks/esigncomply", express.raw({ type: "application/json" }), async (req, res) => { const { data: event, error } = verifyWebhookSignature<Completed>(req.body, req.headers, process.env.ESIGNCOMPLY_WEBHOOK_SECRET!); if (error) return res.status(400).send("Invalid signature"); // Deliveries are at-least-once. This only fills in a row that is still open, so a repeat changes nothing. if (event.type === "record.completed") { const { rows } = await db.query( "select id, signer_id, document_version_ids from acceptances where session_id = $1 and record_id is null", [event.data.session_id], ); const acceptance = rows[0]; const versions = event.data.documents.map((d) => d.version_id).sort(); const matches = acceptance && event.livemode === (process.env.NODE_ENV === "production") && event.data.signer_external_id === acceptance.signer_id && JSON.stringify(versions) === JSON.stringify([...acceptance.document_version_ids].sort()); if (matches) { const { data: record } = await esc.records.get(event.data.record_id); // the payload carries no receipt if (record) { await db.query("update acceptances set record_id = $1, receipt = $2, accepted_at = $3 where id = $4", [ record.id, record.receipt, record.signed_at, acceptance.id, ]); } } } res.sendStatus(200); // also for event types this code does not know });
// server/index.ts import path from "node:path"; import express from "express"; import { ceremony } from "./routes/ceremony"; import { finish } from "./routes/finish"; import { legal } from "./routes/legal"; import { webhook } from "./routes/webhook"; const app = express(); app.use(webhook); // before express.json(): the webhook route reads the raw body app.use(express.json()); app.use(ceremony, finish, legal); // The page the WebView loads, served from your own domain. app.get("/mobile/accept", (_req, res) => res.sendFile(path.resolve("server/public/accept.html"))); app.listen(Number(process.env.PORT ?? 3000)); // server/clients.ts import { EsignComply } from "esigncomply"; import { Pool } from "pg"; // Server only. The secret key never ships in the app bundle. export const esc = new EsignComply(process.env.ESIGNCOMPLY_API_KEY); export const db = new Pool({ connectionString: process.env.DATABASE_URL });
What each file does
Eight files on two sides. The app shows a WebView and relays two messages. Your server creates the session, serves the page and the documents, confirms the record and keeps the receipt.
The app never holds the secret key. It posts the email, country and state to this route, and the server calls esc.sessions.create with the Node SDK. context.url is the page the WebView loads: in live mode it has to be inside your registered domain, which is why that page lives on your site and not in the app bundle.
The route saves one acceptances row with the signer ID and the version IDs the session pinned, then returns four things: a ceremony ID (the session ID), the client token, the API URL and the pinned documents.
This is where the acceptance happens. The page holds the notice, the two document links, an unchecked checkbox and the one button, and it loads the browser SDK with a script tag. On load it posts { type: "ready" } to the app through window.ReactNativeWebView.postMessage. The app answers by calling window.startCeremony with the client token, which stays in memory in the page.
From there it is the same ceremony as on the web: EsignComply.attach, presentDocument for each link, observeAssent on the container, and complete() from the signer's real tap. The page then posts { type: "completed", recordId } back to the app. Because the SDK reports straight from the WebView to Esign Comply, the record is an observation of the signer's device, not a statement by your server.
The screen renders one WebView pointed at your acceptance page. When the page says it is ready, the screen asks your API for a session and passes the client token in with injectJavaScript. When the page says the ceremony is completed, the screen sends the record ID to your API. If the session expires, the page asks for a new one the same way.
onShouldStartLoadWithRequest keeps the acceptance page loaded: a tap on Terms of Service or Privacy Notice opens the document in the system browser instead of navigating the WebView away. react-native-webview is the community WebView package. There is no Esign Comply package for React Native, and none is needed.
The record ID crossed two boundaries to get here, the WebView and the app, so the server treats it as a claim. It loads the open row for the ceremony ID, reads the record with the secret key (GET /v1) and checks four things: the status is recorded, timestamped or anchored, livemode matches the deployment, the signer ID is the one this server made, and the set of document versions is exactly the set the session pinned.
Only then does it create the user and store the user ID, the record ID, the signed receipt and the accepted time. A second request with the same record finds no open row and gets 409.
One row per ceremony, in Postgres. The first three columns are written when the session is created and are the server-owned state the confirmation compares against. The rest are filled in when the record is confirmed. record_id is unique, so one record opens one account.
/legal and /legal serve the version Esign Comply holds, fetched by the version ID in ?v=, inside <article data-esc-document>. They are on the same origin as the acceptance page on purpose: the browser SDK reads the page behind each link, hashes the article's text and reports it, and the API compares the hash with the registered version (rule CR-08).
A phone loses signal, or the app is swiped away right after the tap. record.completed still arrives at your server once the record is sealed. The route keeps the body as raw bytes with express.raw, verifies the signature with verifyWebhookSignature from the Node SDK, and fills in the open row for that session. A repeated delivery finds the row already filled and changes nothing.
index.ts and clients.ts: mount the routes, hold the key
server/index.ts and server/clients.tsView the file The webhook router is mounted before express.json() so that its body is still raw when the signature is checked. clients.ts creates the Node SDK client and the Postgres pool once. The SDK reads the region from the key and retries a 429 by itself.
Run it
From an empty account to a sealed test record from a simulator. The server runs on localhost:3000, which test keys accept without a domain.
- 01
Create a free account and a test key
Sign up, then choose Create test key in the dashboard. The key starts with
esc_test_and is shown once. The Free plan needs no card, and test keys work onlocalhoston any port with no domain. - 02
Register your two documents and a signup profile
In the dashboard, add a document named Terms of Service and one named Privacy Notice, publish a version of each, and create a profile with method
checkboxand levelL1. The names matter: the notice in the form names each document by its title, and ruleCR-02looks for both. Copy the three IDs. - 03
Set the server's environment variables
The key lives on the server only.
APP_ORIGINis where the acceptance page is served..envESIGNCOMPLY_API_KEY=esc_test_us_... # the test key, shown once in the dashboard ESIGNCOMPLY_PROFILE_ID=prof_signup_4f1a # the signup profile: checkbox, L1 ESIGNCOMPLY_TERMS_ID=doc_8Hq2 # Terms of Service ESIGNCOMPLY_PRIVACY_ID=doc_Pv71 # Privacy Notice ESIGNCOMPLY_WEBHOOK_SECRET=whsec_... # only for the webhook APP_ORIGIN="http://localhost:3000" DATABASE_URL="postgres://localhost/myapp"
- 04
Install, migrate and start the server
esigncomplyis the Node SDK, andreact-native-webviewgoes into the app. Applyserver/migrationsto your database, then start the server./001_acceptances.sql $npm install esigncomply express pg && npx tsx --env-file=.env server/index.ts - 05
Point the app at the server
Set
SITEin the screen tohttp:/. The iOS simulator reaches it as is. For the Android emulator run/localhost:3000 adb reverse tcp:3000 tcp:3000so thatlocalhostinside the emulator is your machine. A plainhttp:/address does not work: the SDK needs HTTPS or/192.168.x.x localhostto hash the documents, and test keys acceptlocalhostout of the box. For a physical device, serve the page from an HTTPS host and list that host under Domains, Test origins in the dashboard. - 06
Accept once
Open the screen in the simulator. The checkbox unlocks when the session is attached. Tick it and tap Create account. The app receives the record ID and your server answers the finish request with
200. - 07
Open the test record
The dashboard lists one new test record under Records. It shows what Esign Comply observed from the browser (the page attached, both documents presented, the notice captured, the tick, the signing act), the conformance findings and the evidence report, watermarked TEST. Your
acceptancesrow holds the same record ID and its signed receipt. - 08
Run the conformance check
The acceptance page starts when the app hands it a token, so check the session the app just finished. This script asks for a conformance run over that one session and prints the summary and every finding with its rule, the measurement and the fix. The session ID is the
session_idof the newestacceptancesrow. A clean run reportsblock: 0. The same findings are on the test record in the dashboard.scripts/conformance.ts// scripts/conformance.ts import { EsignComply } from "esigncomply"; // Runs the conformance rules over one finished session and prints the findings. async function main() { const esc = new EsignComply(process.env.ESIGNCOMPLY_API_KEY); const { data: run, error } = await esc.conformance.run({ session_ids: [process.argv[2]] }); if (error) throw new Error(`${error.code}: ${error.message}`); console.log(run.summary); console.log(run.markdown); } main();
$npx tsx --env-file=.env scripts/conformance.ts ses_...
Going live
In live mode the WebView has to load the acceptance page from your registered domain over HTTPS. Everything else is the usual four moves.
- 01Register your domainEnter your production host in the dashboard under Domains. Registering
app.example.comcoversexample.comand every subdomain, and every plan, Free included, covers that one domain. - 02Verify it with one TXT recordAdd a TXT record named
_esigncomplywith the valueesc-verify=<token>that the dashboard shows. Esign Comply checks every minute for the first hour. Leave the record in place: it is checked again every day. - 03Add your organization detailsEnter your organization's legal name and country in the dashboard. The Free plan covers 10 live signature events a month with no checkout. Starter is $200 per year for 2,000 live signature events, and Unlimited is $1,200 per year. One event is one signer's completed signing act, so the terms and the privacy notice accepted together at signup count once.
- 04Switch to the live keyCreate a live key (
esc_live_...) and set it on your production server only. It never goes into the app bundle. Copy your documents and profile to live from the dashboard, set the live IDs beside the key, setAPP_ORIGINto your HTTPS origin and pointSITEin the release build at the same origin.
In live mode context.url has to be inside your registered domain, browser calls are accepted only from it, and a finding at Block level stops the record from being sealed. Run the conformance check until nothing blocks before you switch keys.
Have your AI tool do it instead
Paste this into Cursor, Claude Code or any coding agent that is open on your app and your API. It tells the tool the one thing it will not guess: the acceptance screen is a page on your domain inside a WebView, not a native view.
The prompt generator writes the long version: your own document and profile IDs, the rule packs for your regions and the stack you pick, in one prompt.
Generate a promptAdd a signup clickwrap to this React Native app and its API server with Esign Comply. A new user accepts our Terms of Service and Privacy Notice before the account is created. Esign Comply observes the acceptance and keeps the independent record. Read these first and follow them exactly: - https://esigncomply.com/setup.md - https://esigncomply.com/auth.md - https://esigncomply.com/llms.txt - https://esigncomply.com/guides/react-native-clickwrap (working code for this stack: use it as the reference) Stack - The browser SDK needs a DOM. Build the acceptance screen as a web page served from our own domain and show it with react-native-webview. Do not rebuild it as a native view, and do not look for an Esign Comply package for React Native: there is none. - The page loads <script src="https://esigncomply.com/sdk/v1/esigncomply.js"></script> (global EsignComply). - The secret key lives on the API server only (the esigncomply Node package). It never ships in the app. Build 1. Server: a route creates the session with esc.sessions.create, with context.url set to the acceptance page, and returns only the client token, the API URL and the pinned documents. Save the signer ID and version IDs in an acceptances table. 2. Page: post "ready" to the app with window.ReactNativeWebView.postMessage. When the app calls window.startCeremony with the client token, attach, present each document link, observe our own unchecked checkbox and button, and call complete() from the user's real tap. Post the record ID back to the app. 3. App: render the WebView, pass the token in with injectJavaScript, and send the record ID to the server. 4. Server: before creating the account, read the record with esc.records.get and require status recorded, timestamped or anchored, the expected livemode, and the saved signer ID and version IDs. Store the record ID and the receipt. Never - Never invent API methods, packages or legal wording. - Never pre-check the box, auto-submit or click for the user. - Never put the secret key in client code, in a template or in the repository, and never print it. - Never create the account before the server has confirmed the record. If anything conflicts with existing code, stop and ask me.
Questions about a clickwrap in React Native
Can I add a clickwrap to a React Native app?
Yes. Show the acceptance screen in a WebView that loads a page from your own domain. The browser SDK runs in that page, observes your checkbox and button, and reports the ceremony straight to Esign Comply. The native app passes the client token in and receives the record ID back over the WebView message bridge, and your server confirms the record before it creates the account.
Why does the acceptance screen have to be a WebView?
Because the browser SDK works by observing real page elements: the notice text, the links, the checkbox and the button. A native view has no DOM for it to observe. In a WebView the SDK reports from the signer's device directly to Esign Comply, so the record is an independent observation of what was shown and what was tapped.
Can I build the acceptance screen as a fully native view instead?
Yes, with a different kind of record. Create the session with capture_mode set to server_only, and your server sends the ceremony events and the completion with the secret key. Every event in that record is tagged asserted, because Esign Comply did not observe the signer's device, and the evidence report says so. The WebView keeps the events tagged observed.
Read about server-only sessionsIs there an Esign Comply package for React Native?
No, and you do not need one. The app uses react-native-webview, the community WebView component, and plain fetch calls to your own API. The Esign Comply code runs in two places: the browser SDK in the page your WebView loads, and the esigncomply Node package on your server.
How do I test the WebView flow on a simulator or a phone?
Run your server on localhost:3000 and point the WebView at http://localhost:3000. The iOS simulator reaches it directly. On the Android emulator run adb reverse tcp:3000 tcp:3000 first. Test keys accept localhost, 127.0.0.1 and the hosts you list under Test origins, so a physical phone needs an HTTPS host that is on that list. A plain http address on your LAN does not work, because the SDK needs HTTPS or localhost.
Read about test modePut the acceptance page on your domain and the WebView in your app. Leave the record to us.
Free plan: 10 live signatures a month and a full test mode. No card required.