How a signing record stays tamper-evident, step by step
You vibe coded the signing page. Good. This page is about what happens behind it. Each record goes into an append-only, hash-chained ledger: entries are only ever added, and any change breaks the chain, the signature and the outside timestamp. Here is every step, and how anyone checks the result offline.
{
"iss": "https://esigncomply.com",
"rid": "rec_Z4m8",
"dom": "example.com",
"hash": "sha256:5be7...",
"iat": 1795273400,
"lvl": "simple",
"asr": "L1",
"seq": 18244,
"prev": "sha256:a91c...",
"live": true
}Seven steps from the signer's click to a sealed record
The first three finish inside the request that completes the signature. The record is evidence from that moment. The next four add proof of time and proof that nothing was removed.
A record moves through three states as the steps complete. Your server gets a webhook at each one: record.completed, record.timestamped, record.anchored.
- 01Canonical JSON, then a salted SHA-256 hashThe record is serialized as canonical JSON (RFC 8785), so the same record always gives the same bytes. We add a random 256-bit salt and compute
SHA-256(salt || record.json). The hash covers every event, every document hash and the profile version. - 02An entry in a ledger that only appendsIn the same database transaction, an entry is added to the ledger for your domain. It holds the record hash and the hash of the entry before it. Application roles cannot update or delete an entry.
- 03A receipt signed with keys you do not holdWe sign a receipt (JWS, ES256) over the record ID, the record hash, the signed-at time, your domain, the ledger sequence and the previous-entry hash. The public keys, current and retired, are published at
/.well-known./jwks.json - 04A timestamp from an outside authorityAn RFC 3161 timestamp authority outside Esign Comply issues a token over the record hash. It states that this hash existed no later than the authority's time. The target is under 60 seconds after signing.
- 05A Merkle log with a signed checkpoint each minuteLedger entries become leaves of a per-region Merkle tree (the RFC 6962 construction). Each minute we sign a checkpoint: tree size, root hash, previous root, time. Checkpoints chain to each other.
- 06A public anchor each hourEach hour a commitment to the checkpoints goes to a public anchor outside Esign Comply. It holds hashes only. From then on, rewriting the ledger means contradicting something already public.
- 07An inclusion proof for your recordWe compute the path from your ledger entry to its checkpoint root. The evidence package carries that proof with the receipt, the timestamp token and the public keys.
What immutable means here: what breaks when something changes
Immutable here is something you check, not something you take on trust. The ledger only grows, and every way of changing the past is caught by a check that someone outside Esign Comply can run. That includes changes made by Esign Comply staff.
| If someone… | What breaks | Reported by |
|---|---|---|
| Edits one field of the stored record | SHA-256 over the salt and the record bytes no longer equals the hash in the seal. | Record hash |
| Recomputes the hash after the edit | The receipt names the original hash, and its ES256 signature covers that hash. | Receipt |
| Signs a new receipt with a key of their own | The key is not one of the sealing keys published at /.well-known. | Receipt, with --jwks |
| Says the record was made at another time | The RFC 3161 token covers this exact hash and carries the outside authority's own time. | Timestamp |
| Deletes or reorders a ledger entry | Every entry names the hash of the one before it, and every checkpoint names the previous root. The chain stops recomputing. | Inclusion proof, and consistency proofs from the public log |
| Rewrites the ledger and signs new checkpoints | The new roots match neither the checkpoints already inside exported packages nor the public anchor published each hour. | The public log and the public anchors |
A sealed record is fixed. Later facts, such as a signer's dispute or a withdrawal of consent, are added beside it as their own ledger entries with their own receipts. Nothing is written inside it.
Edit a row. Then edit a record.
The same one-line change, made to an acceptance in your own table and to a record in an exported package.
Your row accepts the edit
update public.acceptances set accepted_at = '2026-11-21 15:03:20+00' where user_id = 'user_7c1d'; -- UPDATE 1
- Postgres does what it is told. The row now says whatever the statement said.
- No other system holds a second copy to compare against.
- A hash column next to it can be updated by the same statement.
The record reports it
$ npx esigncomply-verify rec_Z4m8.zip Evidence package rec_Z4m8 FAIL Manifest Record.json does not match its sha256. FAIL Record hash Sha256(salt || record.json) is sha256:c41d…, seal.json states sha256:5be7…. Result: NOT VERIFIED (failed: Manifest, Record hash)
- The recomputed hash differs from the hash in the seal.
- The receipt still names the original hash, and you cannot sign a new one.
- The outside timestamp and the checkpoint cover the original hash too.
Your table trusts whoever holds the password. The record trusts arithmetic.
Verify an evidence package offline
Anyone you give the package to runs esigncomply-verify on their own machine. It checks the package with public keys and the timestamp authority's certificates only, and it keeps working if neither Esign Comply nor your company is around to ask.
# Download the package (the response holds a short-lived signed URL) curl -s https://esigncomply.com/v1/records/rec_Z4m8/evidence \ -H "Authorization: Bearer $ESIGNCOMPLY_API_KEY" | jq -r .url | xargs curl -s -o rec_Z4m8.zip # Verify with the keys bundled in the package npx esigncomply-verify rec_Z4m8.zip # Verify against the published keys and your own timestamp trust anchors npx esigncomply-verify rec_Z4m8.zip \ --jwks https://esigncomply.com/.well-known/jwks.json \ --tsa-roots roots.pem
Evidence package rec_Z4m8 Mode: LIVE PASS Manifest 17 files are present and match manifest.json. PASS Record hash sha256:5be7… = sha256(salt || record.json). PASS Receipt ES256 signature by key esc-us-live-2026-11 (live), checked against the keys supplied by the caller; … PASS Ledger entry Entry 18244 of the live ledger recomputes to sha256:… and names the record hash. PASS Timestamp RFC 3161 token over the record hash, 2026-11-21T15:03:22.000Z, signed by "…", serial … PASS Timestamp authority chain Chain: … (trust anchor). Valid at 2026-11-21T15:03:22.000Z. PASS Inclusion proof The ledger entry is leaf 48121 of 48130 under signed checkpoint chk_… PASS Documents 2 of 2 document files match the content hashes sealed in record.json. SKIP Annotations The package holds no annotations. SKIP Customer-supplied material The package holds no customer-supplied material. Result: VERIFIED
# The record hash, recomputed with nothing but the standard library import base64, hashlib, json seal = json.load(open("seal.json")) salt = base64.urlsafe_b64decode(seal["salt"] + "==") print("sha256:" + hashlib.sha256(salt + open("record.json", "rb").read()).hexdigest()) print(seal["record_hash"]) # the two lines must be equal
# The latest signed checkpoint. Public, hashes only. curl https://esigncomply.com/v1/log/checkpoint # A proof that a larger tree only appends to a smaller one curl "https://esigncomply.com/v1/log/proof?first=48130&second=52004"
No account, no network
The verifier fetches nothing unless you pass an https URL to --jwks.
Open source
MIT licensed, a command-line tool and a library on Web Crypto. Read every check it runs.
Your own trust anchors
Pass --jwks to check signatures against the published sealing keys, and --tsa-roots to chain the timestamp to a root you chose.
A plain result
Each check prints PASS, FAIL or SKIP with the reason. A skipped check is never counted as a pass. The exit code is 0 only when verified.
Test records run the same pipeline with a test key, and the verifier labels them as test. On the Free plan a test record gets a simulated timestamp. Live records on every plan, Free included, get the outside timestamp. Read the verifier docs.
When someone says you wrote the record afterward
The customer disputing an auto-renewal has a second line of attack: you run the database, so you could have created the acceptance last week. Here is what you can answer.
With a row in your own table
- A backdated insert and an honest one produce the same row.
- Your database logs and backups are yours too.
- The answer comes down to your word that you did not.
With the sealed record
- They run
npx esigncomply-verify rec_Z4m8.zipon their own machine, against the published keys. - The outside authority's token states that this exact record hash existed by 15:03:22 UTC on the day of signup.
- The ledger entry sits at sequence 18244, under a checkpoint signed that same minute, between the entries made before and after it.
The record lets you show what was presented, what the signer did and when, and that none of it changed since. Who keeps it matters as much as how it is sealed. Read why a third party keeps the record.
You build the page. This runs behind it.
None of the steps above is code you write. Your AI tool builds the interface and calls complete(), and the sealing happens on our side when the signer finishes.
Seal a test record
Create a session, attach the SDK to your own checkbox and button, and download the evidence package for the record it returns.
Read the quickstartBuild the interface with a prompt
Generate one prompt for Cursor, Claude Code, v0, Lovable, Bolt or Replit. Building a full signing product is the same call, once per signer.
Every record is sealed this way
The receipt, the evidence report and the evidence package are included on every plan, with no charge per download. The Free plan covers 10 live signatures a month and a full test mode.
See pricingWhy this is the part not to vibe code
- The main argumentVibe code the interface, not the recordWhat to build with your AI tool, and the two parts to hand off.Read it
- Who keeps itWhy a third party keeps the recordYou are a party to the agreement. See what changes when someone who is not holds the evidence.Read it
- What goes wrong7 things AI coding tools get wrongPre-checked boxes, vague notices, links to terms that change, and four more, each as code with the fix.Read it
Questions about tamper-evident records
What makes a signing record tamper-evident?
Any change to it is detectable. Esign Comply hashes the canonical record with a salted SHA-256, chains that hash into an append-only ledger, signs a receipt over it with ES256 keys you do not hold, and gets an RFC 3161 timestamp from an outside authority. Change one byte and the hash, the signature and the timestamp stop matching.
Is the record immutable?
The ledger is. Entries are only ever added, each entry names the hash of the one before it, and a signed Merkle checkpoint each minute plus a public anchor each hour fix the order. Later facts, such as a signer's dispute, are added beside a record as entries of their own and never written inside it.
Evidence and verification referenceHow do I verify a record without trusting Esign Comply?
Export the evidence package and run npx esigncomply-verify rec_Z4m8.zip. The open-source verifier recomputes the record hash, the receipt signature, the ledger entry, the timestamp token and the Merkle inclusion proof with public keys only. It needs no account and no network access.
Verification in the docsWhat is an RFC 3161 timestamp, and why does the record have one?
It is a signed token from a timestamp authority stating that a given hash existed no later than the authority's time. Esign Comply requests one over each live record hash from an authority outside Esign Comply, so the time on the record rests on neither your server's clock nor ours.
Can I read the public log myself?
Yes. GET /v1/log/checkpoint returns the latest signed checkpoint, and GET /v1/log/proof returns inclusion and consistency proofs. Both endpoints are public and return hashes only. Compare the checkpoint inside an evidence package with the log to see that the log still extends the tree your record was sealed in.
Seal a test record with the quickstartSeal every signature. Check any of them yourself.
Free plan: 10 live signatures a month and a full test mode. No card required.