Build an NDA signing flow
You're adding an NDA to your app: the counterparty opens a link, reads the agreement, types their name and clicks Sign. You build that page with your AI coding tool, and Esign Comply gives the tool the signing rules and keeps an independent, sealed record of every signature.
Free plan: 10 live signatures a month and a full test mode. No card required.
Try an NDA signing page
This is a real signing ceremony running against the real Esign Comply API in test mode: type any name, click Sign NDA, and watch the record being sealed.
This is a working signing screen, the kind your AI tool builds. Run it and watch the record being made on the right.
Each step the signer takes is reported from the browser straight to Esign Comply. Run the demo to see the steps for this flow, then the sealed record.
The demo runs at level L1 so you can try it without an inbox. The NDA setup Esign Comply recommends is L2, which adds one step: a six-digit code emailed to the signer and confirmed on your page.
The prompt that builds this NDA flow
This is what the Esign Comply prompt generator produces for NDA signing on Next.js App Router with Supabase and Vercel, under the U.S. Federal rule pack. Paste it into Cursor, Claude Code, v0, Lovable, Bolt or Replit and your tool builds the NDA page, the server confirmation and the webhook.
IDs in angle brackets are placeholders, and the prompt tells your tool to ask you for them. {Company} is your company name. Generate the prompt in the dashboard and both are filled in with your own profile and document.
# Esign Comply integration: NDA signing Prompt esc_prompt_83ec3d076682 · blocks 2026.11 · guidance bundled · region US Jurisdictions: US-FED · mode auto You are adding legally significant signature flows to this Next.js App Router application (TypeScript, Supabase Auth and Postgres, deployed on Vercel). Esign Comply is the independent record keeper. You build every screen. The Esign Comply SDK observes the screens you build and seals the record. Follow this prompt exactly. If something here conflicts with existing code, or you are unsure how to implement a step, stop and ask. Do not invent API methods, packages, or legal wording. This prompt has four kinds of instruction. Keep them apart: - "Required for the record": build all of it. Esign Comply checks these. - "Your obligations": duties the law places on {Company}. Esign Comply does not check them. Build what code can do and list the rest in your report. - "Recommendations": suggestions. Ask the developer before applying any that changes the product. - "What you can send us": optional reports {Company} may file with Esign Comply. ## Context - Packages (the only ones that exist): `esigncomply` (server), `@esigncomply/browser` (client), `@esigncomply/react` (optional hooks). - API host: https://esigncomply.com/v1 - Environment variables (server only, never NEXT_PUBLIC_): ESIGNCOMPLY_API_KEY, ESIGNCOMPLY_WEBHOOK_SECRET - Profiles: NDA = `<profile ID for NDA>` - Documents: Mutual NDA = `<document ID for Mutual NDA>` - An ID in angle brackets does not exist yet. Ask the developer for it. Do not invent IDs. - Rule pack versions: 2026-11-21 (all selected packs). - Server SDK calls return `{ data, error }` and do not throw. Check `error` every time. ## Required for the record 1. Create every session on the server with the secret key. Send only `client_token` to the browser. 2. Read `required_steps` from the session and satisfy each one. Do not hard-code steps. 3. Show the notice text directly above the action button, in the same container, visible without scrolling at 390 x 844 (CR-04). 4. Every notice names the action button by its label and every document by its title (CR-02, CR-03). Each flow's wording is in its build step. 5. Links to documents must be underlined and use a colour that differs from the surrounding text with a contrast ratio of at least 3:1, and at least 4.5:1 against the background. Notice text is at least 14px and never lighter than body text (CR-05, CR-06). 6. Every typed-name field starts empty (CR-01). 7. Only one primary button inside the assent container. Any other action sits outside it (CR-07). 8. Serve each document at a stable page on this domain that renders the registered version fetched from Esign Comply, unmodified (CR-08). 9. Treat the browser result as untrusted. Grant access only after the server has confirmed the record with the secret key (step 4 below). 10. Pass an `Idempotency-Key` on session creation. ### Never - Never pre-check a box, auto-submit, or call `.click()` on the user's behalf. - Never treat sign-in, scrolling, or continued use as acceptance. - Never use "By continuing" or "By clicking below" wording. - Never put the secret key, or any call that uses it, in a client component. - Never proxy `@esigncomply/browser` calls through this application's server. - Never cache or copy document text into the repository. Always render the registered version. - Never write to `esign_acceptances` from the browser. - Never show "signed" or "accepted" in the interface before step 4 confirms it. - Never write or change the text of the Mutual NDA. ## Your obligations These are {Company}'s duties under the rule packs selected. Esign Comply lists them and does not perform, monitor, or verify them. The list is not exhaustive. US-FED · pack 2026-11-21 - Customer: where another law requires {Company} to keep a record, keep an accurate, accessible copy for that period, including after export (US-31); before offering a record in court, give the adverse party reasonable written notice and access to the record and declaration (US-38). Outside this codebase. ## Recommendations Esign Comply recommends the following. Ask the developer which to apply. - State in the NDA notice that the signer agrees to sign electronically, give a way to decline, and show a review step before the final act (US-04, US-05). Already reflected in step 6. - Before a material update to a document takes effect, notify signers in advance and ask for a fresh acceptance (US-18). - Keep saving and printing open wherever a signed record is shown (US-29). - Where minors may sign, consider an age attestation checkbox: `ceremony.ageAttested({ checkbox })` (US-42). ## What you can send us Optional. Each report is sealed with Esign Comply's receipt time and marked as supplied by {Company}; Esign Comply does not verify it. Every field is optional and any text, JSON, or file is accepted. Reports never affect recording, and a failed one never blocks the user's action. Suggested `data` per type: `esc.supplements.types()`. - When the terms-update notice email is sent: `esc.supplements.create({ subject: { signer: signerId }, type: "notice.sent", rule_ids: ["US-18"], text, data: { channel: "email", template } })` - Anything else worth keeping (support ticket, screenshot, policy in force): type `note`, or omit `type`. Only wire these if the developer says yes. ## Build steps ### 1. Install and configure `npm install esigncomply @esigncomply/browser` Create `lib/esigncomply.ts`: ```ts import "server-only"; import { EsignComply } from "esigncomply"; export const esc = new EsignComply(process.env.ESIGNCOMPLY_API_KEY!); ``` Keys go in `.env.local` and the Vercel project settings, never in chat. Run commands in the integrated terminal. Rules file: `.cursor/rules/esigncomply.mdc`. ### 2. Database (Supabase migration) ```sql create table public.esign_acceptances ( id uuid primary key default gen_random_uuid(), user_id uuid references auth.users(id) on delete cascade, signer_id uuid not null, record_id text not null unique, document_id text not null, version_id text not null, purpose text not null, signed_at timestamptz not null, created_at timestamptz not null default now() ); alter table public.esign_acceptances enable row level security; create policy "read own" on public.esign_acceptances for select using (auth.uid() = user_id); -- No insert, update, or delete policies. Only the service role writes. ``` Add `signer_id uuid unique` to the profile table. ### 3. Document pages Create `app/legal/[slug]/page.tsx` for `nda`. Resolve `current` on session creation only. Fetch with `esc.documents.versions.getContent(documentId, versionId)`; render, print and download by the exact version ID returned on the session; the cache key includes that ID. Render inside `<article data-esc-document>` and reject stale versions before the final action. Give users a real opportunity to read the terms. ### 4. Server confirmation (the only place access is granted) Server action `finishNda(recordId)`: - `const { data: record, error } = await esc.records.get(recordId);` - Require: no error; `record.status` is "recorded", "timestamped", or "anchored"; `record.signer.external_id` equals the signer ID this server put on the session; `record.livemode` equals `process.env.VERCEL_ENV === "production"`; the record lists the exact versions pinned in that session. - Only then mark the document signed, and insert one `esign_acceptances` row per document using the service-role client. - If checks are inconclusive, do not mark the document signed. Show: "We could not confirm whether your acceptance was recorded. Please wait while we check." Reconcile the existing session before requesting another act. ### 5. Webhook `app/api/esigncomply/webhook/route.ts`, Node.js runtime. Read the raw body, then `esc.webhooks.verify(rawBody, request.headers, process.env.ESIGNCOMPLY_WEBHOOK_SECRET!)`. Reject on failure with 400. Handle idempotently by `webhook-id`: - `record.completed`: upsert `esign_acceptances` (covers a browser that closed early). - `record.disputed`: flag the row and notify the admin email. - Ignore event types you do not recognise and return 200. Return 200 within 5 seconds. ### 6. NDA signing (`/nda/[id]`) - Server: create a session with `profile: "<profile ID for NDA>"`, `documents: [{ document: "<document ID for Mutual NDA>", version: "current" }]`, `context.purpose: "nda"`, the signer's `external_id`, `name` and `email`, `class: "business"`. - Obtain `country` and applicable jurisdiction from the form/customer configuration; do not guess from IP. - Page layout, top to bottom: 1. The full session-pinned Mutual NDA rendered inline with download and print. Call `ceremony.presentDocument({ versionId, mode: "inline", container })`. 2. Email verification (CR-17): a "Send code" button calls `ceremony.verify.start({ method: "email_otp" })`; a 6-digit field calls `ceremony.verify.confirm({ code })`. Show the masked address returned by the API. Allow resend after 30 seconds. 3. Review line: "You are signing the Mutual NDA between {Company} and {signer name} as {signer name}." Record it with `ceremony.reviewPresented({ container })` (CR-13). 4. Assent container with: the notice "By typing your name and clicking Sign NDA, you agree to sign this agreement electronically and to be bound by it." (CR-12); an empty text field labelled "Type your full legal name" (CR-09); a primary button "Sign NDA"; a secondary text link "Decline" outside the container that calls `ceremony.cancel()`. 5. `ceremony.observeAssent({ region, typedName: nameField, submit })`, then `ceremony.complete()` from the click. - After completion, confirm on the server as in step 4, then show "Signed. A copy has been emailed to you by Esign Comply." with a link to `result.verifyUrl` and a "Download copy" link. - Do not render a signature image or a cursive font as the signature. ### 7. Errors - `ceremony.complete()` rejected with a rule ID: show the message, keep the form, do not retry automatically. - Network failure or 5xx: show "We could not confirm whether your acceptance was recorded. Please wait while we check." Reconcile the same session and idempotency key before requesting another act. Never proceed without a record. - `client_token_expired`: create a new session and re-attach. - `verification_failed`: start a new session; offer no way past verification. ## Verify before you report success 1. `npm run build` passes and no file under `app/**` marked "use client" imports `esigncomply` or reads ESIGNCOMPLY_API_KEY. 2. Run `npx esigncomply check --url http://localhost:3000/nda/test`. Fix every finding marked "block", re-running until none is left. List every finding marked "warn" in your report. 3. Confirm by test that submitting with the name field empty does nothing, and that calling `finishNda` with a made-up record ID does not mark the document signed. 4. Report: files created or changed, anything in this prompt you did not implement and why, the conformance summary, each item under "Your obligations" with "built", "partly built", or "needs a process outside this codebase", and each recommendation with the developer's decision.
The six steps an NDA signature needs
A session created with the recommended NDA profile returns these required_steps, in this order. Your page satisfies each one, and the API seals the record only when all six are recorded.
A typed name with an emailed code
For an NDA, Esign Comply recommends the typed-name method at level L2. The signer types their full legal name into an empty field, and Esign Comply emails a one-time code to the address on the session and confirms it inside the ceremony.
- MethodTyped name
- LevelL2, one-time code by email
- method: typedassurance_level: L2document_type: ndapurpose: nda
- 01
The SDK attaches to your page
client.attachedThe signer seesYour NDA page, opened from the link you sent, on your domain and in your design.
Esign Comply recordsThe page address, the SDK version, the viewport, the browser language and the time zone, reported from the signer's browser.
- 02
The NDA is shown
document.presented:<version_id>The signer seesThe full Mutual NDA rendered inline from the registered version, with download and print.
Esign Comply recordsThe pinned version ID and a hash of the text on screen, which the API compares with the version you registered.
- 03
The notice is captured
notice.capturedThe signer seesThe notice directly above the button: "By typing your name and clicking Sign NDA, you agree to sign this agreement electronically and to be bound by it."
Esign Comply recordsThe visible text of the assent area, the button label, the document links and the layout measurements.
- 04
The emailed code is confirmed
identity.verifiedThe signer seesA Send code button, then a field for the six-digit code that Esign Comply emails them.
Esign Comply recordsThat the code sent to the address on the session came back while it was valid. Esign Comply writes this step itself.
- 05
The signer types their name
intent.capturedThe signer seesAn empty field labelled "Type your full legal name". Nothing is prefilled.
Esign Comply recordsThe typed name, the field label, the button text, and whether every change came from a real user event. Keystrokes are not stored.
- 06
The signing act
signature.appliedThe signer seesThe Sign NDA button, enabled once it is the only step left.
Esign Comply recordsThe signing act with Esign Comply's server time. The API seals the record and returns a signed receipt.
The prompt also has your tool show a review line before the signing act, "You are signing the Mutual NDA between ...", and record it with ceremony.reviewPresented(). Read required_steps from the session every time: your code never hard-codes the list.
What you build for an NDA, and what Esign Comply handles
An NDA has a counterparty who is not your user, and a mutual NDA has two signers. Everything they see is yours. The rules and the record are ours.
The counterparty's link
Create the NDA request in your database, generate a private link and email it from your own domain, for example with Resend.
Nothing to host. Esign Comply has no signing page of its own: the link opens your app.
Both parties signing
Track the packet: who signs, in which order, and who has signed so far.
One session per signer on the same document version. Each signer gets their own ceremony and their own sealed record.
The NDA text
Use one standard NDA for everyone, or register the final text of a negotiated NDA as its own version: Markdown, HTML, plain text or PDF.
Stores each version unchanged and pins the exact one to the record by SHA-256 hash.
The signing page
The NDA viewer, the code field, the name field, the notice and the Sign NDA button.
The prompt gives your AI tool the rules for that page, and the browser SDK reports each step from the signer's browser.
The emailed code
A Send code button and a six-digit input.
Sends the code from its own domain, checks it and records the result. Your app never sees the code.
What the NDA unlocks
Mark the NDA signed only after your server confirms the record, then open what it gates: the data room, the deck, the call.
GET /v1 with your secret key, and the signed record.completed webhook as the backstop.
The signed copy
Stamp names and dates onto a PDF when you want one countersigned file, for example with pdf-lib, and store it with the deal.
Emails each signer a copy with a verification link, and serves an evidence report PDF for every record.
The record you get for each NDA signature
Two parties sign, so you get two sealed records, one per signer. Both are kept by Esign Comply, outside the database your team can edit.
What the sealed record holds
- The exact NDA version, pinned by its SHA-256 hash.
- The notice text and the button label as the signer's browser rendered them.
- The name the signer typed, and that it came from real user events.
- The confirmation of the one-time code sent to the signer's email.
- Esign Comply's server time for every step, in order.
- A receipt signed with ES256 keys you do not hold, an RFC 3161 timestamp from an outside authority, and an entry in a hash-chained ledger.
What you do with it
- Signed receiptStore it with the NDA
complete()returns the receipt in the browser and your server reads it again at confirmation. Save it beside the NDA row with the record ID. - PDF, per recordEvidence report
GET /v1returns a readable account of one signature: the parties, the NDA version and hash, the method, the exact label and button text, and the timeline./records /{id} /report - verify_urlVerification pageEvery record has a verification page. Link it from the signed copy so either party checks the record themselves.
- ZIP, verifies offlineEvidence packageThe record, the receipt, the timestamp token, the ledger proof and the exact document bytes. Anyone you hand it to runs the open-source
esigncomply-verifywith no account and no network.
Build guides, stack guides and AI tools
The NDA is one page of a bigger product. These guides cover the rest.
- Build guidePut a deck or data room behind an NDAShare a link, require the NDA before viewing, and record who accepted which version.Open
- Build guideBuild your own DocuSignUpload any PDF, add signers, email each one a link and collect signatures in your app.Open
- Stack guidesStep-by-step guides for your stackThe same flow on Next.js and Supabase, Rails, Django, Laravel and React Native.Open
- AI toolsBuild it with your AI toolHow to run this prompt in Cursor, Claude Code, Lovable, v0, Bolt, Replit and others.Open
Questions about building an NDA signing flow
How do I add NDA signing to my app?
Register the NDA as a document, create one session per signer on your server with POST /v1/sessions, and attach the browser SDK to your own signing page. The SDK reports the ceremony from the signer's browser, the API seals the record and returns a signed receipt, and your server confirms the record before it marks the NDA signed.
Read the quickstartIs a typed name a valid signature on an NDA?
Yes. Electronic signatures are recognized under the U.S. ESIGN Act and state UETA laws: a signature cannot be denied legal effect just because it is electronic. ESIGN defines an electronic signature as a sound, symbol or process attached to or logically associated with a record and adopted with intent to sign. A typed name is such a symbol, and the record ties it to the exact NDA version and the notice the signer saw.
The U.S. rules we draw onHow do both parties sign a mutual NDA?
Create one session per signer against the same document version. Each party gets their own link, their own ceremony and their own sealed record, and your app tracks who has signed. The NDA is complete when your server has confirmed a record for each signer.
Why add an emailed code to an NDA?
The counterparty is someone outside your app, without an account. At level L2, Esign Comply emails a six-digit code to the address you put on the session and confirms it inside the ceremony. The record then shows that the code sent to that mailbox was confirmed during the ceremony, and the receipt goes to the same address.
How L2 verification worksCan I put a data room or a pitch deck behind an NDA?
Yes. Show the NDA page first and open the content only after your server has confirmed the record with GET /v1/records/{id} or the record.completed webhook. Store the record ID and the receipt next to the viewer, and you can show who accepted which version of the NDA.
Build a DocSend alternativeBuild the NDA flow yourself. Leave the record to us.
Free plan: 10 live signatures a month and a full test mode. No card required.
DocuSign, DocSend and the other product names on this page are trademarks of their owners. Esign Comply is not affiliated with them.