3D Secure Authentication: Improve Payment Journeys in South Africa

Content authorBy EGSPublished onReading time13 min read
A cashier assists a customer with a mobile payment in a small retail store, capturing a warm, friendly interaction.

This article breaks down how 3D Secure authentication actually works inside a mobile card checkout and why a payment can fail after the customer has already proved who they are. It covers the failure patterns and the tests that expose problems before customers do.

Why checkouts break after the customer has done everything right

3D Secure authentication is the step most teams blame when a South African mobile checkout stalls, and that blame is half right. The protocol works. What breaks is everything around it: the hand-off to a banking app and the payment record left sitting in an undefined state while the customer taps "Pay" a second time.

Those failures show up in abandoned baskets and in support tickets from people who swear the money left their account. If you're an issuer or payment service provider (PSP) trying to work out why completion rates look worse than your 3D Secure authentication logs suggest they should, the problem is almost certainly in the seams between systems rather than in the protocol itself.

Authentication versus authorization

These are two separate transactions, carried on different message sets, decided by different parties. Authentication asks whether the person at the checkout is the legitimate cardholder, and the issuer's access control server answers it over the EMV 3DS protocol maintained by EMVCo. Authorization asks whether the account has funds and whether the issuer's fraud engine wants this payment, and it travels as a separate authorization request through the acquirer and the scheme network.

The merchant owns the authentication request. The issuer owns both answers. The acquirer owns the authorization path. When a customer completes a one-time password successfully and then sees a decline, nothing has malfunctioned in the strict sense, because the second decision was never bound to the first.

So a successful 3D Secure authentication guarantees one thing only: you hold a cryptographic result that shifts liability for fraud chargebacks. Payments get declined after authentication for insufficient funds and for a scheme-level block. Payments also sit in limbo because the authorization request was never sent, which is an engineering failure dressed up as a decline.

Here is what has to be true for the two halves to stay connected:

  • The authentication result, which includes the cardholder authentication verification value and the electronic commerce indicator (ECI), has to be stored against your payment record before the authorization is built.

  • The authorization request has to carry those values, because Visa Secure and Mastercard Identity Check both condition liability shift on them arriving intact.

  • Your payment state machine has to distinguish "authenticated, not yet authorized" from "authorized" and from "failed", with a defined timeout and recovery path for each.

3D Secure authentication components

Flowchart depicting the EMV 3DS transaction process with rounded cards, navy headers, and curved arrows on a pale-blue gradient background.

Four parties exchange messages in every EMV 3DS transaction, and each boundary between them is a place where a mobile journey can die. The 3D Secure 2 protocol replaced the browser-redirect model of the original specification with structured messages that carry roughly 150 data elements about the device and the cardholder. More data means more frictionless approvals. It also means more integration surface to get wrong.

Think of the flow as a loop. The merchant-side component builds and sends an authentication request, and the result comes back along the same path. The customer either sees nothing or gets pulled out of your checkout entirely, which is where mobile journeys become fragile.

Merchant-side 3DS component

The 3DS Server, operated by your PSP, assembles the EMV 3DS authentication request message (AReq) and sends it onward. Before that, a client-side piece does the data collection: the 3DS SDK inside a native app, or a hidden iframe in a browser that runs the method URL call to fingerprint the device. Adyen's 3D Secure 2 documentation describes this device data gathering as a prerequisite rather than an optional enrichment, and skipping it pushes transactions toward challenges you didn't need.

The same component interprets what comes back. The authentication response (ARes) carries a transaction status that tells you whether the issuer authenticated the cardholder outright or requires a challenge. Each of those outcomes needs a distinct branch in your code, and "U" for unavailable needs a documented business decision about whether you proceed with the authorization at your own liability.

Where most integrations go thin is persistence. If the result exists only in memory or only in the PSP's logs, you cannot answer a support query three days later, and you cannot prove liability shift when a chargeback lands. Write the DS transaction ID and the status to your own store, timestamped, before you do anything else with it.

