All-in-one clickwrap solution.

Build clickwrap agreements into your product with templates, multi-language modals, version control, and tamper-proof Certificates of Acceptance for every user.

Developer docs Start free
ClickTerm Clickwrap Acceptance Modal showing Terms & Conditions with Accept and Decline buttons
ClickTerm Template Editor with rich text content and version history panel
ClickTerm Clickwrap Events dashboard with filters and event status tracking
ClickTerm Certificate of Acceptance, page 1ClickTerm Certificate of Acceptance, page 2
Toolkit

Manage clickwrap agreements at scale

ClickTerm covers the full clickwrap lifecycle: localization, placeholders, version control, team roles, and a tamper-evident audit log.

Dynamic Placeholders

Inject user-specific data like name, email, company, VAT, and 5 custom fields into every agreement at runtime. Each value appears in the modal, the certificate, and the API response.

Multi-language

Serve clickwrap modals in 7 languages: English, German, French, Spanish, Chinese, Hindi, and Russian. Maintain separate localized content versions for each template.

End User Management

Track every end user across all your apps. View their acceptance history, event statuses, placeholder values, and consent timeline in one place.

Effective At & Must Accept By

Schedule when an agreement becomes active and set a deadline for acceptance. Ideal for rolling out updated terms on a specific date or enforcing time-bound consent.

Team & Roles

Invite team members and assign roles (Owner, Admin, or Member) with granular permissions for template management, publishing, billing, and user administration. All roles are included in every ClickTerm plan at no extra cost.

Audit Log

A tamper-evident chronological record of every action in your organization: events, template changes, user management, and integration updates.

Compliance & Security

Clickwrap compliance built for legal enforceability

ClickTerm uses PAdES digital signatures and HMAC-SHA256 verification to make every clickwrap acceptance legally defensible. Every record is cryptographically signed, stored immutably, and audit-ready for regulators.

PAdES Digital Signatures

Certificates of Acceptance are signed with PAdES (PDF Advanced Electronic Signatures), the EU standard recognized under eIDAS for advanced electronic signatures.

eIDAS PAdES PDF/A

End-to-End Integrity

Every event is protected by HMAC-SHA256 signatures and SHA-256 content hashing. Verification confirms the event was not tampered with between the user's action and your backend.

HMAC-SHA256 SHA-256 TLS 1.3

Regulation-Ready Records

Full audit trail with timestamped records, IP addresses, device metadata, and exact agreement text. Ready for GDPR data subject requests, CCPA, and regulatory audits. Have specific compliance questions? Reach out to our team.

GDPR CCPA Audit-ready

Made in Europe

Built and operated under the world's strictest privacy laws. Your data physically resides in the EU and is governed by GDPR.

Frankfurt, Germany AWS eu-central-1
EU jurisdiction Full GDPR compliance
EU data residency Data stays in the EU
Simple Integration

Set up clickwrap software in four steps

Add ClickTerm to your web or mobile app in under an hour with a lightweight SDK and REST API. The acceptance flow opens inside your product, similar to reCAPTCHA, so users can accept terms without leaving your UI.

1

Create an app

Create an integration in the ClickTerm dashboard and copy your App ID and Key.

2

Build a template

Write your agreement in the editor, add placeholders, and publish the live version.

3

Show the modal

Include the SDK and call ClicktermDialog.show() in your frontend.

4

Verify & record

Send the signature to your backend, call the Verify API, and get a Certificate of Acceptance.

JavaScript 
// Include the SDK script from CDN
// cdn.clickterm.com/sdk/clickterm-widget-2.0.0.min.js
const { ClicktermClient, ClicktermDialog } = window.Clickterm;

// Initialize with your App ID
ClicktermClient.initialize("YOUR_CLICKTERM_APP_ID");

// Show the clickwrap modal
const result = await ClicktermDialog.show({
  endUserId: "user-123",
  clickwrapTemplateId: "tmpl-456",
  language: "en",
  templatePlaceholders: {
    fullName: "Alice Example",
    email: "alice@example.com",
    company: "Acme Corp",
  },
});

console.log("Accepted:", result.signature);
// Send result.signature to your backend for verification
Java 
// build.gradle — add the dependency
// implementation 'com.clickterm:android-sdk:2.0.0'

// 1. Initialize the SDK
ClicktermClient.initialize("YOUR_CLICKTERM_APP_ID");

// 2. Show the clickwrap modal
ClickwrapTemplate contentRequestBody = new ClickwrapTemplate(
    "YOUR_CLICKTERM_TEMPLATE_ID",
    endUserID,
    new HashMap<>(),
    "en"
);

ClicktermDialog.show(this, contentRequestBody, null,
    new ClicktermDialog.OnAgreementResultListener() {
        @Override
        public void onSuccess(String clicktermSignature) {
            Log.i("Clickterm", clicktermSignature);
            // Send signature to your backend for verification
        }

        @Override
        public void onError(String message) {
            Log.e("Clickterm", message);
        }
    }
);
TypeScript 
// npm install @clickterm/react-native-sdk
// Expo: add the plugin, then `npx expo prebuild`
import * as Clickterm from '@clickterm/react-native-sdk';

