Add e-signatures with Windsurf
You're in Windsurf and the next thing on the list is the "I agree" checkbox. One prompt builds the clickwrap in your own form, and Esign Comply gives Windsurf the rules and keeps the record you do not hold.
Free plan: 10 live signatures a month and a full test mode. No card required.
- 01Put a test key in your server environmentYou
- 02Paste one prompt into WindsurfYou
- 03Windsurf wires your form and your serverYou
- 04Acceptance reported from the user's browserEsign Comply
- 05Sealed record, receipt and timestampEsign Comply
- 06Server confirms, then creates the accountYou
The prompt to paste into Windsurf
Open your project in Windsurf 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.
- Read
setup.md,auth.mdandllms.txtbefore 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.
Build a signup clickwrap in this project with Esign Comply: an unchecked "I agree" checkbox and our Create account button, with links to the Terms of Service and the Privacy Notice. We build the screen. Esign Comply records the acceptance and keeps the record. First read these three pages and follow them exactly: - https://esigncomply.com/setup.md - https://esigncomply.com/auth.md - https://esigncomply.com/llms.txt Steps 1. On the server, create the session with the secret key in ESIGNCOMPLY_API_KEY. Only the client token and the document version IDs go to the browser. 2. In the signup form we already have, attach @esigncomply/browser with the client token. Point it at our own checkbox, our own button and the two document links, and call complete() inside the real submit handler. 3. On the server, confirm the record with the secret key before the account is created. Check status, livemode, signer ID and version IDs. Do not - Do not invent API methods, packages or legal wording. - Do not pre-check the box, auto-submit or call .click() for the user. - Do not expose the secret key to client code. If something conflicts with the existing code, or you are unsure about a step, stop and ask. Save these rules in .windsurf/rules/esigncomply.md, run commands in the integrated terminal, and finish with npx esigncomply check --url http://localhost:3000/signup.
How to run it in Windsurf
Windsurf is an AI code editor. This is the whole run, from a new Esign Comply account to your first test record.
- 01Create a free account and a test keySign 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. - 02Add the key to
.env.localOne line:ESIGNCOMPLY_API_KEY=esc_test_us_.... Keep the file in.gitignoreand keep the key out of the chat. Never give the variable a public prefix such asNEXT_PUBLIC_orVITE_. - 03Paste the prompt into WindsurfWindsurf reads the docs, creates the session on your server, attaches the SDK to the form you already have and adds the confirmation. The rules land in
.windsurf/rules./esigncomply.md - 04Run the app, tick the box, run the checkOpen
/signuponlocalhost, tick the checkbox and click Create account. Then read the output ofnpx esigncomply check --url http:/and paste any finding back into Windsurf./localhost:3000 /signup
What you have 60 seconds after Windsurf finishes
Four steps and one signup on localhost. This is what Windsurf leaves in your project, and what Esign Comply holds a minute later.
- 01
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.
- 02
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.
- 03
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.
// 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, }); }
// 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 }), }); }
// 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, Windsurf writes the same three parts under that stack's file names.
One sealed test record, kept by Esign Comply
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.
What Windsurf gets right with the rules, and wrong without them
Left to its own taste, an AI editor optimizes a signup form for looks: quiet links, small print, one tidy line of legal text. The prompt tells Windsurf which of those choices the rules measure.
Affirmative assent control
The checkbox ships already ticked, or a handler ticks it for the user to save a click.
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.
Notice names the action control
"By continuing" or "by clicking below", next to a button that says something else.
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.
Document link contrast
Links to the terms styled to match the sentence around them, because it looked cleaner.
Document links are underlined and differ in colour from the surrounding text by at least 3 to 1. The check prints the ratio it measured.
Notice font size and contrast
Fine print: 10 px, light gray, tucked under a bright button.
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.
Document links resolve to the registered version
A link to /terms that serves whatever is in the repo today, or the legal text pasted into a component.
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.
Go further with Windsurf
The rules file stays in the project, so Windsurf builds the next signing screen under the same rules.
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 DocuSignStack 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 guidesUse 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 casesThe exact rules for your regions
Pick your use case, regions, signer types and stack. You get one prompt to paste into Windsurf, with your own document and profile IDs and the rule packs you selected.
Generate a promptQuestions about Windsurf and e-signatures
Can Windsurf build a clickwrap or a signing page?
Yes. Windsurf builds the page in your own project and your own design. The prompt on this page has it read the Esign Comply docs first, then create the session on the server, attach the browser SDK to your checkbox and button, and confirm the record on the server before the account is created.
Where do I store the API key in a Windsurf project?
In your server environment as ESIGNCOMPLY_API_KEY, for example in .env.local, listed in .gitignore. Only server code reads it. Never use a public prefix such as NEXT_PUBLIC_ or VITE_, because a variable with such a prefix is compiled into the browser bundle.
Read the quickstartWhere does Windsurf keep the Esign Comply rules?
In .windsurf/rules/esigncomply.md. The prompt tells Windsurf to save them there, so the rules apply to later sessions in the same project and not only to the chat you pasted the prompt into.
Is there a generated prompt for Windsurf?
Yes. Windsurf is one of the tools in the prompt generator. Pick your use case, your regions, your signer types and your stack, choose Windsurf, and paste the result. The generated prompt carries your own document and profile IDs and the rules for the packs you selected.
See the prompt generatorHow do I check the page Windsurf built?
Run npx esigncomply check --url http://localhost:3000/signup. The CLI opens the page at 390 by 844, 768 by 1024 and 1440 by 900, runs the ceremony with a test signer and prints each finding with its rule ID, what was measured and the fix.
Read the conformance rulesBuild the screen in Windsurf. Leave the record to us.
Free plan: 10 live signatures a month and a full test mode. No card required.
Windsurf is a trademark of its owner. Esign Comply is not affiliated with it.