Consent certificates for web leads
LimeCert records how a visitor to your web page gave consent to be contacted, and seals it into a certificate you can produce later. One script tag on the page does the recording. Your form posts a footprint id along with the lead, and the API tells you what the certificate says, lets you claim or reject the lead, and lets you add what happened next.
Four things to know:
- The snippet gives each visitor a footprint: a record of the visit, the form they filled in and the consent language they saw, sealed in their browser as they type.
- The footprint id (
fp_…) is posted with your form. Save it with the lead. It is how everything about that lead is found afterwards. - The consent certificate (
cert_…) is issued seconds after a visitor submits with consent. It carries the disclosure word for word, what was measured about it, how it compares with your approved language, the form data, and — if you turn it on — a replay of the session. - The verdict comes back at submit. Within a second of the submit the page is handed a risk score and its level, and how the consent text compares with your approved language, through a JavaScript callback. Cert scores; your page and your systems decide.
- The lead has to be claimed. A certificate is kept for its full term once you claim the lead, by API, in the dashboard or by sending the lead an envelope. Unclaimed leads lapse at a deadline.
https://collect.limebase.app,
the API answers at https://api.limebase.app, and the dashboard and public verify pages are at
https://limebase.app. Authentication, conventions and errors are the same as for the
LimeDocs API; the key you use needs the Cert scope.Install the snippet
Create a publisher key in the dashboard under Cert → Publishers. One key per site, or per agency that sends you leads, so every footprint says who it came through. You can restrict a key to the origins it may be used from. Then put the tag on every page a lead might pass through — not only the page with the form, so the visit is recorded from where it began:
<script async src="https://collect.limebase.app/footprint.js" data-key="pk_y4143af45134fm9qsb1b3vsq4q"></script>
The tag is under 10 KB, loads asynchronously, and never blocks the page. If anything goes wrong inside it, the page carries on as if it were not there: it will not slow a page down, stop a form from submitting, or throw into your console. The publisher key is public; it identifies the site, it does not grant access to anything.
Once the first page view arrives, the key shows as installed under Publishers, with the pages it has been seen on.
The footprint id
When a visitor lands on a page carrying the snippet they are given a footprint, identified by an id
like fp_v5ng84grsgc78y50ew8ewywrha. It follows them from page to page for up to 30 days.
When they submit a form, the snippet adds a hidden field to it, so your server receives the id with the
rest of the lead:
<input type="hidden" name="footprint_id" value="fp_v5ng84grsgc78y50ew8ewywrha">
Store it with the lead. It is the one thing that connects a row in your CRM to its consent
certificate, and it is what every call in this guide takes. To use a different field name, set
data-field-name on the script tag.
The same id is also available to scripts on your page as window.CertFootprint.footprintId, for
forms posted with JavaScript rather than a plain form submit.
submit event fires. If your page posts with fetch without firing it, call
form.requestSubmit() or dispatch a submit event so the consent is recorded at the
moment it is given.What is recorded, and what is never read
For every page view: the page's origin and path (never the query string), the referring site, and the visitor's IP address and browser. For every form the snippet finds: which fields it has and what kind of thing each holds. For every field the visitor types in: the value, sealed in the browser under a key issued for that page load. Nothing readable leaves the page.
The sealed values are opened only when the visitor submits with consent. A visit that never becomes a lead is destroyed after 30 days, key and all, and the values can never be read.
Never read
Some fields are not touched at all — not sealed, not sent: passwords, hidden fields, file inputs,
card numbers and security codes, social security and tax ids, bank account and routing numbers, PINs and
one-time codes. The snippet recognises them by their type, their autocomplete attribute and
their name. Anything you mark data-cert-ignore is left alone too.
Session recording
Optionally, per publisher, the snippet records the session so the certificate can be played back: what the
page looked like, where the visitor scrolled, when the consent box was ticked. Turn it on under
Cert → Publishers → Session recording, where you can also have the visitor shown a notice.
Recordings load a second file, /recorder.js, only when recording is on. Images and fonts from
your page are not captured, and fields the snippet never reads appear as asterisks in the replay.
Marking up your form
The snippet works on an unmodified page: it finds forms, classifies fields from their type, name and
autocomplete, and finds the consent language by looking for a checkbox whose label reads like
consent, or the most specific sentence near the submit button that does. A few attributes let you tell it
instead of letting it guess.
| Attribute | Where | What it does |
|---|---|---|
data-cert-consent | The consent checkbox, or the element holding the disclosure text | Names the disclosure the visitor agrees to. Put it on the checkbox and its label is the disclosure; put it on a block of text and that text is. Strongly recommended: the guess is good, but this is certain. |
data-cert-field="email" | An input, select or textarea | Says what kind of thing the field holds: email, phone, name, address, zip, date or other. Overrides the guess from the field's markup. |
data-cert-form="quote" | A form | Names the form on the certificate. Otherwise its id or name is used. |
data-cert-ignore | Any element | Nothing inside it is read, and it is blocked out of the session recording. |
data-field-name | The script tag | The name of the hidden field the footprint id is posted in. Default footprint_id. |
data-cert-wait | A form | Hold the submit until the verdict is in (a moment and a half at most), so a classic form post can carry it. See the verdict at submit. |
Example
<form method="post" action="/quote" data-cert-form="quote"> <input name="full_name" autocomplete="name" placeholder="Full name"> <input name="email" type="email" placeholder="Email"> <input name="phone" type="tel" placeholder="Phone"> <label> <input type="checkbox" name="tcpa" data-cert-consent> By checking this box I agree to be contacted by Demo Insurance at the number above, including by autodialer and text message. Consent is not a condition of purchase. See our <a href="/privacy">Privacy Policy</a>. </label> <button>Get my quote</button> </form>
Consent can also be given by submitting, when the disclosure says so ("By clicking Get my quote, I
agree…"). Mark that sentence with data-cert-consent and leave the checkbox out. The certificate
records which of the two it was.
The hidden field
The snippet adds a field named footprint_hp to each lead form: invisible, out of the tab order,
hidden from assistive technology. A person never fills it in; a script filling in every field does. It is
disabled before the form posts, so your server never receives it — do not expect it in the lead data, and do
not use the name yourself.
Approved language
Under Cert → Publishers you can set the consent language you approved for a publisher. Every certificate then compares what the visitor actually saw with it, word for word, and shows the difference — the way to find out that a vendor's page quietly changed the wording.
The verdict at submit
When a form is submitted, the snippet sends what it measured along with the submit, and the collector answers within a second with a verdict: the risk score and its level, and a provisional comparison of the consent text with your approved language. The page receives it three ways:
// 1. A callback, set before the submit window.CertFootprint.onVerdict = function (v) { // v.risk → { score: 10, level: "low" } // v.consent → { approvedLanguage: "matches", provisional: true } or null; also "differs" or "not_set" }; // 2. An event on the document document.addEventListener("footprint:verdict", function (e) { console.log(e.detail.risk.score); }); // 3. A property, for a page that asks afterwards window.CertFootprint.verdict
A page that posts its form with JavaScript simply waits for the callback before it does. A classic form post
leaves the page before the answer arrives; put data-cert-wait on the form and the snippet holds the
submit until the verdict is in, or for a moment and a half, whichever comes first, then lets it go. Your own
submit handlers run once, before the hold.
risk.high webhook and alert, which go to your systems, not the page.A pixel, for pages that cannot run script
Some pages cannot carry a script tag — an email template, a locked-down vendor page, a form builder that strips scripts. For those, an image request records that the page was reached, and on a thank-you page, that a form was submitted:
<img src="https://collect.limebase.app/pixel.gif?key=pk_…&event=submit&form=quote" width="1" height="1" alt="">
event is view (the default) or submit; form names the form.
The page it is on comes from the browser's referrer, and a key restricted to origins is checked against it.
Each hit starts a footprint, which the dashboard lists like any other.
Lead lifecycle
A footprint moves through these states. GET /v1/footprints/:id returns the current one.
| State | Meaning |
|---|---|
open | A visit. Pages are being recorded; nothing has been typed yet. |
captured | Something was typed into a form. The values are sealed and unreadable. |
issued | The visitor submitted with consent and the certificate was issued. The lead is waiting to be claimed; claimDeadline says until when. |
claimed | You accepted the lead. The certificate is kept for its full retention term. |
active | Something was added after the claim: an event you reported, or an envelope sent to the lead. It stays here and keeps collecting additions, including further envelopes. |
closed | The record is frozen. Final. |
rejected | You turned the lead down, with a reason. The certificate is kept; the recording is destroyed at the deadline. Final. |
lapsed | Nobody claimed the lead by the deadline. The certificate's contents, the recording and the lead's details were destroyed; its id, hashes and chain position remain. Final. |
expired | A visit that never became a lead, destroyed after 30 days. Final. |
claimed is a perfectly good place for a lead to stay. A signature does not close a lead: an
envelope sent with LimeDocs is added to the record, which keeps taking additions, including the next envelope.
Working with leads
Every call takes the footprint id your form posted. Your API key needs the Cert scope, set when the key is created under Settings → Developer.
1 · Look the lead up
When a lead arrives on your server, look its footprint up. The certificate is issued about ten seconds
after the submit, so a lookup made at once may still say captured; look again, or do it from
the job that processes the lead.
curl https://api.limebase.app/v1/footprints/fp_v5ng84grsgc78y50ew8ewywrha \ -H "Authorization: Bearer $KEY" # → { "id": "fp_v5ng84grsgc78y50ew8ewywrha", "state": "issued", "origin": "snippet", "publisher": "Main site", "createdAt": "2026-10-05T20:21:14.000Z", "expiresAt": null, "claimDeadline": "2026-11-04T20:21:31.780Z", "risk": { "score": 10, "level": "low" }, "certificate": { "id": "cert_tzb1p4vcjtsf7hd8xqpgmmypsa", "kind": "consent", "version": 1, "issuedAt": "2026-10-05T20:21:42.368Z", "approvedLanguage": { "status": "matches", "differences": 0 }, "verifyUrl": "https://limebase.app/verify/cert_tzb1p4vcjtsf7hd8xqpgmmypsa" } }
approvedLanguage.status is matches, differs or not_set, and
differences counts the places the text differs. risk is the risk score and its level against your
threshold — enough to route a lead or hold it for review without reading the certificate.
2 · Claim it
Claiming says you accept the lead. From then on the certificate is kept for its full retention term, and retention is charged. Claiming is idempotent: claim as often as you like, it is recorded once.
curl -X POST https://api.limebase.app/v1/footprints/fp_v5ng…/claim \ -H "Authorization: Bearer $KEY" # → the footprint, with "state": "claimed"
A lead can also be claimed from the dashboard, or by sending it an envelope.
3 · Or reject it
A reason is required and goes on the certificate, which is kept as the record of what was sold to you. A lead can be rejected before it is claimed or after — fraud is often found on the first call — but not once it has a completed signature.
curl -X POST https://api.limebase.app/v1/footprints/fp_v5ng…/reject \ -H "Authorization: Bearer $KEY" \ -H "Content-Type: application/json" \ -d '{"reason":"Disconnected number; the person says they never filled in a form"}'
4 · Report what happened next
Once a lead is claimed, tell LimeCert what your business did with it: the call made, the appointment kept, the policy issued. Each event is sealed into a new version of the certificate with the time you reported it. It is your account of events — LimeCert did not observe it, and the certificate says so.
curl -X POST https://api.limebase.app/v1/footprints/fp_v5ng…/events \ -H "Authorization: Bearer $KEY" \ -H "Content-Type: application/json" \ -d '{ "name": "call.completed", "idempotencyKey": "crm-activity-88213", "occurredAt": "2026-10-06T14:02:00Z", "data": { "agent": "M. Reyes", "outcome": "appointment set" }, "attachments": [ { "label": "Call notes", "data": "<base64 PNG or JPEG>" } ] }' # → 201 {"recorded":true,"attachments":[{"label":"Call notes","sha256":"…",…}]}
| Field | Rules |
|---|---|
name | Your own name for what happened: 1–64 characters, lower-case letters, digits, ., _ or -. |
idempotencyKey | Required, 1–128 characters. Sending the same key twice records the event once; the second call answers 200 with "recorded": false. Use the id of the record in your own system. |
occurredAt | Optional ISO-8601 time; defaults to now. May not be in the future. |
data | Optional JSON object, at most 4 KB. Shown on the certificate as you sent it. |
attachments | Up to 4 images (PNG or JPEG, base64). Each is stored encrypted and listed on the certificate by its SHA-256. |
Events are not a way of claiming: reporting one about an unclaimed lead answers 409 with
claim this lead before reporting events about it.
5 · Produce the certificate
Whenever you need it — a dispute, an audit, a vendor review — fetch the latest version as a PDF or as signed JSON. Both are served by the footprint id, so you never have to store the certificate id.
curl https://api.limebase.app/v1/footprints/fp_v5ng…/certificate \ -H "Authorization: Bearer $KEY" -o consent.pdf curl https://api.limebase.app/v1/footprints/fp_v5ng…/certificate.json \ -H "Authorization: Bearer $KEY" -o consent.json
Sending a lead an envelope
If the lead goes on to sign something — an application, an agreement — send it through LimeDocs and name the lead's footprint on the signer. The envelope then becomes the next part of the same record rather than a separate one.
curl https://api.limebase.app/v1/envelopes \ -H "Authorization: Bearer $KEY" \ -H "Content-Type: application/json" \ -d '{"title":"Policy application","signers":[ {"name":"Ada Lovelace","email":"ada@example.com","footprintId":"fp_v5ng84grsgc78y50ew8ewywrha"}]}'
What happens then:
- Sending the envelope claims the lead (if it was not claimed already), and records whether
the signer's email, phone and name are the ones typed into the form —
match,mismatch, ornot_givenwhen one side did not have it. An envelope addressed to someone other than the person on the form is allowed; the certificate just says so. - Completing the envelope closes the lead. The consent certificate is re-sealed naming the Certificate of Completion by id and hash, and the Certificate of Completion names the consent certificate. Each is evidence for the other.
- The Certificate of Completion tells the envelope's story only. The visit and the consent stay on the consent certificate.
The footprint must be a certified lead of your workspace that is not rejected, not lapsed, and not closed;
otherwise the request is refused with 409. A lead can be sent any number of envelopes, and only
the first one signed moves the certificate to its eSignature stage. The same thing can be done from the dashboard with Send for signature on the lead's certificate.
The consent certificate
A certificate is issued once, a few seconds after the consented submit, and re-sealed as a new version each time something about the lead changes: a claim, a rejection, a reported event, a signature. Every version is kept and verifiable; the latest is what the API serves. What was certified at the submit — the disclosure, the measurements, the form data, the visit, the recording — is carried forward unchanged from version to version.
What it holds
| Part | Contents |
|---|---|
| Disclosure | The consent language word for word as the visitor's browser rendered it, its SHA-256, its markup (redrawn safely on the dashboard), text size, colour, how long it was on screen, its distance from the submit button, and the privacy or terms link with whether it opened. |
| How consent was given | By ticking a box (with the box's timeline: ticked, unticked, by pointer, keyboard or script, pre-ticked on load) or by submitting. |
| Approved language | The word-by-word difference from the language you approved for the publisher, when one is set. |
| The lead | Every value the visitor typed, with its form, field and kind. |
| The visit | When it started, where it came from, IP address, browser, every page viewed. |
| Recording | Whether a replay exists (full, partial or none), the hash of each piece so a piece altered later is found out, and a picture of the page at the moment of submit. |
| Risk signals | The score and level, every rule with what it measured and whether it was flagged, the feature vector the browser sent, what the server measured, each vendor lookup with the vendor's name, and what the page was told at submit. See risk signals. |
| Status | Where the lead stands, when it was claimed and how, the rejection reason, when it closed, and how long the certificate is kept. |
| Reported events | Everything your system reported, with its data and attachments by hash. |
| Closure | The envelope, its Certificate of Completion by id and hashes, and the signer match. |
| History | Everything above as a timeline, in plain sentences. |
Signed JSON
The JSON form is the PDF's contents as data, under a signature: { "payload": { "certificate": …,
"document": … }, "signature": { "algorithm": "ECDSA-P256-SHA256", "keyId": …, "value": … } }.
The document is the certificate's full content; the certificate block carries its id,
version, the PDF's SHA-256, and its position and hash in your workspace's chain. Read the comparison from
payload.document.consent.report.approved and the lead's status from
payload.document.status.state.
Verifying a certificate
Every certificate has a public page, https://limebase.app/verify/<certificate id>, that
anyone holding the id can open — a regulator, a counterparty, a court. It checks the certificate's record
afresh: that the files on record still hash to what was sealed, that the signature holds, and that the
certificate's place in the chain is intact. It shows the certificate's id, when it was issued, its hashes
and its chain position, and nothing about the lead. The verify URL is on the PDF and in the
API's verifyUrl.
To check a PDF you were given, compute its SHA-256 and compare it with the one on the verify page. If they match, your copy is the certificate that was issued, byte for byte.
Checking lead fields against a certificate
A buyer who was handed a lead and its certificate id can ask whether the details they hold are the ones the visitor typed, without seeing the form: fingerprints are compared, never values.
curl -X POST https://api.limebase.app/v1/certificates/cert_tzb1…/verify \ -H "Authorization: Bearer $KEY" \ -H "Content-Type: application/json" \ -d '{"email":"ada@example.com","phone":"+1 555 010 4477","name":"Ada Lovelace"}' # → {"certificateId":"cert_tzb1…","footprintId":"fp_v5ng…","match":{"email":"match","phone":"mismatch","name":"not_given"}}
Each field answers match, mismatch, or not_given when either the form or the
request did not have it. Names are compared only when the form asked for a whole name.
Certificates in a workspace form a hash chain: each one's chain hash covers the one before it. A certificate cannot be removed, reordered or quietly replaced without the chain showing it.
Risk signals
Every submission is scored from 0 to 100 by weighted rules, each of which says what it looked at, what it
measured and whether it counted against the lead. The score is on the certificate with its reasons, on the
footprint in the API, in the dashboard list with a filter, and, without its reasons, in the verdict the page receives. Below 40 is
low; from 40, elevated; from your threshold (70 by default, under
Cert → Cert settings), high.
| Measured by the browser | What it looks for |
|---|---|
| Keystroke dynamics | How long keys are held and the time between them, as statistics. An even, machine-like rhythm is flagged. Which keys were pressed is never recorded. |
| Pointer dynamics | Distance, speed, jumps, and clicks that landed without the pointer moving. A form filled in with no pointer or touch at all is flagged. Where the pointer went is never recorded. |
| How fields were filled | Typed, pasted, filled by the browser, or set by a script — per field, from the browser's own inputType. |
| Timing | Page load to submit, and the time spent in each field. |
| Touch | Taps, and pressure and contact size where the device reports them. |
| Environment | Time zone against the ZIP code given; navigator.webdriver; signs of a headless browser. |
| The hidden field | Filled in by nobody human. |
| A small puzzle | Solved by every browser in idle time; a script posting thousands of forms pays for each. |
| Measured by the server | What it looks for |
|---|---|
| Address velocity | Other footprints from the same IP address in ten minutes and in a day, for your workspace and across all of LimeCert. |
| Shared identifiers | The same email address, phone number or name on other footprints in a day. |
| Clock skew | The browser's clock far from ours, as a replayed or forged request's often is. |
| Returning visitors | Earlier footprints by the same browser under your key, noted on the certificate. |
| Bought signals | Email, IP, phone, address and device intelligence, the FCC Reassigned Numbers Database, Do-Not-Call status and litigator lists — each behind a provider you configure. Without one, the certificate says "no provider configured" for that kind. An email domain check needs none and is on by default. |
The raw feature vector is kept on every certificate's signed JSON under document.signals.features,
so that a better model can be trained on your own data later. All of it is statistics: no keystrokes, no
pointer paths, nothing that reconstructs what was typed.
Webhooks and alerts
The endpoints you register under Settings → Developer for LimeDocs take LimeCert's events
too: tick the ones you want. Signing, retries, headers and the webhook.ping test are exactly as
described in the LimeDocs reference. Lead events always go to the workspace's
default endpoints; a lead belongs to no account.
| Event | Fires when |
|---|---|
certificate.issued | A visitor submitted with consent and the certificate was sealed — the first version. Later versions do not fire it; the events below say what changed. |
consent.differs | The consent text shown differs from your approved language. reason says how many differences; the certificate shows them. |
risk.high | The lead scored at or above your high-risk threshold — at submit, when the page was told, or at issue once the server's rules and lookups ran. Once per lead. reason lists the rules that fired. |
certificate.claimed | The lead was claimed: from the dashboard, through the API, or by sending it an envelope. |
esignature.completed | The lead signed an envelope sent to them; both certificates now name each other. Once per envelope. |
footprint.closed | The record was closed and is frozen. |
snippet.silent | No page has reported under a publisher key for a day, after having reported before. Once per silence; publisher says which key. |
Payload
{
"id": "8c2e…", // unique delivery id — dedupe on this
"type": "risk.high",
"createdAt": "2026-10-06T19:38:58.000Z",
"footprint": {
"id": "fp_sh6m…", "state": "issued", "publisher": "Main site",
"claimDeadline": "2026-11-05T19:38:58.000Z",
"risk": { "score": 80, "level": "high", "reasons": [ "The form was filled in and submitted without any pointer or touch movement", "…" ] }
},
"certificate": { "id": "cert_794x…", "version": 1, "approvedLanguage": { "status": "matches", "differences": 0 }, "verifyUrl": "https://limebase.app/verify/cert_794x…" },
"reason": "The form was filled in and submitted without any pointer or touch movement; …",
"links": {
"footprint": "https://api.limebase.app/v1/footprints/fp_sh6m…",
"certificate": "https://api.limebase.app/v1/footprints/fp_sh6m…/certificate",
"certificateJson": "https://api.limebase.app/v1/footprints/fp_sh6m…/certificate.json"
}
}
certificate is null before one is issued (a risk.high fired at submit arrives seconds
before the certificate); footprint is null for snippet.silent, which carries
publisher instead.
Alert emails
Three of these are also sent by email, so that someone sees them without an integration: a failed consent, a high-risk lead, a silent snippet. By default they go to the workspace's owners and admins; under Cert → Cert settings you can name the addresses instead and turn each kind off. Alerts say what happened and link to the certificate or the publisher; they carry no lead data.
Certificates and publishers API
Beyond the footprint a form posts, the API lets your systems work with certificates as a whole and with the keys the snippet runs under.
Certificates
# The newest high-risk leads still awaiting a claim curl "https://api.limebase.app/v1/certificates?risk=high&status=awaiting&limit=20" \ -H "Authorization: Bearer $KEY" # → {"data":[{"id":"cert_…","kind":"consent","version":1,"approvedLanguage":{"status":"matches","differences":0}, # "footprint":{"id":"fp_…","state":"issued","risk":{"score":80,"level":"high"},…},"links":{…}}],"nextCursor":"…"} # One certificate, an earlier version of it, and everything on record as a zip curl https://api.limebase.app/v1/certificates/cert_… -H "Authorization: Bearer $KEY" curl "https://api.limebase.app/v1/certificates/cert_…/pdf?version=1" -H "Authorization: Bearer $KEY" -o v1.pdf curl https://api.limebase.app/v1/certificates/cert_…/bundle -H "Authorization: Bearer $KEY" -o cert.zip
The list takes kind, status (where the lead stands), risk, from,
to, a search term q (a certificate or footprint id, or part of an envelope title), and
pages by cursor. Certificates of Completion are listed alongside consent certificates, with their
envelope. The bundle is every version's PDF and signed JSON with a manifest.json of
hashes and chain positions — what you hand to counsel or a regulator. A version whose files were destroyed is
in the manifest as such; its hashes remain.
Publisher keys
# Create a key for a site, restricted to its pages; the answer carries the tag to install curl -X POST https://api.limebase.app/v1/publishers \ -H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \ -d '{"name":"Main site","allowedOrigins":["https://www.example.com"]}' # Approve the consent wording its pages should show curl -X PUT https://api.limebase.app/v1/publishers/<id>/approved-language \ -H "Authorization: Bearer $KEY" -H "Content-Type: application/json" \ -d '{"language":"By clicking Get my quote I agree to be contacted by …"}' # Rotate it: a new key with the same settings, the old one revoked at once curl -X POST https://api.limebase.app/v1/publishers/<id>/rotate -H "Authorization: Bearer $KEY"
Put the new tag on the pages before rotating: the old key is refused from the moment of rotation.
GET /v1/consent-templates lists the consent wording library — empty until counsel has signed
wording off. Recording settings stay in the dashboard, where the notice the visitor sees is set.
MCP server
The LimeBase MCP server that creates and sends envelopes also reads LimeCert, with a key
that has the Cert scope: list_certificates, get_certificate,
get_footprint, verify_lead_fields, download_consent_certificate,
download_certificate_bundle and list_publishers. The tools are read-only by
design: claiming or rejecting a lead is a decision for your people, made where they are, not from an
assistant's tool call.
Workspace settings
| Setting | Where | Detail |
|---|---|---|
| Publisher keys | Cert → Publishers | Create, restrict to origins, revoke. A revoked key's snippet is refused from then on. |
| Approved language | Cert → Publishers | The consent wording you approved for that publisher; every certificate is compared with it. |
| Session recording | Cert → Publishers | Off by default. Turn on per publisher, with or without a notice to the visitor and its wording. |
| Alerts | Cert → Cert settings | Who gets alert emails (owners and admins unless addresses are set) and which: failed consent, high risk, silent snippet. |
| Risk threshold | Cert → Cert settings | The score at which a lead is called high risk: 70 by default, 30 to 100. It changes the label only; nothing is held or rejected. |
| Claim deadline | Cert → Cert settings | How many days a lead may wait to be claimed: 30 by default, 7 to 90. A change applies to leads that arrive from then on. |
| API keys | Settings → Developer | Give a key the Cert scope to use the footprints endpoints; the Sign scope for envelopes. One key can have both. |
Retention
- A visit that never becomes a lead is destroyed after 30 days: its sealed values, its keys, its recording. Nothing about it can be read afterwards.
- An issued, unclaimed lead is kept until its claim deadline. At the deadline it lapses: the certificate's contents, the recording and the lead's details are destroyed. The certificate's id, hashes and chain position stay, so the public verify page still says a certificate was issued and when. Lapsing is automatic and cannot be undone; the dashboard flags leads within five days of their deadline.
- A claimed lead's certificate is kept for the full retention term, counted from the claim. Retention is charged from the claim, not from issue.
- A rejected lead keeps its certificate for the full term — it is your evidence in any dispute over the lead — but its session recording is destroyed at the claim deadline.
API reference
The footprints endpoints — their requests, responses, status codes and schemas — are in the interactive reference under Footprints, generated from the same OpenAPI spec as the rest of the API.
Open the API reference → Download the OpenAPI spec
| Endpoint | What it does |
|---|---|
GET /v1/footprints/:id | Where a lead stands, with its certificate. |
POST /v1/footprints/:id/claim | Accept the lead. |
POST /v1/footprints/:id/reject | Turn the lead down, with a reason. |
POST /v1/footprints/:id/events | Report what happened to a claimed lead, with images. |
GET /v1/footprints/:id/certificate | The latest certificate as a PDF. |
GET /v1/footprints/:id/certificate.json | The latest certificate as signed JSON. |
POST /v1/certificates/:id/verify | Whether the lead fields you hold match the form, by fingerprint. |
GET /v1/certificates, /:id, /:id/pdf, /:id/json, /:id/bundle | Every certificate the workspace holds, any version, and everything on record as a zip. |
GET/POST /v1/publishers, /:id/rotate, /:id/revoke, PUT /:id/approved-language | The keys the snippet runs under, and the wording their pages should show. |
GET /v1/consent-templates | The consent wording library. |
POST /v1/envelopes with signers[].footprintId | Send the lead an envelope. It claims the lead if nobody has, and its signature is added to the record. |
Errors
Errors return a non-2xx status and a JSON body of the shape { "error": "message" }.
| Status | Meaning |
|---|---|
400 | The request was malformed: a missing reason, a bad event name, an attachment that is not an image. The message says what. |
401 | Missing, malformed, or invalid/revoked API key. |
403 | The key does not have the Cert scope, or the workspace does not have LimeCert. |
404 | No footprint by that id in your workspace, or an id that is not a footprint id. A certificate is 404 until it has been issued. |
409 | The lead is not in a state that allows the action — cannot claim this lead: it was rejected, claim this lead before reporting events about it — or the footprint named on a signer cannot be sent an envelope. |
500 | An unexpected server error. Safe to retry reads and idempotent calls. |