// Initialize once, early in your app
await Clickterm.initialize("YOUR_CLICKTERM_APP_ID");

// Show the clickwrap dialog
const signature = await Clickterm.show({
  clickwrapTemplateId: "tmpl-456",
  endUserId: "user-123",
  language: "en",
  templatePlaceholders: {
    fullName: "Alice Example",
    email: "alice@example.com",
  },
});

if (signature) {
  // Send signature to your backend for verification
  await sendToBackend(signature);
}
cURL 
# Verify a clickwrap signature
curl -XPOST \
  -H 'X-APP-ID: {YOUR_APP_ID}' \
  -H 'X-APP-KEY: {YOUR_APP_KEY}' \
  -H "Content-type: application/json" \
  -d '{ "clicktermSignature": "{SIGNATURE}" }' \
  'https://api.clickterm.com/public-client/v1/clickwrap/verify'

# Response
{
  "clickwrapEventStatus": "ACCEPTED",
  "clickwrapEventId":     "123e4567-e89b-12d3-a456-426614174000",
  "clickwrapTemplateId":  "987e6543-e21b-45d3-b321-426614174999",
  "endUserId":            "423e4567-e89b-12d3-a456-426614174000",
  "actionAt":             "2025-08-20T14:30:00Z"
}

# Download Certificate of Acceptance
curl -XGET \
  -H 'X-APP-ID: {YOUR_APP_ID}' \
  -H 'X-APP-KEY: {YOUR_APP_KEY}' \
  'https://api.clickterm.com/public-client/v1/clickwrap-events/{eventId}/certificate'
Read the developer docs
Roadmap

What we're building next

Here's what's shipping next, and what's further out on the roadmap.

Coming soon

Bundled Templates

Present multiple agreements in a single modal, each with its own checkbox. Users accept or decline each document individually in one step.

In development

Agreement Links via Email

Send clickwrap agreements directly to end users by email. Recipients click a link to view and accept. No SDK integration required.

In development

Legal Hub

A single public page listing all your organization's published documents. One URL for your entire legal library: terms, policies, NDAs, always current.

In development

On the horizon

E-Signature Documents

Go beyond clickwrap with full electronic signature support. Collect legally binding signatures on contracts, proposals, and agreements.

Planned

Contract Lifecycle Management

A unified workspace to manage all document types (clickwrap, e-signature, and uploaded contracts) from creation through renewal.

Planned

Pre-Signed PDF Support

Upload previously signed PDF documents and manage them alongside your digital agreements. Track, store, and reference legacy contracts in one place.

Planned

Don't see what you need?

We ship what you ask for. Share your idea and help shape the next release.

Request a feature
FAQ

Common questions about clickwrap features

What clickwrap software is, when it holds up in court, and how ClickTerm fits into your stack.

Yes. Clickwrap agreements, also called clickthrough agreements, are widely recognized as enforceable contracts in the US, EU, and many other jurisdictions. Courts consistently uphold clickwrap consent when the user is presented with the terms, required to take an affirmative action (such as clicking "Accept"), and the acceptance is properly recorded. ClickTerm captures all of this (the exact text, the user's action, timestamp, IP, and device) in a PAdES-signed Certificate of Acceptance.

ClickTerm records explicit, timestamped consent for each end user along with the exact version of the agreement they accepted. Every event includes full metadata: IP, timestamp, device, and a content hash, providing the audit trail required to demonstrate valid consent under the GDPR. The Certificate of Acceptance also serves as a standalone compliance record for data subject access requests.

A Certificate of Acceptance (CoA) is a digitally signed PDF generated after each accepted clickwrap event. It contains the event ID, user details, timestamp, IP address, agreement version, and a SHA-256 hash of the content. The PDF is signed using PAdES (PDF Advanced Electronic Signatures), an EU standard under eIDAS, ensuring tamper-proof integrity.

You can validate the signature using either Adobe Acrobat Reader or the DSS Demonstration WebApp.

In Adobe Acrobat Reader:

  1. Open the PDF file.
  2. Look for the signature panel or visible seal/signature.
  3. The document will indicate that it has not been modified since it was signed.

In the DSS Demonstration WebApp:

  1. Upload the PDF file for validation.
  2. The tool will display the signature status.

Minimal changes. Include the ClickTerm SDK script, initialize it with your App ID, and call ClicktermDialog.show() wherever you need consent. The modal runs in an isolated Shadow DOM, so it won't conflict with your styles or scripts. A backend call to the Verify API confirms the result. Most teams integrate in under an hour.

Published versions are immutable. When you update your agreement, you publish a new version. Existing acceptance records remain tied to the original version the user saw. You can then prompt returning users to accept the latest version, creating a new event with a new certificate. You get a complete version-by-version consent timeline for every end user.

Yes. Every organization starts with 500 free verified events per month. No credit card required. Beyond the free tier, pay-as-you-go pricing starts at €0.05 per event and decreases with volume. All features are available from day one, including PAdES certificates, multi-language support, and the full API.