Skip to content
Learn · online assent patterns

Clickwrap vs browsewrap vs sign-in wrap

Clickwrap asks the user to tick a box or press a button that says they agree. Browsewrap posts a link to the terms and treats using the site as agreement. Sign-in wrap puts a notice beside a button the user was going to press anyway. Build clickwrap: an unchecked box, a notice that names the documents and the button, and a record of both. Each pattern is below as code, with how courts have treated it.

At a glance
BrowsewrapRarely enforced
A link in the footer. Using the site counts as agreeing.
Sign-in wrapDepends on the screen
A notice beside Sign up. Pressing the button counts as agreeing.
ClickwrapRoutinely enforced
An unchecked box the user ticks, then a button.

The test courts apply to all three

U.S. courts do not decide these cases by the label. They ask two questions about the screen the user saw.

Question 1

Was the notice of the terms reasonably conspicuous?

Where the notice sat, how large it was, how it contrasted with the page, and whether the links looked like links.

Question 2

Did the user take an action that unambiguously shows assent?

A tick or a click counts when the user was told that it means agreement. In Berman v. Freedom Financial the Ninth Circuit held that a click shows assent only when the user is explicitly advised that it will.

The three names are shorthand for how much of that work the design does. Nobody has to have read the terms: the test is notice and assent, as the Second Circuit put it in Meyer v. Uber. And a recorded click does not repair a notice the user could not see.

Pattern 1 of 3

Browsewrap: a link the user never acts on

Browsewrap is a link to the terms somewhere on the page, with the site treating continued use as agreement and the user never asked to do anything.

How courts have treated it

Courts have been reluctant to enforce it. In Nguyen v. Barnes & Noble (9th Cir. 2014), a Terms of Use link at the bottom of every page, with nothing that asked the user to act, did not bind a customer who never clicked it. In Specht v. Netscape (2d Cir. 2002), license terms that appeared only below the download button, on a part of the screen users had to scroll to, did not bind the people who downloaded. Browsewrap has held where the user actually knew about the terms.

Rules it meets or misses

It misses CR-01: there is no control and no act to observe. Esign Comply cannot seal a record for it at all, because every record needs an explicit act by the signer and the notice text that was shown (US-01, US-08).

Browsewrap: the pattern as code
<main>
  <h1>Welcome to Acme</h1>
  <a href="/signup">Get started</a>
</main>

<footer>
  <a href="/terms">Terms of Use</a>
  <a href="/privacy">Privacy</a>
</footer>

{/* /terms opens with: "By using this site you agree to these terms." */}
Pattern 2 of 3

Sign-in wrap: a notice beside a button

Sign-in wrap is a notice beside a button the user presses for another reason, such as Sign up, Sign in or Place order, saying that pressing it also means agreeing to the terms.

How courts have treated it

Outcomes turn on the design of the screen. Meyer v. Uber (2d Cir. 2017) enforced one where the notice was "spatially and temporally coupled" with the button on an uncluttered screen. Berman (9th Cir. 2022) refused one set in tiny gray type that never said the click meant agreement. Chabolla v. ClassPass (9th Cir. 2025) turned on button text that did not match the notice, and Godun v. JustAnswer (9th Cir. 2025) held that button text alone cannot replace an explicit statement. Context counts as well: Sellers v. JustAnswer looked harder at a one-off purchase and a renewing trial than at an account the user expects to keep.

Rules it meets or misses

Built well, it meets CR-01 (the click is the act, and it has to be a real user event) and CR-02 and CR-03 (the notice names each document and the button by its exact label). It misses CR-09 for consumers and for purchase, trial and renewal flows, where Esign Comply's policy asks for a checkbox.

Sign-in wrap: the pattern as code
<form onSubmit={signUp}>
  <input name="email" type="email" required />
  <input name="password" type="password" required />

  <p>
    By clicking Sign up, you agree to the{" "}
    <a href="/terms">Terms of Service</a> and{" "}
    <a href="/privacy">Privacy Policy</a>.
  </p>
  <button type="submit">Sign up</button>
</form>
Pattern 3 of 3

Clickwrap: an unchecked box, then a button

Clickwrap makes the user take a separate step that means yes, most often ticking an unchecked box that says they agree, before the button does anything.

How courts have treated it

