Accepting EUDI Wallet credentials without building a verifier
eudiw-adapter is our open-source, self-hosted EUDI Wallet verifier. It verifies SD-JWT VC presentations over OpenID4VP 1.0 and HAIP 1.0 and returns only the claims a service asked for. What it does, how to integrate it, and what version 0.1.0 does not cover yet.
The EU Digital Identity Wallet lets people prove facts about themselves from their phone: that they are over 18, where they live, which qualification they hold. For a relying party, accepting one of those proofs means implementing a stack of new standards correctly. The request has to be signed, the response decrypted, the issuer checked against a trust list, the credential checked for revocation, and the holder's key binding checked against the request. Then someone has to decide which of the disclosed data the service may keep.
Most services that want an age check do not want to own any of that. eudiw-adapter is our open-source answer: a self-hosted verifier that puts the stack behind a small REST API and hands the backend only the claims it asked for. Version 0.1.0 is the first release, under the Apache 2.0 license.
what the backend sees
A backend talks to the adapter in three steps.
- It starts a session for a policy, for example
age-over-18, with an OAuth 2.0 client-credentials token from its own authorization server. - It shows the returned
launch_urias a wallet link on the same device, or as a QR code across devices. - When the session is verified, by polling or after a signed webhook, it fetches the result once.
curl -X POST https://adapter.example/v1/verification-sessions \
-H "Authorization: Bearer $TOKEN" -H "Idempotency-Key: $(uuidgen)" \
-H 'Content-Type: application/json' \
-d '{"policy_id":"age-over-18","mode":"same_device","client_reference":"order-42"}'
The result contains the claims the policy names and a short record of which credential type and issuer they came from:
{
"status": "verified",
"policy_id": "age-over-18",
"claims": { "age_over_18": true },
"credential_evidence": [
{ "format": "dc+sd-jwt", "credential_type": "https://credentials.example/age", "issuer": "https://issuer.example" }
]
}
Between steps 2 and 3, the adapter does the protocol work. It serves a signed OpenID4VP 1.0 request object with a DCQL query, receives the wallet's response encrypted to a fresh key, and verifies the SD-JWT VC presentation: the issuer signature, the disclosure digests, the key binding to its own nonce and client identifier, the issuer's certificate chain and the credential's status. Requests follow the OpenID4VC High Assurance Interoperability Profile (HAIP) 1.0, the profile the EUDI Wallet framework builds on.
The full contract is in the OpenAPI document.
only the claims the policy names
A credential usually holds more than a service needs. An age credential can also hold a name. A wallet shows the user what is requested, but once data reaches a backend it tends to end up in logs, databases and support tools.
Each policy in the adapter names the claims that may leave the service. Nothing else the wallet disclosed is passed on. Results are encrypted at rest, can be fetched once and expire. The raw presentation is never stored. Webhooks carry the session id and status, never claims.
Under the EUDI framework, a relying party also registers which attributes it intends to request. The adapter sends its registration certificate and registrar dataset in verifier_info, as ETSI TS 119 472-2 describes, and refuses to start when a configured query asks for more than was registered. Over-asking is caught at deployment, before a wallet refuses the request in front of a user.
trust from the lists issuers are published on
A valid signature only matters if the signer is someone you trust. The adapter takes issuer trust from signed ETSI trusted lists: TS 119 602 lists, such as the EU list of PID providers, and TS 119 612 lists, including the EU list of trusted lists. Every list must be signed by a certificate you pin. Stale lists are rejected, and a list older than one already seen is refused, so an attacker cannot replay an outdated list.
Credential revocation and suspension come from the Token Status List a credential points to. Issuer certificates can also be checked against CRLs, per policy. When the adapter cannot establish something, such as an unknown issuer, an unknown status or a late response, it rejects the presentation and returns a coarse reason code.
built to run in production
The adapter is a Quarkus service on top of adapter-core, a plain Java 21 verification library that can also be used on its own. PostgreSQL holds all state, so any number of replicas can run side by side without a message broker or cache.
- A multi-architecture image on GitHub Container Registry, signed with cosign, with an SBOM and build provenance.
- A signed Helm chart that runs under the restricted Kubernetes Pod Security Standard.
- Request-signing keys in an HSM or KMS through PKCS#11.
- Several tenants, clients and policies from configuration. The tenant always comes from the caller's token, never from the request.
- Prometheus metrics, an audit trail, optional OpenTelemetry traces, per-client rate limits shared across replicas, and configuration reload without a restart.
The threat model describes what the service defends against, and what it does not.
a web component for the frontend
The browser never talks to the adapter directly. The backend holds the client credentials and passes the launch link to the page. To show it, we publish @su-engineering/eudiw-request, a web component with no dependencies:
npm install @su-engineering/eudiw-request
<eudiw-request
launch-uri="openid4vp://?client_id=...&request_uri=..."
status-url="/verifications/7Qx.../status"
request-label="over 18"
expires-at="2026-11-17T10:05:00Z"></eudiw-request>
It renders the QR code and wallet link, says what is being asked, counts down to expiry and follows the session through your own status URL. It fires an event when the check ends, and the backend then fetches the result. The repository has complete Node and Python examples of the backend side.
try it locally
git clone https://github.com/su-engineering/eudiw-adapter.git && cd eudiw-adapter
./deploy/compose/demo.sh
The demo needs Docker, Java 21, curl and jq. It starts PostgreSQL, Keycloak as the OAuth server and the adapter, then plays both sides of a check with the independent eudi-dev test wallet in HAIP mode. The adapter signs with a key held in SoftHSM, trusts the issuer through a signed ETSI trusted list, and returns only age_over_18 from a credential that also holds a name. The same demo runs in CI on every commit.
how it relates to keycloak-oid4vp
We also maintain keycloak-oid4vp, which adds wallet login to Keycloak. The two solve different problems. Use keycloak-oid4vp when a wallet should log a user into an account through your identity provider. Use eudiw-adapter when a service needs to check a fact at a specific moment, such as an age check at checkout, a residency check during onboarding or a qualification check, and the result should go to that service's backend rather than into a login session.
what 0.1.0 does not cover
This is a first release, and the feature matrix lists exactly what is implemented and how each feature is tested. "Supported" there means automated tests pass for a pinned version of a standard. It is not a conformance claim.
- ISO mdoc credentials and the Digital Credentials API are not included. They are first on the roadmap.
- OCSP, wallet attestation and
transaction_dataare not implemented yet. - Interoperability is tested against the eudi-dev wallet, in strict HAIP and ARF modes, and against the OpenID Foundation HAIP verifier test plan run locally. The adapter is not certified, has not been run against the EU reference wallet on real devices, and has had no external security review.
- Trusted lists and registration certificates have been tested with synthetic data, and PKCS#11 signing with SoftHSM.
Test with the wallets and issuers you will accept before going live.
accepting wallets is a product decision
Running a verifier is the part we could make reusable. Choosing which issuers to trust, what each check is allowed to keep, and how a wallet check fits an existing onboarding or checkout flow depends on the service.
We help teams connect EUDI wallets to the products and identity systems they already run. See our identity project work, or tell us what you are building.
Working on something similar? Talk to us