Start building your financial platform?

Speak with EGS engineers about open banking, payment infrastructure, cloud systems, and enterprise software.

Get in Touch →

EMV 3DS directory server

The directory server belongs to the card scheme. It takes the card range from your request and works out which issuer's access control server is enrolled for that range. It also answers the preliminary request that tells you whether the card participates at all and which protocol version the issuer supports.

Version negotiation matters more than it sounds. EMVCo withdrew support for the original 3D Secure protocol in October 2022, and the schemes followed, so every live transaction now runs on some flavor of the 2.x specification. If your 3DS Server negotiates 2.1.0 where the issuer supports 2.2.0, you lose features like decoupled authentication and the ability to flag transactions exempt from a challenge.

The directory server is also a timeout source you don't control. PCI Security Standards Council requirements govern how these components are secured and assessed, but nothing in the standard promises you a response inside your checkout's patience window. Instrument the call. Measure the ninety-fifth percentile.

Issuer access control server

The access control server (ACS) is where the decision happens. It scores the transaction against the data in the request and the issuer's own risk rules, then chooses between frictionless approval and a challenge. A well-tuned ACS lets most legitimate traffic through untouched, because every challenge costs completion.

The response carries a status and, when 3D Secure authentication succeeds, the cryptographic value your authorization needs. It also carries the challenge parameters when the issuer wants one: the URL to load and the method. Nothing in the protocol obliges the ACS to be fast, and South African issuers running challenges over one-time passwords inherit the latency of the mobile network operator delivering the message.

For diagnosis, the useful question is "how long did it take, and what did the customer see while waiting". Those are different measurements and most teams only collect the first.

Customer authentication channel

Four channels dominate locally. The browser challenge renders inside an iframe or a full redirect. The one-time password arrives by SMS and gets typed back. Biometric authentication runs inside the issuer's banking app. And decoupled flows push an approval prompt to the app while the merchant waits on a polling loop.

The app channels are the ones that break mobile journeys, because they require the operating system to switch applications and then switch back. iOS and Android both treat your checkout as backgroundable at that moment. If the customer's phone kills the browser tab or the return URL is misconfigured, your 3D Secure authentication completed successfully somewhere in the issuer's infrastructure and your checkout never learned about it.

That asymmetry is the single most expensive defect in mobile card payments. The issuer thinks the customer authenticated. The customer thinks they paid. Your system has a half-finished record and no inbound message to resolve it.

Mobile authentication journeys

Follow one transaction end to end. The customer taps submit on a phone so your front end can collect device data and your PSP can send the authentication request. The directory server routes it to the ACS, and a result returns after something or nothing is shown to the customer. You build an authorization that the acquirer sends to the issuer, and you tell the customer what happened. Nine hand-offs, at least four of them across network boundaries you don't own.

The EMV 3DS flow splits into two shapes after the ACS decision, and your code needs both paths tested to the same depth. Most teams test the happy frictionless path thoroughly and the challenge path once, by hand, on a desk-mounted phone with good signal.

Frictionless flow

The issuer authenticates on data alone. The customer sees a spinner for a second or two and the authentication response comes back with a transaction status of "Y". This is the outcome 3D Secure 2 was designed to produce for the bulk of traffic.

What you must receive and retain from that response is specific. The transaction status and the ECI value that tells the acquirer what kind of authentication occurred. Stripe's 3D Secure guidance treats the 3D Secure 2 authentication result as an attribute of the payment object rather than a transient response, and that modeling choice is the right one to copy.

Then comes the part teams forget. A frictionless 3D Secure authentication followed by a declined authorization still needs a clear message to the customer, and "payment failed" after they watched a spinner tells them nothing about whether to retry. Map decline reasons to customer-facing language before launch.

Start building your financial platform?

Speak with EGS engineers about open banking, payment infrastructure, cloud systems, and enterprise software.

Get in Touch →

3D Secure 2 challenge

