# Evidence

> How a record is canonicalized, chained, sealed, timestamped and anchored, and what the receipt, the evidence report and the evidence package contain.

Source: https://esigncomply.com/docs/concepts/evidence

An Esign Comply record is meant to be evidence you can check without trusting Esign Comply's servers or your own. This page describes what makes it so: the layers of independence, the sealing pipeline, and the three artifacts you can hold: the receipt, the evidence report and the evidence package.

Records are tamper-evident: any change to the stored record after sealing is detectable. That is a statement about integrity and time. It does not establish who acted or when the act actually occurred.

## The independence model

| Layer | What it establishes | Who can defeat it |
|---|---|---|
| Direct browser channel | Esign Comply received a request from the signer's device at a stated time, on the registered domain, carrying the stated ceremony events | A customer that scripts a fake browser. Mitigated by L2 verification and the signer receipt. |
| Independent verification (L2, L3) | A person controlling the stated email address, phone number or passkey took part in the ceremony | Someone with access to the signer's mailbox, phone or device |
| Signer receipt | The signer was sent a copy and a verification link by a third party. Disputes are recorded. | Non-delivery, which is recorded as a bounce |
| Registered document version | The text is fixed and hashed before the ceremony. The record names the hash. | No one after publication: the version is immutable |
| Seal | The record has not changed since Esign Comply signed it | Compromise of the sealing key. Mitigated by external timestamps and anchoring. |
| External timestamp | The record hash existed no later than the time stated by an outside timestamp authority | Compromise of the authority |
| Ledger and public checkpoints | Records cannot be removed, reordered or back-dated without detection, including by Esign Comply staff | Collusion that also rewrites externally published checkpoints |

Limits stated on every evidence report and certificate: Esign Comply did not see the signer's screen as a human would, did not verify legal identity, and did not review the agreement's content.

## Sealing pipeline

| Step | Action | Timing |
|---|---|---|
| E1 Canonicalize | Serialize the record with the JSON Canonicalization Scheme (RFC 8785), add a random 256-bit salt, and compute SHA-256 over the salt followed by the canonical bytes | In the completion request |
| E2 Chain | Insert a ledger entry containing the record hash and the hash of the previous entry for the same domain. The ledger is append-only. | Same database transaction as the record |
| E3 Seal | Sign a receipt (JWS, ES256) over record ID, record hash, signed-at time, domain, ledger sequence and previous-entry hash. The private key stays in a managed key service. | In the completion request |
| E4 Timestamp | Request an RFC 3161 timestamp token over the record hash from an external timestamp authority. Two authorities are configured, with automatic failover. | Asynchronous, target under 60 seconds |
| E5 Batch | Add ledger entries to a per-region Merkle tree (RFC 6962 construction). Sign a checkpoint: tree size, root hash, previous root, time. Checkpoints chain. | Every 60 seconds |
| E6 Anchor | Timestamp checkpoint roots externally and write batch bundles to restricted write-once storage. Publish non-identifying aggregate commitments as public anchors. | Checkpoints every 60 seconds; public anchors hourly |
| E7 Prove | Compute and store the inclusion proof for each record against its checkpoint | After E6 |

A record is complete evidence at E3. E4 to E7 add independent proof of time and of non-removal. The hash covers every event, every document hash and the profile version.

Quota never blocks completion of a session that has been created. If the signing key service cannot be reached, the record is still committed, the response carries `status: "pending_seal"` and `receipt: null`, and the receipt is signed within 60 seconds.

## Record states

| `status` | Meaning | Webhook |
|---|---|---|
| `pending_seal` | Committed. The receipt is not signed yet. | None |
| `recorded` | The receipt is signed (E3) | `record.completed` |
| `timestamped` | The external timestamp token is attached (E4) | `record.timestamped` |
| `anchored` | Included in a signed checkpoint and a public anchor (E5 to E7) | `record.anchored` |
| `disputed` | The signer used "This was not me". The seal state underneath is unchanged. | `record.disputed` |
| `voided` | Test record purge or erasure completed. Reads return `404`. | None |

