SD-JWT is the second of the two stacks that dominate verifiable credentials today (see Two stacks, not two flavours). It answers the two architectural questions the opposite way from W3C-VC (see The W3C-VC stack): meaning lives outside the signed credential, as flat claims interpreted by agreement, and the signature is the format itself. It is deliberately simple, and that simplicity is a genuine strength. This page draws on the VC guide v1.1 (EUNIS SIG, July 2026), Verifiable Credentials in Higher Education: W3C-VC and SD-JWT VC, published by the EUNIS Special Interest Group – Mobility & Digital Credentials (EUNIS SIG).
What it is
SD-JWT VC assembles verifiable credentials from two familiar parts: the JSON Web Token (JWT), the credential container most widely used on the internet, and selective disclosure built on salted hashes. The mechanism, SD-JWT, is standardised as RFC 9901 (November 2025). The credential profile on top of it, SD-JWT VC (draft-ietf-oauth-sd-jwt-vc), is still an Internet-Draft on the standards track; after its IETF Last Call in September 2026 it is waiting for AD go-ahead with open security-review issues, so the publication date has slipped (status as of October 2026).
One consequence is easy to miss: an SD-JWT credential is not a W3C-VC. Its data model carries no JSON-LD and no @context in the signed payload, and the specification names the result a “Verifiable Digital Credential” to keep it distinct from the W3C-VCDM. A W3C-VC secured with the SD-JWT mechanism is a different object. It has its own media type (application/vc+sd-jwt, against application/dc+sd-jwt here) and its own clause in ETSI TS 119 472-1 (7.6.4.3, against clause 5). See A frequent confusion.
The construction in plain words
The issuer starts from flat key-value claims. Every claim meant to be selectively disclosable has its value swapped, in the payload, for a salted hash, while the holder receives the original values on the side. The issuer then signs the result. When presenting, the holder reveals just the claims a verifier asks for; the verifier hashes those values again and compares them with the signed payload. Whatever stays undisclosed remains a hash: its slot is visible, its value is not.
<Issuer-signed JWT>~<disclosure-1>~<disclosure-2>~...~<disclosure-N>~[<KB-JWT>]
- The issuer generates a random salt per disclosable claim.
- It hashes salt, claim name and value together and places the digest in an
_sdarray in the signed JWT. - The holder receives the JWT and the disclosure objects.
- The holder forwards only the disclosures relevant to a given verifier.
- The verifier recomputes those hashes, matches them against
_sdand validates the issuer’s signature.
A developer familiar with JWTs can grasp this in an afternoon, current token infrastructure handles it with modest changes, and it provides real selective disclosure with no exotic cryptography. When implementation capacity is the scarcest resource, “boring and familiar” is a serious engineering virtue.
Type and semantics
The SD-JWT VC specification requires every credential to carry a vct (verifiable credential type): a URI naming the kind of credential. The vct can resolve to Type Metadata: display information plus a schema_uri pointing to a JSON Schema that describes the credential’s structure. Here is the site’s worked example, the URV Master’s in Computing (EQF 7) issued in 2026 to Aina, in simplified form:
{
"vct": "https://credentials.example.es/UniversityDegree",
"vct#integrity": "sha256-...",
"iss": "https://urv.cat",
"cnf": { "jwk": { ...Aina's wallet key... } },
"_sd": [ "hash(salt1, eqf_level, 7)",
"hash(salt2, field_of_study, 'computing')",
"hash(salt3, degree_title, 'Master in Computing')" ]
}
Meaning lives outside the signed payload
Inside the signature are the string “computing”, the number 7 and a URL. Which framework the 7 belongs to, which classification “computing” maps to, and what legal entity stands behind the URL are answered by the Type Metadata, by verifier code and by prior agreement. In a coordinated ecosystem that is enough: when a national wallet scheme fixes the vct of, say, a student ID and all its verifiers read it the same way, governance pins the semantics down. The design wagers that most credentials circulate inside ecosystems like that, where keeping semantics out of band is an advantage (simple, quick, no ontology to maintain) and not a weakness. The cost appears when a credential leaves its ecosystem, for example when a verifier in another country with no prior coordination must decide what “7” means.
Display is bound to the type
Type Metadata is also where the specification standardises how a credential looks to a human. Display belongs to the type, not to the individual credential, so an issuer that wants its own visual identity must define its own vct. The extends mechanism lets one type inherit from another, which saves definition work but still multiplies types; to learn that two types share an ancestor, a verifier must resolve the Type Metadata chain, since the credential itself does not show its lineage. Wallets may also apply issuer branding from issuance metadata, but that does not travel with the credential.
Lineage and ecosystem
The credential format comes from the IETF; the protocols around it come from the OpenID Foundation: OpenID4VCI for issuance, OpenID4VP for presentation, and the High Assurance Interoperability Profile (HAIP) binding them together. This lineage matters in three ways:
- Wallet support. No other stack has as much wallet support today, and SD-JWT VC is now written into the EUDI Wallet rules: since Implementing Regulation (EU) 2026/1731 (in force 11 August 2026), the binding annexes of the implementing acts require it, alongside ISO/IEC mdoc, for person identification data and name the same two formats for attestations (ETSI TS 119 472-1 profiles). W3C VCDM is not among them today, though the regulation’s recitals foresee wallet support for it in education once new profiles are available. A pilot today finds more working wallets, reference implementations and vendors here than anywhere else.
- Developer ecosystem. JWT tooling exists in every language and the step to SD-JWT is small. Time from decision to working pilot is measured in weeks.
- Governance. The IETF and the OpenID Foundation are serious, open standards bodies. Neither is a European body (nor is the W3C); the difference that matters is that the presentation protocols carry design assumptions from the platform and consumer-identity world in which they matured.
Status, holder binding and correlation
Status. SD-JWT deployments use Token Status List (IESG-approved in June 2026, awaiting the RFC Editor). The specification itself defines a suspended value, but the profiles adopted for the European ecosystem use revocation only: a credential is valid or it is not. With no suspended state in those profiles, a disciplinary review or administrative correction must be handled by revoking and later reissuing, or procedurally outside the credential layer.
Holder binding. The issuer binds the credential to a key held in the holder’s wallet, confirmed in the cnf claim. At presentation the verifier can require a Key Binding JWT (KB-JWT): a fresh JWT signed with that key, carrying a nonce and audience, which prevents replay of a presentation to another verifier.
Correlation. The issuer’s signature and the salted hashes are stable for the credential’s life. In the scenario, if Aina presents her degree to a recruitment platform in March and a licensing body in November, disclosing different attributes each time, both verifiers hold the same signature bytes and the same hashes; if they compare records, the presentations link trivially. Selective disclosure is not unlinkability; batch issuance of single-use copies mitigates correlation between verifiers, but not verifier-issuer collusion, and it needs a lifelong channel to the issuer. See Selective disclosure vs unlinkability.
What the stack demands of the institution
Less technology than the alternative, which is the whole idea: DIDs are not strictly needed, and there is no ontology alignment, SHACL authoring or RDF tooling. What an institution does need is JWT-capable issuance infrastructure, conventional key management, a defined vct with its Type Metadata and JSON Schema, and integration with OpenID4VCI and OpenID4VP.
Governance duties, on the other hand, match those of any recognised credential: a named issuing authority, written criteria, a revocation policy, a designated GDPR controller and, where a third party is involved, a data processing agreement. The technical entry point is low; the governance entry point never is.
Where it excels
- Time and cost to production. Weeks rather than quarters, thanks to well-known tooling, plentiful developer skills and little integration risk.
- Mobile-native experience. Designed for the phone-and-wallet interaction pattern; issuance and presentation flows are smooth and well supported.
- Wallet availability today. If the requirement is that students hold a working credential in a real wallet this academic year, this is the shortest path.
- Regulatory footing. SD-JWT VC is one of the two formats the binding EUDI Wallet annexes name for person identification data and attestations, so every national wallet must handle it. That settles where the credential can be delivered, not what it means to a verifier outside its scheme.
- Simple attributes at volume. Enrolment status, student identity, library access, age or affiliation proofs: short-lived, frequently reissued, semantically light claims, for which out-of-band semantics cost almost nothing.
- Coordinated ecosystems. Where one governance authority defines the credential type and all verifiers implement it, an embedded semantic layer is redundant by construction.
These strengths are real. The open question is whether a given credential resembles the objects the stack was designed for. A degree is long-lived rather than short-lived, cross-border rather than intra-scheme, semantically dense rather than light, and subject to processes such as suspension and verification decades later. That is why most universities will end up running both stacks in two lanes: SD-JWT for student ID, enrolment and access; W3C-VC for degrees, formal microcredentials and professional qualifications. See W3C-VC vs SD-JWT and Choosing a stack.
Key points
- SD-JWT (RFC 9901) is a JWT with salted-hash selective disclosure; SD-JWT VC, still an Internet-Draft after its IETF Last Call, profiles it for credentials.
vct, Type Metadata andschema_uridescribe the type; meaning is fixed by governance outside the signature, which works well in coordinated ecosystems.- Display is bound to the type;
extendslets types inherit. - OpenID4VCI, OpenID4VP and HAIP give it the best wallet support available today, and since Implementing Regulation (EU) 2026/1731 the binding EUDI Wallet annexes name SD-JWT VC, with mdoc, for person identification data and attestations.
- Token Status List is used for revocation only in the European profiles; they do not use the draft’s suspended value.
- Holder binding via
cnf; stable signature and hashes make presentations correlatable. - Lower technical entry cost, same governance obligations.
