Skip to main content

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.

SignalMeaningStatus
Request not fetchedThe 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 responseThe 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 codeThe wallet posted an error to response_uri, in most cases access_denied.error
Unusable responseA response arrived, but it fails validation or arrives after the request lifetime.rejected
Error in own logsAn 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-specific response_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​

ReasonWhat the user seesWhat the Relying Party seesHandlingFrequency
No wallet installedSame-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, timeoutUpfront 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 searchRequest not fetched, timeoutAn 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 opensAn app picker, or a default wallet that lacks the credentialRequest fetched, access_denied or no responseUpfront information naming the wallet, Using DC Api later onRare (increasing)
Device does not meet the wallet's requirementsThe 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 keysRequest not fetched, or fetched followed by timeoutAlternative methodRare
request_uri opened twice (single-use request_uri only)Wallet error that the request is invalid or expiredA second fetch, which the endpoint rejectsFresh request; see the decision on single useRare
Technical error at the Relying PartyWallet error while loading the request object or sending the responseErrors in own logs, or nothing when the call never reaches the endpointMonitoring and alerting; an external check, run by the Relying Party from outside its own network, that calls request_uri and response_uri at intervalsRare

In the wallet​

ReasonWhat the user seesWhat the Relying Party seesHandlingFrequency
Required credential missingThe wallet reports that no matching credential is availableRequest fetched, access_denied or no responseUpfront information on the credential and how to obtain it; return page with optionsCommon
User cancels or switches to another methodConsent screen, the user taps Cancel, closes the wallet or leaves the flowRequest fetched or not, access_denied or no responseReturn page with options; alternative method shown as an equal optionCommon
Wallet rejects the requestThe access certificate or the signature of the request object fails the wallet's check, and the wallet refuses the requestRequest fetched, no responseMonitor certificate expiry; sign the request object with the key of the access certificate, see Using Registrar CertificatesRare (if configured correctly)
Registration certificate fails validationA warning that the Relying Party could not be validated (certificate expired, revoked or from an untrusted provider).access_denied or no responseInclude a valid registration certificate in verifier_info, the request parameter that carries information about the Relying PartyRare (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 responseRequest only attributes the registration certificate coversRare (if configured correctly)
Credential restricts its recipientsThe 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 responseCheck 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 systemThe user leaves the wallet (for example to look for the PIN letter, see PID onboarding), the operating system closes it, the flow is lostRequest fetched, timeoutFresh request on returnMedium
Network lossA loading or sending error in the walletRequest fetched and no response, or nothingFresh requestMedium (mobile)
Technical error in the walletAn error message or a wallet crashTimeoutPoint to the wallet's support pagesRare to medium
User cannot unlock the walletBiometrics or PIN fail, or the wallet is lockedaccess_denied or no responseAlternative method; the cause is outside the Relying Party's controlVery 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​

ReasonWhat the user seesWhat the Relying Party seesHandlingFrequency
Response arrives after the request lifetimeThe user completes a long flow (for example PID onboarding), then gets an errorUnusable response, recorded as lateSame-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 browserAfter 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 cookieBefore 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 returnThe user finishes in the wallet on the phone and does not know to go back to the desktopA completed attempt while the user has already left the desktop pageThe desktop page shows the outcome by itself through polling; an instruction next to the QR codeMedium
Credential fails validationThe user shares the data, then sees a rejectionUnusable 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 currentRare

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.

ReasonWhat the user seesHandlingFrequency
User aborts onboardingThe wallet asks for PID onboarding, the user stops-Common
Onboarding takes longer than the request lifetimeEverything works, the user is still in the processSee the decision on the request lifetimeCommon
NFC reading of the ID card failsCard not detected, reading aborts, NFC switched off or unsupported by the phoneUpfront information on enabling NFC and holding the card to the back of the phone; alternative methodCommon (first onboarding)
No online ID functionThe online ID function is deactivated (possible on older cards), or the user only has a passportAlternative methodMedium
User does not know the eID PINThe 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 functionKeep FAQs about the process close to yours and reachable for usersMedium
User takes too long to find the eID PINThe wallet waits at PIN entry while the user searches for documents or stops the processUpfront information on the documents to have at handMedium
eID PIN blockedAfter 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 usersRare 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 nonce and state, 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.

OptionConsequence
5 to 10 minutes, as in the PID presentation checklist, which also gives a freshness window of 5 minutes as an exampleOpen 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 onboardingUsers 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.

OptionConsequence
Single useThe 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 endsA 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.

OptionConsequence
The error closes the attemptThe 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 endsA 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.

OptionConsequence
HTTP 200The 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 detailThe 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.

OptionConsequence
One attempt for bothThe 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 buttonThe 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​