When your server confirms a record, accept `recorded`, `timestamped` or `anchored`. See [Server confirmation](https://esigncomply.com/docs/guides/server-confirmation.md).

> **Test mode.** Test records run the full pipeline against a separate test ledger and a test signing key. For a test record made on the Free plan no external timestamp authority is contacted: the timestamp step is simulated and is not evidence of time. Reports carry a "TEST" watermark and the statement that no attestation is given. Test records are deleted after 30 days. Live records on the Free plan go through the whole pipeline above, external timestamp included.

## Receipt

A receipt is the compact proof you can store in your own database and present later. It is a JWS signed with ES256. Public keys, current and retired, are at `/.well-known/jwks.json`.

```json
{
  "header": { "alg": "ES256", "kid": "esc-us-live-2026-11", "typ": "esc-receipt+jwt" },
  "payload": {
    "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
  }
}
```

| Claim | Meaning |
|---|---|
| `iss` | Issuer |
| `rid` | Record ID |
| `dom` | Registered domain the record is bound to. Test records made without a registered domain use `sandbox:<domain id>`. |
| `hash` | Record hash |
| `iat` | Signed-at time: server receipt time of the final event, in seconds |
| `lvl` | `signature_level`: `simple` or `not_applicable` |
| `asr` | Assurance level: `L1`, `L2` or `L3` |
| `seq` | Sequence of the record's entry in the domain ledger |
| `prev` | Hash of the previous ledger entry for the domain |
| `live` | `true` for live records. A receipt signed by a test key never verifies as live evidence. |

The receipt comes back from `ceremony.complete()` in the browser and from `GET /v1/records/{id}/receipt` on your server. Store it in your own acceptances table next to the record ID. Anyone who holds the full receipt can check it with `POST /v1/verify`. See [Verification](https://esigncomply.com/docs/concepts/verification.md).

Annotations, supplements and certificates get their own receipts (`typ: "esc-subject-receipt+jwt"`) and their own ledger entries.

## Evidence report

The evidence report is the human-readable PDF generated from the sealed record: `GET /v1/records/{id}/report`. It is included for every record on every plan and is never charged per download. Regenerating it yields the same content. It is produced in English.

| Section | Content |
|---|---|
| Header | "Electronic Signature Evidence Report" or "Electronic Acceptance Evidence Report", record ID, verification URL and QR code, live or test mark |
| Parties | Organization legal name and registered domain; signer details, each field labeled observed or asserted |
| Documents | Title, version label, language, content hash |
| Signature or Acceptance | Method, classification, assurance level, exact label and button text. IP address, raw device data and drawn strokes are omitted by default. |
| Timeline | Server-received time and browser-reported time for each event, kept distinct. The timestamp token time is never labeled as signing time. |
| Presentation | The measured assent region where it was captured, otherwise the registered artifact and its provenance |
| Disclosures and consent | Where applicable: disclosure version, access demonstration, consent, withdrawal status |
| Delivery | Receipt email time and status |
| Integrity | Record hash, sealing key ID, timestamp authority and time, ledger sequence, checkpoint ID |
| Later history | Annotations with times |
| Rules applied | Packs applied with versions and reasons, the asserted signer region and governing law, the rules fired. Conditions in advise are shown as evaluated, not enforced for this record. |
| Limits | "Our signature or seal, if present, authenticates this evidence artifact only. It is not the person's signature, a qualified certificate, or a determination of identity, authority, compliance or enforceability." |
| Asserted at signing (Part B) | Facts you supplied with the session |
| Customer-supplied material (Part C) | A list of supplements with both times and hashes |

What the report never states:

- That the agreement is valid or enforceable. It states what was recorded.
- That a rule check passed or failed as a judgment. Measurements are printed. Advisory pass or fail results are not.
- Anything about your obligations or recommendations, or whether you performed any duty.
- That the signer read a document.

The word "certificate" is reserved for the on-request Contemporaneous Record Statement. See [Certificates](https://esigncomply.com/docs/guides/certificates.md).

A `recording_access` key cannot download reports or packages, so a leaked application key cannot export stored evidence. Use a `full_access` or `read_only` key. Records sealed now are never locked for reports, packages or certificates. A record that was locked under the earlier Starter quota rule returns [`quota_exceeded`](https://esigncomply.com/docs/api/errors.md#quota_exceeded).

## Evidence package

The evidence package is a ZIP archive with everything needed to verify the record offline: `GET /v1/records/{id}/evidence`. By default the response is JSON with a signed download `url` that expires in 600 seconds. `?inline=true` returns the archive itself when it is under 4 MB. `?supplements=false` leaves out the customer-supplied folder.

| File | Content |
|---|---|
| `manifest.json` | Package format, record ID, generation time, and the SHA-256 and size of every other file |
| `record.json` | The canonical record: exactly the bytes that were hashed |
| `seal.json` | Record hash, salt, status, issuer, key ID and the ledger entry |
| `receipt.jws` | The signed receipt |
| `keys/jwks.json` | Public sealing keys valid at seal time |
| `timestamp.tsr`, `timestamp.json` | The RFC 3161 timestamp token and a readable summary, when timestamped |
| `validation/tsa-chain.pem`, `validation/policy.json` | Certificates embedded in the token; the validation policy the package was produced under |
| `inclusion-proof.json` | Merkle inclusion proof and the signed checkpoint, when checkpointed |
| `anchors.json` | Public anchors covering the checkpoint, when anchored |
| `documents/` | `manifest.json` and the exact stored bytes of each document version |
| `notice/` | The captured notice data and the serialized assent region, when captured. Never execute it. |
| `report.pdf` | The evidence report |
| `annotations.json` | Later facts with their own seals |
| `customer_supplied/` | `manifest.json` and supplement content as received, kept apart from `record.json` |
| `rules.json` | Packs, rules fired with each condition's state (`enforce` or `advise`) and result, guidance release, API version |
| `VERIFY.md` | Manual verification steps and the verifier command |

Run `npx esigncomply-verify rec_Z4m8.zip` to check a package. The format and each check are described in [Verification](https://esigncomply.com/docs/concepts/verification.md).

## What a record pins

A sealed record is fixed. It pins the API version, the profile version, the pack versions applied with their reasons, the guidance release, and each record condition's state and result. Nothing published later changes it. Later facts are added beside it, never inside it:

| Addition | What it is | In the sealed hash |
|---|---|---|
| Annotation (`ann_...`) | A later fact Esign Comply observes or enforces: `disputed`, `consent_withdrawn`, `electronic_transactions_refused`, `paper_copy_requested`, `superseded`, `legal_hold`, `erased`, `note` | No. Own ledger entry and receipt. |
| Supplement (`sup_...`) | Customer-supplied material | No. Own ledger entry and receipt. |
| Certificate (`crt_...`) | An on-request statement about the record | No. Own ledger entry and receipt. |
| Conformance results | Advisory findings | No. The measurements behind them are sealed inside `events[]`. |

## Signer receipt and disputes

When the signer's email is known and receipts are enabled, Esign Comply sends the signer a receipt from its own domain, with a copy and a verification link. The receipt contains a "This was not me" link. Using it adds a `disputed` annotation, sends `record.disputed` to you, and shows the dispute on the evidence report. Esign Comply does not adjudicate disputes. Bounces are recorded and sent as `record.copy_bounced`.

## Retention in brief

- Evidence content is kept for up to 10 years while you are subscribed. That is standard capacity, not a legal term. EU customers choose a documented schedule.
- Where a rule records a retention floor on the record (`retention_floor`), content is not deleted before the floor expires. The longest floor among applied packs wins.
- Bulk export of all evidence packages is available at any time on every paid plan. After cancellation, records remain exportable for 12 months.
- Erasing a signer removes the content and leaves the hash, the seal and the ledger entry. Reads then return `content_available: false`.
- Sealing keys are rotated annually. Retired public keys stay published permanently.
- The verifier is open source, and exported packages verify offline with the bundled keys.

The statutory retention duty usually sits with you. Keep your exported copies where another law requires you to keep a record.
