# Build a signup clickwrap with Bolt

> Build a signup clickwrap with Bolt. Paste one prompt and get your own checkbox and button, rules from Esign Comply and an independent record of each one.

Source: https://esigncomply.com/build/bolt

App builder · Bolt

You're prompting an app into existence in Bolt, and the signup form needs a terms checkbox. Paste one prompt and Bolt builds the clickwrap in your form, to rules Esign Comply supplies, with every acceptance kept as an independent record.

[Get started](https://esigncomply.com/signup) · [Generate a prompt](https://esigncomply.com/product/prompt-generator)

Free plan: 10 live signatures a month and a full test mode. No card required.

One prompt, from paste to record

1. Add a test key to the project's secrets · You
2. Paste one prompt into Bolt · You
3. Bolt builds the page and the server code · You
4. Acceptance reported from the user's browser · Esign Comply
5. Sealed record, receipt and timestamp · Esign Comply
6. Server confirms, then creates the account · You

Copy-paste prompt

## The prompt to paste into Bolt

Open your project in Bolt and paste this into the chat. It builds a signup clickwrap: your Terms of Service and Privacy Notice, accepted with your own checkbox and your own button.

What the prompt tells Bolt

- Read `setup.md`, `auth.md` and `llms.txt` before writing anything.
- Create the session on your server with the secret key, and send only the client token to the browser.
- Attach the browser SDK to your own checkbox and button. No widget, no iframe.
- Confirm the record on your server before the account exists.
- Never invent an API method, and stop and ask when something conflicts.

[Generate the prompt for your regions](https://esigncomply.com/product/prompt-generator)

Prompt for Bolt

```
Build the signup page of this app as a clickwrap with Esign Comply: an unchecked checkbox, a notice that links our Terms of Service and Privacy Notice, and a Create account button. The page is ours. Esign Comply records the acceptance and keeps the record.

Start by reading these and follow them exactly:
- https://esigncomply.com/setup.md
- https://esigncomply.com/auth.md
- https://esigncomply.com/llms.txt

Build
1. Server code (a server route or a backend function) that creates the session with the secret key from ESIGNCOMPLY_API_KEY and gives the browser only the client token and the document version IDs. If this app has no server, add this one small piece.
2. The form: attach @esigncomply/browser with the client token to our own checkbox and button. complete() runs from the user's real click.
3. Server code that confirms the record with the secret key before the account is created.

Rules
- Ask me to add ESIGNCOMPLY_API_KEY to the project's environment file, never with a VITE_ or other public prefix.
- Never invent API methods, packages or legal wording.
- Never pre-check the box.
- If the docs do not cover something, or it conflicts with what is already built, stop and ask me.

Run commands in the project terminal and show their output, ending with npx esigncomply check --url on the running app. Keep these rules in the project prompt.
```

5 steps

## How to run it in Bolt

Bolt is an AI app builder. This is the whole run, from a new Esign Comply account to your first test record.

1. **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 mode needs no registered domain.

2. **Add the key to the project's environment**

   Name it `ESIGNCOMPLY_API_KEY`, with no `VITE_` or other public prefix, so only server code reads it. A browser-only app has nowhere safe to keep a secret, which is why the prompt adds one small server piece.

3. **Paste the prompt into Bolt**

   Bolt writes the server code that creates the session, attaches the SDK to your own checkbox and button, and adds the server code that confirms the record.

4. **Add your preview host to your test origins**

   Test keys work on `localhost` with no setup. A hosted preview runs on its own host, so list that host under Domains, Test origins in the Esign Comply dashboard. If a call returns `domain_mismatch`, the message names the origin to add.

5. **Run the app and tick the box**

   Tick the checkbox and click Create account. The prompt ends with `npx esigncomply check --url` on the running app, with the output shown in the project terminal.

[Create a free account](https://esigncomply.com/signup) · [Read the quickstart](https://esigncomply.com/docs/quickstart) · [Guide for AI app builders](https://esigncomply.com/docs/guides/ai-builders)

The 60-second result

## What you have 60 seconds after Bolt finishes

Run the app, tick the box, click Create account. This is the code Bolt wrote, and the record your first test signup produces.

1. **The server route that creates the session**

   e.g. `app/api/ceremony/route.ts`

   It holds the secret key, pins the current version of each document and hands the browser a short-lived client token.

2. **Your signup form, with the SDK attached**

   e.g. `app/signup/signup-form.tsx`

   Your markup and your styles. The SDK renders nothing: it watches your links, your checkbox and your button, and reports what the user did.

3. **The server confirmation**

   e.g. `app/api/signup/confirm/route.ts`

   The record ID came from the browser, so the server reads the record with the secret key before the account exists.

**Create the session**

```ts
// app/api/ceremony/route.ts
import { esc } from "@/lib/esigncomply";

export async function POST(request: Request) {
  const { signerId, email, attempt } = await request.json();

  const { data: session, error } = await esc.sessions.create(
    {
      profile: "prof_signup_4f1a",
      signer: {
        external_id: signerId,
        email,
        class: "consumer",
        country: "US",
      },
      documents: [
        { document: "doc_8Hq2", version: "current" }, // Terms of Service
        { document: "doc_Pv71", version: "current" }, // Privacy Notice
      ],
      context: {
        url: "http://localhost:3000/signup",
        locale: "en-US",
        purpose: "account_signup",
      },
    },
    { idempotencyKey: `signup-${signerId}-${attempt}` },
  );
  if (error) return Response.json({ error: error.code }, { status: 502 });

  // Save signerId and the pinned version IDs in server-owned state.
  return Response.json({
    clientToken: session.client_token,
    documents: session.documents,
  });
}
```

**Signup form**

```tsx
// app/signup/signup-form.tsx
import { EsignComply } from "@esigncomply/browser";

// After /api/ceremony returns clientToken and documents:
const ceremony = await EsignComply.attach({ clientToken });

await ceremony.presentDocument({
  versionId: documents[0].version_id,
  mode: "hyperlink",
  link: document.querySelector("#tos-link"),
});
await ceremony.presentDocument({
  versionId: documents[1].version_id,
  mode: "hyperlink",
  link: document.querySelector("#privacy-link"),
});

await ceremony.observeAssent({
  region: document.querySelector("#assent"), // notice, links, box, button
  checkbox: document.querySelector("#agree"), // yours, unchecked
  submit: document.querySelector("#create-account"), // your button
});

// Called from the real submit handler, after the user ticked the box.
async function finishSignup() {
  const result = await ceremony.complete();
  // result: { recordId, receipt, verifyUrl, status }
  await fetch("/api/signup/confirm", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ recordId: result.recordId }),
  });
}
```

**Confirm on the server**

```ts
// app/api/signup/confirm/route.ts
import { esc } from "@/lib/esigncomply";

export async function POST(request: Request) {
  const { recordId } = await request.json();
  const expected = await loadCeremonyState(request); // server-owned state

  const { data: record, error } = await esc.records.get(recordId);
  if (error) return Response.json({ confirmed: false }, { status: 409 });

  const versions = record.documents.map((d) => d.version_id).sort();
  const confirmed =
    ["recorded", "timestamped", "anchored"].includes(record.status) &&
    record.livemode === (process.env.VERCEL_ENV === "production") &&
    record.signer.external_id === expected.signerId &&
    versions.join() === [...expected.versionIds].sort().join();

  if (!confirmed) return Response.json({ confirmed: false }, { status: 409 });
  // Only now create the account.
  return Response.json({ confirmed: true });
}
```

The example is written as Next.js route handlers. In Bolt, the two server parts are server routes or backend functions that make the same two calls.

The record that appears

### One sealed test record, kept by Esign Comply

Record

`rec_Z4m8`

simple · L1

Recorded

Written durably, receipt signed with ES256

Timestamped

External RFC 3161 token over the record hash

Anchored

Public anchor pending

Checkbox changed by a trusted user event · observed

Terms of Service, version dv_3kT9 · observed

Server time 2026-11-21T15:03:20.291Z · observed

Signer email dana@example.org · asserted

record_hash sha256:5be7… · example record

Your first test record opens in the dashboard with what was observed, what was asserted, and the conformance findings. It is sealed like a live record, on a separate test ledger, and its evidence report is watermarked TEST.

[Sign a live demo](https://esigncomply.com/use-cases) · [What a record holds](https://esigncomply.com/product/evidence)

## What Bolt gets right with the rules, and wrong without them

"Add a terms checkbox" is a five-word prompt, and Bolt fills in the rest with defaults. The prompt on this page replaces the defaults with rules, each one something the SDK can measure.

[CR-01](https://esigncomply.com/docs/conformance#cr-01) · block

### Affirmative assent control

Without the rules

The checkbox ships already ticked, or a handler ticks it for the user to save a click.

With the prompt

The box renders unchecked and only a real user event changes it. The SDK records its state at load, and the check reports a pre-checked box or a scripted click at block level.

[CR-03](https://esigncomply.com/docs/conformance#cr-03) · warn

### Notice names the action control

Without the rules

"By continuing" or "by clicking below", next to a button that says something else.

With the prompt

The notice names the button by its exact label: "By checking the box and clicking Create account, you agree to the Terms of Service." The check flags vague phrases.

[CR-04](https://esigncomply.com/docs/conformance#cr-04) · block

### Notice and control in the same viewport

Without the rules

The agreement line sits in the footer or under a long form, below the fold on a phone.

With the prompt

The notice sits directly above the button in the same container. The SDK records both positions at the signing act, and the check runs your page at 390 by 844.

[CR-06](https://esigncomply.com/docs/conformance#cr-06) · warn

### Notice font size and contrast

Without the rules

Fine print: 10 px, light gray, tucked under a bright button.

With the prompt

The notice is set at body size, never under 12 px, with contrast of at least 4.5 to 1 against its background. The SDK measures both.

[CR-07](https://esigncomply.com/docs/conformance#cr-07) · warn

### Single primary action control

Without the rules

Email signup and two social sign-in buttons in one form, all styled as the main action under one notice.

With the prompt

One primary button inside the assent container. Social sign-in gets its own container, its own notice and its own session.

Each row is a real conformance rule with its ID and its default level. Esign Comply runs 28 of them over your test records, and every finding names the rule, the measurement and the fix.

[E-signature mistakes AI tools make](https://esigncomply.com/learn/vibe-coded-esignature-mistakes) · [All 28 conformance rules](https://esigncomply.com/docs/conformance)

## Go further with Bolt

Keep prompting. The same split carries through a whole signing product: Bolt builds what people see, Esign Comply keeps what they agreed to.

A whole product

### Build your own signing app

Upload a document, email each signer a link to your own application and collect the signatures there. There are 7 build guides, each with the steps and the code.

[Build your own DocuSign](https://esigncomply.com/build/docusign-alternative)

Your stack

### Stack guides

The same integration written out for your framework and your host, with working code for the server, the browser and the confirmation.

[Browse the stack guides](https://esigncomply.com/guides)

Live demos

### Use cases

NDAs, contractor agreements, consent forms, order forms and terms updates. Each page has a live demo you can sign in test mode.

[See the use cases](https://esigncomply.com/use-cases)

Prompt generator

### The exact rules for your regions

Pick your use case, regions, signer types and stack. You get one prompt to paste into Bolt, with your own document and profile IDs and the rule packs you selected.

[Generate a prompt](https://esigncomply.com/product/prompt-generator)

### Build guides to follow with Bolt

- [Build your own DocuSign](https://esigncomply.com/build/docusign-alternative)
- [Build your own Dropbox Sign](https://esigncomply.com/build/dropbox-sign-alternative)
- [Build your own PandaDoc](https://esigncomply.com/build/pandadoc-alternative)
- [Build your own Adobe Acrobat Sign](https://esigncomply.com/build/adobe-sign-alternative)
- [Build your own signNow](https://esigncomply.com/build/signnow-alternative)
- [Build your own DocSend](https://esigncomply.com/build/docsend-alternative)
- [Build your own clickwrap](https://esigncomply.com/build/clickwrap)
- [All build guides](https://esigncomply.com/build)

### The same prompt for another AI tool

- [Cursor](https://esigncomply.com/build/cursor)
- [Claude Code](https://esigncomply.com/build/claude-code)
- [Codex](https://esigncomply.com/build/codex)
- [Windsurf](https://esigncomply.com/build/windsurf)
- [GitHub Copilot](https://esigncomply.com/build/github-copilot)
- [Devin](https://esigncomply.com/build/devin)
- [Lovable](https://esigncomply.com/build/lovable)
- [v0](https://esigncomply.com/build/v0)
- [Replit](https://esigncomply.com/build/replit)
- [ChatGPT](https://esigncomply.com/build/chatgpt)
- [Grok](https://esigncomply.com/build/grok)
- [Grokbot](https://esigncomply.com/build/grokbot)
- [Muse](https://esigncomply.com/build/muse)
- [All AI tools](https://esigncomply.com/build#tools)

## Questions about Bolt and e-signatures

### Can Bolt build a clickwrap?

Yes. A clickwrap is a checkbox, a notice and a button in your own signup form. Paste the prompt on this page and Bolt builds the form, the server code that creates the Esign Comply session and the server code that confirms the record before the account is created.

### Where do I put the API key in Bolt?

In the project's environment file, under the name ESIGNCOMPLY_API_KEY, never with a VITE\_ or other public prefix. Only server code reads it: a server route or a backend function. The browser receives a short-lived client token and nothing else.

[Guide for AI app builders](https://esigncomply.com/docs/guides/ai-builders)

### What if my Bolt app has no server?

Add one small server piece, and the prompt tells Bolt to. It does two jobs, and only these two need the key: create the session and return the client token, and confirm the record before your app grants access. Everything else stays in the browser.

[Guide for AI app builders](https://esigncomply.com/docs/guides/ai-builders)

### Why does the preview return domain_mismatch?

Because test keys accept browser calls from localhost and from the preview hosts you list. Add the host your preview runs on under Domains, Test origins in the Esign Comply dashboard. The error message names the exact origin to add.

[How test mode works](https://esigncomply.com/docs/guides/test-mode)

### Is a signature collected in an app I built with an AI tool recognized?

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 Comply gives your AI tool the ceremony rules drawn from those laws and from leading U.S. online-assent decisions, and keeps each signature as an independent, tamper-evident record.

[U.S. rules we draw on](https://esigncomply.com/compliance/united-states)

## Prompt the page in Bolt. Leave the record to us.

[Get started](https://esigncomply.com/signup) · [Documentation](https://esigncomply.com/docs)

Free plan: 10 live signatures a month and a full test mode. No card required.

Bolt is a trademark of its owner. Esign Comply is not affiliated with it.

---

Every page on esigncomply.com has a Markdown version at the same URL plus `.md` (the home page is `https://esigncomply.com/index.md`). https://esigncomply.com/llms.txt lists them.
