Re-acceptance flow for a terms of service update
Your terms changed, and the people who accepted the old version have to accept the new one before they continue. Esign Comply tells you which signed-in users are outstanding, your AI coding tool builds the blocking screen, and each re-acceptance is sealed as a new record.
Free plan: 10 live signatures a month and a full test mode. No card required.
Try the re-acceptance screen
This is a real signing ceremony against the real Esign Comply API in test mode: check the box, click Accept and continue, and the re-acceptance is sealed as a new record.
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 the setup Esign Comply recommends for a terms update: an unchecked checkbox, a button labelled Accept and continue, and level L1.
The prompt that builds the re-acceptance flow
The Esign Comply prompt generator produced this for terms update re-acceptance 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. Your tool builds the gate in your authenticated layout, the /accept-updates screen, the server confirmation and the webhook.
IDs in angle brackets are placeholders the prompt tells your tool to ask for, and {Company} is your company name. Generate the prompt in the dashboard and it names your own profile and your own Terms of Service document.
# Esign Comply integration: terms update re-acceptance Prompt esc_prompt_e2de4b46e557 · blocks 2026.11 · guidance bundled · region US Jurisdictions: US-FED · mode auto You are adding legally significant acceptance 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: terms update = `<profile ID for terms update>` - Documents: Terms of Service = `<document ID for Terms of Service>` - 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. Notice wording for terms update, verbatim, with links: "By checking the box and clicking Accept and continue, you agree to the [Terms of Service]." (CR-02, CR-03) 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 checkbox starts unchecked (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 5 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 5 confirms it. - Never write or change the text of the Terms of Service. ## 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. - Give the signer a clear way to decline (US-04). - Before a material terms update takes effect, notify users in advance and present a blocking screen with an unchecked checkbox (US-18). Step 7 builds the screen; the advance notice email is the developer's choice. - 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 `terms`. 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. Terms update ceremony (`/accept-updates`) Server action `startUpdateCeremony()`: - `signerId` is the signed-in user's `signer_id`; create and store one with `crypto.randomUUID()` if it is missing. Never accept it from the browser. `attemptId` is a UUID made when the page first renders and reused on retry. - Call: ```ts const { data, error } = await esc.sessions.create({ profile: "<profile ID for terms update>", signer: { external_id: signerId, email, class: signerClass, country, region }, documents: [ { document: "<document ID for Terms of Service>", version: "current" }, ], context: { url: `${origin}/accept-updates`, locale, purpose: "policy_update" }, }, { idempotencyKey: `update-${attemptId}` }); ``` - `signerClass` is "consumer" or "business" from the account type field. Obtain `country` and applicable jurisdiction from the form/customer configuration; do not guess from IP. `region`: the U.S. state as an ISO code ("US-NY"), if collected. - Return `data.client_token` and `data.documents` to the client. Client component `UpdateForm`: ```tsx "use client"; import { EsignComply } from "@esigncomply/browser"; // after the server action returns clientToken: const ceremony = await EsignComply.attach({ clientToken }); await ceremony.presentDocument({ versionId: termsVersionId, mode: "hyperlink", link: termsLinkRef.current }); ceremony.observeAssent({ region: assentRef.current, // contains notice, links, checkbox, button checkbox: checkboxRef.current, submit: submitRef.current, }); // in the submit handler, from the user's real click: try { const result = await ceremony.complete(); // { recordId, receipt, verifyUrl } await finishUpdate(formData, result.recordId); // server action, step 5 } catch (err) { showError(err.message); // typed error with rule ID } ``` Disable the button until `ceremony.remainingSteps()` contains only "signature.applied". Start the ceremony when the page renders, not on submit. ### 5. Server confirmation (the only place access is granted) Server action `finishUpdate(formData, 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 signed-in user's `signer_id`; `record.livemode` equals `process.env.VERCEL_ENV === "production"`; the record lists the exact versions pinned in that session. - Only then clear the re-acceptance gate, and insert one `esign_acceptances` row per document using the service-role client. - If checks are inconclusive, do not clear the re-acceptance gate. Show: "We could not confirm whether your acceptance was recorded. Please wait while we check." Reconcile the existing session before requesting another act. ### 6. 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. - `signer.reacceptance_required`: no action; the gate in step 7 handles it. - Ignore event types you do not recognise and return 200. Return 200 within 5 seconds. ### 7. Gate and re-acceptance In the authenticated layout, call `esc.signers.status(signerId)` (cache 5 minutes per user). If any required document is outstanding, redirect to `/accept-updates`. That page shows the list of updated documents with links, the summary of changes returned by the API, an unchecked checkbox labelled "I agree to the updated [document titles]", and a button labelled "Accept and continue". It is the page built in step 4. Offer "Log out" as the alternative. Do not offer "Remind me later". ### 8. 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. ## 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/accept-updates`. 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 box unchecked does nothing, and that calling `finishUpdate` with a made-up record ID does not clear the re-acceptance gate. 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 five steps a re-acceptance needs
A session created with the recommended terms update profile returns these required_steps. With more than one updated document, document.presented appears once per document.
An unchecked checkbox and Accept and continue
For a terms update, Esign Comply recommends the checkbox method at level L1, on a blocking screen. The user is already signed in to your app, so there is no code to confirm. Signing in, scrolling and continued use are never recorded as acceptance.
- MethodCheckbox
- LevelL1, no identity step
- method: checkboxassurance_level: L1document_type: termspurpose: policy_update
- 01
The SDK attaches to the blocking screen
client.attachedThe signer seesYour
/accept-updatesscreen, where the gate sent them after sign-in.Esign Comply recordsThe address of that screen, the SDK version, the viewport, the language and the time zone.
- 02
The updated terms are shown
document.presented:<version_id>The signer seesThe list of updated documents, each linked to its page, with your summary of what changed.
Esign Comply recordsThe new version ID of each document, the link text and address, and whether the user opened the link.
- 03
The notice is captured
notice.capturedThe signer seesThe notice above the button: "By checking the box and clicking Accept and continue, you agree to the Terms of Service."
Esign Comply recordsThe notice text, the checkbox label and its unchecked starting state, the button label and the placement of each.
- 04
The user ticks the box
intent.capturedThe signer seesAn unchecked box labelled "I agree to the updated Terms of Service".
Esign Comply recordsThe tick, the label, the starting state, and whether a real user event made the change.
- 05
The acceptance
signature.appliedThe signer seesThe Accept and continue button, with Log out as the only other way off the screen.
Esign Comply recordsA new sealed record with
context.purposeset topolicy_update. The earlier acceptance stays on record unchanged.
One ceremony covers up to 10 updated documents and counts as one signature event. The prompt tells your tool not to offer "Remind me later".
What you build for a terms update, and what Esign Comply handles
The hard part of a terms update is knowing who has not accepted the current version and stopping them at the right place. Esign Comply answers the first question. Your app does the stopping.
Publishing the change
Publish the new version with material_change: true, a summary_of_changes and, for a notice period, an effective_at in the future.
Sends signer.reacceptance_required for each affected signer when you publish, and makes the version current at effective_at.
Finding who has not accepted
Call esc.signers.status(signerId) for the signed-in user and cache the answer for five minutes.
GET /v1 returns each document with outstanding, the reason and your summary of changes.
The gate
In your authenticated layout, redirect anyone with an outstanding document to /accept-updates. Keep that page outside the gated layout.
One status call in your request path. Earlier acceptances stay on record while the user is blocked.
The blocking screen
The list of updated documents, the summary, an unchecked checkbox, an Accept and continue button and a Log out link.
The rules prompt, and the SDK that records the ceremony with purpose policy_update.
Advance notice
Email your users before the change takes effect. That notice is your message, sent from your domain.
Recommends the notice in the prompt and seals your report of it as a notice.sent supplement when you send one.
Letting them through
Confirm the record on your server, save the acceptance in your table and clear the cached status.
Once the record exists, the status call reports outstanding: false for those documents.
The record you get for each re-acceptance
Every user who accepts the update leaves a new sealed record that names the new version. The record of what they accepted before is still there, untouched, so you hold the full history per user.
What the sealed record holds
- The exact new version of each updated document, by SHA-256 hash.
- The purpose
policy_update, which marks the record as a re-acceptance. - The checkbox label, its unchecked starting state and the user's own tick.
- The notice and the button label as rendered on the blocking screen.
- Esign Comply's server time for each step.
- A signed receipt (ES256), an outside RFC 3161 timestamp and a hash-chained ledger entry.
What you do with it
- Signed receiptStore it in your acceptances tableOne row per user and version, with the record ID and the receipt. Your gate reads Esign Comply's status call, and your table keeps the history.
- PDF, per recordEvidence report
GET /v1shows which version of the terms a user accepted, on which screen, with which words, and when./records /{id} /report - verify_urlVerification pageEach re-acceptance has a verification page, and with receipts on the user gets a copy of what they accepted by email.
- 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
Re-acceptance is the second half of a clickwrap. These pages cover the first half and the stacks it runs on.
- Build guideBuild your own clickwrapSignup, checkout and terms updates with versioned terms and a record per acceptance.Open
- MigrationMove off Ironclad ClickwrapRebuild the acceptance flow in your own UI and keep an independent record of every acceptance.Open
- Stack guidesStep-by-step guides for your stackClickwrap and re-acceptance on Next.js and Supabase, Rails, Django, Laravel and React Native.Open
- AI toolsBuild it with your AI toolPaste this prompt into Cursor, Claude Code, Lovable, v0, Bolt or Replit.Open
Questions about terms update re-acceptance
How do I make users re-accept updated terms of service?
Publish the new version with material_change set to true. In your authenticated layout, call GET /v1/signers/{external_id}/status for the signed-in user and redirect anyone with an outstanding document to a blocking screen. That screen shows the updated documents, an unchecked checkbox and an Accept and continue button, and runs a ceremony with purpose policy_update.
Re-acceptance guideHow do I find the users who have not accepted the current terms?
Ask Esign Comply. GET /v1/signers/{external_id}/status returns every document the signer has accepted, the version they accepted, the current version, and whether acceptance is outstanding. Esign Comply also sends a signer.reacceptance_required webhook for each affected signer when you publish a material change.
Signers APIIs continued use of the app enough to accept new terms?
Not for the record. Esign Comply records an acceptance only when the user ticks an unchecked box and clicks the button the notice names. Its guidance for a terms update is a blocking screen with that checkbox and an Accept and continue button, at level L1. Signing in, scrolling and continued use are not recorded as acceptance.
What happens to the earlier acceptance?
It stays on record unchanged. A record is never edited to point at a newer version. The re-acceptance is a new record that names the exact new versions, so you hold the history of what each user accepted and when.
Does every edit to my terms force re-acceptance?
No. Only a version you publish with material_change set to true makes earlier acceptances outstanding. A version published without it becomes the current one for new signers and leaves existing users alone.
Build the re-acceptance flow yourself. Leave the record to us.
Free plan: 10 live signatures a month and a full test mode. No card required.
Ironclad, Supabase and the other product names on this page are trademarks of their owners. Esign Comply is not affiliated with them.