The strongest sentence you can say to an auditor is: "don't take our word for it — check it yourself." Most vendors can't say it, because their verification runs on their own servers, which is the platform grading its own homework. This post is about the machinery that lets you say it for real.
The circularity problem
A green "verified ✓" in a vendor's dashboard proves one thing: the vendor's software prints green checkmarks. If the same party stores the record and judges the record, the judgement adds nothing — an auditor worth their fee will point this out in the first meeting. Breaking the circle requires verification that runs where the vendor isn't, against keys the vendor doesn't hold. That's precisely what customer-held signing keys make possible: your events verify against your public key, and anyone can run that check without asking us — or telling us. We can't see who verifies what, which is exactly how it should be.
Three ways to check, none of them through us
- In the browser. Our verify page takes an Evidence Pack and checks it entirely client-side — the file never leaves the browser. Your evidence isn't uploaded anywhere; even we don't see what you verify. It's the right first stop for a compliance manager who wants the check done in the next five minutes without installing anything.
- On the command line. The CLI verifier runs the same checks in an air-gapped review, for auditors whose policies won't let a browser near the evidence — and for anyone who wants verification in a script, on a schedule, with the results logged on their side.
- From first principles. The signatures are standard Ed25519 over documented content, and the method is published. A skeptical engineer can re-implement verification from scratch — the most durable option of the three, because it survives even us. Evidence with a seven-year life needs a verification story that doesn't expire with a vendor, and "standard crypto, documented recipe" is that story.
Verdicts that tell you what actually happened
A binary pass/fail hides the interesting cases, so the verifier distinguishes them. Contents altered since signing is one verdict — the seal itself fails. Contents intact but signed by a key other than the one we publish is a different verdict — someone else made this document. And a published key failing to match its recorded fingerprint is flagged as exactly that. Events that can't be checked offline aren't silently skipped either: each is counted, with a stated reason. An honest verifier tells you what it couldn't check, or its passes mean nothing.
Fails closed, by design
One more property worth knowing: when a step like the published- fingerprint check can't run, the verifier fails closed — it reports failure, not success-by-omission. A verifier that shrugs its way to green under degraded conditions would be a rubber stamp with extra steps. The rule generalises: every ambiguous state resolves toward "not verified", because a false alarm costs an email and a false pass costs the thing the product exists to protect.
Try it with nothing at stake
The verify page includes a downloadable specimen pack, so you — or your auditor — can practise the whole flow before any real evidence is involved. Run it and watch the checks pass. Then open the file, alter a single byte, and run it again: the verdict flips, and names what failed. That two-minute exercise is the entire thesis of the product in miniature — a record that can defend itself, and a tamper that cannot hide. It's also the best possible artefact to send an auditor before kickoff: "here's a specimen and the verifier; see for yourself" starts the engagement from evidence rather than marketing.
The signatures being verified are the subject of The per-event signature. Questions about an auditor's verification workflow? Ask us.