The ACS returns status "C". Your client loads the challenge, and in the local market that increasingly means switching to the issuer's banking app for a biometric approval rather than waiting on an SMS. The customer authenticates there. The app returns control to your checkout and your 3DS Server sends a results request.

Three things in that sequence are outside your control and all three need defensive handling:

  1. The app switch itself, which fails silently if the issuer app isn't installed or if deep linking is misconfigured.

  2. The return journey, where the customer lands back on a stale page or no page at all.

  3. The timing of the final result, which arrives after the customer has already decided your checkout is broken.

Build the return as a server-side resolution rather than a client-side one. The authoritative answer comes from the results request between your 3DS Server and the directory server. Design the checkout so that a customer who returns by any route lands on the real current state of their payment.

Where journeys fail

Abandonment is the baseline. Baymard Institute puts cart abandonment at 70.19% across 49 studies, and authentication friction sits at the most expensive point in that funnel, after the customer has already decided to buy. Every additional second and every app switch subtracts from completion.

The failures that cost more than abandonment are the ambiguous ones. A delayed response that arrives after your timeout leaves two systems disagreeing about the same transaction. An interrupted hand-off produces a 3D Secure authentication the customer completed and your checkout never recorded. A customer who retries creates a second authentication and a reconciliation exception that someone works through by hand.

These compound. 3D Secure 2 challenges that fail on the app switch generate support contacts at a rate out of proportion to their volume, because the customer has no way to tell whether they paid. The support agent can't tell either, unless your logs tie the authentication identifiers to the payment record and the authorization attempt. When they don't, the resolution path is a manual query to the acquirer, measured in days.

Symptoms worth auditing in your own data: payments stuck in an authenticating state past any reasonable timeout and duplicate authentication requests for the same order identifier within a short window. Each one points at a specific defect in how 3D Secure authentication results are persisted and resolved.

Standards and local requirements

Verify against the current specification rather than against your integration's documentation, which ages faster. EMVCo publishes the protocol and the core functions document, and the schemes layer their own mandates on top through Visa and Mastercard program rules. Those are the mandatory controls. Your acquirer will tell you which scheme program version you're certified against.

Locally, the South African Reserve Bank's National Payment System oversight applies, with the Payments Association of South Africa setting industry rules for participants and BankservAfrica operating the clearing infrastructure. The Protection of Personal Information Act governs the cardholder and device data that EMV 3DS messages carry, and the Information Regulator enforces it. Device fingerprinting for 3D Secure authentication is lawful processing, but it still needs a documented basis and a retention policy.

Separate from all of that sits engineering practice, which nobody mandates and which determines whether your checkout works. Idempotency keys on payment creation. Server-side state resolution. Distributed tracing across the authentication and authorization legs with something like OpenTelemetry so a single trace covers both. They appear in the difference between a 94% and an 85% completion rate.

Test the full journey

Certification testing proves your messages are well-formed. It proves nothing about what happens when a customer's phone rings during an app switch. The tests that matter simulate the conditions your production traffic actually meets, and most of them involve something going wrong at the worst moment.

Cover these cases, each with an explicit assertion about the payment's state afterward:

  • Customer abandons at the challenge screen and never returns. The payment resolves to a terminal state within a defined window and no authorization is sent.

  • The ACS responds after your timeout. The late result is reconciled against the existing record instead of creating a second one.

  • The same authentication result arrives twice. The second is ignored and logged.

  • The redirect back to the checkout is interrupted and the customer reopens your site from scratch. They see the current state of the payment.

  • The issuer app isn't installed or the deep link fails. The journey falls back to a browser challenge rather than hanging.

  • Authentication returns "U" or "R". The code follows the documented business rule rather than defaulting to a retry.

  • Authentication succeeds and authorization declines. The customer gets a message that distinguishes this from an authentication failure.

Every one of those tests needs the asserted payment state and the log entries a support agent would use to explain the outcome to a customer. If a test passes but produces no searchable log line tying the authentication identifiers to the order, it hasn't tested enough. Testing 3D Secure authentication properly means testing your observability at the same time.

