Payments

Payment authorization and strong customer authentication

Authorise a payment with an identity-bound approval that covers amount and payee.

Use case
Payments / SCA
Wallet data
PID
Authbound capability
Payments
Flow
Authorise
What changes

Before and after the wallet

Today

  1. SMS code
  2. Generic push prompt
  3. No identity binding
  4. Settlement

With the EUDI Wallet

  1. Amount and payee in wallet
  2. Authbound verifies
  3. Bound authorisation
  4. Settlement

The wallet changes how the evidence is collected. The step at the end stays yours.

The problem

Why this is worth changing

For the business
Fraud losses from phished SMS codes and SIM swaps land on the payment provider.
For the user
Generic approve prompts do not show what is being paid, so users approve blind.
For operations
Dynamic linking needs separate controls on top of codes and push prompts.

Why the wallet helps

A wallet authorization ties the confirmation to the payer and to the specific transaction. The consent screen shows amount and payee, and the signature covers both, which is what PSD2 dynamic linking asks for. The result resists phishing and carries an identity binding the issuer can rely on.

  • No code to read out to a caller, so voice phishing fails
  • Dynamic linking satisfied by construction rather than by a separate control
  • An identity binding that strengthens dispute handling
User journey

What actually happens

  1. 01

    You create a request with amount and payee

  2. 02

    The payer gets it by QR or deep link

  3. 03

    The wallet shows amount and payee

  4. 04

    The payer approves with their device unlock

  5. 05

    The wallet returns an approval bound to the transaction

  6. 06

    Authbound verifies the approval

  7. 07

    Your backend receives the authorisation result

  8. 08

    You settle the payment

How it works

Three steps with Authbound

  1. Step 01

    Show the transaction

    The payer sees amount and payee in their wallet, not a generic approve prompt.

  2. Step 02

    Bind the approval

    The signature covers amount and payee, so an intercepted approval cannot be replayed against a different payment.

  3. Step 03

    Settle with an audit record

    Your flow receives an authorization tied to a verified identity, with the record attached.

Technical flow

  1. Your application
  2. Authbound API
  3. Wallet request
  4. Bound approval
  5. Trust and binding checks
  6. Your backend
Technical details
const verification = await authbound.verifications.create({
  policyId: 'pol_…',      // the claims this flow requests
  customerUserRef: user.id,
});

// Your webhook then receives verification.completed
// with the verified result and its audit record.
  • Request: an OpenID4VP presentation request built from your policy.
  • Hand-off: QR code on desktop, deep link on mobile.
  • Checks: issuer against the EU trust lists, status list revocation, device binding.
  • Result: structured claims plus an audit record, delivered by webhook.
Who does what

What Authbound handles, what you handle

Authbound handles

  • The wallet request, with QR on desktop and a deep link on mobile
  • Verifying the presentation the wallet returns
  • Checking the issuer against the EU trust lists
  • Revocation and device binding checks
  • A structured result delivered to your backend
  • An audit record of every verification

Your application handles

  • Choosing which attributes the flow requests
  • Your business logic and account creation
  • Settlement
  • Risk and fraud decisions
  • How long you keep the result
  • A path for users without a wallet
What's involved

Credentials, standards and rules

Wallet presents

  • PID

Regulatory context

PSD2 strong customer authentication and dynamic linking, eIDAS 2.0

PSD2 requires strong customer authentication and dynamic linking of the approval to amount and payee. eIDAS 2.0 lets the wallet serve as an SCA method, but wallet payments are still being specified, with EU roll-out expected around 2027 to 2028. Scheme rules, fraud liability and dispute handling remain with the payment provider.

PulsePay demo
Live demo

See the complete flow in PulsePay

Wallet-native payment authorization with identity-bound dynamic linking.

What it asks the wallet for

  • payment_consent
  • amount:249EUR
  • payee: Aurora Events Oy

What the business gets back

Status
Authorized
Receipt
PP-2026-1884
Identity binding
Complete
Open the PulsePay demo

PulsePay is a fictional company built by Authbound. The wallet integration in it uses the real Authbound SDK.

Questions

What buyers ask

What is dynamic linking under PSD2?

The authentication code has to be specific to the amount and the payee, and any change to either must invalidate it. A signature over the transaction details does this directly, which is awkward to achieve with a generic one-time code.

Does this replace 3-D Secure?

Not on day one. It is an authentication method that runs inside your SCA flow. How far it displaces existing challenges depends on scheme support and issuer adoption.

Does the merchant see the payer identity?

Only what the flow needs. The authorization can confirm a valid identity-bound approval happened without disclosing the payer’s full attributes.

Is wallet payment authorisation live today?

Not at scale. The EU expects wallet payments around 2027 to 2028, and Authbound’s payments product is on the roadmap. The demo shows the target flow.

Can we keep our current SCA methods?

Yes. The wallet runs as an extra authentication method inside your SCA flow, and existing methods stay as the fallback.

What does our backend receive?

An approval bound to the amount and payee, the payer’s identity binding, and a verification ID for your audit trail.

What if the payer has no wallet?

They authenticate with your current method. Nothing in the payment flow depends on the wallet being there.

Does it work across member states?

That is the aim. Wallets use the same protocols everywhere, so a cross-border payer would not need a separate method.

Who carries fraud liability?

Liability rules under PSD2 and your scheme do not change. A stronger, identity-bound approval helps with disputes but does not move liability on its own.

What do we build ourselves?

The payment request, the step that triggers authorisation, and settlement. Authbound would handle the wallet interaction and verify the approval.

Next step

Have a different wallet use case in mind?

Tell us what you are trying to build. We will map the user journey, the credentials and the wallet interaction to an implementation.