Certificates
Request a Contemporaneous Record Statement for a timestamped record or a set of records, with a quote before any charge.
A certificate is a dated statement about one or more sealed records, issued on request. Its printed title is "Contemporaneous Record Statement". It says when and how Esign Comply made its record, shows the time evidence that rests on parties other than Esign Comply and you, and reports a fresh integrity check run at the moment of issue.
It is not the per-record PDF. That document is the evidence report: it is generated for every record, included in every plan and never charged per download. Request a certificate only when a dispute turns on when a record was made.
In the API the object is certificate, with IDs prefixed crt_. Requests need a full_access key. read_only keys can list and download certificates. recording_access keys have no certificate access and can never incur a charge.
What the statement says
| Section | Content |
|---|---|
| Header | Printed title, certificate ID, issue time in UTC, record ID or set description, requester class, your reference marked asserted, live or test mark, verification URL and QR code |
| What is stated | A fixed paragraph (below) |
| Chronology | For each ceremony event: browser-reported time (reported, not verified) and Esign Comply server receipt time (observed), with the difference. Then record committed, receipt signed with key ID, external timestamp, checkpoint and public anchor. Every time is labeled with its source. |
| Intervals | Measured durations from the final ceremony event to commit, receipt signature, external timestamp, checkpoint and public anchor. Printed as numbers. No adjective such as "immediately". |
| Independent time bound | "The timestamp token issued by {authority} shows that this record hash existed no later than {time}. The public anchor {reference} shows that the checkpoint containing it existed no later than {time}." |
| Integrity check at issue | Record hash recomputed from stored content, receipt signature, timestamp token, inclusion proof, consistency proof to the current checkpoint, and write-once storage status. Each with its result and check time. |
| Capture mode | direct, server_only, deferred or imported, with one sentence on what that means for when the record was made |
| Later history | Annotations with times (dispute, consent withdrawal, supersession, legal hold) and earlier certificates for the record |
| Process in force | System description version, jurisdiction packs and versions applied, the time source used |
| Limits | A fixed text (below) |
| Seal | Certificate hash, signed receipt, external timestamp and ledger sequence for the certificate itself |
The fixed statement for a record captured directly from the signer's browser reads:
Esign Comply's systems created record {record ID} by an automated process. Each event in it was recorded when Esign Comply's server received it from the signer's browser session, at the server receipt time shown. Esign Comply makes and keeps records of this kind in the regular course of providing its recording service to {customer}, and making them is its regular practice. The record was sealed at {time}. On {issue time} Esign Comply recomputed the hash of the stored record and found that it matches the hash committed to the seal, the external timestamp token and the ledger checkpoint, with the results shown below. This statement was issued on {issue time}; the record it describes was made at the times shown in the chronology.
For deferred and imported records the statement does not say the record was made at or near the time of the act. It says that you reported the signing act at the receipt time, that you assert when it occurred, and that Esign Comply did not observe it. For server_only records it says the events were received from your server and not from the signer's browser.
What the statement does not say
Every certificate prints this limits text:
This statement describes when and how Esign Comply's record was made and whether it has changed since. It does not establish who the signer was, the signer's capacity or authority, that the signer read the documents, or that any agreement is valid or enforceable. Times reported by the signer's browser are reported, not verified. A court decides admissibility and weight. The automated statement is not a custodian declaration. A custodian-signed unsworn declaration is available on request where the forum permits it. This document is not a qualified certificate, a qualified electronic time stamp, or a qualified electronic seal.
The external timestamp bounds when the record hash existed. It does not show when the person acted. No free text from you appears on the statement except reference (120 characters at most), printed as "Requester reference (asserted)". IP addresses, raw device data and drawn-signature images are left out by default.
Before you request
| Record status | Result |
|---|---|
timestamped or anchored |
A certificate can be issued. If the public anchor is not available yet, its line reads "pending". |
recorded or pending_seal |
record_not_timestamped (409) with Retry-After: 30. The external timestamp normally follows within 60 seconds. |
disputed |
A certificate can be issued. The dispute appears under Later history. |
voided |
not_found |
| Locked under the earlier Starter quota rule | quota_exceeded (402). Records sealed now are not locked. |
If any integrity check fails at issue, nothing is issued. The request returns certificate_verification_failed, an integrity incident is opened, and certificate.failed is sent. Do not retry: contact support with the request ID.
Price
One unit is one issued single-record certificate, or each 100 records (or part of 100) covered by a set certificate. Issuing a certificate is not a signature event and uses no event quota.
| Plan | Included per subscription year | Price beyond the allowance | Records per set request |
|---|---|---|---|
| Free | None for live records. Test certificates are unlimited and watermarked "TEST". | Not sold | 10 (test certificates) |
| Starter, $200 per year | None | $20 per certificate, charged only when one is issued | Up to 100 |
| Unlimited, $1,200 per year | 25 | $20 per certificate | Up to 10,000 |
| Enterprise, from $10,000 per year | Unlimited | Included | By contract |
Certificates for live records are on paid plans. On the Free plan a certificate request or quote for a live record returns 403 plan_feature_unavailable. Test certificates are free and watermarked "TEST" on every plan.
The Unlimited allowance is counted per domain subscription and per subscription year. It does not roll over and cannot be moved between domains. Included units are used first. Charged certificates are invoiced monthly in arrears to the payment method on file, one line per certificate. The same numbers are in pricing.md.
| Plan | Activity in a year | Certificate cost |
|---|---|---|
| Starter | No certificates | $0 |
| Starter | 3 single-record certificates for one dispute | $60 |
| Starter | One set certificate covering 100 records | $20 |
| Unlimited | 18 single-record certificates | $0 (18 of 25 included) |
| Unlimited | 40 single-record certificates | $300 (25 included, 15 at $20) |
| Unlimited | One set certificate covering 2,500 records | $0 (25 units, all included) |
Quote, then confirm
No charge is created without a recorded confirmation: a confirming click in the dashboard, or confirm_charge: true from a full_access key. A request covered by an allowance, by an Enterprise contract or by test mode needs no confirmation.
1. Ask for a quote. POST /v1/certificates/quote accepts a certificate request body and returns what it would cost. It never issues and never charges. full_access and read_only keys can call it.
curl https://esigncomply.com/v1/certificates/quote \
-H "Authorization: Bearer $ESIGNCOMPLY_API_KEY" \
-H "Content-Type: application/json" \
-d '{ "type": "contemporaneous_record", "record_id": "rec_Z4m8" }'
{
"object": "certificate_quote",
"record_count": 1,
"units": 1,
"unit_amount": 2000,
"amount": 2000,
"currency": "usd",
"allowance_remaining": 0,
"month_to_date": 4000,
"spend_limit": 20000,
"charge_class": "charged",
"units_included": 0,
"units_charged": 1,
"requires_confirmation": true
}
Amounts are integers in the smallest currency unit: 2000 is $20.00. units_included come from your allowance and units_charged are billed. For a set, send the same filter you will use for the request: the quote counts the matching records.
2. Show the quote to a person. An administrator approves the charge.
3. Issue with confirm_charge: true.
const { data: certificate, error } = await esc.records.certify("rec_Z4m8", {
type: "contemporaneous_record",
wording: "auto",
reference: "Matter 2026-0412",
share: { expires_in: 2592000 },
confirm_charge: true, // only after an administrator approved the quote
});
if (error) throw new Error(`${error.code}: ${error.message}`);
console.log(certificate.id, certificate.pdf_url, certificate.billing.charge_class);
The same call over HTTP:
curl https://esigncomply.com/v1/records/rec_Z4m8/certificates \
-H "Authorization: Bearer $ESIGNCOMPLY_API_KEY" \
-H "Content-Type: application/json" \
-H "Idempotency-Key: cert-rec_Z4m8-matter-0412" \
-d '{ "type": "contemporaneous_record", "wording": "auto", "reference": "Matter 2026-0412", "confirm_charge": true }'
A single-record certificate is synchronous (201 Created), with a target of under 10 seconds. If the request would incur a charge and does not carry confirm_charge: true, nothing is issued and the quote comes back in the error:
{
"error": {
"type": "billing_error",
"code": "certificate_charge_unconfirmed",
"message": "This certificate costs $20.00. Resend the request with confirm_charge set to true to issue it.",
"quote": { "units": 1, "unit_amount": 2000, "amount": 2000, "currency": "usd", "allowance_remaining": 0, "month_to_date": 4000, "spend_limit": 20000, "charge_class": "charged", "units_included": 0, "units_charged": 1 },
"doc_url": "https://esigncomply.com/docs/api/errors#certificate_charge_unconfirmed",
"request_id": "req_8Wd3"
}
}
The issued certificate carries the full statement, the verification results, pdf_url, json_url and a billing object: charge_class (included, charged, enterprise, test or reissue), units, unit_amount, amount, currency, the allowance counters, month_to_date, spend_limit and confirmed_by. Treat charge_class as an open list. The full response is on the Certificates API page.
Never. Do not build a certificate request that can run without a person confirming the charge. Do not send
confirm_charge: trueby default.
Idempotency matters here. A repeat with the same Idempotency-Key and body returns the same certificate and is never charged twice. A call without a key, or with a new key, issues a new certificate with a new issue time. Earlier certificates stay retrievable and verifiable.
Sets of records
One certificate can cover many records: one statement plus a manifest that lists every record with its hash, its times and its check results. In the JSON form the manifest is under statement.manifest.
POST /v1/certificates
Authorization: Bearer esc_test_us_...
Content-Type: application/json
{
"type": "contemporaneous_record_set",
"filter": { "version_id": "dv_3kT9", "created_after": "2026-12-01T00:00:00Z", "created_before": "2027-06-01T00:00:00Z" },
"wording": "US-NY",
"reference": "Arbitration clause, first half of the term",
"confirm_charge": true
}
The call returns 202 Accepted with status: "processing" and a billing object with the unit count. The certificate.issued webhook carries the certificate ID when it is ready, or poll GET /v1/certificates/{id}. The target is under 10 minutes per 1,000 records.
- The filter is one of
record_ids[],signer_external_id,document_idorversion_id, each optionally bounded bycreated_afterandcreated_before. - A set of 250 records is three units. A set that needs more units than your allowance has left uses what remains and charges the rest. The quote shows both numbers.
- A request above your plan's set size returns
certificate_set_too_largewith the count. - Records that fail a precondition are listed in the manifest as excluded, with the reason. They are never silently dropped.
- Set certificates identify signers by external ID only.
- A filter that matches no records returns
400 invalid_request. - At most five set jobs run per domain at a time. A sixth returns
rate_limit_exceededwithRetry-After. - If an integrity check fails during the job, the certificate ends with
status: "failed"and afailureobject,certificate.failedis sent, and nothing is charged.
Spend limit
Each domain has a monthly certificate spend limit: $200 by default. An owner can set it from $0 to $5,000 in the dashboard, or higher on request. A limit of $0 switches paid certificates off. Through the API, send certificate_spend_limit in cents to PATCH /v1/domains/{id} with a full_access key.
- A request that would pass the limit returns
certificate_spend_limit_reachedand issues nothing. - A charged certificate on a domain with no valid payment method returns
payment_method_required. The same code is returned while an invoice for the domain is unpaid. Certificates already issued stay valid and verifiable, and recording, evidence reports and verification are not affected. - Owners are notified at 80% and 100% of the limit, and the
certificate.spend_threshold_reachedwebhook is sent. GET /v1/usagereportscertificates: { included, used, remaining, charged_units, resets_at, charged_month_to_date, spend_limit, unit_amount }.
What is not charged
- Test-mode certificates.
- A request that is refused or fails, including a set job that fails.
- Downloads, JSON retrieval, share links and verification of an issued certificate.
- An idempotent repeat.
- One re-issue for the same record or set within 30 days of a certificate whose public-anchor line read "pending". Send
reissue_of: "crt_7Hd2". - A certificate re-issued to correct an Esign Comply error.
Only you pay Esign Comply. A signer, the holder of a share link or any other reader is never charged, and opening or verifying an issued certificate is free for everyone. Certificate charges are not refunded on a plan change or a cancellation.
Share links
A share link lets someone outside your account open the certificate and run verification without signing in.
- Create one with
share: { "expires_in": 2592000 }on the request, or later withPOST /v1/certificates/{id}/share.expires_inis in seconds: 60 at least, 90 days at most, 30 days when omitted. Only an issued certificate can be shared. - The response carries
share_urlandshare_expires_at. The link carries an access secret in the URL fragment, which browsers do not send to servers. The secret is shown once and stored only as a hash, so keep the URL. - Revoke every active link for a certificate with
DELETE /v1/certificates/{id}/share. Opens are counted and shown on the certificate undershare. - Without the certificate file or the secret, a certificate ID reveals nothing.
curl https://esigncomply.com/v1/certificates/crt_7Hd2/share \
-H "Authorization: Bearer $ESIGNCOMPLY_API_KEY" \
-H "Content-Type: application/json" \
-d '{ "expires_in": 2592000 }'
{
"object": "certificate_share",
"certificate_id": "crt_7Hd2",
"id": "shr_2Lp7",
"share_url": "https://esigncomply.com/verify/c/crt_7Hd2#<secret>",
"share_expires_at": "2026-12-21T18:40:02.117Z"
}
Third parties do not request certificates. You issue one and share it.
Wording variants
wording is auto (the packs applied on the record) or a pack code that names the forum's variant, for example a record made under US-CA with a dispute before a New York court. A code that is not in the catalogue returns jurisdiction_unknown. It changes the statement paragraph only: the timing wording, the declaration form and the notice reminder. The underlying facts do not change, and wording never changes ceremony rules.
include is empty by default. ["supplements"] adds a list of customer-supplied material for the record under the sentence "The following material was supplied by {customer}. Esign Comply received it at the times shown and did not verify its contents." ["network"] adds network facts where they were captured and you confirm the need. It is refused with certificate_field_unavailable for records that hold no network facts, which includes every record made under EU minimal capture.
Custodian-signed form
type: "custodian_certification" requests a separate service: a named Esign Comply records custodian reviews the automated statement and signs a dated, unsworn declaration, printed as "Certification of Custodian of Records", with the automated statement attached as an exhibit.
- It is asynchronous. The request returns
202 Acceptedwithstatus: "requested"and aserviceobject that restates the form, the delivery target and the price.statusthen moves throughin_reviewtoissued. The target is 5 business days. - It is a live-mode service on paid plans. In test mode, and on the Free plan, the request returns
plan_feature_unavailable. - Price: Starter $250 per request. Unlimited: 5 included per subscription year, then $250 per request. Enterprise: by contract. It does not use the certificate allowance.
- It covers facts Esign Comply observed and records it made. It does not cover facts you asserted or who the signer was.
- A notarized affidavit is not offered.
Test mode
Certificates for test records are free, carry the "TEST" watermark, are sealed with the test key and are not anchored publicly. billing.charge_class is test. Use them to build and review the request flow, including the quote step, before go-live. See Test mode.
Signer-requested certificates (Planned)
Planned.
POST /v1/receipts/{receipt_token}/certificatesis not part of the current API.
A signer would request a certificate for their own record from the signer view. The option is off unless you enable it per profile. When on, each request uses your allowance or is charged to you within the spend limit, never to the signer. Until then such a request is refused with signer_certificates_disabled.
Standing issue (Planned)
Planned. The Enterprise profile option
certify_on_anchoris not available yet.
It would issue the automated statement when a record reaches anchored and add it to the evidence package. On Starter and Unlimited every certificate is requested and confirmed one at a time.
Related
- Evidence for the seal, the timestamp and the checkpoint the statement reports on.
- Verification for checking a certificate offline with
esigncomply-verify. - Certificates API for every endpoint and field.