#OpenID4VCI
OpenID4VCI Deep Dive: 1.0 Final, the Errata, Interactive Authorization in 1.1, and Server-to-Server
In OpenID4VCI 1.0 Final, a Wallet that sends the wrong PIN gets `invalid_grant`. A Wallet whose Pre-Authorized Code has expired also gets `invalid_grant`. The Wallet can't tell "ask the user to type it again" from "this offer is dead", and the Final text puts no limit on how many PINs an attacker may try against one code. Both have been addressed since, in two different documents with two different answers, and neither document is the text that was approved. That's the state of OpenID4VCI in late 2026: one Final spec, and three editor's drafts next to it that a peer might be following instead. I checked everything against openid/OpenID4VCI at commit `21ffd6c` (27 October 2026) and the PRs it cites, on 2026-11-15. My full notes are on Identity Deep Dive. ## Four texts Text | Where | Status ---|---|--- 1.0 Final | `openid-4-verifiable-credential-issuance-1_0-final.html`, git tag `1.0-final` | Approved 16 September 2025: 102 approve, 1 object, 12 abstain 1.0 errata set 1 | `1.0/`, revision `-19` | Editor's draft 1.1 | `1.1/`, revision `-01` | Editor's draft, "created with same text as 1.0 Final" and then extended Server to Server | `s2s/`, revision `-01` | First draft merged 4 August 2026 (#753) All four belong to the OpenID Digital Credentials Protocols (DCP) working group. Section numbers below are from 1.0 unless I say 1.1 or s2s. 1.1 inserted a new Section 6, so everything after Section 5 shifts by one there. ## The model in one paragraph The Credential Issuer is an OAuth Resource Server. Its one mandatory endpoint is the Credential Endpoint; a Nonce Endpoint, a Deferred Credential Endpoint, a Notification Endpoint and Credential Offers are optional (Section 3.1). The Wallet is the OAuth client. It finds the Authorization Server through `authorization_servers` in the issuer's metadata, gets an access token, and calls `POST /credential`. On top of plain OAuth, 1.0 adds four things (Section 3.2): the grant type `urn:ietf:params:oauth:grant-type:pre-authorized_code`, the RAR type `openid_credential`, the `issuer_state` authorization request parameter, and a `credential_offer_endpoint` in Wallet client metadata. Everything format-specific (SD-JWT VC, mdoc, the W3C VCDM variants) is pushed into Appendix A. The flow is the same for all of them. ## Pre-Authorized Code Flow The issuer has already identified the user through its own process (a bank login, a counter visit), so the Wallet never sees an Authorization Endpoint. It gets a code in a QR and trades it for a token. The offer (Section 4.1.1). In a QR it is usually by reference (`credential_offer_uri`), because the by-value JSON doesn't fit; the two parameters MUST NOT appear together: { "credential_issuer": "https://credential-issuer.example.com", "credential_configuration_ids": ["UniversityDegreeCredential"], "grants": { "urn:ietf:params:oauth:grant-type:pre-authorized_code": { "pre-authorized_code": "adhjhdjajkdkhjhdj", "tx_code": { "description": "Please provide the one-time code which was sent to your mobile phone via SMS" } } } } `tx_code` here is an object, not the code. Its presence, even as `{}`, means "a Transaction Code is required". `input_mode` defaults to `numeric`, `length` is a UI hint, and `description` is capped at 300 characters. The code itself goes to the user over a second channel. Then the Token Request (Section 6.1): POST /token HTTP/1.1 Host: server.example.com Content-Type: application/x-www-form-urlencoded grant_type=urn:ietf:params:oauth:grant-type:pre-authorized_code &pre-authorized_code=SplxlOBeZQQYbYS6WxSbIA &tx_code=493536 &authorization_details=%5B%7B%22type%22%3A%20%22openid_credential%22%2C%20%22 credential_configuration_id%22%3A%20%22UniversityDegreeCredential%22%7D%5D There is no `client_id`. Client authentication is OPTIONAL for this grant, and an AS advertises whether it accepts anonymous requests with `pre-authorized_grant_anonymous_access_supported`. That gives you the security model. The spec says it plainly in Section 13.6.1: the Pre-Authorized Code "is not bound to a certain session (as the Authorization Code Flow does with PKCE)". Whoever scans the QR first holds a bearer code. The offer itself is unauthenticated too: Section 13.5 says the Wallet MUST treat every value in it as untrusted and run the same issuer checks as if the user had started the flow. The `tx_code` is the only thing tying the code to the person who received the SMS. A 6-digit numeric `tx_code` is 10^6 guesses, and 1.0 Final says nothing about rate limiting them. That's the gap the errata closes, further down. ## Authorization Code Flow This one is ordinary OAuth with PKCE, with two OpenID4VCI-specific parameters. The Wallet asks for credentials either by `scope` (taken from the `scope` field of the configuration in `credential_configurations_supported`) or with RAR: [ { "type": "openid_credential", "credential_configuration_id": "UniversityDegreeCredential" } ] If the issuer's metadata lists `authorization_servers`, the `locations` field MUST carry the Credential Issuer Identifier, because one AS can front several issuers (Section 5.1.1). `issuer_state` is the hook back to an issuer-initiated offer. If the offer contained one and the Wallet picks this grant, the Wallet MUST send it back. The AS in turn MUST assume it may have been injected by an attacker (Section 5.1.3), because offers are unauthenticated. The Token Response decides what the Wallet sends next, and this is the part implementations get wrong: { "access_token": "eyJhbGciOiJSUzI1NiIsInR5cCI6Ikp..sHQ", "token_type": "Bearer", "expires_in": 86400, "authorization_details": [ { "type": "openid_credential", "credential_configuration_id": "UniversityDegreeCredential", "credential_identifiers": [ "CivilEngineeringDegree-2023", "ElectricalEngineeringDegree-2023" ] } ] } If `credential_identifiers` came back, the Credential Request MUST use `credential_identifier` and MUST NOT carry `credential_configuration_id`. If they didn't (the `scope` path, with an AS that doesn't return them), it's the other way round (Sections 3.3.4 and 8.2). One configuration can expand into several datasets; here, two degrees. PKCE is unchanged; I wrote about it in RFC 7636 Deep Dive. ## The Credential Endpoint, shared by both If the issuer has a Nonce Endpoint, the Wallet first does `POST /nonce` with no access token and gets `{"c_nonce": "..."}` back with `Cache-Control: no-store` (Section 7). An issuer that wants nonces in proofs MUST run this endpoint. Then the Credential Request (Section 8.2): POST /credential HTTP/1.1 Host: server.example.com Content-Type: application/json Authorization: Bearer czZCaGRSa3F0MzpnWDFmQmF0M2JW { "credential_identifier": "CivilEngineeringDegree-2023", "proofs": { "jwt": ["eyJ0eXAiOiJvcGVuaWQ0dmNpLXByb29mK2p3dCIs...", "eyJraWQiOi..."] } } A decoded `jwt` proof from Appendix F.1: { "typ": "openid4vci-proof+jwt", "alg": "ES256", "jwk": { "kty": "EC", "crv": "P-256", "x": "nUWAoAv3...", "y": "HskHU8Bj..." } }.{ "aud": "https://credential-issuer.example.com", "iat": 1701960444, "nonce": "LarRGSbmUPYtRYO6BQ4yn8" } `iss` is the `client_id`, and it MUST be omitted when the token came from an anonymous Pre-Authorized Code request. The other proof types are `di_vp` (nonce in `challenge`, issuer in `domain`) and `attestation`. The array is the batch. Each key gets at most one credential, and every credential in one response shares the same Credential Format and Credential Dataset but SHOULD differ in key (Section 3.3.2). That is how a Wallet gets ten unlinkable copies of the same mDL. Different formats or datasets need separate requests. The response is either `200` with `credentials: [{credential: ...}]`, or, when the issuer can't issue yet, `202` with `transaction_id` and `interval`. The 202 is a MUST, not a hint (Section 8.3). The Wallet then polls `POST /deferred_credential` with the `transaction_id`, and gets 200 or another 202 with the same id (Section 9). Errors that matter in practice: `invalid_proof` covers a missing proof and a proof without the required `c_nonce`, while `invalid_nonce` means the nonce is there but stale, so the Wallet should fetch a new one and retry (Section 8.3.1.2). `credential_request_denied` is unrecoverable. ## What the 1.0 errata draft actually changes The notes I started from listed the Document History entries. I wanted the whole picture, so I diffed tag `1.0-final` against `1.0/` at `21ffd6c`. That's the entire normative delta: 33 lines added, 7 removed. * `202 OK` becomes `202 Accepted` in the deferred example (#722). * "MUST but used" becomes "MUST be used" in Section 9.1. * A paragraph in Section 14.2: if Cryptographic Key Binding isn't needed, the issuer omits `cryptographic_binding_methods_supported`, therefore also `proof_types_supported`, and the Wallet omits `proofs` (#714). This is the coupon and ticket case. * The metadata URL rule for a trailing `/` is back (#775). * New Section 13.6.3, Transaction Code Guessing (#686). The trailing slash looks like nothing, but it changes which URL a Wallet fetches: Credential Issuer Identifier | 1.0 Final, read literally | errata `-19` and 1.1 ---|---|--- `https://issuer.example.com/tenant` | `/.well-known/openid-credential-issuer/tenant` | same `https://issuer.example.com/tenant/` | `/.well-known/openid-credential-issuer/tenant/` | `/.well-known/openid-credential-issuer/tenant` `https://tenant.issuer.example.com` | `/.well-known/openid-credential-issuer` | same The rule used to be there. PR #527 rewrote the sentence to insert the well-known segment between host and path, RFC 8414 style, and the "remove any terminating `/`" clause got lost. Issue #744 points out that RFC 8414 Section 3.1 has the rule and Final is "silent", and its author says restoring it "would technically be a breaking change". It was raised with the conformance suite team as well. If your identifier ends in `/`, serve both paths until this settles. Transaction Code Guessing is what the opening was about. Here is how the error behaviour now differs across the three 1.x texts: The new section says the AS SHOULD cap failed `tx_code` attempts per Pre-Authorized Code, invalidate the code once the cap is hit, treat `tx_code` as single-use, and return `invalid_grant` for a dead code. For a wrong code on a live grant, the errata text says the AS SHOULD return "an error indicating that the provided Transaction Code is invalid". It doesn't name one. Section 6.3 of the same errata draft still lists the wrong-`tx_code` case under `invalid_grant`, and an errata can't add an error code to a Final. The same PR (#686) gave 1.1 a real one, `invalid_tx_code` (1.1 Section 7.3). So a 1.0 Wallet still can't tell the two cases apart from the error code alone, and a 1.1 Wallet can. ## 1.1: Interactive Authorization This is the main reason 1.1 exists. Some issuers want to see another credential before issuing: "present your PID, then I'll issue your mDL". In 1.0 that means a browser round trip in which the AS acts as an OpenID4VP Verifier, and the Wallet ends up presenting to a web page in another app. 1.1 Section 6 lets the Wallet do it natively, as a profile of OAuth 2.0 for First-Party Applications (FPA, pinned at draft -04). The AS advertises `authorization_challenge_endpoint` in its metadata (that's the FPA name), and can set `require_interactive_authorization: true` if it accepts nothing else (1.1 Section 13.3). The Wallet's first request is a normal authorization request sent as a POST, plus `interaction_types_supported`, a comma-separated list of URNs: * `urn:openid:dcp:ia:openid4vp_presentation` * `urn:openid:dcp:ia:auth_via_web` The AS answers with FPA's 403 (#781 moved it from 401 to match FPA -04): HTTP/1.1 403 Forbidden Content-Type: application/json Cache-Control: no-store { "error": "insufficient_authorization", "interaction_type_required": "urn:openid:dcp:ia:openid4vp_presentation", "auth_session": "wxroVrBY2MCq4dDNGXACS", "openid4vp_request": { "response_type": "vp_token", "response_mode": "ia_post", "dcql_query": { "credentials": [ { "id": "some_identity_credential", "format": "dc+sd-jwt" } ] }, "nonce": "n-0S6_WzA2Mj" } } The Wallet presents and POSTs back `auth_session` plus `openid4vp_response` to the same endpoint. That can repeat. When the AS is satisfied, it returns FPA's `200 {"authorization_code": ...}` and the rest is 1.0 again. `auth_via_web` is the escape hatch: the 403 carries a PAR-style `request_uri`, the Wallet opens a real browser (an embedded user agent is forbidden), and the redirect brings back either a `code` or an `auth_session` to continue with. The binding rules are where the WG has spent the last six months: * `auth_session` is REQUIRED only if the interaction type says so (#706). The Wallet MUST send the most recent one (#710). With DPoP, the AS MUST tie `auth_session` to the DPoP public key (#803), so a stolen session value is useless from another key. * Session fixation (1.1 Section 6.2.1.4): the AS MUST bind the OpenID4VP `nonce` to the `auth_session` and check that the presentation used it. * Forwarding (1.1 Section 6.2.1.5): a malicious AS could relay another AS's 403 to the Wallet and harvest the presentation. Two defences are given. If `expected_origins` is present, it MUST contain only the Origin of the challenge endpoint, and the Wallet checks it. The presentation's holder binding also names the challenge endpoint, and the AS checks that. * `auth_via_web`: each `request_uri` is used once (#704), and a Wallet with concurrent sessions MUST send `state` (#797). The draft text isn't settled yet, and three open items affect what goes on the wire: 1. The prose in 1.1 Section 6.2.1 says the AS sets `error_code` to `insufficient_authorization`. All four examples, and FPA -04 Section 5.2.2, use `error`. #819 (open) fixes the word. Implement `error`. 2. The holder-binding value for the forwarding defence differs by format. The SD-JWT VC section says the KB-JWT `aud` is the derived Origin with an `ia:` prefix, and gives `ia:https://example.com/authorize-challenge` as the example, which is a full URL. The JWT VC and Data Integrity sections say the endpoint URL. The mdoc section says the endpoint URL and "MUST NOT be prefixed with `ia:`". #812 (open, filed by someone profiling 1.1 for conformance work) lays this out and makes the right point about leniency: an AS that accepts either value to make interop work has quietly turned off the anti-relay check. 3. The Document History says `iae:`, `iae_post`, `interactive_authorization_endpoint` and `require_interactive_authorization_request`. The normative text says `ia:`, `ia_post`, `authorization_challenge_endpoint` and `require_interactive_authorization`. #811 (open) tracks this. Go by the normative text. ## 1.1: the smaller wire changes * `invalid_tx_code` (1.1 Section 7.3), covered above. * Credential Response gets `credential_metadata` (OPTIONAL, #721), and `credential_dataset_id` and `credential_dataset_tag` (RECOMMENDED, #472, merged 15 October 2026). The tag MUST be present when the id is, and MUST NOT be present otherwise. A Wallet holding credentials from dataset `8xR2vQpL9dKm4TzN` that sees a new tag knows the old batch is superseded. Before this, a Wallet had no standard way to tell a refresh from a new credential. * The deferred response RECOMMENDS the same two dataset fields. * PAR moves from an informative to a normative reference (1.0 only RECOMMENDS it), and Interactive Authorization is allowed in its place. A 1.0 Wallet ignores the new response fields, since unknown parameters MUST be ignored. Problems only come up when the two sides disagree on a value that's actually checked: the error code, the metadata URL, the binding `aud`. ## Server to Server The s2s draft solves a different problem. Some Wallet Providers run a backend and would rather it talk to the issuer than have every phone do so: phones are hard to update, have bad connectivity, and are a less trusted place to run issuance logic (s2s Section 4). The catch is that the backend shouldn't see the user's identity data or the credentials. It isn't OAuth at all. The Wallet Server and Issuer Server authenticate with mTLS on every endpoint (RFC 8705), send `Api-Version` with semantic versions and `Sunset` for retirement, require `x-request-id` for idempotency, and return RFC 9457 Problem Details. Anything that comes from the phone is a Client Encrypted Payload: a JWS signed with the Wallet Signing Key (WSK), wrapped in an HPKE JWE to the issuer. The inner `aud` is the JWK thumbprint of the encryption key, so a payload can't be re-wrapped to another recipient (s2s Section 5.5.2). The issuer encrypts credentials to the Wallet Encryption Key. The Wallet Server forwards ciphertext in both directions and adds its own risk signals as Verification Data. Issuance happens in two phases. Verification (`/verification/initiate`, `/supplement`, `/status`, `/cancel`, plus `/verification/notify` back to the Wallet) ends in one of `APPROVED`, `REJECTED`, `DENIED`, `ADDITIONAL_INFO_REQUIRED`, `PENDING`, `EXPIRED`. Then `/credential/provision` returns instance ids and `/credential/get` fetches credentials. Lifecycle operations (`/credential/manage` for suspend, resume, unlink, and `/credential/status`) run in both directions. This draft is moving fast. #809 converted every property to snake_case (merged 27 October). #810 renamed `session_id` to `wallet_id` and `credential_instance_id` to `credential_id`, and it merged on 10 November 2026, after the commit I pinned, so the current HEAD (`41c8c66`) already differs from `21ffd6c`. Deferred credentials with their own endpoint (#816) are still open. There are TODOs in the text for post-quantum algorithms and required curves. Treat it as a design document for now. Don't build to it yet. ## What I'd ship today * Implement 1.0 Final. Accept both metadata paths when the identifier ends in `/`. On the AS, cap `tx_code` attempts and invalidate the code at the cap. The errata asks for it, and nothing in Final forbids it. * Wallet side: treat `invalid_grant` after a `tx_code` entry as possibly fatal, and also accept `invalid_tx_code`, since a 1.1 AS will send it. * Ignore unknown Credential Response fields, but store `credential_dataset_id` and `credential_dataset_tag` when they show up. They cost nothing and make refresh correct later. * Interactive Authorization: prototype it, use `error`, and don't relax the binding `aud` check to work around #812. * s2s: watch it. Still open: whether #775's metadata rule ships as published errata or only in 1.1, how the WG settles `nonce` in key attestations (#678 currently says "at the Issuer's discretion" in its 1.0 text and "left to the Wallet" in 1.1), and when 1.1 goes to an Implementer's Draft. #687 is a personal timeline from a WG participant (jogu) that puts WG last call and a formal security analysis side by side, with the months marked "indicative".
dev.to
November 14, 2026 at 10:41 PM
With standard navigator.credentials.create() and OpenID4VCI, Android Credential Manager presents compatible wallets for the user to choose. It supports both same-device flows on Android and cross-device flows via QR code and Bluetooth proximity verification from desktop.
October 26, 2026 at 10:18 AM
OpenID Foundation launches conformance testing for digital identity wallets. The self-certification programme covers OpenID4VP and OpenID4VCI, the specs already deployed across 30+ jurisdictions. Critical infrastructure standardisation work.
OpenID Foundation Opens Conformance Testing for Digital Identity Wallets
The Foundation’s new self-certification programme covers OpenID4VP and OpenID4VCI, the specs underpinning wallets across more than 30 jurisdictions.
thefintechtimes.com
September 27, 2026 at 8:17 PM
September 21, 2026 at 5:39 AM
AuthleteがOpenID4VCI認定取得、世界標準への道を切り開く#東京都#千代田区#Authlete#OpenID4VCI#VC発行