This is the form courts enforce most readily. Berman describes the range: at one end a box the user ticks that says "I agree", which courts have routinely found enforceable, and at the other a bare link, which they are reluctant to enforce. In Good v. Uber (Mass. 2024) the court enforced updated terms shown on a blocking screen with a checkbox and a confirm button. When a court refused a sign-in wrap in Cruz v. Tapestry (Cal. Ct. App. 2025), it noted that the merchant could have required a checkbox. The box does not rescue a broken page: in an unpublished 2025 memorandum the Ninth Circuit found no mutual assent where the terms link did not open.

Rules it meets or misses

It meets CR-01 when the box starts unchecked and the user ticks it, and CR-09 in every acceptance flow. The snippet here still needs work: the label does not name the button (CR-03), and the links point at pages that change (CR-08). The version to build is below.

Clickwrap: the pattern as code
<form onSubmit={signUp}>
  <input name="email" type="email" required />
  <input name="password" type="password" required />

  <label>
    <input type="checkbox" name="agree" required />
    I agree to the <a href="/terms">Terms of Service</a> and{" "}
    <a href="/privacy">Privacy Policy</a>.
  </label>
  <button type="submit">Sign up</button>
</form>

Which rules each pattern meets

The same three patterns against the conformance rules Esign Comply measures on a signing screen. The rules are drawn from the decisions above.

Browsewrap, sign-in wrap and clickwrap against the conformance rules
RuleBrowsewrapSign-in wrapClickwrap
An affirmative act CR-01Misses. There is no control and no act.Meets, when the click is a real user event.Meets. The box starts unchecked and the user ticks it.
The notice names the documents CR-02Misses. A footer link is not a notice of agreement.Meets when each document is named by its title.Meets when each document is named by its title.
The notice names the action CR-03Misses. There is no action to name.Meets only with the button's exact label in the notice.Meets. The notice names the box and the button.
Notice and control on screen together CR-04Misses. The link sits in the footer.Depends on your layout at 390 by 844.Meets when the notice is the checkbox label, directly above the button.
The method fits the context CR-09No method to check.Misses for consumers and for purchase, trial and renewal flows.Meets in every acceptance flow.
What can be recordedNothing. No act took place.One click, with the notice text beside it.The state of the box at load, the tick, the click, the notice text and the exact document versions.

Which one to build: clickwrap, with an unchecked box

Build clickwrap. Use one unchecked box whose label is the notice, naming every document and the button, directly above one primary button. It costs your user one extra click.

  • It is the form courts routinely enforce, and the one a court pointed to when it refused a sign-in wrap.
  • It gives you two acts to record instead of one: a box that went from unchecked to checked by the user's own click, then the button.
  • It is the method the rules accept in every acceptance context, so signup, checkout, trials and renewals all use the same pattern.
1. Your markup
<form id="signup">
  <input id="email" type="email" autocomplete="email" required />

  <div id="assent">
    <label for="agree">
      <input id="agree" type="checkbox" />
      By checking the box and clicking Create account, you agree
      to the <a id="tos-link" href="/legal/terms">Terms of Service</a>
      and acknowledge the
      <a id="privacy-link" href="/legal/privacy">Privacy Notice</a>.
    </label>
    <button id="create-account" type="submit" disabled>
      Create account
    </button>
  </div>

  <p id="message" role="alert"></p>
</form>
2. Your server: create the session
// app/api/ceremony/route.ts
import { esc } from "@/lib/esigncomply"; // server-only SDK client

