User Abandonment in Presentation Flows
A presentation passes through the user's browser, the operating system and the wallet app. The user can leave the flow at each of these three points. This page lists the known reasons, what the user and the Relying Party see in each case, and the measures that lead the user either to a successful presentation or to another method.
What the Relying Party observes
The backend keeps a status for every attempt: created, fetched, completed, partial, rejected, error or expired. "Completed" is the successful outcome. The desktop page in cross-device flows for example polls this status. Every abandonment ends in one of five signals. A sixth row lists errors on the Relying Party's side.
| Signal | Meaning | Status |
|---|---|---|
| Request not fetched | The wallet never called request_uri. The flow ended before the wallet opened, a different app received the link, or a network or TLS (encrypted connection) failure stopped the call before it reached the endpoint. | expired |
| Request fetched, no response | The wallet loaded the request object, then the flow ended in the wallet or on the device. The Relying Party learns this only at the timeout. | expired |
| Response with an error code | The wallet posted an error to response_uri, in most cases access_denied. | error |
| Unusable response | A response arrived, but it fails validation or arrives after the request lifetime. | rejected |
| Error in own logs | An endpoint of the Relying Party failed while processing a call. | the attempt keeps its last status |
An error code is a fixed string the wallet sends instead of a response. access_denied covers three situations: the wallet holds no credential that matches the request, the user declined to share, or the wallet failed to authenticate the user. The error code does not say which of the three happened, and some wallets send no error at all in these cases.
Measures that apply to most cases
Most rows in the tables below share these measures and refer to them by name.
- Upfront information: before the wallet opens, the Relying Party's page names the wallet and the credential the user needs, where to obtain them, and how long the step takes. For the PID the page adds the prerequisites listed under PID onboarding. The Touchpoint Design Guide specifies the button and the modal.
- Fresh request: a "Try again" button creates a new attempt with a new
nonce,state,request_uri, response encryption key and session-specificresponse_uri. It closes the previous attempts of the same browser session. - Alternative method: another way to complete the process, for example an identity check with the online ID function of the ID card in another app, or a visit in person. Whether to offer one is the Relying Party's decision. Offering it gives users without a wallet a route to completion. It requires a second verification path with its own level of assurance (how reliably the path establishes a person's identity).
- Return page with options: in same-device flows, the return page after an error offers a fresh request and the alternative method. In cross-device flows, the desktop page learns of the error through polling and offers the same options itself.
Abandonment reasons
The frequency column gives estimates, not measurements, of how often each reason occurs in the first months after the launch of the German EUDI Wallet. The labels rank the reasons on one scale: very rare, rare, medium, common, very common. A qualifier in brackets names where the estimate applies. The estimates will shift as more users install a wallet.
Before the wallet opens
| Reason | What the user sees | What the Relying Party sees | Handling | Frequency |
|---|---|---|---|---|
| No wallet installed | Same-device flow: an operating system message that no app can open the link, or no reaction at all. Cross-device flow: the scanned QR code opens nothing useful. | Request not fetched, timeout | Upfront information with an install link; alternative method. | Very common (at launch) |
| QR code scanned with the wrong app (i.e. own QR Reader in a banking app) | A scanner app shows the link as text or starts a web search | Request not fetched, timeout | An instruction next to the QR code to scan it with the wallet or the phone's camera app, invoke wallet links from own apps. | Medium |
| Several wallets installed, the wrong one opens | An app picker, or a default wallet that lacks the credential | Request fetched, access_denied or no response | Upfront information naming the wallet, Using DC Api later on | Rare (increasing) |
| Device does not meet the wallet's requirements | The wallet refuses installation or PID issuance, for example on a rooted device (one whose operating system protections were removed), after a failed check of the device's integrity, or on a phone without secure storage for keys | Request not fetched, or fetched followed by timeout | Alternative method | Rare |
request_uri opened twice (single-use request_uri only) | Wallet error that the request is invalid or expired | A second fetch, which the endpoint rejects | Fresh request; see the decision on single use | Rare |
| Technical error at the Relying Party | Wallet error while loading the request object or sending the response | Errors in own logs, or nothing when the call never reaches the endpoint | Monitoring and alerting; an external check, run by the Relying Party from outside its own network, that calls request_uri and response_uri at intervals | Rare |
In the wallet
| Reason | What the user sees | What the Relying Party sees | Handling | Frequency |
|---|---|---|---|---|
| Required credential missing | The wallet reports that no matching credential is available | Request fetched, access_denied or no response | Upfront information on the credential and how to obtain it; return page with options | Common |
| User cancels or switches to another method | Consent screen, the user taps Cancel, closes the wallet or leaves the flow | Request fetched or not, access_denied or no response | Return page with options; alternative method shown as an equal option | Common |
| Wallet rejects the request | The access certificate or the signature of the request object fails the wallet's check, and the wallet refuses the request | Request fetched, no response | Monitor certificate expiry; sign the request object with the key of the access certificate, see Using Registrar Certificates | Rare (if configured correctly) |
| Registration certificate fails validation | A warning that the Relying Party could not be validated (certificate expired, revoked or from an untrusted provider). | access_denied or no response | Include a valid registration certificate in verifier_info, the request parameter that carries information about the Relying Party | Rare (if configured correctly) |
| Request exceeds the registration (overasking) | A warning that the Relying Party asks for attributes beyond its registration certificate. The wallet rejects the request. | access_denied, partial response or no response | Request only attributes the registration certificate covers | Rare (if configured correctly) |
| Credential restricts its recipients | The provider of an electronic attestation of attributes (EAA, a credential other than the PID) embedded a disclosure policy that excludes this Relying Party, and the wallet tells the user. | access_denied or no response | Check the rulebook of the credential type before requesting it. The rulebook is the document in which the credential's provider specifies the credential's attributes and any restrictions on who may receive it. | Rare |
| Wallet closed by the operating system | The user leaves the wallet (for example to look for the PIN letter, see PID onboarding), the operating system closes it, the flow is lost | Request fetched, timeout | Fresh request on return | Medium |
| Network loss | A loading or sending error in the wallet | Request fetched and no response, or nothing | Fresh request | Medium (mobile) |
| Technical error in the wallet | An error message or a wallet crash | Timeout | Point to the wallet's support pages | Rare to medium |
| User cannot unlock the wallet | Biometrics or PIN fail, or the wallet is locked | access_denied or no response | Alternative method; the cause is outside the Relying Party's control | Very rare |
Wallets have to validate the registration certificate from 11 August 2028. Some wallets may already show the two warnings above before that date, so whether a user sees them today depends on the wallet.
After the wallet responds
| Reason | What the user sees | What the Relying Party sees | Handling | Frequency |
|---|---|---|---|---|
| Response arrives after the request lifetime | The user completes a long flow (for example PID onboarding), then gets an error | Unusable response, recorded as late | Same-device flow: the return page offers a fresh request. Cross-device flow: see the decision on the reply to a rejected response. | Medium (PID flows) |
| Same-device flow: the return opens a different browser | After presenting, a browser opens without the original session. This is typical when the flow started in the in-app browser of a mail or social media app, a browser built into that app that keeps its own session apart from the phone's main browser. | A valid response, but the browser that opens the redirect_uri lacks the session cookie | Before the wallet opens, detect in-app browsers by the app names they add to their browser identification (the User-Agent header). This detection catches common apps but not all. Ask the user to open the page in the phone's main browser. The return page offers a fresh request. If you use a mobile device, ensure to use deeplinking. | Medium (mobile) |
| Cross-device flow: the user does not return | The user finishes in the wallet on the phone and does not know to go back to the desktop | A completed attempt while the user has already left the desktop page | The desktop page shows the outcome by itself through polling; an instruction next to the QR code | Medium |
| Credential fails validation | The user shares the data, then sees a rejection | Unusable response: the credential's status, which the Relying Party looks up in the status list its issuer publishes, shows it as expired or revoked, or the issuer is missing from the trust list (the published list of trusted issuers) | A message pointing to re-issuance; trust lists kept current | Rare |
PID onboarding
In PID onboarding, the wallet reads the German ID card over NFC (the short-range radio in the phone), and the user enters the eID PIN. The eID PIN is the six-digit PIN of the card's online ID function (eID, electronic identification). Onboarding takes several minutes and needs three things: the ID card, an activated online ID function and the eID PIN.
The PIN letter is sent to the card holder after the card is issued. It holds the five-digit transport PIN, which the holder replaces with a self-chosen six-digit eID PIN before first use, and the ten-digit PUK (unblocking key). The six-digit CAN (card access number) is printed on the front of the card.
Wallets differ in whether they start onboarding from within a presentation request, and in whether they continue that request after onboarding. The signal the Relying Party sees therefore depends on the wallet the user has:
- Onboarding started from within the request gives "request fetched, no response".
- Onboarding started separately, after a first attempt failed with a missing credential, gives "request not fetched", because the wallet makes no call for the earlier request.
The PID measures apply to every row of the table below: upfront information on the prerequisites and the duration, a request lifetime chosen for the flow, and a fresh request after onboarding. The Handling column adds what is specific to each row.
| Reason | What the user sees | Handling | Frequency |
|---|---|---|---|
| User aborts onboarding | The wallet asks for PID onboarding, the user stops | - | Common |
| Onboarding takes longer than the request lifetime | Everything works, the user is still in the process | See the decision on the request lifetime | Common |
| NFC reading of the ID card fails | Card not detected, reading aborts, NFC switched off or unsupported by the phone | Upfront information on enabling NFC and holding the card to the back of the phone; alternative method | Common (first onboarding) |
| No online ID function | The online ID function is deactivated (possible on older cards), or the user only has a passport | Alternative method | Medium |
| User does not know the eID PIN | The user forgot the PIN or only has the transport PIN, which has to be replaced first, for example with the AusweisApp, the German government's app for the online ID function | Keep FAQs about the process close to yours and reachable for users | Medium |
| User takes too long to find the eID PIN | The wallet waits at PIN entry while the user searches for documents or stops the process | Upfront information on the documents to have at hand | Medium |
| eID PIN blocked | After the second wrong entry, the card asks for the CAN. After the third wrong entry, the PIN is blocked, and only the PUK unblocks it. | Keep FAQs about the process close to yours and reachable for users | Rare to medium |
Decisions for the Relying Party
Request lifetime
Three values together set the request lifetime:
- the
exp(expiry time) inside the request object, which the wallet checks when it fetches the request object; - the server-side lifetime of
nonceandstate, which decides whether the backend accepts a response; - the freshness window, the largest age of the response's issue time that the backend accepts.
A longer request lifetime needs all three raised. The Relying Party chooses the values. The duration of PID onboarding varies by user, so the Relying Party measures it in its own flow.
| Option | Consequence |
|---|---|
| 5 to 10 minutes, as in the PID presentation checklist, which also gives a freshness window of 5 minutes as an example | Open attempts and unused nonces expire quickly, which keeps the time in which a copied request_uri works short. Users who first onboard their PID exceed the request lifetime and need a fresh request after onboarding. |
| Long enough to cover PID onboarding | Users who onboard from within the request finish in one attempt, if their wallet continues the original request after onboarding. A copied request_uri stays usable for longer, the backend holds more open attempts, and the timeout that signals abandonment arrives later. |
Single-use request_uri
The Relying Party chooses whether the endpoint behind request_uri serves the request object once or repeatedly. A wallet ends the flow when the fetch returns an HTTP error.
| Option | Consequence |
|---|---|
| Single use | The first fetch marks the attempt as fetched in a single operation on storage shared by all backend instances, so two parallel fetches cannot both succeed. Later fetches get HTTP 400. A request_uri opened twice or forwarded fails, and so does a wallet that fetches again after a network loss or a restart. A copied request_uri no longer works after the first fetch. |
| Repeatable until the request lifetime ends | A request_uri opened twice still works. Any device that obtains the request_uri can load the request object until the request lifetime ends; the backend still accepts only one response per attempt. |
Effect of an error post
An error post carries no signature, so a third party that knows state can send one.
| Option | Consequence |
|---|---|
| The error closes the attempt | The return page or the desktop page shows the error right away. A forged error post ends the user's attempt, and a valid response that follows is rejected. |
| The attempt stays open until the request lifetime ends | A forged error post leaves the attempt intact, and a later valid response still completes it. The status error is provisional: it can still change to completed. The page shows the error with an option to continue, since the outcome is final only at the timeout. |
Reply to a rejected response in cross-device flows
This applies to a response that arrives after the request lifetime or fails validation. In same-device flows the reply is always HTTP 200 with the redirect_uri of the return page. In cross-device flows the user's browser is on another device, so the reply carries no redirect_uri.
| Option | Consequence |
|---|---|
| HTTP 200 | The wallet shows the presentation as sent. The user learns of the rejection only on the desktop page, which offers a fresh request. |
| HTTP 400 without detail | The wallet shows an error, so the user sees on the phone that the presentation failed. The desktop page shows the same outcome and offers a fresh request. |
One or two attempts per modal
The modal creates the attempt when it opens, before the user picks the QR code or the same-device button.
| Option | Consequence |
|---|---|
| One attempt for both | The backend cannot tell a same-device from a cross-device flow when the response arrives. A redirect_uri returned in a cross-device flow opens on the phone in a browser without the session, which shows a failed attempt while the desktop page shows success. |
| One attempt for the QR code and one for the button | The backend stores the flow type and returns a redirect_uri only in same-device flows. The modal creates two attempts each time it opens, and the one the user does not use expires unused. |
Monitoring abandonment
One record per attempt shows at which step users leave. It holds the attempt identifier, flow type, creation time, fetch time, expiry time, status and error code.
Timeouts, access_denied and partial responses count as abandonment. Unusable responses count separately, since they come from credential status, trust lists or the request lifetime.
Request defects (the codes listed under What the Relying Party observes), technical errors on the wallet's side and errors in own logs count as technical errors. Alerts then react to failures of the Relying Party's own service.
A rise in unfetched requests without a change in user behaviour is compared with the result of the external check of request_uri. Failures of TLS, of DNS (the name lookup for the Relying Party's domain) or of a firewall look the same as users who never open the wallet. Logging and Monitoring covers retention and data minimisation for these records.
Further Reading
- OpenID for Verifiable Presentations 1.0, sections 8.2 (Response Mode
direct_post,redirect_uri), 8.3.1 (unencrypted error responses), 8.5 (error codes), 13.3 (response_code) and 14.2 (session fixation) - OpenID4VC High Assurance Interoperability Profile 1.0, section 5.1
- Commission Implementing Regulation (EU) 2026/1731, Annex XII (presentation protocols) and the amendments to Articles 3 and 5 of Implementing Regulation (EU) 2024/2982