API Reference
REST API for programmatic timestamping — use your API key from Settings → API Keys
Authentication
/auth/registerpublicCreate a new user account and a new organisation tenant. The response carries no token: the account activates at first login, after the emailed verification link (valid 48 hours) is clicked. Some new organisations are reviewed before first use: the response then has pendingReview: true, sign-in answers 403 tenant_pending_review until the review is done, and the owner is emailed with the outcome. Person and organisation name are required; disposable email domains are rejected. Existing organisations are joined through an invitation or verified identity-provider flow, never by supplying a matching email domain at signup.
Request body
{
"name": "string",
"email": "string",
"password": "string (min 10)",
"organisationName": "string"
}Response 200
{
"message": "Account created. Check your inbox…",
"email": "string",
"pendingReview": false
}/auth/loginpublicAuthenticate and receive a JWT.
Request body
{
"email": "string",
"password": "string"
}Response 200
{
"token": "<jwt>",
"userId": "uuid",
"email": "string",
"tenantId": "uuid|null"
}/auth/refreshJWTRe-issue a JWT with the latest tenant context. Call after creating an organisation.
Response 200
{
"token": "<new jwt>"
}/auth/meJWTReturn the current user's profile decoded from the JWT.
Timestamping
Timestamp and verification endpoints accept digests and TSR evidence only. Deprecated full-file stamp/verify and raw TSA proxy endpoints have been removed.
/tsa/stamp-hashJWT / API keyTimestamp a document by its hash. Compute SHA-256 (or SHA-384 / SHA-512) of the file locally — only the digest is sent to Sigill. The file never leaves your machine. This is how RFC 3161 is meant to work.
Request body
{
"hashHex": "hex digest — SHA-256 (64 chars), SHA-384 (96), or SHA-512 (128)",
"tsaSlug": "qualified=false: auto | byot:<id-or-slug>; qualified=true: qualified option where available",
"label": "string (optional)",
"force": "boolean — re-stamp an already-stamped hash (default false)",
"qualified": "boolean — request an eIDAS-qualified timestamp (default false)",
"sealOperationId": "uuid (optional) — ties the stamp to one of your seal operations; used by the SDK's delegated PAdES flow to register the archival DocTimeStamp on the seal's evidence record",
"reminders": "inherit | on | off (optional) — expiry-reminder policy for the created evidence; default inherit follows the organisation setting",
"reminderDays": "30 | 60 | 90 | 180 (optional) — threshold override when reminders is on",
"secondaryHashHex": "hex digest (optional) — the SAME content under a DIFFERENT supported algorithm (e.g. SHA-512 alongside a SHA-256 primary). Recorded as a CLIENT ASSERTION: Sigill never sees the content and no timestamp covers this digest, so it does not by itself carry evidentiary weight — it is captured while you still hold the original as input for future algorithm-migration protocols, and exported as such in the audit package. If the hash was already stamped: an empty secondary is filled in, an identical one is a no-op, a conflicting one returns 409",
"tags": [
"string[] (optional) — up to 10 distinct tags to attach to the evidence at creation; more than 10 in the request is a 400. When the evidence already carries tags, inserts stop silently at the 10-tag cap. With sealOperationId, tags attach to the SEAL's document hash — the evidence the list shows — not the timestamp imprint"
]
}Response 200
{
"serial": "string",
"genTime": "ISO 8601",
"hashAlgorithmOid": "OID string",
"hashHex": "hex string",
"tsrBase64": "base64 .tsr token",
"tsaName": "string — timestamp token issuer metadata or customer authority label",
"qualified": "boolean",
"policyOid": "string | null — present when qualified: true"
}tsaSlug is "auto". Sigill may use multiple timestamp sources internally for reliability and failover; customers do not select individual Sigill-managed standard sources. Standard mode never routes to an eIDAS qualified option unless qualified: true is explicitly sent, and a standard response carrying a qualified policy is rejected rather than returned or stored. See Automatic TSA selection. If your organisation has already stamped this hash, the existing record is reused; force: true creates a second independent proof. Other organisations' records never affect yours — every organisation always gets its own evidence record.You can also point
tsaSlug at one of your verified tenant-private BYOT references from Timestamp Authorities when you need to use a customer-managed TSA endpoint.Qualified stamps (
qualified: true) route exclusively to eIDAS Qualified Trust Service Providers on the EU Trust List. With tsaSlug: "auto" (or "qualified") Sigill uses its primary qualified provider and fails over to the next one if it is unavailable; a token that does not carry a qualified policy is never returned. The response names the authority that signed (tsaName). Naming one qualified option in tsaSlug pins it: one attempt, no failover. Qualified stamps are counted separately: the Free plan receives three lifetime trial credits, while paid plans use their monthly qualified quota. Response 502 — all TSAs failed (auto)
{
"message": "All Sigill-managed timestamp sources failed.",
"attemptsTried": 3,
"failures": [
{
"source": "standard-pool-1",
"errorClass": "timeout",
"statusCode": null,
"message": "Request timed out after 10s",
"latencyMs": 10042
}
]
}Response 402 — quota exceeded
{
"message": "Monthly stamp limit of 50 reached. Upgrade your plan to continue."
}/tsa/restampJWT / API keyArchival renewal — never the original file. Profiled rfc4998-v1 chains renew natively per RFC 4998 §5.2: the new token covers the previous timeStamp content (for chains of three or more, the cover-all tree root over every predecessor), same digest algorithm throughout; a profiled chain whose links cannot be proven native fails with 409, never silently degraded. Legacy chains hash the previous full TimeStampResp (RFC 3161 §4 re-stamping). Qualification is inherited from the chain's origin by default: a qualified original renews via a qualified service (billed against your qualified quota), a standard original via the standard pool — so future renewals never downgrade the evidence. Links created before inheritance existed, or via an explicit override, may still be standard; each link's policy is visible in the chain. Pass qualified to override explicitly. A required qualified renewal that fails against the providers (network, auth, outage) returns 503 and is never silently downgraded. When every service answers validly but none extends the current horizon — typical for a fresh chain whose tip already carries the pool's longest cert — the response is instead 409 renewal_not_beneficial with the current horizon: the evidence is healthy, nothing is stored or billed, and no action is required (a standard downgrade is not suggested — it is not the answer to a healthy chain). Use before the renewal horizon passes.
Request body
{
"transactionId": "uuid — the record to restamp",
"tsaSlug": "auto | byot:<id-or-slug>",
"qualified": "boolean (optional, tsaSlug=auto only — combined with a BYOT slug the request is a 400) — override the inherited qualification: true forces a qualified renewal, false explicitly accepts a standard one; omitted = inherit from the chain's origin"
}Response 200
{
"id": "uuid",
"parentTransactionId": "uuid",
"tsaName": "string",
"genTime": "ISO 8601"
}tsaSlug: "auto" for Sigill-managed standard timestamping. Use a verified BYOT timestamp authority when you need to restamp through a customer-managed TSA endpoint. /tsa/verify-hashpublicVerify a file against a TSR by its hash. The server validates the TSR token signature and timestamping certificate usage as well as the hash match. Call /tsa/inspect first to find the recorded hash algorithm, then compute that hash locally. The file never leaves your machine.
Request body
{
"fileHashHex": "hex digest of the file (algorithm from /tsa/inspect)",
"tsrBase64": "base64 .tsr token"
}Response 200
{
"valid": true,
"message": "File matches the timestamp.",
"details": {
"serial": "string",
"genTime": "ISO 8601",
"hashAlgorithmOid": "string",
"claimedHashHex": "string",
"providedHashHex": "string",
"hashMatch": true,
"tokenSignatureValid": true
}
}/tsa/inspectpublicParse and return the contents of a TSR token without verifying against a file. qualified only says the token's policy claims the ETSI qualified arc (0.4.0.2023.*) — a claim, not proof. lotlQualified is true only when all three hold: the policy is that qualified arc, the token's signature verifies with its own timestamping certificate, and that certificate is listed as a qualified timestamp service (TSA/QTST) on the EU trusted lists — the same rule as lotlQualified on the evidence chain.
Request body
{
"tsrBase64": "base64 .tsr token"
}Response 200
{
"serial": "string",
"genTime": "ISO 8601",
"hashAlgorithmOid": "OID string",
"hashHex": "hex",
"tsaPolicyOid": "OID string | null",
"ordering": false,
"certNotBefore": "ISO 8601",
"certNotAfter": "ISO 8601",
"qualified": "bool — policy claim only",
"lotlQualified": "bool — qualified policy AND verified signature AND TSA/QTST listing"
}Automatic TSA selection
Pass tsaSlug: "auto" to /tsa/stamp-hash for Sigill-managed standard RFC 3161 timestamping; /tsa/restamp with auto additionally inherits the chain origin's qualification (see below). Seal operations with qualified: false via /seal/sign use the same path; passing qualified: true embeds a qualified RFC 3161 timestamp inside the seal — the seal itself remains an advanced electronic seal (AdES) regardless. Verified tenant-private BYOT authorities may be selected explicitly when you need to use a customer-managed endpoint. If the saved credentials for a BYOT authority can no longer be read, stamping answers 409 credentials_unreadable: an owner re-enters them under Settings → Timestamp authorities.
How it works
- Managed standard pool. Sigill may use multiple timestamp sources internally for reliability and failover. The exact internal source is not customer-selectable unless you configure BYOT.
- Failover on the same request. If an internal source fails, Sigill can try another source before returning an error. The caller only sees the final outcome.
- BYOT stays customer-managed. Verified tenant-private timestamp authorities are selected by their BYOT reference. If one returns a token carrying a qualified policy, standard mode rejects that response.
- Every internal failure is logged. Errors are stored with classification (
network,timeout,http_status,parse) for Sigill operations monitoring.
When to use auto
Default to auto in production. Use a verified BYOT timestamp authority when you need to use a customer-managed TSA endpoint.
Error response when all TSAs fail
If every Sigill-managed standard source fails within the same request, you get a 502 Bad Gateway with anonymized failure details:
{
"message": "All Sigill-managed timestamp sources failed.",
"attemptsTried": 3,
"failures": [
{
"source": "standard-pool-1",
"errorClass": "timeout",
"statusCode": null,
"message": "Request timed out after 10s",
"latencyMs": 10042
},
{
"source": "standard-pool-2",
"errorClass": "http_status",
"statusCode": 503,
"message": "service unavailable",
"latencyMs": 412
},
{
"source": "standard-pool-3",
"errorClass": "parse",
"statusCode": 200,
"message": "malformed TSR: unexpected ASN.1 tag",
"latencyMs": 980
}
]
}errorClass values are stable strings you can match in client code: network (connection refused, DNS, TLS), timeout (HTTP client timeout), http_status (TSA responded non-2xx), parse (response wasn't a valid TSR), unexpected_qualified (a standard candidate returned a qualified-policy token), not_qualified (a qualified candidate returned a token without a qualified policy), unknown (catch-all). Lookup
/api/lookup/{hash}publicCheck if a file hash has been stamped. The hash must be a SHA-512 hex string. This endpoint is public — no authentication required.
Discoverability is opt-in. Records only appear here when the owning organisation allows public existence checks — either the organisation-wide setting (Settings → Public existence checks, default off) or a per-evidence override from the evidence detail page. Intended for publicly verifiable artifacts (software releases, published documents): anyone holding the file can confirm it was timestamped and is unmodified, by hash only. A hash whose owner has not opted in answers exactly like one that was never stamped. To look up your own records regardless of this setting, use the authenticated GET /api/transactions/by-hash/{hash}.
Path parameter
hash SHA-512 hex string (128 chars)Response 200
{
"found": true,
"count": 2,
"latest": {
"id": "uuid",
"hash": "hex string",
"alg": "OID string",
"tsaName": "string",
"genTime": "ISO 8601",
"certNotAfter": "ISO 8601",
"hasTsr": true
},
"records": [
"same public cryptographic fields"
]
}/api/transactions/{id}/public-lookupJWT · ownerPer-evidence override of the organisation's public-existence-check default, stored on the evidence (same tri-state contract as the reminder override). inherit follows the organisation setting, on makes this evidence publicly checkable even when the organisation default is off, off hides it even when the default is on. Owner only — the same role that controls the organisation default; members and API keys are rejected. Audited as evidence.public_lookup_changed.
Request body
{
"mode": "inherit | on | off"
}Response 200
{
"mode": "on",
"discoverable": true
}Mímir assistant
Mímir is the in-app assistant (Claude on Amazon Bedrock, EU region), included in the Starter, Business, Scale and Enterprise plans; it is not part of the Free plan. It answers questions about your organisation's Evidence Store — counts, what needs attention, which evidence carries qualified timestamps, whether a given hash is on file and when it must be renewed — and acts as a reference on the standards Sigill implements (RFC 3161, RFC 4998, RFC 5652, ETSI EN 319 142, TS 119 102-2, eIDAS). It never acts on your behalf: it reads through the same authorised evidence endpoints your session already has, and cites its sources by file and line. Statements about what Sigill supports come only from this documentation page and the Trust Center; where those are silent it says so rather than guessing. Conversation history is held in the browser and sent with each turn; nothing is stored server-side beyond usage counters.
Data processing. Each question, together with the evidence metadata Mímir looks up to answer it (labels, tags, hashes, timestamp-authority names, expiry and verification state), is sent to Amazon Bedrock in the EU (eu-north-1, EU cross-region inference). File content is never involved — Sigill does not hold it. Bedrock does not store prompts or responses, does not share them with the model provider, and does not use them to train models. Amazon Bedrock is listed on the sub-processors page.
/api/assistant/statusJWTWhether the assistant is enabled on this deployment and which model backs it. With ?tenantId=… (member) also available — false with reason: "assistant_plan_required" on the Free plan — and the quota object.
Response 200
{
"enabled": true,
"model": "eu.anthropic.claude-haiku-4-5-20251001-v1:0",
"available": true,
"reason": null,
"quota": {
"dailyLimit": 10,
"usedToday": 3,
"remainingToday": 7,
"resetsAt": "ISO 8601"
}
}/api/assistant/chatJWT · memberOne conversational turn. Send the whole conversation as plain-text turns ending with the user's message (max 4,000 characters per message; the last 24 turns are used). The assistant may call tenant-scoped evidence tools and the RFC/ETSI corpus before replying; tools lists what it consulted. Each call counts one assistant message plus the model tokens against the organisation's usage (visible under Settings → Plan and in GET /api/billing/{tenantId}/usage). Paid plans include a daily allowance — Starter 10, Business 100, Scale 200 questions per UTC day (Enterprise by agreement); 402 assistant_quota_exceeded when it is used up. The response's quota object reports dailyLimit, usedToday, remainingToday and resetsAt.
Optional context — the page the question is asked from (the Mímir button in the app sends it): {"{"}kind, id, route{"}"} with kind one of page, run, policy, agent, evidence, the record's id (a GUID; an agent id for agent) and the route path. Ids only: Sigill reads the record itself through your own access and gives it to the model as data — a record outside your organisation reads as not available. 400 when the id does not fit the kind.
Streaming. Send Accept: text/event-stream to receive the turn as server-sent events while it runs: text (a piece of the answer), discard (drop the provisional text — Mímir is looking something up), tool (a lookup done, with name and summary), then done (the same body as the JSON response) or error (status, message; the question is not counted). Refusals — 402, 400, 403 — are ordinary JSON responses before the stream starts. Lines starting with : are keep-alive comments (sent while Mímir is working silently); ignore them. Only done completes an answer — a stream that ends without it was cut off.
Request body
{
"tenantId": "uuid",
"messages": [
{
"role": "user",
"content": "Does anything need my attention?"
}
]
}Response 200
{
"reply": "markdown text",
"tools": [
{
"name": "list_evidence",
"summary": "12 evidence rows"
}
],
"usage": {
"inputTokens": 8868,
"outputTokens": 180,
"rounds": 2
},
"quota": {
"dailyLimit": 10,
"usedToday": 1,
"remainingToday": 9,
"resetsAt": "ISO 8601"
}
}Errors: 400 malformed conversation · 402 assistant_plan_required (Free plan — the question is not sent to the model) · 403 not a member of the organisation · 429 too many questions in a short window · 502 model unavailable · 503 assistant disabled on this deployment.
Timestamps
/api/transactions/detailsJWT / API keyPaginated list of timestamp records for a tenant, with optional search. Each item includes hasRestamp so clients can identify records whose archival renewal chain has already advanced.
Query parameters
tenantId uuid (required)
page integer (default 1)
pageSize integer (default 50, max 200)
search string — filters on label or hash prefix (optional)Response 200
{
"total": 42,
"page": 1,
"pageSize": 50,
"items": [
{
"id": "uuid",
"parentTransactionId": null,
"isRestamp": false,
"hasRestamp": true,
"certNotAfter": "ISO 8601"
}
]
}/api/transactions/{id}/labelJWT / API keySet or update the label on a timestamp record.
Request body
{
"label": "string (max 255)"
}Response 200
{
"id": "uuid",
"label": "string"
}/api/evidenceJWT / API keyThe Evidence Store list, grouped by artifact: one row per content hash (a document, archive, payload — anything hashed). Restamp-chain members and seal-linked timestamp transactions fold into their evidence; multiple top-level records of the same artifact (re-seals, independent stamps) merge into one row with a record count. The row's horizon is the earliest member horizon — the date needing action first governs the artifact's status — and the primary record (the newest) is where the row links.
Query parameters
tenantId uuid (required)
page integer (default 1)
pageSize integer (default 50, max 200)
search string — label contains, tag contains, hash
prefix, token serial (hex or decimal), TSA
policy OID, or signer-cert SHA-256 (exact or
≥8-char prefix); token matches resolve to
their artifact row
archived boolean — list the archive view (default false)
formats repeatable — rfc3161 | pades | cades | jades | pqc
statuses repeatable — valid | expiring | expired
verify repeatable — valid | failed | indeterminate
| unverified (latest verification verdict)
tsas repeatable — active TSA name
tags repeatable — customer-defined tag
(case-insensitive)
ers boolean — only evidence with an RFC 4998-exportable stamp chain (rfc4998-v1 root, ers-native renewals)
needsAction boolean — only the work queue: expired,
failed verification, or an unacknowledged
expiry alarm
sort lastEvent (default) | horizon (most urgent
first) | lastVerified (stalest first)
kind all (default) | seals | timestamps |
files | agent-records — rows carrying a
PAdES/CAdES/JAdES seal, or an RFC 3161
chain (a stamped and sealed artifact is in
both); files = your own files and payloads
(no envelope profile), agent-records =
records an agent run or policy approval
produced (any envelope profile). Narrows
the list and the tabs counts; for files and
agent-records also the stats
hideAgentEvents boolean — drop quiet per-event seals of
agent runs (signature-only, profile
agent_event, no lifecycle finding); a row
with a finding is never hidden. Hidden
rows also leave stats, tabs and kinds
app github — only evidence issued by that
connected app's workflows; rows, stats
and tabs all follow it (Settings → Apps
archive health)Facet filters apply before pagination — OR within a facet, AND across facets. Unknown formats/statuses/verify/sort/kind/app values return 400. expiring follows the evidence-reminder policy: the horizon is inside the effective reminder window (per-evidence override, else the tenant default) and reminders are enabled for that evidence; expired always applies regardless of policy. verify reflects the latest persisted verification run per chain — worst-of across an evidence's chains — where indeterminate means the material was insufficient (e.g. TSR not stored), never that verification failed.
Response 200
{
"total": 5,
"page": 1,
"pageSize": 50,
"stats": {
"total": 5,
"valid": 4,
"expiring": 1,
"expired": 0,
"noHorizon": 0,
"ersExportable": 2,
"needsAction": 1,
"verify": {
"valid": 3,
"failed": 1,
"indeterminate": 0,
"unverified": 1
},
"alarm": {
"enabled": true,
"days": 90
},
"byFormat": {
"rfc3161": 2,
"cades": 1
},
"byTsa": {
"GlobalSign": 2
},
"byTag": {
"q3-audit": 2
},
"horizonBuckets": [
{
"key": "expired | yyyy-MM (24 months) | later",
"n": 0
}
]
},
"kind": "all",
"tabs": {
"needsAction": 1,
"active": 5,
"expiring": 1,
"failedVerify": 1,
"archived": 1
},
"kinds": {
"all": 5,
"seals": 2,
"timestamps": 3
},
"sweep": {
"lastSweepAt": "ISO 8601 | null",
"running": false
},
"agentEvents": 0,
"items": [
{
"hash": "hex",
"alg": "OID string",
"label": "string | null",
"formats": [
"rfc3161",
"cades"
],
"records": 2,
"pqc": true,
"ersExportable": true,
"tokens": 3,
"lastEventAt": "ISO 8601",
"horizon": "ISO 8601 | null",
"horizonType": "stamp | seal | null",
"horizonId": "uuid | null",
"alarmEnabled": true,
"alarmDays": 90,
"tags": [
"q3-audit"
],
"verifyVerdict": "valid | failed | indeterminate | unverified",
"lastVerifiedAt": "ISO 8601 | null",
"needsAction": false,
"primaryType": "stamp | seal",
"primaryId": "uuid",
"activeTsaName": "string | null",
"docTs": false,
"level": "cades-t | cades-x-l | pades-b-t | jades-b-b | jades-b-t | null",
"signatureOnly": false,
"profile": "agent_event | control_basis | evaluation | null",
"certificateNotAfter": "ISO 8601 | null (signature-only seals: signing-certificate expiry, display only)",
"verifiable": true,
"agentRun": {
"runId": "uuid",
"agentId": "string",
"correlationId": "string",
"seq": 3,
"stepType": "control | run_end | …"
},
"members": [
{
"type": "stamp | seal",
"id": "uuid",
"at": "ISO 8601",
"format": "string",
"label": "string | null"
}
]
}
]
}stats aggregates the whole view (all pages, unaffected by search or facet filters): status counts, the verification-verdict distribution, the work-queue size, the tenant alarm policy, per-format and per-TSA row counts, and the monthly renewal-horizon distribution. revocation reports TSA-signer revocation monitoring: signersRevoked (distinct timestamp-authority signer certificates protecting this tenant's evidence that are now revoked) and evidencesAffected — the dashboard lights up and each affected row carries signerRevoked: true when this is non-zero. The hourly revocation sweep detects a signer that has gone revoked, emails the tenant's owners once, and records evidence.revocation_detected in the custody log. alarmEnabled/alarmDays on each row are the effective reminder policy of the member governing the row's horizon. verifyVerdict/lastVerifiedAt come from the latest persisted verification run; docTs marks a document-timestamp chain on the primary record (the PAdES B-LTA shape). level is the signature level ACHIEVED at seal time (e.g. cades-t when revocation data could not be embedded); null on stamps and on seals created before level tracking — no level is asserted then. sweep reports the background verification sweep: when it last completed and whether one is running now. tabs counts the work queues within the requested kind; kinds counts the active view per kind (all, seals, timestamps, files, agentRecords). horizonType/horizonId name the record whose horizon is the row's (it can be older than the primary record) — renew that one. agentRun is present when the row's primary record is a seal of an indexed agent run (ids only) — it links the artifact to its run.
/api/evidence/archiveJWT / API keyArchive or restore whole evidences by content hash (1–200 per call). Every top-level record of each artifact moves to (or out of) the archive view. Archiving mutes expiry reminders instantly; restoring returns the reminder override to inherit.
Request body
{
"hashes": [
"hex",
"hex"
],
"archive": true
}Response 200
{
"archived": true,
"documents": 2,
"records": 3
}/api/transactions/{id}/chainJWT / API keyResolve the full archival restamp chain containing a transaction (any member ID resolves to the same chain, root first). Each token includes metadata parsed from the stored TSR — serial, TSA policy OID, qualified flag, message-imprint algorithm — plus the evidence's expiry horizon (the active token's TSA-cert notAfter) and its reminder state. Backs the evidence detail page.
Response 200
{
"rootId": "uuid",
"activeId": "uuid",
"label": "string",
"hash": "hex string",
"storeTsr": true,
"horizon": "ISO 8601",
"reminder": {
"enabled": true,
"days": 90,
"notifyEmail": "string",
"riskAcknowledgedAt": null
},
"tokens": [
{
"id": "uuid",
"index": 1,
"tsaName": "string",
"genTime": "ISO 8601",
"certNotAfter": "ISO 8601",
"serial": "string",
"policyOid": "OID string",
"qualified": false,
"hashAlgorithmOid": "OID string",
"signatureValid": true
}
]
}/api/transactions/{id}/chain.zipJWT / API keyDownload every stored TSR in the restamp chain as a zip, together with a chain.json manifest describing the parent → child linkage. 404 when no TSRs are stored for the chain.
/api/transactions/{id}/audit-package.zipJWT / API keyOne download with everything an independent reviewer needs, verifiable offline without access to Sigill: every stored RFC 3161 token (tokens/*.tsr), the certificates embedded in each token (certificates/*.pem), the chain linkage manifest (chain.json), the latest persisted verification report (verification.json), the chain-of-custody event log (events.json), the stored detached signature where one exists (signature/), archived TSA revocation material — the TSA chain’s certificates and CRL/OCSP responses, captured at restamp time and refreshed by an hourly background sweep while the TSA still publishes them, so the package stays verifiable offline after the responders go dark; revocation/snapshots.json explicitly lists any signer whose material is not captured yet (revocation/, RFC 3161 §4) — the standards exports (evidence-record.ers — a conformant RFC 4998 EvidenceRecord, for natively-renewed chains — and validation-report.xml — the ETSI TS 119 102-2 V1.4.1 report with its detached CAdES signature validation-report.xml.p7s, when a current verification run with full provenance exists), a SHA-256 checksum manifest over every entry (manifest.json), and a human-readable SUMMARY.txt with step-by-step verification instructions — verifiable with open, standards-based tooling, without Sigill (OpenSSL covers the RFC 3161 tokens; full evidence-record validation uses an RFC 4998 tool). The export itself is recorded in the evidence's custody log as evidence.exported.
/api/transactions/{id}/evidence-record.ersJWT / API keyThe whole restamp chain as one conformant RFC 4998 EvidenceRecord (DER) — independent ERS tooling validates it without any Sigill documentation: the first ArchiveTimeStamp covers the artifact digest, each renewal covers the previous timeStamp content with the chain's single digest algorithm (§5.2/§5.3), and every token signature verifies against its embedded certificates. Available for chains whose root carries the rfc4998-v1 profile (set at creation for new plain-artifact evidence) and whose every renewal is provably native. Legacy/unprofiled roots — including all pre-existing evidence and seal-linked stamps — can never export as .ers; their export is the audit package. Chains with legacy renewal links are refused with 409: re-encoding cannot make them conformant, and their fully verifiable export remains the audit package's open, documented recipe. Also 409 on a broken/truncated chain or a link without a stored TSR — the builder verifies linkage cryptographically, never from metadata.
/api/transactions/{id}/validation-report.xmlJWT / API keyThe evidence's latest persisted verification run as an ETSI TS 119 102-2 V1.4.1 validation report — the real schema (namespace http://uri.etsi.org/19102/v1.4.1#, validated against the ETSI XSD in tests and CI, plus an independent semantic checker). EN 319 102-1 three-state vocabulary (total-passed / total-failed / indeterminate — insufficient material is never reported as failed) with per-token sub-indications, the validation policy identified by URI and SHA-256 over its published, immutable text (/api/policies/chain-validation-v1), the root token's genTime as best-signature-time, and per-timestamp validation objects: signature, RFC 4998 cover-all proof-of-existence provisioning, trust anchoring, signer certificate, and the revocation status proven from capture-time snapshot material — citing the exact revocation/… file in the audit package that was consulted. total-passed requires proven-good revocation on every token; unprovable status degrades to indeterminate, never up. Reports are bound to one chain version: after a restamp, re-run verify-chain for a current report (earlier runs are kept as history). 404 until a run exists; 409 when the run predates the current chain or provenance capture.
/api/transactions/{id}/validation-report.zipJWT / API keyThe issued report as a signed bundle. Reports are issued once per verification run — the exact XML bytes and their SHA-256 are stored and served byte-identically on every later download, so history is reproducible and KMS/TSA cost is per issuance, never per download. The bundle carries the XML, a detached CAdES signature by Sigill's platform certificate over those exact bytes with an RFC 3161 timestamp (validation-report.xml.p7s), the signer certificate, the exact validation-policy bytes (policies/chain-validation-v1.txt — the report's SigPolicyHash binds to them, so the rules the verdict was produced under are reconstructible offline; the public URI is a convenience, not the only source), and step-by-step OpenSSL verification instructions. Signed always means signed and timestamped: if the signature cannot be produced, the endpoint returns 503 instead of a silently unsigned bundle — the raw XML stays available at validation-report.xml. The signature authenticates that Sigill produced the report unaltered — deliberately separate from the evidence's own trust: the report cites external anchors (EU LOTL, TSA chains) for the evidence itself.
/api/transactions/{id}/validation-reportsJWT / API keyThe issued-report history for the evidence: every validation report ever issued — current and superseded — with sha256, signing state, issue time and the supersession links. Reports are immutable snapshots; when one must be replaced (e.g. a remediation), the old row is preserved byte-for-byte and linked to its replacement — exactly one report per verification run is current. Fetch any specific report's exact bytes with validation-report.xml?reportId=<id> (superseded reports answer with an X-Report-Superseded-By header); the report must belong to this evidence's chain — a report id from another evidence is 404 even within the same tenant.
/api/transactions/{id}/verify-chainJWT / API keyCryptographically verify the whole chain in one call: each token's TSA signature (RFC 3161 §2.2 with the timestamping EKU of §2.3), the hash linkage — the root token covers the recorded file digest; each renewal per its linkage protocol: ers-native covers previous timeStamp content (cover-all per RFC 4998 §5.2), legacy covers a digest of the previous full TimeStampResp (RFC 3161 §4) — and the signer certificate's chain trust, including the EU LOTL check for qualified tokens. Trust states: qualified_lotl, trusted_chain (anchor matched — EU LOTL, Sigill's pinned pool-TSA root anchors, or the OS trust store), valid_untrusted_chain, self_signed. Two independent top-level verdicts: cryptographicallyValid (signatures + linkage) and trustAnchored (every token anchored); valid requires both. verdict is the three-state summary in the spirit of ETSI EN 319 102-1: failed only on a definitive negative (broken signature or linkage); insufficient material — a TSR not stored, a signer chain that doesn't reach an anchor — is indeterminate, never collapsed into failed. Every run is persisted and becomes the evidence's last verified state in the Evidence Store.
Response 200
{
"valid": true,
"verdict": "valid | failed | indeterminate",
"cryptographicallyValid": true,
"trustAnchored": true,
"checkedAt": "ISO 8601",
"tokens": [
{
"id": "uuid",
"index": 1,
"signatureValid": true,
"linkValid": true,
"trust": "trusted_chain",
"chainPath": [
"subject DN chain"
]
}
]
}/api/transactions/{id}/revalidateJWT / API keyQueue a validation maturation for the evidence (returns 202). A freshly sealed artifact is cryptographically valid immediately, but the definitive ETSI verdict needs TSA revocation material issued after the newest token — until it is captured, the validation report is interim (indeterminate / TRY_LATER). The maturation fetches fresh revocation data only for the signer(s) whose material cannot yet prove their token (a per-signer advisory lock and cooldown keep a burst of seals off the TSA), then re-verifies the chain and regenerates the current validation report. Sigill queues the same maturation automatically about two minutes after every seal; this endpoint is the manual trigger. Poll GET /api/transactions/{id}/chain until validation.current.revocationStatus is proven (values: proven | pending | invalidated | not_assessed — invalidated is a definitive revocation failure, not a pending state). validation.current.bestEffort is true when the protective TSA is non-qualified — such authorities publish revocation slowly (a periodic CRL, often no per-certificate OCSP), so pending is expected and clears on the TSA's next CRL rather than indicating a fault; qualified TSAs prove promptly.
Response 202
{
"queued": true
}/api/evidence/tagsJWT / API keyTag or untag whole evidences by content hash (1–200 per call) — the grouping and filtering dimension of the Evidence Store, distinct from the single display label. Tags attach to the artifact identity (content hash), so they survive re-seals and restamps. At most 10 tags per evidence and 40 characters per tag; case-preserving, case-insensitively unique and matched. Unknown hashes are skipped; evidences already at the cap are reported in capReached.
Request body
{
"hashes": [
"hex",
"hex"
],
"add": [
"q3-audit"
],
"remove": [
"old-tag"
]
}Response 200
{
"evidences": 2,
"added": 2,
"removed": 1,
"capReached": []
}/api/evidence/verifyJWT / API keyVerify whole evidences by content hash (1–50 per call). Every chain of each artifact is verified — stamp chains and all chains of its seal operations (signature timestamp and DocTimeStamp) — with the same treatment as verify-chain, and every verdict is persisted. Returns the worst-of verdict per artifact.
Request body
{
"hashes": [
"hex",
"hex"
]
}Response 200
{
"chains": 3,
"items": [
{
"hash": "hex",
"verdict": "valid | failed | indeterminate"
}
]
}/api/evidence/restampJWT / API keyBulk archival renewal by content hash (1–200 per call): every member chain of each artifact — stamp chains and a seal’s signature-timestamp and DocTimeStamp chains — whose tip is inside its effective expiry-alarm window (or already expired) is queued for an RFC 3161 §4.3 restamp. The job runs on a durable, database-backed queue: it survives restarts and deployments, retries TSA throttling per item with growing cooldowns, and each restamp consumes one plain-timestamp quota token (on exhaustion, remaining items are skipped, never failed). Healthy tips and tips without a stored TSR are reported as skipped. dryRun: true returns the counts without queuing anything.
Request body
{
"hashes": [
"hex",
"hex"
],
"dryRun": false
}Response 202 (job queued)
{
"jobId": "uuid",
"queued": 12,
"skippedHealthy": 3,
"skippedNoTsr": 1,
"skippedQueued": 0
}Response 200 (nothing to queue, or dryRun)
{
"jobId": null,
"queued": 0,
"skippedHealthy": 3,
"skippedNoTsr": 1,
"skippedQueued": 2
}skippedQueued counts chains that already have a renewal in flight — at most one live renewal per chain is enforced by the database, so overlapping submissions can never fork a chain. With dryRun: true the 200 body uses wouldQueue in place of queued and nothing is created./api/evidence/resealJWT / API keyBulk re-seal by content hash (1–200 per call): one fresh detached seal per artifact and format — CAdES .p7s or JAdES .jades.json — produced from the newest eligible seal operation of each (artifact, format) group. Fidelity is preserved: hybrid ML-DSA where the chosen operation was post-quantum, the original JAdES content type, the original expiry-reminder policy, and — crucially — a qualified timestamp where the original was qualified (evidence is never downgraded; qualified re-seals consume qualified quota). A re-seal is only counted done when a fresh timestamp was embedded — TSA outages retry, they never deliver an untimestamped renewal. PAdES operations are reported as unsupported (use the SDK’s delegated flow); operations whose certificate is no longer active are skipped unless fallbackCertificateId names an active replacement, which is used only for those. Requires the tenant’s Store detached seals setting: artifacts are delivered from storage via GET /api/evidence/jobs/{id}/artifacts.zip. Runs on the same durable queue as bulk restamp; at most one live re-seal per operation is enforced by the database. dryRun: true returns counts only.
Request body
{
"hashes": [
"hex",
"hex"
],
"dryRun": false,
"fallbackCertificateId": "uuid (opt) — active cert used only where the original is inactive"
}Response 202 / 200
{
"jobId": "uuid | null",
"queued": 4,
"skippedUnsupported": 1,
"skippedCertInactive": 0,
"skippedQueued": 0,
"skippedNoSeals": 2
}/api/evidence/jobs/{id}/artifacts.zipJWT / API keyThe detached seals a re-seal job produced, served from stored artifacts, with a SHA-256 checksum manifest.json that also confesses its gaps: expected, delivered, and a missing list of operation ids whose artifact is not in storage. 404 while the job is still running or when nothing was produced; only re-seal jobs produce artifacts.
/api/evidence/jobs/{id}JWT / API keyProgress of a renewal job — poll it live or come back later; the job record is durable. status is running, completed, or completed_with_errors; problems lists the latest failed/skipped items with their reasons. GET /api/evidence/jobs returns the five most recent jobs.
Response 200
{
"id": "uuid",
"kind": "restamp",
"status": "running | completed | completed_with_errors",
"total": 12,
"done": 9,
"failed": 1,
"skipped": 0,
"createdAt": "ISO 8601",
"completedAt": "ISO 8601 | null",
"problems": [
{
"hash": "hex",
"status": "failed | skipped",
"error": "string"
}
]
}/api/evidence/verify-sweepJWT / API keyVerify what is due now — the "Verify now" action. Every chain that was never verified, or not re-confirmed within the last 16 hours, gets the same treatment as verify-chain, and each verdict is persisted. Requests are queued and handled one after another; the whole store is re-verified automatically every night (01:00–06:00 Europe/Oslo). Business and Scale plans.
Response 202
{
"started": true,
"alreadyRunning": false
}alreadyRunning: true when a verification for your organisation is already queued or running. Within 10 minutes of your last request: 429 with code: "verify_cooldown", retryAfterSeconds and a Retry-After header.
/api/transactions/{id}/eventsJWT / API keyChronological event log for the evidence: stamping, archival restamps, sealing, reminder-setting changes, reminder emails, and risk acknowledgements — with the acting user where one exists.
Response 200
{
"events": [
{
"at": "ISO 8601",
"type": "stamped | restamped | timestamped | sealed | evidence.reminders_changed | evidence.risk_acknowledged | evidence.reminder_sent",
"actor": "string | null",
"detail": "string | null",
"transactionId": "uuid | null"
}
]
}/api/transactions/{id}/remindersJWT / API keySet the evidence's reminder override. The policy lives on the organisation (Settings → Notifications → Evidence expiry reminders, or PUT /api/tenants/{id}/notifications); evidences inherit it by default. mode: "off" mutes an evidence that is no longer relevant; "on" forces reminders even when the organisation default is off. Reminders arrive as one digest email per organisation, not one per evidence. A restamp moves the horizon forward and re-arms the reminder.
Request body
{
"mode": "inherit | on | off",
"days": "30 | 60 | 90 | 180 (optional, with mode on)"
}Response 200
{
"mode": "on",
"enabled": true,
"days": 90,
"nextReminderAt": "ISO 8601"
}/api/tenants/{id}/notificationsJWT · memberThe organisation's notification settings (Settings → Notifications) and who receives them: recipients (owners or members = owners and members) with the resulting recipientEmails, evidenceReminders (enabled, days), agentFindings (off, serious = failed checks, all = also missing evidence) and agentFindingsSince (only agent evidence received from then on is ever mailed), policyAlerts and usageWarnings, and stats: emails sent in the last 30 days per kind (evidenceReminders, revocation, agentFindings, policyAlerts, usageWarnings) and lastSentAt — counts only. Revocation alerts for a timestamp authority protecting your evidence, and sign-in, invitation and two-factor emails, are always sent and have no setting.
/api/tenants/{id}/notificationsJWT · ownerChange any of recipients, evidenceReminders (bool), evidenceReminderDays (30, 60, 90 or 180), agentFindings, policyAlerts, usageWarnings; omitted fields keep their value. Switching agentFindings on from off starts from now. Agent finding emails come at most once an hour, each run once per assessment, never for acknowledged findings. Returns the settings as above; 400 for an unknown value.
/api/transactions/{id}/acknowledge-riskJWTRecord that a signed-in user accepts the current expiry risk. The acknowledgement is written to the tenant audit log and silences reminders until the next threshold crossing. Not available to API keys — acknowledgement is a personal act.
Response 200
{
"riskAcknowledgedAt": "ISO 8601",
"riskAcknowledgedBy": "string"
}Timestamp Authorities
/proxy/servicesJWT / API keyList customer-selectable timestamping options available to the caller's tenant. Sigill-managed standard RFC 3161 timestamping is selected with tsaSlug: "auto" and internal standard sources are not returned here. Verified tenant-private BYOT authorities are returned as source: "tenant" entries; qualified timestamping options may appear as source: "qualified" when entitled.
Response 200
[
{
"id": "uuid",
"name": "My timestamp authority",
"proxySlug": "byot:my-tsa",
"preferredHashOid": "2.16.840.1.101.3.4.2.3",
"isQualified": false,
"source": "tenant"
},
{
"id": "uuid",
"name": "Qualified timestamping",
"proxySlug": "qualified",
"preferredHashOid": "2.16.840.1.101.3.4.2.3",
"isQualified": true,
"source": "qualified"
}
]Timestamp Authorities
Tenants on the Business plan or above can add their own RFC 3161 endpoints under Settings → Timestamp authorities. Sigill verifies each configuration server-side before saving it, protects stored credentials with Data Protection, and exposes verified entries as tenant-private BYOT references.
/api/tenant/tsaJWTList the authenticated tenant's BYO TSA configurations. Returns the verification status and the last successful test result for each row.
Response 200
{
"planAllows": true,
"plan": "business",
"maxPerTenant": 10,
"items": [
{
"id": "uuid",
"label": "My TSA",
"slug": "my-tsa",
"endpointUrl": "https://tsa.example.com",
"preferredHashOid": "2.16.840.1.101.3.4.2.3",
"authType": "basic",
"username": "tsa-user",
"hasSecret": true,
"isActive": true,
"verifiedAt": "ISO 8601",
"lastVerifySerialHex": "string",
"lastVerifyTsaName": "string"
}
]
}/api/tenant/tsa/verifyJWTRun a one-shot RFC 3161 probe against a candidate endpoint without saving it. This is the same server-side verification step used by Save. keyWarning is set when the TSA's signing certificate uses an RSA key below 3000 bits (ETSI TS 119 312 §8.4: no new certificates on such keys after 2026-12-31, and they must expire by 2028-12-31); the endpoint still verifies. Create and update return the same field.
Request body
{
"endpointUrl": "https://tsa.example.com",
"preferredHashOid": "2.16.840.1.101.3.4.2.3",
"authType": "none | basic | bearer",
"username": "string (basic only)",
"secret": "string (password or bearer token)"
}Response 200
{
"ok": true,
"serial": "string",
"genTime": "ISO 8601",
"hashAlgorithmOid": "OID string",
"tsaName": "string",
"lotlQualified": false,
"keyWarning": "string | null"
}/api/tenant/tsaJWTCreate a BYO TSA after the server verifies it. Tenants below the Business plan get a 402. The configuration is saved only after the endpoint passes the live RFC 3161 check.
Request body
{
"label": "My timestamp authority",
"slug": "my-tsa",
"endpointUrl": "https://tsa.example.com",
"preferredHashOid": "2.16.840.1.101.3.4.2.3",
"authType": "none | basic | bearer",
"username": "string (basic only)",
"secret": "string (password or bearer token)",
"responsibilityConfirmed": true
}/api/tenant/tsa/:idJWTUpdate a BYO TSA. Transport changes trigger a fresh verification before the row is committed.
/api/tenant/tsa/:idJWTRemove a BYO TSA. This remains available even after a plan downgrade so tenants can clean up their configuration.
tsaSlug values using their slug or byot:<slug>. BYOT endpoints are customer-managed; Sigill verifies technical RFC 3161 compatibility, not the customer's right to use the endpoint. Seals
Cryptographic seals backed by KMS — the private key never leaves. An RFC 3161 timestamp is embedded in every seal automatically. Owner role required to manage certificates; any authenticated user can seal.
Every format has a hash-only path — the document itself never has to reach Sigill:
POST /seal/sign-pades-hash— the recommended way to seal PDFs. The SDK assembles the PDF signature revision locally and sends only the ByteRange SHA-256 digest; Sigill returns the PAdES CMS (ETSI EN 319 142-1) and the SDK embeds it. The PDF never leaves your environment. Supported out of the box by the .NET and Python SDKs (SealPadesAsync/seal_pades).POST /seal/sign-hash— accepts a pre-computed SHA-256 digest only. Non-PDF files (e.g. JSONL, XML, plain text) receive a detached CAdES.p7swithout the original content ever leaving the client. Same privacy model as/tsa/stamp-hash.format: "jades"— on/seal/signand/seal/sign-hash, returns a detached JAdES signature (ETSI TS 119 182-1,.jades.json) instead of CAdES. The ETSI signature format for JSON — recommended for JSON/JSONL data such as API payloads and AI conversation logs. Same detached, hash-only model as CAdES.POST /seal/sign-hashes— multi-object JAdES: one seal binding an envelope plus any number of payloads, each by digest (sigD ObjectIdByURIHash). Built for AI-evidence records; neither the envelope nor content is ever transmitted. Verify object-level withPOST /seal/verify-objects.POST /seal/sign— uploads the full file; PDFs come back as a sealed PDF, other files as detached CAdES/JAdES. The convenience path used by this web app — prefer the hash-only endpoints for integrations. (The MCP server never uses it: MCP has no document upload or download capability.)
/seal/certificatesJWT / API keyList active signing certificates for the tenant. The Sigill platform certificate is always appended at the end with source: "platform".
Response 200
[
{
"id": "uuid",
"label": "string",
"status": "active | provisioning | revoked",
"source": "byoc | platform",
"certSubject": "CN=...",
"certNotBefore": "ISO 8601",
"certNotAfter": "ISO 8601"
}
]/seal/certificatesJWT (owner)Provision a new signing key. Generates RSA-4096 in KMS and returns a PKCS#10 CSR for CA submission. Submit the CSR to a CA, then activate via the endpoint below. Seal signatures with this key use RSASSA-PSS by default (the ETSI TS 119 312-recommended RSA padding; SHA-256, MGF1-SHA-256; an operator-level rollback to PKCS#1 v1.5 exists) — existing PKCS#1 v1.5 seals remain valid and verifiable.
Request body
{
"commonName": "Acme Corp Seal 2026",
"organization": "Acme Corp AS",
"countryCode": "NO",
"organizationalUnit": "string (opt)",
"locality": "string (opt)",
"state": "string (opt)",
"label": "string (opt)"
}Response 200
{
"id": "uuid",
"label": "string",
"status": "provisioning",
"kmsKeyArn": "arn:aws:kms:...",
"csrPem": "-----BEGIN CERTIFICATE REQUEST-----..."
}/seal/certificates/:id/activateJWT (owner)Upload the CA-signed certificate chain PEM. Validates that the public key matches the provisioned KMS key before activating.
Request body
{
"certificatePem": "PEM certificate chain: leaf certificate plus optional intermediates"
}Response 200
{
"id": "uuid",
"status": "active",
"certSubject": "CN=...",
"certNotBefore": "ISO 8601",
"certNotAfter": "ISO 8601"
}/seal/certificates/:idJWT (owner)Revoke a certificate and schedule the KMS key for deletion (7-day grace period). Cannot be undone. Platform certificate cannot be revoked via this endpoint.
Response 200
{
"message": "Certificate revoked. KMS key deletion scheduled."
}/seal/signJWT / API keySeal a file by uploading it. Accepts multipart/form-data. File type is detected server-side from magic bytes — PDFs produce a PAdES-signed PDF (application/pdf); other files produce a detached CAdES .p7s (application/pkcs7-signature). Pass format: "jades" to get a detached JAdES .jades.json (application/jose+json) instead. For detached formats, pqc: true adds an ML-DSA-87 signer (a second CMS SignerInfo, or a second JWS signatures[] entry per RFC 9964). For non-PDF files where privacy matters, prefer POST /seal/sign-hash instead — it never receives the file content.
Form fields
{
"file": "file to seal (required)",
"certificateId": "uuid (required)",
"label": "string — stored in operation log (opt)",
"reason": "PDF only — written into PDF /Reason field (opt)",
"location": "PDF only — written into PDF /Location field (opt)",
"qualified": "boolean — embed a qualified RFC 3161 timestamp (default false)",
"format": "\"jades\" for a detached JAdES signature (opt; default CAdES for non-PDF)",
"pqc": "boolean — detached formats only, add ML-DSA-87 signer (default false)",
"tags": "repeatable field (opt) — up to 10 distinct tags attached at creation; >10 in the request is a 400, inserts stop silently at an evidence's existing 10-tag cap"
}Response headers
{
"X-Seal-Operation-Id": "uuid",
"X-Seal-Certificate-Id": "uuid",
"X-Seal-Timestamped-By": "TSA name",
"X-Seal-Format": "pades-b-lta | pades-b-lt | pades-b-t | cades-x-l | cades-t | jades-b-t",
"X-Seal-Qualified": "true | false",
"X-Seal-Pqc": "ml-dsa-87 | none",
"X-Seal-Warning": "document_timestamp_unavailable (PDF only, when present)"
}application/pdf), save as filename_sealed.pdf.Non-PDF response — detached CAdES signature (
application/pkcs7-signature), save as filename.p7s alongside the original file.JAdES response (
format: "jades") — detached JAdES signature (application/jose+json), save as filename.jades.json alongside the original file. The seal covers the exact bytes — re-serializing the original JSON breaks it by design.Every seal carries an RFC 3161 signature timestamp. If no Sigill-managed TSA answers, the response is 503 with
Retry-After and {"code":"timestamp_unavailable","retryAfterSeconds":30}: nothing is sealed and nothing is counted, so retrying is safe. A PDF seal whose archival document timestamp could not be added is still returned, at pades-b-lt, with X-Seal-Warning: document_timestamp_unavailable.With Store PAdES seal data enabled in Settings, the CMS embedded in a sealed PDF is also escrowed and re-downloadable via
GET /seal/operations/:id/p7s — repair material if the PDF's signature contents are ever damaged, and a detached proof object. It cannot reconstruct the sealed PDF on its own; keep the returned file. Off by default. /seal/sign-hashJWT / API keySeal a file by sending only its digest. The original file content never leaves the client — same privacy model as /tsa/stamp-hash. Returns a detached CAdES .p7s by default, or a detached JAdES .jades.json with format: "jades" — both verify against the original file. For pqc: true, send both SHA-256 (hashHex) for the classical signer and SHA-512 (hashHex512) for the ML-DSA signer.
Request body (JSON)
{
"hashHex": "64-char lowercase SHA-256 hex of the file (required)",
"certificateId": "uuid (required)",
"label": "string — stored in operation log (opt)",
"qualified": "boolean — embed a qualified RFC 3161 timestamp (default false)",
"format": "\"cades\" (default) | \"jades\" (opt)",
"contentType": "MIME type of the sealed object, e.g. application/json — JAdES only (opt)",
"pqc": "boolean — add ML-DSA-87 signer (default false)",
"hashHex512": "128-char SHA-512 hex of same file; required when pqc=true",
"tags": [
"string[] (opt) — up to 10 distinct tags attached at creation; >10 in the request is a 400, inserts stop silently at an evidence's existing 10-tag cap"
]
}Response headers
{
"X-Seal-Operation-Id": "uuid",
"X-Seal-Certificate-Id": "uuid",
"X-Seal-Timestamped-By": "TSA name",
"X-Seal-Format": "cades-x-l | cades-t | jades-b-t",
"X-Seal-Qualified": "true | false",
"X-Seal-Pqc": "ml-dsa-87 | none"
}.p7s (application/pkcs7-signature) or, with format: "jades", a detached JAdES signature (application/jose+json). Save it alongside the original file. To verify, supply both the original file and the detached signature to POST /seal/verify — the verifier recomputes the hash and checks it matches the digest embedded in the signature.503
timestamp_unavailable (with Retry-After) if no timestamp authority answers — nothing is sealed or counted, so retrying is safe.400 if
hashHex is not a valid 64-character hex string. For PDFs, use /seal/sign-pades-hash (hash-only, recommended) or /seal/sign (upload). /seal/sign-hashesJWT / API keySeal a multi-object record — an envelope plus any number of content payloads — by digests alone (blind JAdES). Built for AI-evidence envelopes and sibling envelope formats: the envelope's canonical digest becomes signed object 0 (named by sigD.pars[0], the envelope reference — see the note below), each payload is bound by its own digest, and neither the envelope nor any content is ever transmitted or stored. Sigill signs the multi-object sigD with your seal certificate, timestamps it (unless timestamp: false), and returns the JAdES JWS — you assemble the final artifact locally.
Request body (JSON)
{
"envelopeHashHex": "64-char SHA-256 hex of the canonical (RFC 8785) envelope (required)",
"certificateId": "uuid (required)",
"objects": [
{
"uri": "unique opaque relative reference, e.g. objects/<uuid> — use identifiers, not filenames (max 128 objects)",
"hashHex": "64-char SHA-256 hex of the raw payload bytes",
"hashHex512": "128-char SHA-512 hex; required when pqc=true",
"contentType": "MIME type (opt)"
}
],
"envelopeContentType": "cty for object 0 (default application/vnd.sigill.ai-evidence+json)",
"envelopeHashHex512": "128-char SHA-512 hex; required when pqc=true",
"label": "string (opt)",
"qualified": "boolean (default false)",
"pqc": "boolean — add ML-DSA-87 hybrid signer (default false)",
"tags": [
"string[] (opt)"
],
"timestamp": "boolean (default true) — false signs without a TSA timestamp (jades-b-b by request): for chained records where a later checkpoint's timestamp anchors the chain"
}Response 200 (JSON)
{
"signature": "General JWS JSON object — the JAdES signature; wrap it with your envelope as {envelope, signature}",
"operationId": "uuid",
"format": "jades-b-t | jades-b-b",
"timestampedBy": "TSA name | null",
"qualified": "boolean",
"pqc": "boolean",
"timestampRequested": "boolean — false when you asked for no timestamp (format jades-b-b)",
"warnings": [
"present only when an object URI is outside the production profile (it is still sealed, for now)"
]
}sigD.pars entry to resolve to a locator, so object URIs are opaque relative references: segments of A–Z a–z 0–9 . _ ~ - separated by /, such as objects/<uuid> (what the current SDKs, the agent plugin and the browser extension generate). Other URIs — urn: identifiers, URLs — are still sealed for now, with a warnings entry, and will be refused once Sigill enforces the profile. The envelope is object 0; Sigill is moving its reference from urn:sigill:envelope to sigill-envelope.json, so read sigD.pars[0] rather than assuming either. Both names are reserved. URIs are compared byte-exactly and must be unique. Keep URIs opaque — a filename in a URI leaks through any amount of hashing. Sigill persists only the seal operation and the signed digest list (hashes, content types, count) — never the URIs, never the envelope, never content. The operation's recorded document hash is the envelope digest, so grouping, tags, renewal reminders and archival restamps work like any other seal.To verify, use
POST /seal/verify-objects (digests only) or any TS 119 182-1 validator with the payload bytes. For a whole controlled AI-agent run (Agent Evidence Profiles v1, as the SDKs record it: a control basis, a chain of events, optional control evaluations), the Verify a run bundle page reads the envelopes in your browser — the control basis and its binding, sequence, chain links, the signed timestamp policy, finalization, evaluations — and asks Sigill only the blind question, one POST /seal/verify-objects per artifact with the signature and locally computed digests. No envelope and no content leaves your machine; an SDK does the same offline.400 on duplicate or reserved URIs, malformed digests, content types that are not plain MIME types (
type/subtype — they are persisted, so free text is rejected), or more than 128 objects; 404 if the certificate is unknown, inactive, or not visible to the tenant; 503 timestamp_unavailable (with Retry-After) if a timestamp was requested and no timestamp authority answers — nothing is sealed or counted, so retrying is safe. Metering: a seal whose envelopeContentType is an Agent Evidence Profiles type (application/vnd.sigill.agent-control+json, …agent-execution+json, …control-evaluation+json) counts in the monthly agent evidence pool on every plan, not as a document seal; at the limit the response is 402 with {"code":"agent_evidence_quota_exceeded","limit":…,"resetsAt":"…"}. Qualified timestamps still count in the qualified pool. GET /api/billing/{tenantId}/usage reports agentEvidenceThisMonth and agentEvidenceLimit. /seal/sign-pades-hashJWT / API keyDelegated PAdES signing — seal a PDF without uploading it. The client prepares the PDF signature revision locally (placeholder /Contents slot + /ByteRange), hashes the signed byte ranges, and sends only that digest. Sigill signs it with the KMS-held key, embeds the RFC 3161 timestamp, and returns the PAdES CMS for the client to embed. On the Business plan and above, the response also carries the certificate-chain, OCSP and CRL DERs needed to build the PDF's Document Security Store locally (PAdES B-LT — CRLs cover the CRL-only CAs that publish no OCSP responder) — lower tiers stop at B-T and receive empty arrays. For B-LTA (Business+), hash the DocTimeStamp ByteRange and stamp it via /tsa/stamp-hash; the response's tokenBase64 is the token to embed. The .NET and Python SDKs implement the whole flow in one call.
Request body (JSON)
{
"hashHex": "64-char lowercase SHA-256 hex of the PDF ByteRange (required)",
"certificateId": "uuid (required)",
"label": "string — stored in operation log (opt)",
"qualified": "boolean — qualified RFC 3161 timestamp (default false)",
"tags": [
"string[] (opt) — up to 10 distinct tags attached at creation; >10 in the request is a 400, inserts stop silently at an evidence's existing 10-tag cap"
]
}Response 200 (JSON)
{
"cmsBase64": "DER CMS for the /Contents slot",
"certChainDers": [
"base64 DER — for the PDF DSS (Business+; empty below)"
],
"ocspDers": [
"base64 DER OCSP responses — for the PDF DSS (Business+; empty below)"
],
"crlDers": [
"base64 DER CRLs — for the PDF DSS /CRLs (Business+; empty below)"
],
"operationId": "uuid",
"certificateId": "uuid",
"timestampedBy": "TSA name",
"qualified": "boolean",
"format": "pades-b-t"
}/Contents slot (the SDKs do). Post-quantum hybrid signing is not offered for PAdES — the profile allows a single SignerInfo; use detached CAdES or JAdES for ML-DSA-87 hybrid seals.With Store PAdES seal data enabled in Settings, the final returned CMS is also escrowed and re-downloadable via
GET /seal/operations/:id/p7s — insurance if your pipeline loses the response before embedding, and a detached proof object. The CMS holds the signature, certificate chain, ByteRange digest and signature timestamp — never document content. Off by default.400 if
hashHex is malformed; 404 if the certificate is unknown, inactive, or not visible to the tenant; 503 timestamp_unavailable (with Retry-After) if no timestamp authority answers — nothing is sealed or counted, so retrying is safe. /seal/operationsJWT / API keyPaginated seal history for the authenticated tenant.
Query params
{
"page": 1,
"pageSize": 50,
"search": "label prefix or hash prefix (opt)"
}Response 200
{
"total": 42,
"page": 1,
"pageSize": 50,
"items": [
{
"id": "uuid",
"documentHash": "hex",
"label": "string",
"status": "success",
"createdAt": "ISO 8601",
"certLabel": "string",
"signatureType": "pades | cades | jades",
"hasP7s": "boolean — true when the detached signature is stored and downloadable",
"tsaName": "string | null"
}
]
}/seal/operations/:idJWT / API keySingle seal operation with the detail the evidence page needs: the sealing certificate's validity window, the ML-DSA-87 hybrid signer certificate when the seal is post-quantum hybrid, the linked signature-timestamp transaction ID, and any linked DocTimeStamp transaction IDs (B-LTA archival tokens). Each transaction's restamp chain is served by /api/transactions/:id/chain.
Response 200
{
"id": "uuid",
"documentHash": "hex",
"label": "string",
"status": "success",
"signatureType": "pades | cades | jades",
"tsaTransactionId": "uuid | null",
"docTimestampTransactionIds": [
"uuid"
],
"hasP7s": true,
"pqc": false,
"cert": {
"label": "string",
"source": "byoc | platform",
"certNotBefore": "ISO 8601",
"certNotAfter": "ISO 8601"
},
"pqcCert": "same shape | null"
}/seal/operations/:id/p7sJWT / API keyDownload the stored signature object for a seal operation — CAdES .p7s (application/pkcs7-signature) or JAdES .jades.json (application/jose+json) when the tenant has Store detached seals enabled, or the escrowed PAdES /Contents CMS (.pades.p7s, both the upload and delegated sealing paths) when Store PAdES seal data is enabled. Note the PAdES CMS signs the signature revision's ByteRange digest: it belongs in the PDF's /Contents slot — it is not a detached signature over the original file bytes.
Response 200
detached signature bytes (binary)Response 404
{
"message": "Signature not stored — enable Store detached seals in Settings, or download immediately after sealing."
}/seal/verifypublicVerify a sealed document. Accepts multipart/form-data. Routes automatically — if a p7s field is present, it is inspected: DER bytes verify as CAdES, JSON verifies as JAdES, both against the original file. Otherwise file is treated as a sealed PDF (PAdES).
Form fields
{
"file": "original file or sealed PDF (required)",
"p7s": "detached signature — .p7s (CAdES) or .jades.json (JAdES), auto-detected (opt)",
"tsr": "standalone .tsr token for external timestamp verification (opt)"
}Response 200 — PAdES
{
"format": "pades",
"pades": {
"signaturePresent": true,
"hashMatch": true,
"certificate": {
"subject": "CN=Acme Corp Seal",
"trust": "chained | dev_ca | self_signed",
"qc": {
"isEidasQualified": false
}
},
"timestamp": {
"genTime": "ISO 8601",
"tsaName": "string",
"qc": {
"isEidasQualified": true
}
}
}
}Response 200 — CAdES
{
"format": "cades",
"cades": {
"signaturePresent": true,
"hashMatch": true,
"fileHashHex": "hex",
"certificate": {
"subject": "CN=Acme Corp Seal",
"trust": "chained"
},
"timestamp": {
"genTime": "ISO 8601",
"tsaName": "string"
},
"postQuantum": {
"present": true,
"valid": true,
"algorithm": "ml-dsa-87",
"signatureValid": true,
"contentBound": "yes | no | not_checked",
"trusted": "yes | no | not_evaluated"
},
"tsrSource": "embedded | external | null",
"tsrMatchError": null,
"error": null
}
}Response 200 — JAdES
{
"format": "jades",
"jades": {
"signaturePresent": true,
"hashMatch": true,
"signatureValid": true,
"fileHashHex": "hex",
"embeddedDigestHex": "hex — sigD.hashV the signer committed to",
"certificate": {
"subject": "CN=Acme Corp Seal",
"trust": "chained"
},
"timestamp": {
"genTime": "ISO 8601",
"tsaName": "string"
},
"tsrSource": "embedded | external | null",
"error": null
}
}Error responses
{
"type": "https://tools.ietf.org/html/rfc9110#section-15.5.1",
"title": "Bad Request",
"status": 400,
"detail": "No file provided."
}/seal/verify-hashpublicVerify a detached CAdES or JAdES seal using content digests only. p7sBase64 carries either artifact — the format is detected automatically. For hybrid PQC seals, include hashHex512 to check the ML-DSA signer's SHA-512 content binding. Without it, the PQC signature can still be checked but postQuantum.contentBound is "not_checked".
Request body
{
"hashHex": "SHA-256/384/512 hex for the classical signer",
"hashHex512": "128-char SHA-512 hex for PQC binding (optional)",
"p7sBase64": "base64 of the detached signature — .p7s or .jades.json (auto-detected)",
"tsrBase64": "base64 standalone TSR (optional)"
}Response 200
{
"format": "cades",
"cades": {
"signaturePresent": true,
"hashMatch": true,
"signatureValid": true,
"postQuantum": {
"present": true,
"valid": false,
"algorithm": "ml-dsa-87",
"signatureValid": true,
"contentBound": "not_checked",
"trusted": "no | not_evaluated"
}
}
}/seal/verify-objectspublicObject-level verification of a multi-object JAdES seal, by digests only — the record-keeping verdict. Send the JWS plus a digest per referenced URI (the envelope's digest goes under the envelope reference the signature carries — sigD.pars[0]: sigill-envelope.json, or urn:sigill:envelope for earlier seals — like any other object; the two names are never interchangeable). Returns per-object verdicts and complete — true only when the signature verifies and every signed object was supplied and matched. A partial supply yields an honest "signature valid, record incomplete", never a blended verdict. Distinct from membership checks ("does this digest appear?") — use /seal/verify-hash for those.
Request body
{
"signature": "the General JWS JSON object (the artifact's signature member)",
"digests": {
"sigill-envelope.json": "64-char hex of the canonical envelope, under sigD.pars[0] as signed",
"objects/…": "64-char hex per referenced object"
},
"digests512": {
"sigill-envelope.json": "128-char SHA-512 hex — required to fully verify hybrid (pqc) seals",
"objects/…": "…"
},
"tsrBase64": "base64 standalone TSR (optional)"
}Response 200
{
"format": "jades",
"objects": {
"signatureValid": true,
"complete": true,
"objectCount": 3,
"suppliedCount": 3,
"matchedCount": 3,
"objects": [
{
"par": "uri",
"contentType": "MIME | null",
"supplied": true,
"hashMatch": true
}
],
"missing": [
"signed URIs you did not supply"
],
"unreferenced": [
"supplied URIs the signature never signed — flagged, never silently accepted"
],
"pqc": "absent | verified | failed | not_checked",
"underlying": "signature/certificate/timestamp detail",
"warnings": [
"skipped invalid signature entries, if any"
]
}
}sigD-bearing classical signature; object lists are never merged across signatures. Role coverage ("is a prompt and an output present?") is an envelope-layer check your verifier runs against its own copy of the envelope — Sigill sees URIs and digests, not roles.Hybrid (pqc) seals are both-required:
complete is only reachable when the ML-DSA-87 signer's mirrored SHA-512 commitment is also verified, via digests512. A hybrid seal verified with SHA-256 digests alone reports pqc: "not_checked" and complete: false — the classical verdict never masquerades as full hybrid verification. Agent runs
Agent runs recorded with Agent Evidence Profiles v1 — by the SDKs or the Sigill plugin for Claude Code and OpenAI Codex — appear in Evidence as one entry per agent, with its runs and each run's control basis (before), event chain (during) and control evaluations (after). The producer seals every artifact blind with POST /seal/sign-hashes and then uploads the signed envelope: step types, tool names, times, actor and correlation identifiers, and object digests. The producer decides what is uploaded; content (prompts, arguments, results, output) never is.
- Only your own seals are indexed. An upload is accepted only if it matches a successful JAdES seal made by your organisation: the same envelope digest and content type, the same object digests in signed order, and exactly the signature Sigill issued for that seal (protected header and signature value; timestamps and revocation values added later are allowed).
- Read views show identifiers, never free text. Envelope fields such as
step.detailand producer extensions are not returned by the read endpoints; the full signed envelope leaves only through the run-file export. - Verdicts are dated. A verdict describes the artifacts it was computed over. When artifacts are added later, or the verification rules change, it is reported as stale (
verdict: null,lastVerdictkept) until the run is verified again.
Recording with Sigill sign-in. The Sigill plugin (Claude Code and Codex) connects with OAuth instead of an API key and uses three MCP tools, listed only for connections that hold the opt-in scope mcp:agent:record: sigill_agent_recording_config (the organisation's active certificates, its own first, then the Sigill Platform Seal), sigill_seal_agent_artifact (blind JAdES seal of one Agent Evidence envelope digest and its object digests, with an explicit timestamp choice and an optional qualified (eIDAS) timestamp, off by default) and sigill_index_agent_artifacts (up to 50 signed envelopes per call, one result per item: indexed, exists, rejected or retry). They forward to the endpoints below, so the same binding rules apply. Recording calls have their own rate budget per connection and per organisation, separate from other connectors; a throttled call returns a tool error with retryable: true and retryAfterSeconds.
/api/agent-evidence/artifactsJWT / API keyIndex one sealed artifact (a Control Artifact or an Execution Evidence event). Idempotent per seal: uploading the same artifact again returns 200. An Execution Evidence event may be schemaVersion "1" to "4" and is validated against the schema of its own version; a version-4 member in a version 1–3 event is refused (422 schema_invalid). One run uses one version: a run that mixes them is indexed and then fails verification.
Request body (JSON)
{
"envelope": "the signed AgentControlArtifact or AgentExecutionEvidence envelope (max 64 KiB)",
"signature": "the JAdES JWS returned by /seal/sign-hashes",
"objectDigests": {
"urn:uuid:… (each envelope object uri)": "64-char SHA-256 hex — one per object (max 128)"
},
"controlSet": "optional, Control Artifact only: base64 of the policy control-set document (max 64 KiB)"
}Response 201 / 200 (JSON)
{
"status": "indexed | exists",
"runId": "uuid",
"artifactId": "uuid"
}not_sealed (no seal in your organisation has this envelope), signature_mismatch (not the signature issued for it), objects_mismatch, not_provable (an older seal whose signature was neither committed nor retained), schema_invalid, signature_invalid, run_limit (a run holds at most 2000 events, the portable run-bundle limit), or control_set_not_policy / control_set_mismatch / control_set_invalid (a controlSet that is not the policy control set the seal signed, or not a valid one), control_set_unexpected (sent with an event), or index_limit — signed values are stored exactly or not at all: agent id up to 255 characters, agent version 128, evidenceId 128, step.type 32, object URI 1024, role 32, content type 255 — or free_text_limit: a new artifact whose free text is over the profiles' limits (step.detail 512 characters; activity name, step.approver, step.decision and an object's content type 255; an object's metadata and the envelope's extensions 2,048 bytes each), the same rule the SDK applies before it seals (0.15.0); the message names the field and the limit, never the value. 409 seq_conflict / control_conflict when another seal already holds that position in the run; conflict when a concurrent upload won (retry). /api/agent-evidence/agentsJWT / API keyOne row per agent.id: run and event counts, runs with a control basis, runs with at least one event (withEvents), current verdict counts (finalized, invalid, notVerified — runs Sigill can check without a current verdict, except sessions still receiving events (activeUnchecked, checked in the background once they go quiet), stale; runs in the earlier draft format are counted in preV1, never in notVerified, because they are checked from the run file), mode (interactive when a person works with the agent — the Sigill plugin and browser extension recorders, or a producer that signs interaction: "interactive" in an extension of its control artifact or run_start — otherwise system), open runs split into active (an artifact received in the last 30 minutes) and idle, abandoned (system runs with at least one event, no run_end and nothing received for 24 hours — activity is measured by when Sigill received artifacts, never by producer-stated times; a run of which Sigill holds only the control basis and no event is never abandoned and never a finding: its steps were not shared with Sigill), outsideApproved (runs under an unapproved policy that the approved version would have flagged) and needsAttention (findings only: an invalid record, a policy violation, a run outside the approved policy, or an abandoned system run — an open interactive session or a run not checked yet is not a finding), policy outcome counts from each run's current Sigill policy evaluation (evaluated; passed = a finalized PASS covering every event; limited = an outdated or partial PASS; indeterminate; violations = FAIL — a superseded evaluation no longer counts), formats, TSAs, last run and attribution — organisation (sealed with your own certificate), platform (the Sigill Platform Seal: an advanced seal with Sigill’s organisation certificate) or unknown. The agent id is stated by the producer. Counts cover root runs; delegatesTo lists the sub-agents observed in this agent's runs (Agent Delegation v1: a sub-agent run's run_start names its parent) with their run counts and attribution — observed in signed runs, not a configured hierarchy. An agent that only ever ran as a sub-agent appears there, not as a row of its own.
/api/agent-evidence/runs?agentId=…JWT / API keyThe agent's sessions, newest first (page, pageSize, 50 by default). Runs that share a producer-stated session reference — a resumed session, or one split at the 2,000-event limit — are one session with several segments; a run without one is a session of its own. Each row: first and latest run, correlation id, producer-stated start and last activity, disposition (open, or what the latest run's run_end states: completed, failed, aborted, or halted — the agent's own guard stopped the run, Execution Evidence v4), event, consequential-step and sub-agent-step counts, tool names, phases (before = control basis, during = events, after = every segment has a sealed control evaluation), closed (every segment has a run_end), mode, activity (ended, active, steps_not_shared — of a system (non-interactive) session Sigill holds the control basis and no event, and nothing has arrived for 30 minutes: the steps stay with the producer unless it delivers them, so Sigill cannot say whether the run is running or has ended; within those 30 minutes such a run is active, and an interactive session with no event is active or idle, never this — idle — open but quiet for 30 minutes, normal for an interactive session — or abandoned), needsAttention, verdict (the weakest current verdict of its segments), stale and attribution. Sigill checks the integrity of every run in the background once it has been quiet for a few minutes, so verdicts stay current while sessions grow (long open sessions are re-checked less often — at most every 15 minutes from 200 artifacts, hourly from 1,000 — and every run is checked promptly once it ends). Filters: status (open, closed, invalid, attention — sessions with a finding, changed — a verdict exists but artifacts arrived or rules changed since, unchecked — a segment Sigill can check has no current verdict: never checked or changed since, and the session is not still active), subAgents=true, tool, from/to (ISO dates), q (correlation id or session reference). summary counts sessions, runs, open, invalid and not-verified runs, sessions with sub-agents, with a control basis and in the earlier draft format, and lists the agent versions, the agent's mode and the actor (submitter) of the latest control basis; attentionSessions, openSessions, closedSessions, invalidSessions and changedSessions count sessions per status (other filters applied), and evaluated counts runs with a sealed control evaluation. Each row's policy is the declared policy its first run sealed — version (the label that run sealed) and status (approved_before_run, approved_after_start or unapproved, with a reason) and schemaVersion ("2": the run is evaluated as a ControlEvaluation v3, and result.enforcement is its comparison) — or null. result is Sigill's sealed policy result for the session — overall (PASS, FAIL or INDETERMINATE, the worst over its segments), state (finalized or partial), outdated (events arrived after the evaluation) — or null until one is sealed. When a run declared a policy change that is not approved, approvedCheck holds the same facts against the agent's newest approved version — overall, the approved policyId, the rules that would have fired or stayed undecided — marked unsealed: true: Sigill's comparison, not part of the sealed evaluation. Sub-agent runs are never sessions of their own: each row carries delegations and subAgentRuns (id, correlation id, agent id, depth, events, closed, phases and current verdict), depth first.
/api/agent-evidence/objects?hash=…JWT / API keyFind by file: which of your indexed agent runs reference a content digest. Hash the file locally and pass one to three hex digests (hash, repeatable — SHA-256, SHA-384 or SHA-512); the file never leaves your machine. Returns up to 50 hits — run id, agent id, correlation id, seq, step type, profile, the object's role and kind, its SHA-256 and seal time — matched against the signed object digests of indexed artifacts, newest first. Only your organisation's runs are searched; malformed input returns 400. Pair it with GET /api/evidence?search=<hash> for the timestamps and seals of the same file.
Declared policies. An agent can seal a policy with each run: a control-set document of type application/vnd.sigill.control-set+json holding forbid-only Cedar rules, private controls and a coverage contract (Agent Policy Control Set v1, in the SDKs' spec/). The SDKs share it with DisclosePolicy / disclose_policy — the Control Artifact and the document travel together; no run content does. Each distinct approval scope is one version. An owner approves a version; Sigill records and seals the approval (approvalBasis: sigill_attested — it proves Sigill registered the approval, not that the owner signed it). Approving never switches a run to another version: every run shows the status of the version it sealed. Under a v1 policy nothing is stopped: Sigill observes and alerts.
Control Set v2. A document with "schemaVersion": "2" (Agent Policy Control Set v2, SDK 0.14.0) also declares enforcement and cedar.entities (the tools, agents and their groups the rules refer to), and each rule may carry an effect (observe, deny, halt). In enforce mode the agent's own Sigill SDK, by design, refuses tool calls that a deny or halt rule matches, can halt the run, and records each decision in the run's evidence. Sigill registers, strictly validates (against Cedar schema v2), shows and approves v2 versions — the approval covers the enforcement settings and the entities too. Sigill does not stop anything itself. It receives runs under a v2 policy (Execution Evidence v4, next paragraph), verifies that their record is consistent with itself and, once a run has finished, evaluates it: what the policy required of the agent's guard against what the run's record shows (Sealed policy evaluations, below). Its alerts are that evaluation's findings and what the guard itself recorded (see the alerts endpoint below). The editor writes v1 only: a v2 policy is changed as a file and registered with POST /api/agent-evidence/policies or shared by the agent's SDK with a run.
Execution Evidence v4: the guard's decisions. A run under a Control Set v2 policy is recorded as Execution Evidence schemaVersion "4" (Agent Enforcement v1, SDK 0.14.0): version 3 plus a required step.tool.useId on tool_call and tool_result; the object role tool-definition on a tool_call; the guard's enforcement record — an authorization with decision: "denied", step.rules (rule ids) and step.enforcer (engine, factsVersion, and reason: rule, rule_error, unknown_tool, tool_changed, unavailable or configuration_locked), sealed directly after the event it decides; step.covers on a human_approval (tool, argumentsSha256, optional useId and expiresAt); and runDisposition: "halted" on the run_end the guard seals when it stops the run. As everywhere, Sigill holds the signed envelopes and digests only: a tool alias, ids, rule ids and digests — never arguments, prompts or results. Verification adds the check enforcement to such a run: a result without its call (orphan_result), two results for one call (conflicting_result), a result for a call the guard refused (executed_after_denial), tool calls sharing a use id (duplicate_use_id), a record that does not directly follow the event it decides (misplaced_decision), a halted run_end without a record before it (unrecorded_halt), a run that continued after a record that stops it (continued_after_halt); and, for a run whose disclosed policy is Control Set v2 but whose events are not all version 4, evidence_version_mismatch. Any of them makes the run run_invalid: the record contradicts itself. The check does not evaluate the policy — a guard that skipped a refusal or a halt that was due is not detected by it; Sigill's sealed evaluation of the finished run does (policy.enforcement, Sealed policy evaluations below).
Timestamps for testing and for production. Testing and development: standard timestamps. Sigill's standard pool issues RFC 3161 timestamps from public TSAs at no extra cost. The pool is best-effort: Sigill fails over between several TSAs but promises no availability, no accuracy and no particular TSA over time; the timestamps prove existence at a time but have no eIDAS status. Production: qualified timestamps. When an agent acts on behalf of your organisation, or its evidence may be used in a dispute, an audit or with a supervisor, require qualified timestamps when approving the policy. They come from qualified trust service providers on the EU trusted list and carry a legal presumption of accuracy in every member state (eIDAS Article 41). With the requirement on, every timestamp the runs rest on must be qualified — a TSA counts as qualified only when its policy is a qualified one and it is listed as a qualified time-stamping service on the EU trusted lists — and Sigill shows when a run falls short. Configure the SDK to request qualified timestamps (Qualified = true / qualified=True); they draw on your plan's qualified quota. In short: test with standard, run production with qualified, and let the policy decide.
Sealed policy evaluations. For a run whose policy has Cedar rules, Sigill evaluates the run once it has finished and been quiet for 10 minutes (a run that never finishes: as partial after 24 hours) and seals the result as a Control Evaluation v2 (kind: "policy") with the Sigill Platform Seal, a timestamp and the role urn:sigill:role:policy-evaluator in the seal's signer attributes — a role no customer seal can carry. The evaluation carries its facts (one Cedar request per signed event, factsVersion 1): anyone can rebuild them from the run's signed envelopes and reproduce the result with the open Cedar engine; for a version-1 policy the run view does so in your browser (a version-2 evaluation is not recomputed there). Late events lead to at most two corrections, each superseding the previous evaluation. Sigill's evaluations do not count against your agent evidence quota. Runs under a Control Set v2 policy are evaluated as a ControlEvaluation v3 (SDK 0.16.0): facts version 2 and the per-rule results as above, plus policy.enforcement — for each event, what the policy required the agent's guard to do (due: none, refused, halted, with dueReason and dueRules) against what the run's record shows (recorded), with an outcome: as_required, let_through (findings refusal_missing, unknown_tool_allowed, configuration_not_enforced, halt_missing), over_enforced (unfounded_record, unfounded_halt, reason_mismatch, rules_mismatch), not_checkable (the guard recorded that its engine was unavailable) or pending (the evaluated steps end there); a result over the run; or comparison: "not_performed" with notPerformed: chain_inconsistent, engine_inconsistent or engine_unavailable (the guard's records name a Cedar version Sigill does not run) — never a pass. A rule's result keeps its meaning: a rule that matched is FAIL also where the guard refused as required, so for such a run read enforcement beside overall. The run view returns it as after.evaluations[].enforcement (comparison, notPerformed, recordedEngine, result, decisions[]: seq, due, dueReason, dueRules, recorded, outcome, findings), the session list as result.enforcement (result, notPerformed, and how many decisions were asRequired, letThrough, overEnforced, notCheckable), and the agent counts read it: a call let through is a violation and needs attention, a comparison not performed needs attention, a run as required or over-enforced passes. The comparison shows only what the record shows: not which tool in fact ran under a call's name, nor what ran outside the recorded run.
/api/agent-evidence/policies[?agentId=…]JWT / API keyThe agent's declared policy versions, newest first — or, without agentId, every policy version of every agent in your organisation, including agents with no runs yet (each version names its agentId): control set id, version label, approvalScopeDigest, cedarDigest, first seen, rules (id and the action each is scoped to — all, tool_call, run, …), coverage, private control ids, run count and last run, runsSinceApproval, approvals (effective time, basis, revocation) and state (approved, revoked or unapproved). schemaVersion ("1" or "2") and, for v2, enforcement with the defaults applied — mode, defaultEffect, lockedConfiguration, unknownTools, onRuleError, haltAfterDenials and ruleEffects (each rule's effective effect; every rule is observe unless the mode is enforce); null for v1.
/api/agent-evidence/policies/:idJWT / API keyOne version: the policy document, its digests, controlSetText — the registered document's exact text, whose UTF-8 bytes hash to controlSetSha256 (the file to give the agent) — schemaVersion and enforcement (as in the list), the published schema digest of its version, approvals, the version it is compared with (previous: the newest other version still approved, else the newest seen before it) and a diff per member (cedar, entities, enforcement, schemaVersion, coverage, privateControls, controls) with rules added, removed and changed (a changed effect is a changed rule) — a rule diff, not a formal analysis.
/api/agent-evidence/policies/alerts?agentId=…&state=…JWT / API keyPolicy alerts, one per agent, approval scope and signal. From Sigill's sealed policy evaluations: a rule that fired (rule:<id>), a rule that could not be evaluated (indeterminate:<id>), qualified time required but not met (qualified-time), a run under an unapproved policy (unapproved), a rule of the approved version that such a run would have broken (outside-approved:<id>) or one approved only after it started (approved-after-start). Each with state (open, muted, resolved), occurrences, first and last seen, the latest run (lastRunId, and lastRunCorrelationId — the id the run list shows) and where. New and reopened alerts are emailed to the organisation's owners, one email with everything pending, at most one an hour and six a day however many alerts there are; an alert still open after a day is mentioned again. No run content is ever in an alert or an email.
Runs under a Control Set v2 policy raise the signals above from Sigill's evaluation, except that a rule's rule:<id> is not raised where every step it matched is one the guard refused or halted as required, or a call let through under that rule (its own alert names the rule). The evaluation adds: a call the guard let through where a rule required a refusal (refusal-missing:<rule>, or refusal-missing for a tool whose definition is not the one the policy names), a run not halted where the policy required it (halt-missing), a tool the policy does not list let through (unknown-tool-allowed), a run whose locked configuration was not enforced (configuration-not-enforced), a refusal or halt the policy did not require (over-enforced), and a run not compared with the policy (not-compared:chain_inconsistent, not-compared:engine_inconsistent, not-compared:engine_unavailable). Their alerts also include what the agent's own guard recorded in the run (Execution Evidence v4): a tool call refused because a rule matched (guard-denied:<rule>), a run halted because a rule matched an event that is not a tool call (guard-halt-rule:<rule>), a call refused because a rule could not be evaluated (guard-rule-error:<rule>), a tool the policy does not list (guard-unknown-tool), a tool whose definition is not the one the policy names (guard-tool-changed), an event the guard could not evaluate, which stops the run (guard-unavailable), a start refused because the run's configuration is not the one the policy locks (guard-config-locked), and a halted run (guard-halt). Such an alert holds the rule id, the reason and the event number (where: seq N) — never the tool alias, arguments or results — and its occurrences count runs, not refusals. Sigill stopped nothing: it reports what the guard sealed, and only from a run whose current verification is not run_invalid and whose enforcement check is ok. An invalid run raises a verification finding instead, and a run that has not been checked yet raises its alerts once it has: Once a run's run_end has arrived (with its control basis and every event before it), Sigill checks it right away, and otherwise when it has been quiet for three minutes (a long run that is still growing at most every 15 or 60 minutes), without waiting for run_end. When it is the organisation's first email within the hour, the email usually follows within seconds of the run's end, at most about a minute later when another collection is running; later alerts are bundled into the next allowed email. These immediate checks share one queue with the Check button across organisations, so under heavy load both can wait. A refusal in a run that keeps going is alerted when the run ends or goes quiet, not while it runs. A rule the guard did not act on — an observe rule, or a guard in observe mode — seals no guard record; Sigill's evaluation raises its rule:<id>. A run whose policy was never shared with Sigill raises no alert.
/api/agent-evidence/policies/alerts/:id/mute | unmute | resolveJWT · ownerMute an alert (it is still counted but never emailed), unmute it, or resolve it (a new hit reopens it and emails again). Owners only (role checked against the database); recorded in the audit log.
/api/agent-evidence/policiesJWT · ownerRegister a policy before the agent's first run, so it can be approved up front (the policy editor under Evidence → Agents does this). Body: agentId (the agent.id the agent's runs will sign) and controlSet — base64 of the exact control-set document bytes the agent will seal. The document — Control Set v1 or v2 — gets the same checks as one a run discloses (structure, rules, the published Cedar schema of its version) plus strict Cedar validation: the rules, and for v2 the entities, against that schema (422 policy_invalid, 503 policy_validation_unavailable). Returns {"{"}id, created, approvalScopeDigest{"}"}: 201 for a new version, 200 when the agent already has this approval scope. Then approve it with POST /api/agent-evidence/policies/:id/approve: a run whose Control Artifact seals the same approval scope links to this version, so it shows as approved before run from the very first run.
/api/agent-evidence/policies/:id/approveJWT · ownerApprove a version. Approving also resolves that version's unapproved and outside-approved:<id> alerts (a new hit reopens them); rule alerts stay. Body: { "revokeApprovalIds": [], "requireQualifiedTimestamps": false } — optionally, active approvals of other versions of the same agent to revoke at the same time (each must be one; otherwise 409 revoke_mismatch), and whether every timestamp the agent's runs rest on must be qualified (eIDAS): the approval itself, the control basis, every stamped step, run_end and Sigill's evaluation. The requirement is part of the sealed approval record, the approval is then itself sealed with a qualified timestamp, and each evaluation states whether the requirement was met and where not. It needs a paid plan with a qualified quota (402 qualified_timestamps_not_in_plan); a qualified timestamp that cannot be obtained is never replaced by a standard one. The policy must validate in Cedar's strict mode against the published schema of its version, v2 entities included (422 policy_invalid; 503 policy_validation_unavailable when it cannot be checked — it is then not approved). The decision is stored first and sealed second: an approval counts only once its sealed record is stored, so every sealed record names a stored decision; if sealing fails the approval stays pending (502 approval_pending) and approving again completes it. Approval changes of one agent are applied one at a time, and a version has at most one active approval. Owners only (role checked against the database); API keys are refused. 409 already_approved / approval_in_progress / no_seal_certificate / conflict.
/api/agent-evidence/policies/:id/approvals/:approvalId/revokeJWT · ownerRevoke an approval. The revocation is in effect as soon as it is stored and is then sealed; if sealing fails (502 revocation_pending) revoking again completes the seal. Runs from then on that seal the version show as unapproved; earlier runs keep their status. 409 already_revoked.
/api/agent-evidence/runs/:idJWT / API keyOne run: run.activity (the activity of the run's session, as its row in the unfiltered session list states it), attribution (with the signing certificate's subject) and signerCertificate (issuer, notAfter), structural checks recomputed on every request (correlation, sequence, chain, envelope, binding), the stored verdict with its checks and warnings, the control basis (agent, actor, control set, timestamp policy, object digests, seal time, TSA) and every event (seq, step type, tool name, operation and use id, authorization decision and policy id, consequential flag, producer-stated event time, seal time, TSA, signature and previous-signature SHA-256, bindsControl on run_start, object digests, sub-agent id and type when the producer tags them; on a model_output sealed under Agent Model Calls v1 (schemaVersion "3"): step.model — provider, served and requested model, deployment, region — step.vendorRefs, the provider's own ids for the call (provider, kind, id), and step.usage, token counts and stop reason, all as the provider returned them; on Execution Evidence v4 (schemaVersion "4"): step.rules and step.enforcer — engine, facts version and reason — on an enforcement record of the agent's own guard, step.covers — tool, arguments SHA-256, use id, expiry — on a human_approval, and runDisposition: halted on run_end), plus after: the final output's digests, the run_end closure checks and evaluations — the run's sealed control evaluations, oldest first: kind (policy for Sigill's own), overall, state, policyStatus, throughSeq, each rule's result and where (the seqs, or run, that produced it), the evaluator and engine, sealedFor (urn:sigill:role:policy-evaluator on Sigill's seals), current (no later evaluation supersedes it), outdated, and timestamps when the approval requires qualified time — met and where it was not (approval, control, a seq, run_end). For Agent Delegation v1: tree.parent (the parent run its run_start names, and whether it is in your index), tree.subAgentRuns, bindsParentDelegation on a sub-agent's run_start, and step.delegation on delegation / delegation_result events — the child's correlation id and agent id, the tool use id, and the child's run_end signature SHA-256 and disposition. What the parent asked the sub-agent stays a digest. policy: the declared policy the run sealed — declared/shared, control set id and the version label the run sealed, approvalScopeDigest, cedarDigest, status (approved_before_run, approved_after_start, unapproved, or not_assessed with reason: agent_mismatch when the run's events name another agent than its policy) and reason, the approval it rests on and approvedBy (the email of the member who approved it, from Sigill's own approval record) (an approval counts before the run only if it was effective at least the timestamp's stated accuracy — 1 s when none is stated — before the Control Artifact's timestamp), stamp (stampedAtSealing: the Control Artifact's timestamp was issued in its own sealing operation, which approved_before_run requires; genTime; qualified), and the Cedar rules, coverage contract and private controls for checking the run, with schemaVersion and, for a Control Set v2 policy, enforcement (as in the policy list; such runs are evaluated as a ControlEvaluation v3, see after.evaluations[].enforcement). session.segments lists the runs of the same session (id, start, events, closed, checkable — Sigill can check it, not an earlier-draft run or over the event limit — and current — whether its stored verdict still describes it, so a client re-checks only the segments that need it).
/api/agent-evidence/runs/:id/verifyJWT / API keyFull verification of the run — signatures, certificates, timestamps against the signed policy, chain, binding and finalization — and stores the verdict: run_finalized, run_open or run_invalid, with checks, findings, warnings and scope, the statement of what the verdict does and does not establish. objects: warn means the content is not held by Sigill, so it was not re-hashed — its digests are signed. A version-4 run has a tenth check, enforcement (the guard's records are consistent with the rest of the run; see Execution Evidence v4 above), and a run under a disclosed Control Set v2 policy whose events are not all version 4 fails it; it says nothing about whether the guard refused everything the policy required — Sigill's sealed evaluation (ControlEvaluation v3) does. evaluations reports every control evaluation on its own (it never changes the run verdict): valid, current, overall, and for a policy evaluation factsMatch (the facts rebuilt from the run's signed events equal the sealed ones, byte for byte), policyDigestsMatch and sealedFor. 422 run_limit for runs above 2000 events.
/api/agent-evidence/runs/:id/checkJWT / API keyThe same full verification as /verify, run by Sigill's background checker right away instead of inside the request — use it for long runs, whose check can take longer than an HTTP request may stay open. 202 { queued: true, verifiedAt } (also when the run is already queued; verifiedAt is the current verdict's time, omitted if the run was never checked). Follow it with GET /api/agent-evidence/runs/:id/check: verdict, verifiedAt (changes when the check is done), queued (still queued or being checked) and failedUntil (the check did not finish; Sigill retries after that time). 404 for a run outside your organisation, 409 for runs in the earlier draft format, 422 run_limit above 2000 events, 429 check_tenant_limit when your organisation already has 25 checks queued, or a plain 429 above 60 check/verify requests a minute, 503 check_queue_full when the service has too many checks queued.
/api/agent-evidence/runs/:id/bundleJWT / API keyThe run as a portable AgentRunBundle (signed envelopes and signatures, no content) for offline verification with an SDK or the Verify a run bundle page. Sealed control evaluations travel with the objects needed to check them — the policy control set, the facts and the approval record — never run content.
/api/agent-evidence/runs/:id/etsi-exportJWT / API keyThe run for ETSI JAdES validators such as EU DSS: a zip (export format 2) with one folder per artifact holding its detached JAdES signature (signature.jws.json) and the byte-exact canonical envelope it signs, stored under the signed reference (sigill-envelope.json; envelope.json for seals that name it urn:sigill:envelope), plus a manifest.json listing every other signed object by URI and SHA-256, and a README with validation steps. Each seal validates on its own (JAdES-BASELINE-B, or -T where timestamped); that the steps form one closed run is checked with the AgentRunBundle above. No content is included.
/api/agent-evidence/runs/:id/treeJWT / API keyAgent Delegation v1: the run tree containing this run — its root (following the signed parent links upwards) and every sub-agent run below it, from your organisation's index only. Each run: id, correlation id, agent id and version, parentCorrelationId, start, events, control basis and run_end present, delegation count and current verdict. Structure only, no cryptography; truncated when the tree is larger than a run tree may be (256 runs, 8 levels).
/api/agent-evidence/runs/:id/tree/verifyJWT / API keyVerifies every run of the tree and every delegation edge between them, and stores each run's own verdict. verdict: tree_finalized, tree_open or tree_invalid; edges with binding (mutually_bound, child_missing, parent_missing, unbound) and completion (result_bound, result_mismatch, result_unresolved, no_result); structural findings by code; openReasons (run_open, delegation_pending, parent_terminated); each run's verdict and affiliation; the tree fingerprint and scope. A child the parent recorded a result for but that is not in your index makes the tree tree_invalid — withheld evidence. 422 tree_limit above 20,000 events.
/api/agent-evidence/runs/:id/tree/bundleJWT / API keyThe tree as a portable AgentRunTreeBundle (one AgentRunBundle per run, no content), verifiable offline with the SDK's tree verifier or the Verify a run bundle page.
Findings and their handling
Every stored verdict carries findings (in verification.summary and handling of the run): stable codes with a category — integrity_check_failed (a signature, timestamp or chain-link check failed), verification_failed (a check failed and its cause is not established), record_inconsistent (for example events after run_end) or evidence_incomplete (referenced or required evidence is not in your index) — plus the check and event seq where it was found. Findings say what verification established, never who changed what or why. A system run with at least one event, no run_end and nothing received for 24 hours adds run_abandoned; a run with no event never does. The run's handling block holds the current assessment — its key identifies the exact assessment: the evidence, rules version, finding code set, every finding with its location, and whether the run is abandoned — the state (open, acknowledged, none once a later verification found none of the findings, or unchecked while a new check is pending), the report preview and the latest history (historyTotal counts all of it). Level 1 adds acknowledged (acknowledged failed checks and abandoned runs) and acknowledgedInvalid (acknowledged failed checks only); level 2 rows add acknowledged and findingCategory, with status=acknowledged and acknowledgedSessions. needsAttention counts only findings that are not acknowledged.
/api/agent-evidence/runs/:id/acknowledgeJWT · ownerAcknowledge the run's current findings: an owner has seen them and taken responsibility. It never makes the evidence valid or changes the verdict. Body: assessment (the handling.assessment.key you were shown) and reason (required, at most 1,000 characters). It holds only for that assessment: re-checking identical evidence keeps it; new evidence, a rules or finding-code change, different findings, or the run becoming abandoned makes it open again. 409 assessment_changed when the assessment changed since you were shown it; 422 nothing_to_handle without findings. Recorded append-only with the owner, the time and a snapshot of the assessment.
/api/agent-evidence/runs/:id/reopenJWT · ownerReopen an acknowledged run (same body: assessment and a required reason). 409 not_acknowledged when it is not acknowledged.
/api/agent-evidence/runs/:id/reportJWT · memberReport the run's findings to Sigill support (tenant member). The ticket holds the run and correlation ids, agent, verdict, assessment and finding codes — shown to you before sending as handling.reportPreview — and an optional note; never envelopes, prompts, arguments or results. Sigill support is notified by email with the reporter's name, email and organisation id. One ticket per assessment: a repeat returns the same ticketId with existing: true. Body: assessment (the key you were shown), optional note; 409 assessment_changed as above.
/api/agent-evidence/runs/:id/handling-receiptJWT / API keyA JSON receipt: the current assessment and the complete handling history, newest first — each entry with its action (acknowledge, reopen, reported, resolved), actor (member id and email; the id stays when a member leaves), time, reason, ticket reference and a snapshot of the assessment it was made against. It records how the findings were handled; it never states that the evidence is valid.
GitHub Actions API
Install the Sigill app on your GitHub organisation, choose the repositories in GitHub, and accept the connection in Sigill (Settings → Apps → Connect GitHub). Workflows in those repositories then timestamp and seal build output with no Sigill key or secret stored in GitHub: the job requests its GitHub OIDC identity token (audience https://sigill.ai, permission id-token: write) and exchanges it for a 15-minute Sigill token. Only digests are sent. Each timestamp or seal is linked to the repository, commit, ref and run taken from GitHub's signed token — not from the request — and shown on the evidence page. Only runs triggered by push, release, workflow_dispatch or schedule are trusted — never pull requests.
Trust model. Anyone who can run such a workflow in a repository the app covers can issue evidence as your organisation — the same reach as an API key stored in that repository's secrets, without the key. Control it in GitHub: install the app only on the repositories that should produce evidence, and use GitHub's branch protection and environments for who can push and run workflows. Sigill adds no settings of its own.
/api/ci/github/tokenGitHub OIDC tokenSend the GitHub OIDC token as Authorization: Bearer <token> (required for GitHub-hosted runners to pass the edge firewall); an optional body { tenantId } pins the organisation you expect. Admitted when the repository's GitHub organisation is connected to a Sigill organisation and the Sigill app is installed on the repository — checked with GitHub on every exchange, so removing a repository or uninstalling the app in GitHub takes effect within a minute. tenantId optionally pins the organisation you expect. Each GitHub token can be exchanged once. The credential only issues new evidence: on /tsa/stamp-hash every call creates its own record (with the workflow as Issued by), even for a hash your organisation already has; on every seal and stamp path, tags apply only to an artifact the workflow brought in; and sealOperationId is accepted only for a seal the same workflow run issued (delegated PAdES), otherwise refused (403 ci_issue_only).
Response 200
{
"accessToken": "eyJ…",
"tokenType": "Bearer",
"expiresAt": "ISO 8601",
"sessionId": "uuid",
"tenantId": "uuid"
}Errors
401 invalid_id_token
403 event_not_trusted
403 github_not_connected
403 repository_not_covered
409 id_token_replayed
429 rate limited
503 github_unavailable
503 github_app_not_configuredThe returned bearer token works only on POST /tsa/stamp-hash, POST /seal/sign-hash (CAdES, or JAdES with format: "jades"; certificateId optional — the Sigill Platform Seal is used when omitted; your organisation's own certificate only when named) and POST /seal/sign-hashes, and stops working as soon as the connection is removed in Sigill. Seals follow the usual plan rules (JAdES needs Business or Scale); timestamps work on every plan. A seal with your organisation's own certificate also needs a signing rule that matches the run (below); without one it is refused with 403 signing_rule_required. The Sigill Platform Seal needs no rule.
/api/tenants/{id}/ci/signing-rulesJWT + memberSigning rules: which workflows may seal with your organisation's own certificates. Returns certificates, repositories (those that have run a workflow with Sigill), rules and blocked (refused seal requests of the last 30 days).
/api/tenants/{id}/ci/signing-rulesJWT + ownerGitHub Actions: body { certificateId, provider: "github", repositoryId, workflow, refPattern, environment? }. Google Drive: { certificateId, provider: "google", googleEmail? } — one Google account in your verified, connected domain, or everyone in it when omitted. A GitHub rule matches a run when the GitHub-signed identity token names that repository id, the workflow file under .github/workflows/, a ref matching refPattern (* is the only wildcard, e.g. refs/tags/v*) and, when set, that environment. DELETE /api/tenants/{id}/ci/signing-rules/{ruleId} removes one (owner).
/api/tenants/{id}/ci/provenance?hash=JWT + memberThe verified workflow runs behind one evidence (by content hash). GET /api/tenants/{id}/ci/runs lists recent runs with their evidence counts and links to the first ten evidence items (repositoryId, provider, before, limit filters).
Most workflows do not call these endpoints directly: the Sigill Evidence action (sigill-ai/evidence-action@v1) does the exchange, hashing and upload. Setup guide with screenshots: Apps → GitHub.
Google Drive add-on API
The Sigill add-on for Google Drive timestamps and seals files you select in Drive. It hashes the file inside Google and sends only the digest. Connect your organisation's DNS-verified domain under Settings → Apps → Google Drive; your Google admin decides who gets the add-on. There are no API keys: the add-on proves who you are with your Google ID token. Sealing with your organisation's own certificate from Drive needs a signing rule for the person or the whole domain (/api/tenants/{id}/ci/signing-rules, above); otherwise 403 signing_rule_required. The Sigill Platform Seal needs no rule.
/api/ci/google/tokenGoogle ID tokenExchanges the signed-in user's Google ID token (sent as Authorization: Bearer) for a Sigill token, valid until that Google token expires (at most one hour), that can only call POST /tsa/stamp-hash, POST /seal/sign-hash, POST /seal/sign-hashes and POST /seal/sign-pades-hash (a sealed PDF: the add-on writes the PDF signature revision inside Google and sends only its ByteRange digest), and list the seal certificates it may use (GET /seal/certificates). Accepted only for tokens Google issued to the Sigill add-on, for a verified Google Workspace account whose domain is connected. Each ID token can be exchanged once. Evidence issued with the Sigill token records the Google user and domain under "Issued by".
Response 200
{
"accessToken": "eyJ…",
"tokenType": "Bearer",
"expiresAt": "ISO 8601",
"sessionId": "uuid",
"tenantId": "uuid"
}Errors
401 invalid_id_token
403 google_not_connected
409 id_token_replayedMCP server
/mcpOAuth / API keyModel Context Protocol server (Streamable HTTP, JSON-RPC 2.0) for AI assistants and agents. Stateless: protocol 2026-07-28 (per-request metadata, server/discover) and the earlier initialize-based versions 2025-11-25, 2025-06-18 and 2025-03-26; no sessions, no GET stream. Every tool declares a title, read-only/destructive hints and an output schema, and returns structured content alongside text.
Connect from ChatGPT or Claude: add https://api.sigill.ai/mcp as a custom connector and sign in when asked. You are sent to a Sigill consent page; approving connects the assistant to your current organisation with the permissions shown (read evidence and usage, create timestamps, create seals — and, only if you tick it, organise evidence). Manage or disconnect it under Settings → Connectors; owners see and can disconnect their members' connections, and removing a member ends theirs immediately. Scripts and Claude Code can keep passing an API key as Authorization: Bearer <key>. sigill_verify, sigill_inspect, sigill_lookup, sigill_verify_seal_hash and sigill_verify_objects work without signing in.
OAuth details (for client developers): authorization code with PKCE (S256), public clients only. Discovery at /.well-known/oauth-protected-resource and /.well-known/oauth-authorization-server; client ID metadata documents, or dynamic registration at POST /oauth/register with redirect URIs limited to known assistant callbacks and loopback /callback; GET /oauth/authorize, POST /oauth/token, POST /oauth/revoke. Scopes mcp:read, mcp:stamp, mcp:seal, mcp:evidence:write (opt-in), mcp:agent:record (opt-in, see Agent runs), offline_access. Access tokens last one hour and are valid only at /mcp; refresh tokens rotate on every use, and reusing an old one disconnects the app. Native apps may use a loopback redirect registered without a port (http://127.0.0.1/callback) and choose the port at runtime (RFC 8252 §7.3), and may send an opaque device_id (16–64 of A-Z a-z 0-9 - _) with a short device_label so each device keeps its own connection.
No document content. The MCP server has no document upload or download capability, in either direction. Tools take hashes, evidence tokens (timestamp tokens, detached signatures) and ordinary text arguments such as labels and tags, and return the same. Hash files locally (sha256sum, Get-FileHash) and pass the hex digest. Detached seals (CAdES .p7s, JAdES) are created and verified over the digest; save the returned signature next to the file. Embedded PDF (PAdES) seals need the document, so they are not available over MCP — use the SDKs (delegated PAdES, the PDF still stays local), the web app or the seal endpoints.
Tools
sigill_stamp timestamp a hex digest — TSA choice,
second digest, reminders, tags (key)
sigill_verify digest + TSR → match / signature check
sigill_inspect TSR metadata
sigill_lookup public existence check (opt-in records)
sigill_list_tsas authorities you can choose (key)
sigill_seal_hash detached CAdES/JAdES seal over a digest,
signature returned inline; timestamped
when a TSA responds (key)
sigill_verify_seal_hash verify a detached seal by digest
sigill_seal_objects multi-object JAdES seal by digests,
≤32 objects, URIs ≤256 chars (key)
sigill_verify_objects verify a multi-object seal by digests
sigill_list_operations recent seal operations + level (key)
sigill_list_certificates seal certificates (key)
sigill_usage plan, quotas, trials, features (key)
Evidence store (key):
sigill_list_evidence list/filter evidence; ids, hashes, links
sigill_get_evidence restamp chain or seal detail
sigill_evidence_events custody event log
sigill_list_validation_reports / sigill_get_validation_report
ETSI TS 119 102-2 reports (XML)
sigill_export_evidence_record RFC 4998 .ers (base64)
sigill_get_timestamp_token stored .tsr (base64)
sigill_tag_evidence · sigill_label_evidence · sigill_archive_evidence
sigill_set_evidence_reminders · sigill_verify_evidence
sigill_revalidate_evidence · sigill_list_renewal_jobs
sigill_restamp_evidence · sigill_reseal_evidence (dry run by default)
search · fetch evidence search for ChatGPT deep researchLimits
request body 256 KB
rate per organisation, and a smaller
shared limit for unauthenticated calls
→ HTTP 429, code "rate_limited"sigill_create_upload, sigill_seal_uploaded_file and sigill_verify_uploaded_seal and their upload/download URLs have been removed; calling them is now a protocol error (Unknown tool). Use sigill_seal_hash / sigill_verify_seal_hash for detached seals, and the SDKs or the web app for PDFs. Code examples
Stamp a file with curl
# 1. Hash your file locally — the file never leaves your machine
HASH=$(sha256sum yourfile.pdf | awk '{print $1}')
# 2. Stamp the hash — "auto" uses Sigill-managed standard
# RFC 3161 timestamping with redundancy and failover.
curl -X POST https://api.sigill.ai/tsa/stamp-hash \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"hashHex": "'"$HASH"'",
"tsaSlug": "auto",
"label": "yourfile.pdf"
}' | jq .
# 3. Save the .tsr token
curl -X POST https://api.sigill.ai/tsa/stamp-hash \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"hashHex":"'"$HASH"'","tsaSlug":"auto"}' \
| jq -r .tsrBase64 | base64 -d > yourfile.tsrStamp a file with Python
import hashlib, base64, httpx
API_KEY = "your_api_key"
BASE_URL = "https://api.sigill.ai"
# Hash the file locally — it never leaves your machine
with open("yourfile.pdf", "rb") as f:
hash_hex = hashlib.sha256(f.read()).hexdigest()
resp = httpx.post(
f"{BASE_URL}/tsa/stamp-hash",
headers={"Authorization": f"Bearer {API_KEY}"},
json={
# "auto" uses Sigill-managed standard RFC 3161 timestamping.
# Use a verified BYOT reference when you need a customer-managed TSA endpoint.
"hashHex": hash_hex,
"tsaSlug": "auto",
"label": "yourfile.pdf",
},
)
resp.raise_for_status()
data = resp.json()
# Save the .tsr token
tsr_bytes = base64.b64decode(data["tsrBase64"])
with open("yourfile.tsr", "wb") as f:
f.write(tsr_bytes)
# data["tsaName"] reports timestamp token issuer metadata or your BYOT label
print(f"Stamped at {data['genTime']} by {data['tsaName']}")Stamp a file with Node.js
import fs from "fs";
import crypto from "crypto";
import fetch from "node-fetch";
const API_KEY = "your_api_key";
const BASE_URL = "https://api.sigill.ai";
// Hash the file locally — it never leaves your machine
const hashHex = crypto
.createHash("sha256")
.update(fs.readFileSync("yourfile.pdf"))
.digest("hex");
const res = await fetch(`${BASE_URL}/tsa/stamp-hash`, {
method: "POST",
headers: {
"Authorization": `Bearer ${API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
// "auto" = Sigill-managed standard timestamping with failover. Recommended for production.
hashHex,
tsaSlug: "auto",
label: "yourfile.pdf",
}),
});
if (res.status === 502) {
// All TSAs failed — inspect the structured failure list
const err = await res.json();
console.error(`${err.attemptsTried} TSA(s) failed:`, err.failures);
process.exit(1);
}
const data = await res.json();
// Save the .tsr token
const tsr = Buffer.from(data.tsrBase64, "base64");
fs.writeFileSync("yourfile.tsr", tsr);
console.log(`Stamped at ${data.genTime} by ${data.tsaName}`);Seal a non-PDF file (CAdES) with curl
For PDFs the response is a signed PDF; for any other file you get a .p7s detached signature. Check X-Seal-Format to branch.
# Seal any file — PDF gets PAdES, everything else gets CAdES .p7s
CERT_ID="<your-certificate-uuid>"
FILE="report.json"
RESPONSE=$(curl -s -D - -o /tmp/sealed_output -X POST https://api.sigill.ai/seal/sign -H "Authorization: Bearer YOUR_API_KEY" -F "file=@$FILE" -F "certificateId=$CERT_ID" -F "label=$FILE" -F "qualified=false")
FORMAT=$(echo "$RESPONSE" | grep -i "x-seal-format:" | tr -d '
' | awk '{print $2}')
if [ "$FORMAT" = "cades" ]; then
# Non-PDF: response is a detached .p7s signature
# Keep both the original file and the .p7s — you need both to verify
mv /tmp/sealed_output "${FILE%.json}.p7s"
echo "CAdES seal saved: ${FILE%.json}.p7s"
echo "Keep alongside original: $FILE"
else
# PDF: response is the sealed PDF with embedded signature
mv /tmp/sealed_output "${FILE%.pdf}_sealed.pdf"
echo "PAdES seal saved: ${FILE%.pdf}_sealed.pdf"
fiSeal a non-PDF file (CAdES) with Python
import httpx, pathlib
API_KEY = "your_api_key"
BASE_URL = "https://api.sigill.ai"
CERT_ID = "<your-certificate-uuid>"
file_path = pathlib.Path("report.json")
with open(file_path, "rb") as fh:
resp = httpx.post(
f"{BASE_URL}/seal/sign",
headers={"Authorization": f"Bearer {API_KEY}"},
files={"file": (file_path.name, fh, "application/octet-stream")},
data={
"certificateId": CERT_ID,
"label": file_path.name,
"qualified": "false",
},
timeout=60,
)
resp.raise_for_status()
fmt = resp.headers.get("x-seal-format", "pades")
if fmt == "cades":
# Non-PDF: detached CAdES .p7s — store alongside the original file
out = file_path.with_suffix(".p7s")
out.write_bytes(resp.content)
print(f"CAdES seal → {out}")
print(f"Keep original file: {file_path}")
print(f"Verify: POST /seal/verify with file={file_path.name} + p7s={out.name}")
else:
# PDF: sealed PDF with embedded PAdES signature
out = file_path.with_stem(file_path.stem + "_sealed").with_suffix(".pdf")
out.write_bytes(resp.content)
print(f"PAdES seal → {out}")Verify a CAdES seal with curl
# Verify a CAdES seal — pass original file + .p7s
# The server checks the signature and returns structured JSON
curl -s -X POST https://api.sigill.ai/seal/verify \
-F "file=@report.json" \
-F "p7s=@report.p7s" \
| jq '{
format: .format,
intact: .cades.hashMatch,
signer: .cades.certificate.subject,
timestamp: .cades.timestamp.genTime,
tsa: .cades.timestamp.tsaName,
qualified: .cades.timestamp.qc.isEidasQualified
}'
# To also verify the embedded timestamp against the standalone .tsr:
curl -s -X POST https://api.sigill.ai/seal/verify \
-F "file=@report.json" \
-F "p7s=@report.p7s" \
-F "tsr=@report.tsr" \
| jq '.cades.tsrSource' # → "external" when .tsr matchedSeal & verify JSON data (JAdES) with curl
JAdES is the ETSI signature format for JSON — ideal for API payloads, structured records, and AI conversation logs. Only the hash leaves your machine.
# Seal JSON data as JAdES (ETSI TS 119 182-1) — hash-only, the file never leaves your machine
CERT_ID="<your-certificate-uuid>"
FILE="conversation.json"
HASH=$(sha256sum "$FILE" | awk '{print $1}')
curl -s -X POST https://api.sigill.ai/seal/sign-hash \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d "{\"hashHex\":\"$HASH\",\"certificateId\":\"$CERT_ID\",\"label\":\"$FILE\",\"format\":\"jades\",\"contentType\":\"application/json\"}" \
-o "${FILE%.json}.jades.json"
# Verify — original file + detached .jades.json (same endpoint as CAdES)
curl -s -X POST https://api.sigill.ai/seal/verify \
-F "file=@$FILE" \
-F "p7s=@${FILE%.json}.jades.json" \
| jq '{format, intact: .jades.hashMatch, signer: .jades.certificate.subject}'
# NOTE: the seal covers the exact bytes of $FILE.
# Re-exporting or pretty-printing the JSON breaks it — by design.