Skip to main content

Verifier

A verifier is the party that checks a presented credential: validating the issuer's signature, checking the holder binding proof that the credential was presented by the wallet it was issued to, confirming the credential has not been revoked, and reading only the claims the holder chose to disclose.

A verifier is often the same organisation as the relying party requesting the credential, but the roles are distinct: the relying party decides what to ask for and what to do with the result, while the verifier is the technical function that checks the signature, the Trusted List entry of the issuer, the holder binding proof, and the revocation status before that result can be trusted.

In an OpenID4VP exchange, a verifier sends a presentation request describing which credential and claims it needs, receives the holder's response, and then runs four checks before accepting it: that the signature matches the issuer's published key, that the issuer appears on the relevant Trusted List for the credential type presented, that the presentation carries proof of holder binding, signed over a fresh nonce the verifier supplied, so a copied credential or a replayed presentation is rejected, and that the credential has not since been revoked according to its status list. Only after all four pass does the verifier hand a trusted result back to the relying party, for example confirming that a person is over eighteen or holds a valid professional qualification, without ever seeing claims the holder did not choose to disclose.

Because verification is a well-defined, repeatable check rather than a judgement call, the same verifier logic can serve many different relying parties and credential types, which is why organisations often buy verification as a service rather than building it once per use case. A poorly implemented verifier, one that skips the Trusted List check or caches revocation status too long, is a common source of trust framework failures even when the credential and the issuer are both entirely legitimate.

Is a verifier the same thing as a relying party?

Not exactly. The relying party is the organisation deciding what to ask for and what to do with the result, such as granting access after an age check. The verifier is the technical function performing that check: validating the signature, the issuer's Trusted List entry, the holder binding proof that the credential was presented by the wallet it was issued to, and revocation status. The same organisation often plays both roles.

What does a verifier check before accepting a credential?

Four things: that the signature matches the issuer's published key, that the issuer appears on the relevant Trusted List for the credential type presented, that the presentation carries proof of holder binding signed over a fresh nonce the verifier supplied, and that the credential has not been revoked according to its status list.

What goes wrong when a verifier is implemented badly?

The credential and the issuer can both be legitimate and the result still worthless. A verifier that skips the Trusted List check accepts credentials from issuers nobody vouches for, and one that caches revocation status too long keeps accepting a credential the issuer has already withdrawn.

Back to the glossary