株式会社AuthleteがOpenID4VCIの認定を取得し、迅速で高いセキュリティを持つVC発行基盤を実現。社会実装への貢献にも注目。
AuthleteがOpenID4VCI認定取得、世界標準への道を切り開く
株式会社AuthleteがOpenID4VCIの認定を取得し、迅速で高いセキュリティを持つVC発行基盤を実現。社会実装への貢献にも注目。
news.3rd-in.co.jp
September 14, 2026 at 2:50 AM
Authlete Achieves OpenID Certification for Verifiable Credentials in Compliance with HAIP Standards#Japan#Tokyo#Authlete#Verifiable_Credential#OpenID4VCI
Authlete Achieves OpenID Certification for Verifiable Credentials in Compliance with HAIP Standards
Authlete has successfully obtained OpenID certification for its implementation of OpenID4VCI under HAIP standards, ensuring secure verifiable credential issuance.
third-news.com
September 14, 2026 at 3:03 AM
STANDARDS COMPLIANCE CONFIRMED:

✅ W3C Verifiable Credentials Data Model 1.1
✅ OpenID4VCI (issuance protocol)
✅ OpenID4VP (presentation + selective disclosure)
✅ StatusList2021 (privacy-preserving revocation)
✅ European Learning Model
✅ eIDAS 2.0 ARF alignment

