# Add e-signatures with Cursor

> Add e-signatures with Cursor: copy one prompt, paste it into your repo, and get a signup clickwrap with an independent record. See the 60-second result.

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

Coding agent · Cursor

You're building in Cursor and your app needs people to agree to something: terms at signup, an order at checkout, a contract. Paste one prompt and Cursor builds the flow in your own UI, while Esign Comply supplies the rules and keeps the independent record of every signature.

[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. Put a test key in your server environment · You
2. Paste one prompt into Cursor · You
3. Cursor wires your form and your server · 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 Cursor

Open your project in Cursor 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 Cursor

- 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 Cursor

```
Add a signup clickwrap to this repository with Esign Comply. A new user accepts our Terms of Service and Privacy Notice before the account is created. We render every screen. Esign Comply observes it 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

Build
1. Server: create the session with the secret key from ESIGNCOMPLY_API_KEY. Send only the client token to the browser, with the document version IDs it presents.
2. Browser: in our existing signup form, attach @esigncomply/browser with the client token to our own unchecked checkbox and our Create account button. Call complete() from the user's real click.
3. Server: before creating the account, confirm the record. Read it with the secret key and check its status, livemode, signer ID and version IDs against what the server saved.

Never
- Never invent API methods, packages or legal wording.
- Never pre-check the box or click for the user.
- Never put the secret key in client code, and never print it.

If anything here conflicts with existing code, or the docs do not cover a step, stop and ask me. Save these rules as .cursor/rules/esigncomply.mdc. Run commands in the integrated terminal. Finish with npx esigncomply check --url http://localhost:3000/signup and fix every finding marked "block".
```

5 steps

## How to run it in Cursor

Cursor is an AI code editor. 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 keys work on `localhost` with no domain.

2. **Put the key in your server environment**

   Add `ESIGNCOMPLY_API_KEY=esc_test_us_...` to `.env.local` and check that the file is in `.gitignore`. The key stays out of the chat: the prompt tells Cursor to read it from the environment.

3. **Paste the prompt into Cursor**

   Cursor reads the three docs pages, then writes the session route, wires your signup form and adds the server confirmation. It saves the rules as `.cursor/rules/esigncomply.mdc`, so later sessions in this repo build under them too.

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

   Start your dev server, open `/signup`, tick the checkbox and click Create account. Test keys work on `localhost` with no setup.

5. **Read the conformance check**

   `npx esigncomply check --url http://localhost:3000/signup` runs your page at three window sizes and prints each finding with its rule ID, the measurement and the fix. Paste a finding back into Cursor and it repairs the page.

[Create a free account](https://esigncomply.com/signup) · [Read the quickstart](https://esigncomply.com/docs/quickstart)

The 60-second result

## What you have 60 seconds after Cursor finishes

Run the app, tick the box, click Create account. A minute after Cursor finishes, this is what is in your repo and in your Esign Comply dashboard.

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 a Next.js repository. In another stack, Cursor writes the same three parts under that stack's file names.

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 Cursor gets right with the rules, and wrong without them

Cursor writes a signing page that looks finished from one sentence. The prompt gives it what the sentence left out: where the notice goes, what it has to say and what the checkbox starts as.

[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-08](https://esigncomply.com/docs/conformance#cr-08) · block

### Document links resolve to the registered version

Without the rules

A link to `/terms` that serves whatever is in the repo today, or the legal text pasted into a component.

With the prompt

Every link serves the registered version by its ID, and the record pins that version by SHA-256 hash. Document text is never copied into your code.

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 Cursor

The signup clickwrap is the smallest flow. Cursor builds the larger ones from the same pattern: one session per signer, your own screens, a record you do not hold.

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 Cursor, 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 Cursor

- [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

- [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)
- [Bolt](https://esigncomply.com/build/bolt)
- [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 Cursor and e-signatures

### Can Cursor build an e-signature flow?

Yes. Cursor writes the form, the server route and the confirmation in your own repository. Paste the prompt on this page and it reads the Esign Comply setup runbook first, then builds a signup clickwrap with your own checkbox and button. Esign Comply supplies the rules and keeps the independent record of every acceptance.

### Where do I put the Esign Comply API key when I use Cursor?

In your server environment as ESIGNCOMPLY_API_KEY, for example in .env.local, which stays in .gitignore. Never paste the key into the chat and never give it a public prefix such as NEXT_PUBLIC\_. The browser only ever receives a short-lived client token for one session.

[Read the quickstart](https://esigncomply.com/docs/quickstart)

### Where does Cursor keep the Esign Comply rules?

In .cursor/rules/esigncomply.mdc. The prompt on this page tells Cursor to save the rules there, and a prompt generated in the Esign Comply dashboard downloads as that same file, so every later session in the repository builds under the same rules.

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

### How do I know the page Cursor built follows the rules?

Run npx esigncomply check --url http://localhost:3000/signup. The CLI opens your page at three window sizes, runs the ceremony with a test signer and prints each finding with its rule ID, the measurement and the fix. It returns an exit code, so the same command runs in CI.

[Read the conformance rules](https://esigncomply.com/docs/conformance)

### Can Cursor build more than a signup checkbox?

Yes. The same pattern builds NDA and contract signing with a typed name and an emailed one-time code, checkout terms, terms updates and a whole send-for-signature product with uploads and signer links. Pick the use case in the prompt generator, or start from a build guide.

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

## Paste the prompt into Cursor. 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.

Cursor 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.
