# Re-acceptance flow for a terms of service update

> Build a re-acceptance flow for a terms of service update: find users who have not accepted the current version, gate them, and seal each acceptance. Live demo.

Source: https://esigncomply.com/use-cases/terms-update

Use case · terms 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.

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

Live demo · test mode

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

**Interactive on the HTML page:** A live demo of a signing screen (Terms update). It runs a real signing ceremony against the Esign Comply API in test mode and shows each step as it is recorded. Open https://esigncomply.com/use-cases/terms-update#demo to use it.

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 · from the generator

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

[Generate it for your own regions and stack](https://esigncomply.com/product/prompt-generator)

esigncomply-terms-update-prompt.md · 1,760 words

````markdown
# 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.
````

5 required steps

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

Esign Comply's guidance for a terms update

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

- Method · Checkbox
- Level · L1, no identity step
- method: checkbox · assurance_level: L1 · document_type: terms · purpose: policy_update

1. **The SDK attaches to the blocking screen**

   `client.attached`

   The signer sees

   Your `/accept-updates` screen, where the gate sent them after sign-in.

   Esign Comply records

   The address of that screen, the SDK version, the viewport, the language and the time zone.

2. **The updated terms are shown**

   `document.presented:<version_id>`

   The signer sees

   The list of updated documents, each linked to its page, with your summary of what changed.

   Esign Comply records

   The new version ID of each document, the link text and address, and whether the user opened the link.

3. **The notice is captured**

   `notice.captured`

   The signer sees

   The notice above the button: "By checking the box and clicking Accept and continue, you agree to the Terms of Service."

   Esign Comply records

   The notice text, the checkbox label and its unchecked starting state, the button label and the placement of each.

4. **The user ticks the box**

   `intent.captured`

   The signer sees

   An unchecked box labelled "I agree to the updated Terms of Service".

   Esign Comply records

   The tick, the label, the starting state, and whether a real user event made the change.

5. **The acceptance**

   `signature.applied`

   The signer sees

   The Accept and continue button, with Log out as the only other way off the screen.

   Esign Comply records

   A new sealed record with `context.purpose` set to `policy_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".

[How the ceremony works](https://esigncomply.com/docs/concepts/ceremony) · [Browser SDK reference](https://esigncomply.com/docs/sdk/browser) · [Ceremony SDK and conformance checks](https://esigncomply.com/product/ceremony-sdk)

You vibe code · Esign Comply handles

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

You vibe code

Publish the new version with `material_change: true`, a `summary_of_changes` and, for a notice period, an `effective_at` in the future.

Esign Comply handles

Sends `signer.reacceptance_required` for each affected signer when you publish, and makes the version current at `effective_at`.

### Finding who has not accepted

You vibe code

Call `esc.signers.status(signerId)` for the signed-in user and cache the answer for five minutes.

Esign Comply handles

`GET /v1/signers/{external_id}/status` returns each document with `outstanding`, the reason and your summary of changes.

### The gate

You vibe code

In your authenticated layout, redirect anyone with an outstanding document to `/accept-updates`. Keep that page outside the gated layout.

Esign Comply handles

One status call in your request path. Earlier acceptances stay on record while the user is blocked.

### The blocking screen

You vibe code

The list of updated documents, the summary, an unchecked checkbox, an Accept and continue button and a Log out link.

Esign Comply handles

The rules prompt, and the SDK that records the ceremony with purpose `policy_update`.

### Advance notice

You vibe code

Email your users before the change takes effect. That notice is your message, sent from your domain.

Esign Comply handles

Recommends the notice in the prompt and seals your report of it as a `notice.sent` supplement when you send one.

### Letting them through

You vibe code

Confirm the record on your server, save the acceptance in your table and clear the cached status.

Esign Comply handles

Once the record exists, the status call reports `outstanding: false` for those documents.

The record

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

Sealed at signing · kept by Esign Comply

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

Yours to store, send and check

### What you do with it

- Signed receipt

  **Store it in your acceptances table**

  One 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 record

  **Evidence report**

  `GET /v1/records/{id}/report` shows which version of the terms a user accepted, on which screen, with which words, and when.

- `verify_url`

  **Verification page**

  Each re-acceptance has a verification page, and with receipts on the user gets a copy of what they accepted by email.

- ZIP, verifies offline

  **Evidence package**

  The record, the receipt, the timestamp token, the ledger proof and the exact document bytes. Anyone you hand it to runs the open-source `esigncomply-verify` with no account and no network.

[How sealing and verification work](https://esigncomply.com/product/evidence) · [Why a third party keeps the record](https://esigncomply.com/why/third-party-record)

## 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 guide

  **[Build your own clickwrap](https://esigncomply.com/build/clickwrap)**

  Signup, checkout and terms updates with versioned terms and a record per acceptance.

- Migration

  **[Move off Ironclad Clickwrap](https://esigncomply.com/migrate/ironclad-clickwrap)**

  Rebuild the acceptance flow in your own UI and keep an independent record of every acceptance.

- Stack guides

  **[Step-by-step guides for your stack](https://esigncomply.com/guides)**

  Clickwrap and re-acceptance on Next.js and Supabase, Rails, Django, Laravel and React Native.

- AI tools

  **[Build it with your AI tool](https://esigncomply.com/build#tools)**

  Paste this prompt into Cursor, Claude Code, Lovable, v0, Bolt or Replit.

### Run the prompt in your 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)
- [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 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 guide](https://esigncomply.com/docs/guides/reacceptance)

### How 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 API](https://esigncomply.com/docs/api/signers)

### Is 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.

### More use cases

- [NDA](https://esigncomply.com/use-cases/nda)
- [Contractor agreement](https://esigncomply.com/use-cases/contractor-agreement)
- [Consent form](https://esigncomply.com/use-cases/consent-form)
- [Order form](https://esigncomply.com/use-cases/order-form)
- [All use cases](https://esigncomply.com/use-cases)

## Build the re-acceptance flow yourself. 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.

Ironclad, Supabase and the other product names on this page are trademarks of their owners. Esign Comply is not affiliated with them.

---

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.