#W3C #OpenID #eIDAS2
November 19, 2025 at 7:17 AM
Android Hadirkan Dukungan Untuk Kredensial Digital | WinPoin – https://bit.ly/3YUPqPl – #Opsitek #Techno #Tekno

May 06, 2025 at 09:19PM Smartphone, Gadget, Android Hadirkan Dukungan Untuk Kredensial Digital | WinPoin Google baru baru ini telah mengumumkan bahwa Android akan mendapatkan dukungan…
Android Hadirkan Dukungan Untuk Kredensial Digital | WinPoin – https://bit.ly/3YUPqPl – #Opsitek #Techno #Tekno
May 06, 2025 at 09:19PM Smartphone, Gadget, Android Hadirkan Dukungan Untuk Kredensial Digital | WinPoin Google baru baru ini telah mengumumkan bahwa Android akan mendapatkan dukungan untuk penyajian dan penerbitan kredensial digital. Dukungan ini diberikan dengan dukungan bawaan untuk standar OpenID4VP dan OpenID4VCI yang terintegrasi dengan Android’s Credential Manager. Baca Juga : Youtube Uji Paket Premium Untuk Dua Orang Berkat kehadiran dan penambahan fitur ini, nantinya pengguna akan dapat menyimpan kredensial digital di perangkat mereka dalam aplikasi apapun yang mendukung API DigitalCredential.
pastikubisa9.wordpress.com
May 6, 2025 at 2:24 PM
Feed: "Latest from Android Central"
By: vishnu.skar@gmail.com (Vishnu Sarangapurkar) on Monday, May 5, 2025
Google makes it easier to share digital credentials on your Android phone
Expanding interoperability, Android supports OpenID4VP and OpenID4VCI, allowing users to securely share digital credentials across apps.
www.androidcentral.com
May 5, 2025 at 4:05 AM
VESS Labsがデジタル証明書の国際標準に正式対応、未来のインフラを先取り#デジタル証明書#VESS_Labs#国際標準