export async function POST(request: Request) {
  const user = await requireUser(request); // your auth

  const { data: session, error } = await esc.sessions.create(
    {
      profile: "prof_signup_4f1a", // method checkbox, level L1
      signer: {
        external_id: user.id,
        email: user.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-${user.id}` },
  );
  if (error) return Response.json({ error: error.code }, { status: 502 });

  // Server-owned state: the versions this session pinned.
  await saveCeremony(user.id, session.id, session.documents);

  return Response.json({
    clientToken: session.client_token, // esc_ct_..., not a secret key
    apiUrl: session.api_url,
    documents: session.documents,
  });
}
3. The browser: attach, present, observe, complete
import { EsignComply, EsignComplyError } from "@esigncomply/browser";

const $ = <T extends Element>(css: string) => document.querySelector<T>(css)!;
const form = $<HTMLFormElement>("#signup");
const submit = $<HTMLButtonElement>("#create-account");
const tosLink = $<HTMLAnchorElement>("#tos-link");
const privacyLink = $<HTMLAnchorElement>("#privacy-link");

const res = await fetch("/api/ceremony", { method: "POST" });
if (!res.ok) throw new Error("Unable to create ceremony");
const { clientToken, apiUrl, documents } = await res.json();
const [tos, privacy] = documents;

// Link each document at the exact version this session pinned.
tosLink.href = `/legal/terms?v=${tos.version_id}`;
privacyLink.href = `/legal/privacy?v=${privacy.version_id}`;

const ceremony = await EsignComply.attach({ clientToken, apiUrl });

await ceremony.presentDocument({
  versionId: tos.version_id,
  mode: "hyperlink",
  link: tosLink,
});
await ceremony.presentDocument({
  versionId: privacy.version_id,
  mode: "hyperlink",
  link: privacyLink,
});

ceremony.observeAssent({
  region: $("#assent"), // notice text, links, checkbox, button
  checkbox: $("#agree"),
  submit,
});

// The button opens once the box is ticked and each step is recorded.
const sync = () => {
  const open = ceremony.remainingSteps().every((s) => s === "signature.applied");
  submit.disabled = !open;
};
ceremony.on("change", sync);
sync();

form.addEventListener("submit", async (event) => {
  event.preventDefault();
  try {
    const { recordId } = await ceremony.complete();
    // Your server confirms the record before it creates the account.
    const confirmed = await fetch("/api/signup/finish", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ recordId }),
    });
    if (!confirmed.ok) throw new Error("Not confirmed");
    location.assign("/welcome");
  } catch (err) {
    const refused =
      err instanceof EsignComplyError &&
      err.code !== "network_error" &&
      err.status < 500;
    $<HTMLElement>("#message").textContent = refused
      ? err.message // carries the rule ID and a fix
      : "We could not confirm whether your acceptance was recorded.";
  }
});

What the code does

Your server creates a session with your secret key and sends the browser a short-lived client token. The headless SDK attaches to the box and button you built, checks that each link serves the registered version, and reports the notice, the tick and the click straight to Esign Comply. complete() returns a record ID and a signed receipt.

What to do next

Confirm the record on your server before you create the account, and store the receipt. Then run npx esigncomply@latest check --url on the page: it measures the rules above at three window sizes and prints each miss with its fix.

Or let your AI tool write it

Pick your use case, regions, signer types and stack. You get one prompt for Cursor, Claude Code, v0, Lovable, Bolt or Replit that carries these rules, in your own components.

Generate a prompt

If you keep a sign-in wrap for a business signup, hold it to the same rules: the notice names the button by its exact label, sits directly above it and is as large as your body text. For a document someone signs, such as an NDA or a contract, use a typed name and a signing button instead. Build clickwrap end to end, browse the stack guides and the use cases, or read the ESIGN Act and UETA checklist.

Questions about clickwrap, browsewrap and sign-in wrap

What is the difference between clickwrap and browsewrap?

Clickwrap makes the user do something that says yes: tick a box or press a button labelled as agreement, next to a notice of the terms. Browsewrap only posts a link to the terms and treats using the site as agreement. Clickwrap records an act by the user. Browsewrap records nothing, because nothing happened.

Is browsewrap enforceable?

Rarely. Courts have declined to enforce browsewrap where the only notice was a link the user was never asked to act on, as in Nguyen v. Barnes & Noble and Specht v. Netscape. It has held where the user actually knew about the terms. For terms you need to rely on, build clickwrap.

Is a sign-in wrap enforceable?

It depends on the screen. Meyer v. Uber enforced a sign-in wrap whose notice sat directly below the button on an uncluttered screen. Berman v. Freedom Financial refused one whose notice was in tiny gray type and did not say that the click meant agreement. If you use one, the notice has to name the button by its exact label, sit beside it and be easy to read.

Do I need a checkbox for terms of service?

No statute requires a checkbox. An unchecked box the user ticks is the clearest act of assent you can record, and it is the form courts routinely enforce. Esign Comply's rules ask for a checkbox in consumer, purchase, trial and renewal flows as a design policy, and accept a button with a matching notice for business signups.

Read rule CR-09

What should a clickwrap checkbox say?

Name the action and every document: "By checking the box and clicking Create account, you agree to the Terms of Service and acknowledge the Privacy Notice." Use the exact label of your button, link each document to its exact version, and render the box unchecked.

Seven mistakes to avoid

Build the clickwrap yourself. Keep a record of every click.

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

Working with an AI tool? This page is also available as Markdown: /learn/clickwrap-vs-browsewrap.md