Review 3D Secure authentication

A useful review starts with evidence rather than architecture. EGS examines your existing flow against your own failure data: the stuck payments and the support tickets grouped by what the customer actually described. That tells us where the breaks are before anyone opens a specification.

From there the review covers the integration boundaries we've mapped above and whether your logs and metrics let you diagnose a failure without contacting your acquirer. It also asks a question that isn't technical: who owns the payment state machine. Flows break at boundaries, and ownership gaps show up at exactly the same boundaries.

The output is a prioritized list of engineering changes tied to EGS's work in card processing and secure transaction engineering, with the expected effect of each on completion and support volume.

Measure engineering outcomes

Checkout completion and support contact volume are the two numbers worth tracking, and both are objectives rather than promises. Instrument them before you change anything, so you have a baseline to argue from. Fixing state resolution and app-switch handling improves completion because it removes failures the protocol never caused. Discuss your journey with EGS and identify the engineering changes needed to address payment friction in your 3D Secure authentication flow.

Start building your financial platform?

Speak with EGS engineers about open banking, payment infrastructure, cloud systems, and enterprise software.

Get in Touch →

The payment should move to a recoverable state and resolve through your server, even if the browser never receives the return. When the customer reopens checkout, show the stored payment status instead of starting a second attempt. A background reconciliation check should capture the late authentication or authorization result.

Use an idempotency key tied to the order and enforce one active payment attempt for that key. If a customer taps Pay again, return the existing payment state rather than creating a new authentication request. Log the repeated request so support staff can distinguish a retry from a separate purchase.

Yes, but retention must have a documented purpose, lawful basis, access controls, and a defined deletion period under the Protection of Personal Information Act. Store only the authentication data needed for payment processing, dispute handling, and audit. Review device data separately because it can contain personal information.

A U status means the issuer couldn't provide an authentication result, so it doesn't establish the same liability position as a successful result. Your 3d secure authentication flow should define whether to stop, continue at the merchant's risk, or offer another payment method. Record the decision and its reason.

Ask the provider to investigate when authentication succeeded but no authorization record appears after your defined timeout, or when your record conflicts with the acquirer’s result. Give the client the order ID, DS transaction ID, timestamps, and trace ID. EGS can review the evidence and identify whether the break occurred before authorization or during reconciliation.

Schedule a Meeting

Book a time that works best for you

You Might Also Like

Discover more insights and articles

A project manager in business casual attire discusses a document intake process with a team in a modern office, focusing on a large monitor.

Bank document intake workflow: A readiness checklist

This article gives you a checkpoint-by-checkpoint method for testing a document intake process before you turn it on. It includes a worksheet structure you can copy into a spreadsheet and the evidence each control needs to produce.

Two business partners collaborate on configuring a POS terminal in a modern office, surrounded by payment devices and colleagues.

EthioPay for Ethiopian Banks: Turn Readiness into a Delivery Plan

This article explains how an Ethiopian bank moves from "we want to participate" to a dated, costed integration plan for the country's domestic card scheme and instant payment rails. It covers service selection and a phased release sequence.

A modern smartphone displaying a mobile banking app lies on a wooden desk, surrounded by abstract payment cards and a notebook.

AfriGO Card Readiness: Plan Your Nigerian Bank’s Rollout

This article is a readiness guide for moving from "we're considering it" to a controlled pilot on Nigeria's domestic card rails. It covers role definition and launch scope, then maps the transaction flow so you can assess systems and assign requirement ownership through the workstream matrix that holds the whole program together.

A professional seated at a desk uses a smartphone and payment card, engaged in online banking in a bright, modern office.

G2P Payments in Africa: Build Reliable Social Payment Infrastructure

This article traces the full lifecycle of a government social payment in Africa, from eligibility approval through to reconciliation and investigation evidence. It assigns operational ownership at each system boundary and sets out how to control exceptions and assisted access.