株式会社VESS Labsが、デジタル証明書の国際標準仕様「OpenID4VCI 1.0」と「OpenID4VP 1.0」に対応を完了しました。これにより、安全で迅速なデジタルアイデンティティ管理が実現します。
VESS Labsがデジタル証明書の国際標準に正式対応、未来のインフラを先取り
株式会社VESS Labsが、デジタル証明書の国際標準仕様「OpenID4VCI 1.0」と「OpenID4VP 1.0」に対応を完了しました。これにより、安全で迅速なデジタルアイデンティティ管理が実現します。
tokyo.publishing.3rd-in.co.jp
June 8, 2026 at 5:02 AM
⬆️ European Digital Identity just released OpenID4VCI v0.12.0 – Implementation of OpenID for Verifiable Credential Issuance protocol (wallet's role) in Swift

https://swiftpackageindex.com/eu-digital-identity-wallet/eudi-lib-ios-openid4vci-swift#releases
February 12, 2025 at 6:58 PM
📦 European Digital Identity just added a new package, OpenID4VCI – Implementation of OpenID for Verifiable Credential Issuance protocol (wallet's role) in Swift

https://swiftpackageindex.com/eu-digital-identity-wallet/eudi-lib-ios-openid4vci-swift
February 11, 2025 at 8:13 AM
VESS Labs Becomes First to Officially Support OpenID4VCI and OpenID4VP International Standards#Japan#digital_identity#Shibuya#VESS_Labs#OpenID4VCI
VESS Labs Becomes First to Officially Support OpenID4VCI and OpenID4VP International Standards
VESS Labs has formally integrated the latest international standards for digital certificates into all its products, ensuring secure data exchange worldwide.
third-news.com
June 8, 2026 at 5:03 AM
Announcing Android support of digital credentials
_Posted by Rohey Livne – Group Product Manager_ In today's interconnected world, managing digital identity is essential. Android aims to support open standards that ensure seamless interoperability with various identity providers and services. As part of this goal, we are excited to announce that Android, via Credential Manager's DigitalCredential API, now natively supports OpenID4VP and OpenID4VCI for digital credential presentation and issuance respectively. ## What are digital credentials? Digital credentials are cryptographically verifiable documents. The most common emerging use case for digital credentials is identity documents such as driver's licenses, passports, or national ID cards. In the coming years, it is anticipated that Android developers will develop innovative applications of this technology for a wider range of personal credentials that users will need to present digitally, including education certifications, insurance policies, memberships, permits, and more. Digital credentials can be provided by any installed Android app. These apps are known as "credential holders"; typically digital wallet apps such as Google Wallet or Samsung Wallet. Other apps not necessarily thought of as "wallets" may also have a use for exposing a digital credential. For example an airline app might want to offer their users' air miles reward program membership as a digital credential to be presented to other apps or websites. Digital credentials can be presented by the user to any other app or website on the same device, and Android also supports securely presenting Digital Credentials between devices using the same industry standard protocols used by passkeys (CTAP), by establishing encrypted communication tunnels. Users can store multiple credentials across multiple apps on their device. By leveraging OpenID4VP requests from websites using the W3C Digital Credential API, or from native apps using Android Credential Manager API, a user can select what credential to present from across all available credentials across all installed digital wallet apps. ## How digital credentials work ### Presentation To present the credential, the verifier sends an OpenID4VP request to the Digital Credential API, which then prompts the user to select a credential across all the credentials that can satisfy this request. Note that the user is selecting a credential, not a digital wallet app: _Digital credentials selection interface_ Once the user chooses a credential to proceed with, Android platform redirects the original OpenID4VP request to the digital wallet app that holds the chosen credential to complete the presentation back to the verifier. When the digital wallet app receives the OpenID4VP request from Android, it can also perform any additional due-diligence steps it needs to perform prior to releasing the credential to the verifier. ## Issuance Android also allows developers to issue their own Digital Credentials to a user's digital wallet app. This process can be done using an OpenID4VCI request, which prompts the user to choose the digital wallet app that they want to store the credential in. Alternatively, the issuance could be done directly from within the digital wallet app (some apps might not even have an explicit user facing issuance step if they store credentials based on their association to a signed-in user account). _A wallet app holds a single credential_ Over time, the user can repeat this process to issue multiple credentials across multiple digital wallet apps: _Multiple wallet apps hold multiple credentials_ > **Note:** _To ensure that at presentation time Android can appropriately list all the credentials that digital wallet apps hold, digital wallets must register their credentials' metadata with Credential Manager. Credential Manager uses this metadata to match credentials across available digital wallet apps to the verifier's request, so that it can only present a list of valid credentials that can satisfy the request for the user to select from._ ## Early adopters As Google Wallet announced yesterday, soon users will be able to use digital credentials to recover Amazon accounts, access online health services with CVS and MyChart by Epic, and verify profiles or identity on platforms like Uber and Bumble. These use cases will take advantage of users' digital credentials stored in any digital wallet app users have on their Android device. To that end, we're also happy to share that both Samsung Wallet and 1Password will hold users' digital credentials as digital wallets and support OpenID standards via Android's Credential Manager API. ## Learn more Credential Manager API lets every Android app implement credential verification or provide credentials on the Android platform. Check out our new digital credential documentation on how to become a credential verifier, taking advantage of users' existing digital credentials using Jetpack Credential Manager, or to become a digital wallet app holding your own credentials for other apps or websites to verify.
android-developers.googleblog.com
May 8, 2025 at 11:34 AM
Announcing Android support of digital credentials
_Posted by Rohey Livne – Group Product Manager_ In today's interconnected world, managing digital identity is essential. Android aims to support open standards that ensure seamless interoperability with various identity providers and services. As part of this goal, we are excited to announce that Android, via Credential Manager's DigitalCredential API, now natively supports OpenID4VP and OpenID4VCI for digital credential presentation and issuance respectively. ## What are digital credentials? Digital credentials are cryptographically verifiable documents. The most common emerging use case for digital credentials is identity documents such as driver's licenses, passports, or national ID cards. In the coming years, it is anticipated that Android developers will develop innovative applications of this technology for a wider range of personal credentials that users will need to present digitally, including education certifications, insurance policies, memberships, permits, and more. Digital credentials can be provided by any installed Android app. These apps are known as "credential holders"; typically digital wallet apps such as Google Wallet or Samsung Wallet. Other apps not necessarily thought of as "wallets" may also have a use for exposing a digital credential. For example an airline app might want to offer their users' air miles reward program membership as a digital credential to be presented to other apps or websites. Digital credentials can be presented by the user to any other app or website on the same device, and Android also supports securely presenting Digital Credentials between devices using the same industry standard protocols used by passkeys (CTAP), by establishing encrypted communication tunnels. Users can store multiple credentials across multiple apps on their device. By leveraging OpenID4VP requests from websites using the W3C Digital Credential API, or from native apps using Android Credential Manager API, a user can select what credential to present from across all available credentials across all installed digital wallet apps. ## How digital credentials work ### Presentation To present the credential, the verifier sends an OpenID4VP request to the Digital Credential API, which then prompts the user to select a credential across all the credentials that can satisfy this request. Note that the user is selecting a credential, not a digital wallet app: _Digital credentials selection interface_ Once the user chooses a credential to proceed with, Android platform redirects the original OpenID4VP request to the digital wallet app that holds the chosen credential to complete the presentation back to the verifier. When the digital wallet app receives the OpenID4VP request from Android, it can also perform any additional due-diligence steps it needs to perform prior to releasing the credential to the verifier. ## Issuance Android also allows developers to issue their own Digital Credentials to a user's digital wallet app. This process can be done using an OpenID4VCI request, which prompts the user to choose the digital wallet app that they want to store the credential in. Alternatively, the issuance could be done directly from within the digital wallet app (some apps might not even have an explicit user facing issuance step if they store credentials based on their association to a signed-in user account). _A wallet app holds a single credential_ Over time, the user can repeat this process to issue multiple credentials across multiple digital wallet apps: _Multiple wallet apps hold multiple credentials_ > **Note:** _To ensure that at presentation time Android can appropriately list all the credentials that digital wallet apps hold, digital wallets must register their credentials' metadata with Credential Manager. Credential Manager uses this metadata to match credentials across available digital wallet apps to the verifier's request, so that it can only present a list of valid credentials that can satisfy the request for the user to select from._ ## Early adopters As Google Wallet announced yesterday, soon users will be able to use digital credentials to recover Amazon accounts, access online health services with CVS and MyChart by Epic, and verify profiles or identity on platforms like Uber and Bumble. These use cases will take advantage of users' digital credentials stored in any digital wallet app users have on their Android device. To that end, we're also happy to share that both Samsung Wallet and 1Password will hold users' digital credentials as digital wallets and support OpenID standards via Android's Credential Manager API. ## Learn more Credential Manager API lets every Android app implement credential verification or provide credentials on the Android platform. Check out our new digital credential documentation on how to become a credential verifier, taking advantage of users' existing digital credentials using Jetpack Credential Manager, or to become a digital wallet app holding your own credentials for other apps or websites to verify.
android-developers.googleblog.com
May 1, 2025 at 12:08 PM
Google Android now supports OpenID4VP and OpenID4VCI for cryptographic identity credentials (e.g. national ID cards) via Credential Manager's DigitalCredential API android-developers.googleblog.com/2025/04/anno...
May 7, 2025 at 11:17 AM
For national electronic identity (E-ID) system and E-Wallet, Switzerland will use SD-JWT (Selective Disclosure JSON Web Token) including OpenID4VCI and OpenID4VP for credential issuance and verification, establishing communication between participants idtechwire.com/switzerland-...
Switzerland Unveils Technical Framework for National Digital ID System and E-Wallet
idtechwire.com
December 11, 2024 at 9:57 AM
Android pridáva podporu pre digitálne doklady: Nová éra digitálnej identity

Spoločnosť Google oznámila, že operačný systém Android teraz podporuje prezentáciu a vydávanie digitálnych dokladov. Táto funkcionalita je implementovaná prostredníctvom natívnej podpory štandardov OpenID4VP a OpenID4VCI,…
Android pridáva podporu pre digitálne doklady: Nová éra digitálnej identity
Spoločnosť Google oznámila, že operačný systém Android teraz podporuje prezentáciu a vydávanie digitálnych dokladov. Táto funkcionalita je implementovaná prostredníctvom natívnej podpory štandardov OpenID4VP a OpenID4VCI, ktoré sú integrované do správcu poverení systému Android (Credential Manager). Vďaka tejto aktualizácii môžu používatelia ukladať digitálne doklady vo svojich zariadeniach prostredníctvom aplikácií podporujúcich API DigitalCredential. Tieto aplikácie umožňujú zdieľanie informácií s inými aplikáciami a používateľ môže svoje doklady prezentovať podľa potreby. Prenosy údajov prebiehajú cez šifrované komunikačné kanály, čo zaručuje bezpečnosť a ochranu súkromia. Digitálne doklady sú kryptograficky overiteľné dokumenty, ktoré môžu zahŕňať vodičské preukazy, pasy, národné identifikačné preukazy, ale aj certifikáty o vzdelaní, poistné zmluvy, členstvá či povolenia.
www.techarena.sk
May 3, 2025 at 3:51 PM
VESS Labsがデジタル証明書の国際標準1.0に正式対応✨ #VESS Labs の全製品で #OpenID4VCI やVP 1.0に準拠しました。開発コストを削減しつつ欧州EUDI Walletなど国内外のシステムとの相互運用性を確保します。
https://finwave.jp/archives/4510
June 8, 2026 at 7:42 AM