SD-JWT
selective disclosure JWT · Selective Disclosure for JWTs · RFC 9901 · RFC9901
By Boston Identity · Explained · 7 min read
The short answer
SD-JWT is a signed JSON Web Token in which the issuer replaces chosen claims with salted hashes, so the holder can show each verifier only the claims it picks and, optionally, prove it holds a bound key.
- What it is
- A standard
- Defined by
- IETF, RFC 9901 (Standards Track)
- Who it's for
- Teams accepting credentials from wallets or agents
- In our briefings
- 343by month, last 12
What is SD-JWT?
A JSON Web Token (JWT) is a signed bundle of JSON (JavaScript Object Notation) claims, often used to describe a user.§1 When a server sends one straight to the site that uses it, the server can simply leave out claims at issuance.§1 SD-JWT, short for Selectively Disclosable JWT, serves a different model. An issuer gives a token with many claims to a holder, and the holder later shows it to several verifiers, each of which may need only some of the claims.§1 The RFC's own example is a token with an address and a birthdate: the holder shows the address to one verifier and the birthdate to another.§1
The method is salted hashes. For each claim that should be hideable, the issuer signs a digest in place of the value, and the holder sends the value with its random salt only to a verifier that should see it.§1 That verifier hashes what it received and checks that the digest is in the signed payload. The salt stops a verifier from guessing hidden values.§1
The Internet Engineering Task Force (IETF) published the specification as RFC 9901 on the Standards Track in November 2025.S1 It also defines optional key binding, in which the holder proves possession of a private key whose public key sits in the token, to stop the token being presented without the holder's consent.§1
Not an anonymous credential: RFC 9901 says it does not meet those security properties, and colluding verifiers and issuers can recognise the same token whatever was disclosed.§10.1
How does SD-JWT work?
Three parties take part: the issuer, which creates the SD-JWT; the holder, which receives and controls it and may be the user, their device and software, or both; and the verifier, which checks what it is shown.§1.2
Figure steps
- The issuer swaps claims for salted digests
- The issuer hands everything to the holder
- The holder chooses what to reveal
- The holder signs a Key Binding JWT, if required
- The verifier checks the signature and every disclosure
- The verifier checks the key binding
The issuer signs digests in place of claims, the holder sends only the disclosures it chooses, and the verifier hashes each one to find it in the signed token.
Drawn from RFC 9901, sections 4 and 7
Swipe for the full figure →
The issuer swaps claims for salted digests
For each claim it chooses to make hideable, the issuer builds a small array of a random salt, the claim name and the value, and encodes it as text; that string is a disclosure.§4.2.1 It hashes each disclosure, with SHA-256 by default, and puts the digests in the payload in place of the claims.§4.2.3 It may add decoy digests to hide how many claims there are.§4.2.5 It then signs the JWT with its private key.§4.1
The issuer hands everything to the holder
The issuer sends the signed JWT followed by all the disclosures, each separated by a tilde (~) character.§4 It issues a plain SD-JWT, and a holder must reject one that arrives with key binding attached.§7.2 On receipt the holder must validate the token and check that its claims are acceptable.§7.2
The holder chooses what to reveal
For a presentation, the holder decides which disclosures to release, getting consent if necessary; how consent is obtained is outside the RFC.§7.2 It may send none, some or all of them, and must not reveal the salts of claims it holds back.§4 A nested disclosure is useless without the disclosure that contains it, so the holder must send both.§4.2.6
The holder signs a Key Binding JWT, if required
When key binding is required, the holder creates a Key Binding JWT (KB-JWT) tied to the token and appends it after the last tilde.§4, §7.2 The KB-JWT must carry its issue time (iat), the intended verifier (aud), a nonce for freshness, and sd_hash, a hash over the signed JWT and the chosen disclosures.§4.3 The holder signs it with the private key matching the public key in the token.§4.3.2
The verifier checks the signature and every disclosure
The verifier first decides from its own policy whether key binding is required, and rejects a presentation without one when it is.§7.3 It checks the issuer's signature and key and refuses the none algorithm.§7.1 It hashes each disclosure, finds the matching digest, and puts that claim back in place; digests with no disclosure are ignored.§7.1 A disclosure that matches no digest, or a digest that appears twice, gets the token rejected, as does a missing validity claim it requires.§7.1
The verifier checks the key binding
If key binding is required, the verifier takes the holder's public key from the token and validates the KB-JWT signature with it.§7.3 It checks that typ is kb+jwt, that iat falls in an acceptable window, and that nonce and aud match this transaction and this verifier.§7.3 It recomputes sd_hash over what it received, so a changed set of disclosures fails.§7.3
Why does SD-JWT matter now?
SD-JWT has become the token under several agent payment designs. Google's AP2 payment protocol authorizes an agent's purchase with a checkout mandate and a payment mandate, and both travel as SD-JWTs.1 Verifiable Intent chains three signed SD-JWT layers, from card issuer to user to agent.2 EMVCo's agent-payment framework presents Verifiable Intent as one realisation of its three layers and specifies SD-JWT VC, the IETF's verifiable-credential format built on SD-JWT, in section 6.7.3
The standards on top are still moving. SD-JWT VC is in evaluation by the Internet Engineering Steering Group (IESG), and we forecast it is published as an RFC by 31 October 2027.4 The chairs of the IETF's OAuth working group, which maintains the OAuth authorization standards, opened a call for adoption of the Delegate SD-JWT draft on 28 September 2026; all fifteen replies we counted on 6 October supported it.5
RFC 9901 itself never mentions agents or delegation.6 Key binding is optional and each verifier decides whether to require it, which we read as making replay protection a setting each verifier has to get right.7
Where does it fit?
| Compared with | How SD-JWT differs |
|---|---|
| Key Binding JWT | The Key Binding JWT is one optional part of an SD-JWT presentation: the holder's signed proof of key possession, covering a nonce, an audience and a hash of the SD-JWT as sent.§3.3 SD-JWT is the whole format, which also works without it. |
| Delegate SD-JWT | Delegate SD-JWT lets the key-binding slot hold a selective-disclosure token of its own that can name the next holder's key, so a verifier can trace hand-offs back to the issuer.8 RFC 9901 has no such chain.6 |
| Token Status List | Token Status List handles revocation: the issuer publishes one signed, compressed bit array, and a verifier reads the bits for the token in front of it.9 RFC 9901 defines no status or revocation check of its own.10 |
| OpenID for Verifiable Presentations | OpenID for Verifiable Presentations (OpenID4VP) is a protocol for presenting credentials, not a token format; the OpenID Foundation's presentation tests cover both SD-JWT and mdoc credentials.11 |
What goes wrong?
- Without key binding, anyone who gets the token can replay it, and a malicious verifier can present it to another verifier that does not require binding.§9.5 Verifiers must decide whether binding is required before verifying, and must not base that on whether a KB-JWT arrived, because an attacker could strip it off.§9.5
- In a bare SD-JWT the set of disclosures is not integrity protected, so the token can be changed by adding or removing disclosures and still be valid.§9.10 Any party holding it can forward it, with fewer disclosures, to a receiver that does not enforce key binding.§9.9 As we read the format, nothing in it names who forwarded it.6
- Unlinkability between issuer and verifier cannot be achieved when the verifier is careless, colluding, compromised or coerced, because it can forward the issuer-signed token to the issuer.§10.1 Batch issuance, with new key-binding keys and salts for each copy, can stop verifiers linking presentations.§10.1
- An issuer must not make content that is critical to the token's validity selectively disclosable, and verifiers must make sure every validity claim they need is present.§9.7
- Hidden values are only as safe as their salts, which must be random and infeasible to guess; the recommended minimum is 128 bits.§9.3
- RFC 9901 defines no status or revocation check for an issued token.10
What should a security leader ask?
- 01
Which of our verifiers require key binding for SD-JWTs, and is that decision fixed in policy before a token is read?
- 02
When an agent presents an SD-JWT for a user, how does our verifier tell the agent from the user, given that the format names no forwarder?
- 03
How do we learn that a credential we accept has been revoked, since RFC 9901 defines no status check?
- 04
Which validity claims, such as iss, exp and cnf, do our credential profiles keep out of selective disclosure?
- 05
How long do we keep presented SD-JWTs, including in log files?
Sources
- S1
Selective Disclosure for JSON Web TokensIETF · RFC 9901, Standards Track, November 2025
›Evidence: 11 claims from 8 briefings
- 1BI-FIND-2026-0414 · Google's AP2 v0.2 lets a person sign spending limits once and leave; the agent then signs each purchase itselfAP2 v0.2 authorizes an agent's purchase with two signed objects and a chain of hashes. The Checkout Mandate is bound by a checkout_hash claim to a Checkout JWT the merchant signed; the Payment Mandate is bound to the hash of that same JWT; both travel as SD-JWTs with a versioned type claim (mandate.payment.1, mandate.checkout.open.1) that verifiers must match exactly, and each verifier, merchant, credential provider, network and processor, has its own MUST list of what to check. The merchant's Checkout JWT must use a non-deterministic signature such as ECDSA rather than Ed25519, so a hash cannot be reversed from a table. Verifiers always receive closed mandates whatever mode produced them.
- 2BI-FIND-2026-0477 · Verifiable Intent stops an agent from handing its authority on, and has no way to take that authority backVerifiable Intent chains three signed SD-JWT layers: the card issuer binds the user's key for about a year (L1), the user signs mandates for the agent (L2: final values for an immediate purchase, or constraints plus the agent's key for up to thirty days in autonomous mode), and the agent signs a payment mandate for the network and a checkout mandate for the merchant, each valid about five minutes (L3a, L3b). L3 carries no confirmation key, and "The absence of `cnf` signals that no further delegation is permitted", so an agent cannot pass its authority to another agent. The only narrowing check is that the agent's final values satisfy the user's constraints, and a verifier checks only the constraints disclosed to it: with no allowlist disclosed, the allowlist check is skipped. Eight constraint types are defined (merchants, line items, payees, amount range, budget, recurrence, agent recurrence, reference); budget and the two recurrence limits need the payment network to keep a running count.
- 3BI-FIND-2026-0440 · EMVCo's agent-payment framework is not a spec; its consent proof is FIDO's Verifiable Intent, in AP2's shapeThe consent mechanism in EMVCo's framework is not EMVCo's. Section 6 presents Verifiable Intent v0.1 as one realisation of the framework's three layers and tells reviewers the authoritative text lives in a FIDO Alliance repository: three chained SD-JWT verifiable credentials, the first signed by a payment credential provider (the named candidate is EMVCo's own Card DPC), the second by the consumer through a wallet with the agent's key inside it, the third by the agent as closed checkout and payment mandates bound by hash to a merchant-signed checkout. That is the open-mandate and closed-mandate structure of Google's AP2 v0.2, down to the rule that an unrecognised constraint type must fail. The framework never names AP2, Google, Mastercard or Visa, declares SD-JWT out of scope in section 1.2.2, and specifies SD-JWT VC as the format in 6.7. Two of the three groups writing agent-payment rules have settled on one credential shape; the Agentic Commerce Protocol's allowance-bound vault token is the one that has not.
- 4BI-CALL-2026-0077 · Bad display metadata no longer gets an SD-JWT VC rejected, and Token Status List becomes normativedraft-ietf-oauth-sd-jwt-vc is published as an RFC by 31 October 2027. The IETF tracker lists it in IESG evaluation, and revision 22, posted on 27 October 2026, answers IESG ballot comments from Ketan Talaulikar; IANA has yet to review the new revision. Revision 22 also makes the Token Status List draft a normative reference. That draft is already in the RFC Editor's queue, still without an RFC number, so we expect the new dependency to cost little time. We are wrong if no RFC has been published by that date.
- 5BI-FIND-2026-0447 · Delegate SD-JWT lets a verifier trace hand-offs back to the issuer, but never checks each one narrowed authorityThe draft is moving. The OAuth working group chairs opened an official call for adoption on 28 September 2026, replies due 12 October. We counted the list on 6 October: fifteen replies, every one in support and none opposed, among them Arnar Birgisson of Google and names from the SD-JWT VC and OpenID4VP work. One reply, supporting 'as a starting point', listed attenuation first among the things the group would have to address. The author's repository shows an editorial pass merged on 21 September that the datatracker's -00 does not carry. A working-group revision would make this the only delegation format in our corpus with a standards home: AAuth, Agentic JWT and the agent name service all remain individual drafts.
- 6BI-FIND-2025-0143 · The SD-JWT standard that agent drafts build on never mentions agents and leaves key binding to each verifierRFC 9901 never mentions agents or delegation. Its holder "may refer to the actual user, the supporting hardware and software in their possession, or both", and section 9.9 covers a credential moving past its holder: any entity holding an SD-JWT can forward it to any third party that does not enforce key binding, and may remove disclosures as it does. The RFC says this "could be desirable" in some cases and gives a supply chain where each party can choose to pass on less. The set of disclosures in a bare SD-JWT is not integrity protected, so the receiver has no way to tell what was dropped, and, as we read the format, nothing in it names who forwarded it. An agent handing on authority under the bare RFC therefore looks like whoever presents the token, which is why the delegation designs in our briefings add a chain of their own; our briefing on the Delegate SD-JWT draft found it lets the key-binding JWT itself be an SD-JWT that names the next holder's key.
- 7BI-FIND-2025-0144 · The SD-JWT standard that agent drafts build on never mentions agents and leaves key binding to each verifierKey binding is optional, and the RFC gives the decision to the verifier: it "MUST decide whether Key Binding is required for a particular use case before verifying", and must not base that on whether a key-binding JWT arrived, because an attacker can strip one off. Without binding, the RFC says, the credential "can be replayed by anyone who gets access to it", a malicious verifier can present it to another verifier that does not require binding, and disclosures can be added or removed with the SD-JWT still valid. With binding, the key-binding JWT must carry iat, aud, nonce and an sd_hash over the issuer-signed JWT and the chosen disclosures, so the disclosure set is signed as well. For agents, we read this as making replay protection a setting each verifier has to get right. One agent draft in our briefings does not keep the binding as written: the SD-Card draft, now expired, lists the nonce as an optional value where RFC 9901 makes it required.
- 8BI-FIND-2026-0444 · Delegate SD-JWT lets a verifier trace hand-offs back to the issuer, but never checks each one narrowed authorityThe mechanism is one substitution. In RFC 9901 the holder proves possession by appending a signed Key Binding JWT; here that slot can hold a KB-SD-JWT, a selective-disclosure token in its own right whose 'delegate payload' carries the claims an issuer would have written and, for any link that delegates onward, a cnf key naming the next holder. A verifier splits the compact form, validates the issuer's SD-JWT, then validates each KB-SD-JWT with the previous link's cnf as the issuer key, requires exactly one disclosed delegate payload, and checks a hash of the predecessor: sd_hash pins the exact disclosures that were passed on, issuer_jwt_hash lets the delegate drop some. Any failed step aborts. One signature may pre-authorise several alternative delegations, of which the delegate reveals one. The worked example is an AI agent buying at a merchant without revealing which other merchants could have filled the order.
- 9BI-FIND-2026-0632 · OAuth's revocation list for issuers is nearly an RFC, and agent drafts we read that need revocation don't use itToken Status List replaces per-token checks with one signed, compressed bit array per issuer. Each token (JWT, SD-JWT VC, CWT or ISO mdoc) carries an index and a list URI; a verifier fetches the list, checks its signature and reads 1 to 8 bits for VALID, INVALID, SUSPENDED or an application value. Because everyone downloads the same list, the issuer does not learn which token is being checked, the property the authors call herd privacy, unlike OAuth introspection or OCSP. Revocation reaches a verifier only when it refetches, which the issuer steers with the list's exp and ttl.
- 10BI-FIND-2025-0145 · The SD-JWT standard that agent drafts build on never mentions agents and leaves key binding to each verifierWhat RFC 9901 hands to the protocol or profile on top is, as we read it, most of what an agent deployment has to settle: how the holder's key pair is established (section 4.1.2), how the key-binding JWT's audience is represented and how its nonce is obtained (4.3), if and how consent to disclose is obtained (7.2), which validity claims a verifier must see, which application-specific profiles SHOULD list (9.7), and how verifiers get issuers' keys, which it does not define (9.8). It defines no status or revocation check for an issued SD-JWT; Token Status List appears only as an example of a revocation callback that tells the issuer little. In our briefings these gaps mostly carry forward: Verifiable Intent v0.1 and the Delegate SD-JWT draft define no revocation, and the SD-Card draft puts the registry that issues agent cards out of scope. Our briefing on SD-JWT VC found that it answers the issuer-key question with a well-known metadata document or an X.509 chain.
- 11BI-FIND-2025-0230 · The OpenID Foundation set 26 February 2026 for verifiable credential self-certification, with issuance tests still SD-JWT onlyIn December 2025 the OpenID Foundation said implementers could start self-certifying against OpenID4VP 1.0, OpenID4VCI 1.0 and HAIP 1.0 on 26 February 2026, using free, open-source tests that run locally or on its servers. The two suites were at different stages. Presentation tests already covered both SD-JWT and mdoc credentials, but issuance tests covered SD-JWT only, with mdoc support "planned for release in the weeks ahead." Sending test logs to the Foundation for review and publication is optional. Accreditation of local bodies and labs was to follow in the second quarter of 2026.
›In our briefings
What our briefings say about SD-JWT itself, with the most direct claims first.
RFC 9901 never mentions agents or delegation. Its holder "may refer to the actual user, the supporting hardware and software in their possession, or both", and section 9.9 covers a credential moving past its holder: any entity holding an SD-JWT can forward it to any third party that does not enforce key binding, and may remove disclosures as it does. The RFC says this "could be desirable" in some cases and gives a supply chain where each party can choose to pass on less. The set of disclosures in a bare SD-JWT is not integrity protected, so the receiver has no way to tell what was dropped, and, as we read the format, nothing in it names who forwarded it. An agent handing on authority under the bare RFC therefore looks like whoever presents the token, which is why the delegation designs in our briefings add a chain of their own; our briefing on the Delegate SD-JWT draft found it lets the key-binding JWT itself be an SD-JWT that names the next holder's key.
The SD-JWT standard that agent drafts build on never mentions agents and leaves key binding to each verifierBI-FIND-2025-0143
The Recommendation registers six media types, application/vc+jwt, vp+jwt, vc+sd-jwt, vp+sd-jwt, vc+cose and vp+cose, with the W3C Verifiable Credentials Working Group as change controller, and its revision history lists the rename from application/{vc,vp}+ld+json+{jwt,sd-jwt,cose} among the changes since the First Candidate Recommendation. A credential secured with SD-JWT under this spec SHOULD carry typ vc+sd-jwt. The text does not mention the IETF's SD-JWT VC format, and our briefing on that draft found its typ MUST be dc+sd-jwt. We read this as two SD-JWT credential formats a verifier may meet. The typ header tells them apart, and on the W3C side it is only a SHOULD.
W3C's JOSE and COSE rules for credentials admit there is no standard way yet to fetch a JWK from a DID URLBI-FIND-2026-2224
The mechanism is one substitution. In RFC 9901 a holder proves possession by appending a signed key-binding JWT; here that slot can hold a KB-SD-JWT, a selective-disclosure token in its own right. Its delegate payload carries the claims an issuer would have written and, on a link that delegates onward, a cnf key naming the next holder. A verifier splits the compact form and validates the issuer's SD-JWT. It then validates each KB-SD-JWT with the previous link's cnf as the issuer key and, for each link before the last, requires exactly one disclosed delegate payload and a matching hash of the link before. sd_hash covers that link with its disclosures as passed on; issuer_jwt_hash covers only its signed part, and a holder that wants the delegate free to drop disclosures must use it. Any failed step aborts. One signature can delegate several alternative payloads, of which the delegate discloses exactly one. The draft's example is an AI agent buying from a merchant without revealing which other merchants could have filled the order.
OAuth adopts Delegate SD-JWT, which traces each hand-off to the issuer but never checks that authority narrowedBI-FIND-2026-0444
›Cited in 34 briefings
Every briefing that discusses this term, newest first.
- In SD-JWT VC, the X.509 key route does not authenticate the iss claim
Draft · · IETF Datatracker · Oliver Terbu et al. · Aug 31, 2026
- Agent registry draft lets another identity block an agent's key changes, not switch it off
Draft · · IETF Datatracker · Christopher Drake, 1id.com · Oct 27, 2026
- Verifiable Intent stops an AI agent from passing its buying authority on, and v0.1 has no protocol to revoke it
Article · · Verifiable Intent (GitHub, agent-intent/verifiable-intent) · Verifiable Intent Working Group · Apr 18, 2026
- OAuth's token revocation list nears RFC, and a shared list hides which token is checked
Draft · · IETF Datatracker · Tobias Looker et al. · Aug 13, 2026
- EMVCo's agent card-payment draft binds no one yet and points to a spec FIDO maintains for proof of consent
Article · · EMVCo · Aug 27, 2026
- Google's AP2 v0.2 ties an agent's purchase to the merchant's own signed checkout by hash
Article · · ap2-protocol.org · Google · Apr 28, 2026
- A new STIR draft would let a number's holder require AI agents calling from it to say so
Draft · · IETF Datatracker · Jon Peterson, TransUnion · Nov 2, 2026
- W3C's JOSE and COSE rules for credentials admit there is no standard way yet to fetch a JWK from a DID URL
Article · · W3C · Michael Jones et al. · Oct 13, 2026
- An agent-mandate draft checks who may delegate, and now intends to carry its chain in Asor's format
Draft · · IETF Datatracker · Claudiu Hulea, Braincap SRL · Oct 24, 2026
- The attested-TLS draft drops cached verifier results, so the verifier now sits inside each handshake
Draft · · IETF Datatracker · Thomas Fossati et al. · Oct 14, 2026
- An IETF draft puts TLS attestation after the handshake and bans session resumption; its formal analysis is unfinished
Draft · · IETF Datatracker · Muhammad Usama Sardar et al. · Nov 2, 2026
- A draft joining four agent records on one hash reports no valid joint run and now claims less about what agents did
Draft · · IETF Datatracker · Steven Mih et al. · Aug 16, 2026
- Cisco's SD-Card rewrite pins MCP tools to what a registry signed; its security sections still read TODO
Draft · · IETF Datatracker · Suhas Nandakumar et al. · Nov 1, 2026
- OAuth adopts Delegate SD-JWT, which traces each hand-off to the issuer but never checks that authority narrowed
Draft · · IETF Datatracker · Gareth Oliver et al. · Apr 22, 2026
- Drake's revised draft: an agent identity outlives its operator but is never reissued once its last key is gone
Draft · · IETF Datatracker · Christopher Drake, 1id.com · Sep 25, 2026
- Drake's agent-mail draft puts hardware-maker proof on hold, but its abstract still offers it
Draft · · IETF Datatracker · Christopher Drake, 1id.com · Oct 27, 2026
- Delegation receipts for AI agents, revision 15: holding a copy of a receipt no longer lets you extend the chain
Draft · · IETF Datatracker · Ryan Nelson, Authproof · Oct 22, 2026
- The SD-JWT standard that agent drafts build on never mentions agents and leaves key binding to each verifier
Article · · IETF (RFC Editor) · Daniel Fett et al. · Nov 20, 2025
- A draft token hides some claims, works with old servers unchanged, and leaves agent delegation claims visible
Draft · · IETF Datatracker · Su-hyeon Forten Lee · Oct 3, 2026
- Cisco's SD-Card puts an A2A Agent Card in a selective-disclosure token, and leaves its registry out of scope
Draft · · IETF Datatracker · Suhas Nandakumar et al. · Mar 2, 2026
- Google's AP2 authorization companion lets a verifier trust a credential issuer or the agent's provider, and names no trust list or revocation
Article · · ap2-protocol.org · Google · Apr 28, 2026
- July TLS-attestation draft withdraws itself and leaves key safeguards outside the protocol
Draft · · IETF Datatracker · Hannes Tschofenig et al. · Jul 23, 2026
- Glide pitches the SIM card's key as the replacement for SMS codes, resting its AAL3 claim on hardware alone
Podcast · · The Future of Identity · Eran Haggiag – Rebuilding Digital Identity Around SIM Cards for the AI Era · Jun 23, 2026
- A Cisco-led agent draft puts the verifiable credential at a public URL, with selective disclosure a SHOULD it does not yet show
Draft · · IETF Datatracker · Jean Diaconu et al. · Feb 6, 2026
- SD-CWT requires a key-signed proof for each verifier, yet none of its three prototypes reports interop testing
Draft · · IETF Datatracker · Michael Prorock et al. · Jan 13, 2026
- The OpenID Foundation set 26 February 2026 for verifiable credential self-certification, with issuance tests still SD-JWT only
Article · · OpenID Foundation · Serj Hallam · Dec 18, 2025
- Credential wallet draft makes holder binding a MUST; its own SD-JWT profile names no way to provide it
Draft · · IETF Datatracker · Leif Johansson et al. · Nov 4, 2025
- FIDO pairs passkeys with digital ID credentials but spells out steps only for moderate assurance
Article · · FIDO Alliance · Christine Owen et al. · Sep 22, 2025
- OpenID's credential issuance standard is OAuth for wallets, and its recommended wallet check is built for native apps
Article · · OpenID Foundation · Torsten Lodderstedt et al. · Sep 16, 2025
- OpenID4VCI's third interop test: 87% of tested pairs passed, on counts the post does not reconcile
Article · · OpenID Foundation · Gail Hodges · Jul 24, 2025
- OpenID4VP 1.0 makes verifiers re-check what a wallet returns, and cannot show a holder acting for someone else
Article · · OpenID Foundation · Oliver Terbu et al. · Jul 9, 2025
- W3C Data Integrity proofs name their purpose, so a verifier can refuse a credential signature offered as a login
Article · · W3C · Manu Sporny et al. · May 15, 2025
- The W3C credential standard leaves out what agents need most: which issuers to trust, and who may present
Article · · W3C · Manu Sporny et al. · May 15, 2025
- In May 2023, Parecki described OAuth 2.1 as consolidation and DPoP as token protection
Video · · Identiverse - A CRA Resource · Jun 17, 2024
In our columns
- To stop sites over-asking for ID, the wallet must know who is asking and why
Column · Nov 17, 2026
- Wallet specs won't decide which credentials get accepted; acceptance networks will
Column · Oct 26, 2026
Related terms
What appears alongside SD-JWT in the same briefings.
Delegate SD-JWTSD Agent (SD-Card)Selective Disclosure CBOR Web Tokens (SD-CWT)Verifiable digital credential (VDC)Cross-Domain AuthZ Information sharing for AgentsOpenID for Verifiable PresentationsOpenID for Verifiable Credential IssuanceToken Status List
Was this explainer useful?
Share this explainer
Every finding, forecast and open question on this site has a permanent ID. If we reword one, its ID stays the same, so a citation keeps pointing to the same claim.
Working on an identity problem that involves SD-JWT? Talk to Boston Identity