ORBIS.ID · VERIFY · THE CHECKS
Four checks have names. There are five.
The industry names four: the signature is real, the organization behind it is trusted, this is the right holder, it has not been withdrawn. Our own verifier ran those four and still accepted a claim that had been spliced into a genuine proof — because decoding a disclosed value is not the same as checking the organization signed it. So there is a fifth, it runs on every proof, and this page counts it out loud rather than keeping the tidier number.
Not run
the checks have not run in this browser yet
- the signature is real not run yet
- the organization behind it is trusted not run yet
- this is the right holder not run yet
- it has not been withdrawn not run yet
- the claims shown were the ones the issuer signed not run yet
The strip under the seal is the five checks, in the order they run, filled in by the run that just happened on your device.
Verifying a conformance vector recorded from https://id.orbis.id/conformance/vectors on 2026-08-30. Recorded data, live verification — the maths ran here, just now.
A check is only worth describing by what gets through when you skip it. That is how each of the five is described below.
The five, in the order they run.
-
The signature is real
Re-computed against the key the organization publishes at its own domain. Catches a proof invented from nothing, and a proof signed by a key that organization never claimed.
-
The organization behind it is trusted
The key is the one that domain names as its own, fetched from the organization, not from us. Catches a genuine signature from an organization you never agreed to accept.
-
This is the right holder
The presentation is signed by the key inside the holder’s device, over the exact challenge you issued. Catches a real credential captured from somebody else and replayed at you.
-
It has not been withdrawn
One bit, read from a list the organization signs and publishes. Catches an employee card that was genuine on the day it was issued and was cancelled the week after.
-
The claims shown were the ones the issuer signed
Every disclosed value is re-hashed and its digest looked for in the signed set. Catches a fabricated row spliced into a genuine proof, and a genuine row whose value was edited after signing. This is the check that is usually missing.
Nothing here asks anybody’s permission.
Every input the checking needs was published by the organization that vouched: its key at its own domain, its status list at its own address. Reading them is reading a page. That is why there is no account, no key and no bill — and it is also why the organization never learns where its credential was used, because it is never in the conversation.
The one thing the checking cannot do is decide which organizations you accept. That is a policy you hold and can change on a Tuesday, and no amount of cryptography will make it for you. Anybody who tells you their product settles it is selling you their opinion with a signature on it.
The proofs that are supposed to fail.
A conformance set that only contains valid proofs tests nothing. These are the ones the cell publishes, each with the mistake it exists to catch, read straight from the set rather than typed here.
-
valid
A genuine credential, presented to the stated challenge, whose status bit is clear.
The whole chain is walked and accepted, exactly the disclosed claims are readable, and the withheld claim never appears.
-
revoked
The same issuer and the same signed status list, but this credential's bit has been set.
Revocation is actually read from the signed list. Signature and holder binding are still sound, so an implementation that skips the status step accepts this and is caught.
-
forged-disclosure
A genuine credential with a fabricated disclosure spliced in before the key-binding JWT — a claim the issuer never signed.
A verifier that only DECODES disclosures for display, without checking each digest is in the signed `_sd` array, shows and accepts a claim the issuer never made.
-
tampered-value
A genuine credential whose disclosed `organization` value has been altered after signing.
A verifier that trusts the disclosure bytes without re-hashing them against the signed `_sd` array accepts a changed value.
Read from https://id.orbis.id/conformance/vectors — reached on 2026-08-30.
What is real here.
The checks described above are the part of the platform with the most evidence behind it. That does not make every capability they sit on finished, and the rows say which are not.
- LIVE Publishes deterministic vectors a third party can recompute offline to check their implementation against ours conformance-vectors
The register holds 17 live · 2 partial · 2 planned · 5 not yet.
4 of the 5 capabilities this page depends on have no row in the register yet, so this page will not print a state for them. They are named rather than dropped, because a slice that silently shortens itself is the same defect as a claim with no receipt.
- hosted-verification
- selective-disclosure
- revocation
- did-web-anchor
The register route serves, but it carries no row for these yet. List what it does carry:
curl -s https://id.orbis.id/api/site/register | jq -r '.entries[].slug' Straight answers.
- If all five pass, is the credential true?
- No. Five passes mean a named organization signed exactly these claims, that they have not been altered, that they have not been withdrawn, and that the device presenting them holds the key. Whether that organization was right about the person is the organization’s problem, and choosing which organizations to believe is yours.
- What happens if one check fails?
- The chain names the link that broke and gives the reason in plain language, and the seal stops where it stopped. There is no partial acceptance and no score. A proof either walked the whole chain or it did not.
- What if the checker itself is broken?
- It returns “could not tell”, never “no”. A verifier that turns its own confusion into an accusation about a person is the worst failure mode available to it, so the outcome for an internal error is indeterminate and is labelled as such.
- Do any of the checks make a network call to ORBIS?
- No. The verifier makes no network call at all — the key document, the status list and the presentation are handed to it as bytes. Fetching those bytes is the caller’s business, and the organization they come from is not ours.
- Can I run these checks without your code?
- Yes, and that is the intent. The set of failing proofs below is the contract. Point your own verifier at it in whatever language you write, and if it accepts one of them, the fault is found before it ships rather than after.
A checker that cannot fail has not checked anything.