Payment Authorization Rate Optimization: Soft Declines, Smart Retries, Network Tokens and Account Updater Architecture (2026)

Payment Authorization Rate Optimization: Soft Declines, Smart Retries, Network Tokens and Account Updater Architecture (2026)

Payment Authorization Rate Optimization: Soft Declines, Smart Retries, Network Tokens and Account Updater Architecture (2026)

Most teams that try to raise their payment authorization rate start by retrying declines harder, and most of them end up paying network fees for the privilege. A decline is not a failure to be repeated; it is a typed message from the issuer telling you what would have to change for the next attempt to succeed. Read correctly, an issuer response code, a Mastercard Merchant Advice Code and a token status tell you whether to stop, refresh the credential, authenticate the cardholder, wait for funds, or route elsewhere.

This matters more in 2026 than it did three years ago. Visa and Mastercard both police reattempts with fee programs, both are pushing merchants toward network tokens, and European issuers return SCA soft declines whenever an exemption is misjudged. Blind retries now cost real money and damage issuer trust in your merchant ID.

This post treats payment authorization rate uplift as a systems design problem: a decline normalizer, a remediation router and a guarded retry scheduler, fed by token lifecycle events and account updater data.

What this covers: decline taxonomy, approval-funnel maths, network tokens and updater flows, SCA exemptions, a retry scheduler in Python, a data model, A/B measurement and the failure modes that create duplicate charges and retry fines.

Disclaimer: this is systems architecture analysis, not financial, legal or compliance advice. Confirm network rules with your acquirer.

Context and Background

An authorization is a real-time request, carried in ISO 8583 messages between acquirer, network and issuer, asking the issuer to approve a specific amount on a specific credential. The issuer answers with a response code in data element 39: 00 for approval, and a long tail of two-character codes for everything else. If the message formats themselves are unfamiliar, our explainer on ISO 8583 vs ISO 20022 card messaging walks through the fields that matter here.

The payment authorization rate is, on paper, simply approvals divided by attempts, but that definition hides most of the engineering. Do you count a retry as a new attempt? Do you count a transaction that was declined, re-authenticated with 3-D Secure and then approved as one success or one failure plus one success? Do you exclude fraud-screen rejections that never reached the issuer? Teams that do not pin these definitions down cannot tell whether a change helped.

Three industry shifts make the topic current. First, network tokenization has gone mainstream. Visa reported in June 2024 that it had issued its 10 billionth token, and that tokenization had lifted global payment approval rates by six basis points while reducing fraud by up to 60% (Visa press release). Mastercard committed the same month to 100% e-commerce tokenization in Europe by 2030 (Mastercard announcement).

Second, both schemes tightened retry governance. Visa runs an excessive reattempts rule that classifies decline codes into four categories and charges for reattempts that break the rules; Mastercard’s Transaction Processing Excellence program charges for excessive authorization attempts and defines Merchant Advice Codes (MACs) that tell you when, and whether, to retry. Third, PSD2 strong customer authentication (SCA) in the EEA and UK means a meaningful slice of declines are not about money at all. They are issuers asking for authentication.

Incumbent tooling covers parts of this. PSPs offer “smart retries”, orchestration platforms offer cascading, and account updater services are a checkbox at most acquirers. What is usually missing is the glue: one place that interprets every decline consistently and decides the next action under shared guardrails. That is the architecture this post builds.

The Payment Authorization Rate Remediation Architecture

A higher payment authorization rate comes from treating each decline as a classified signal and routing it to exactly one remediation: stop, refresh the credential, step up authentication, wait and retry within network limits, or cascade to another acquirer. Pre-authorization enrichment with network tokens and account updater data prevents many declines before they happen.

Payment authorization rate remediation architecture with credential resolver, exemption engine, decline normalizer and retry scheduler

Figure 1: Reference architecture for payment authorization rate optimization. Declines flow through a normalizer and a remediation router that feed back into the credential, authentication or routing stage.

The diagram reads left to right. A checkout or billing job asks the credential resolver for the best credential to present: a network token with a fresh cryptogram if one exists, otherwise a PAN refreshed by the account updater. The exemption and 3DS engine decides whether to request an SCA exemption, run frictionless 3DS or flag the transaction as merchant-initiated. The routing layer chooses an acquirer. Responses, approvals and declines alike, come back to a normalizer that maps acquirer-specific codes into one internal taxonomy, and the remediation router picks the next step. Every loop back into the system passes through the same retry scheduler and its guardrails.

Separate prevention from recovery

There are two levers, and they have very different economics. Prevention improves the first attempt: presenting a token instead of a stale PAN, sending complete stored-credential indicators, choosing the right exemption, routing domestically where possible. Recovery acts after a decline: re-authentication, scheduled retries, cascading.

Prevention is almost always the cheaper way to raise the payment authorization rate. A first-attempt approval costs one authorization fee and no customer friction. A recovered decline costs at least two authorizations, often a delay, sometimes a 3DS challenge, and counts against network reattempt limits. A team that spends its first quarter on retry logic before fixing credential freshness is optimizing the expensive end of the funnel.

The architecture enforces this split structurally. The credential resolver and exemption engine sit in front of the first authorization, so every improvement there lifts the payment authorization rate without consuming retry budget. The remediation router only sees what prevention could not fix.

Normalize before you decide

Every acquirer and PSP reshapes issuer responses. One returns the raw ISO code, another a proprietary string such as insufficient_funds, a third collapses several codes into generic_decline. If your retry logic branches on PSP-specific strings, adding a second acquirer doubles your decision table and guarantees drift.

The normalizer’s job is to recover, wherever possible, the raw network response code, the MAC (Mastercard), the scheme, the stored-credential type and whether the transaction was customer-initiated (CIT) or merchant-initiated (MIT). It then emits an internal decline class. Raw values must be stored as well, because the class mapping will change as you learn, and you will want to re-derive history.

A useful test: given a decline record, can a human tell from your data alone whether a retry is permitted under Visa’s category rules and Mastercard’s MAC guidance? If not, the normalizer is losing information the router needs.

One router, one action per decline

The router enforces a simple invariant: each decline produces exactly one next action, chosen from a closed set. That closed set is short: hard stop, credential refresh, authentication step-up, scheduled retry, cascade, or customer outreach. Mixing actions, for example cascading to a second acquirer while also scheduling a retry on the first, is how merchants generate duplicate authorizations and blow through reattempt counters.

The router is also where business context enters. A subscription renewal can wait three days for funds; a food-delivery order cannot. A high-value B2B invoice may justify a manual outreach after the first soft decline, while a low-value consumer purchase should simply fail gracefully. Encoding this as policy per transaction type, rather than as global retry counts, is the main difference between a remediation architecture and a PSP’s default smart-retry toggle.

For the routing and cascading mechanics across PSPs in more depth, see our companion piece on payment orchestration architecture with smart routing, retries, cascading and failover. This post concentrates on the decline semantics that orchestration layers consume.

Decline Codes, Network Rules and the Payment Authorization Rate Funnel

Before building the router, you need a taxonomy that is faithful to network rules. The soft decline vs hard decline split everyone quotes is a start, but it is too coarse to drive automation. “Soft” includes insufficient funds, which may resolve in days, and SCA required, which resolves in seconds if the customer is present and never if they are not.

A working decline taxonomy

The table below groups the most common card decline codes by remediation, not by meaning. Code meanings follow common acquirer documentation of ISO 8583 and scheme-specific values; individual issuers use them inconsistently, so treat this as a starting map to tune against your own data.

Code(s) Typical meaning Visa category (reported) Internal class Default action
04, 07, 41, 43 Pick up card, lost, stolen 1 (never retry) HARD_FRAUD_OR_LOST Stop; block credential; ask customer for new card
14, 15 Invalid card number, no such issuer 1 HARD_INVALID Stop; updater lookup only if stored credential
R0, R1, R3 Stop payment or revocation of recurring authorization 1 HARD_REVOKED Stop; cancel mandate; never retry
12, 46, 57 Transaction not permitted, closed account 1 HARD_NOT_PERMITTED Stop; offer another method
51, 61 Insufficient funds, over limit 2 SOFT_FUNDS Scheduled retry; honor MAC timing
59 Suspected fraud 2 SOFT_RISK No immediate retry; consider 3DS on next CIT
54 Expired card 3 DATA_EXPIRED Updater or token refresh, then single retry
N7, 82 CVV2 or data mismatch 3 DATA_MISMATCH Re-collect data from customer
1A (Visa), 65 (Mastercard, EEA SCA context) Additional authentication required Generic SCA_REQUIRED 3DS step-up if CIT; else outreach
91, 96, timeouts Issuer or switch unavailable Generic TECHNICAL Cascade or short delayed retry
05 Do not honor 4 GENERIC Bounded retries; feature-driven

Two subtleties deserve emphasis. Code 65 means “exceeds frequency limit” under Visa but is used by Mastercard as an SCA soft decline in Europe, so the scheme must be part of the key. And code 05, do not honor, is the single largest bucket at many merchants precisely because it is uninformative; treating it as uniformly retryable is how retry storms start.

Card decline codes decision tree routing hard declines, SCA soft declines, data quality, funds and technical failures

Figure 2: Decline classification tree used by the remediation router. Order matters: revocation and Category 1 checks run before anything that could trigger another authorization.

The tree is evaluated top to bottom, and the ordering is deliberate. Hard stops come first because no downstream rule should ever be able to override them. SCA comes next because it is cheap to fix when the customer is present. Data quality issues come before funds because a refreshed credential may also resolve what looked like a funds problem on a closed, replaced card.

What the networks actually allow

Visa’s excessive reattempts rule assigns every decline code to one of four categories. Category 1 means the issuer will never approve the transaction, and any reattempt is chargeable. Categories 2 (temporary declines such as insufficient funds), 3 (data quality, such as expired card or CVV2 failure) and 4 (all other codes) allow a capped number of reattempts in a 30-day window on the same card and merchant.

The cap has changed, and this is a good illustration of why rules belong in configuration. Processor documentation long cited 15 reattempts in 30 days. TabaPay’s network documentation reports that, effective 25 May 2025, Visa raised the limit to 20 reattempts in 30 days and introduced separate counters for CIT and MIT authorization requests. Some acquirer pages still state 15, so confirm the current figure with your acquirer. Reported fee levels in US acquirer guidance are USD 0.10 per excessive domestic reattempt plus USD 0.05 for cross-border; treat these as reported, not authoritative.

Mastercard’s approach centres on MACs, returned alongside the response code. Per processor documentation of Mastercard’s program, MAC 01 means updated account information is available, 03 means do not try again (closed account or fraud), 21 means the cardholder cancelled the payment agreement, and codes 24 through 30 attach to insufficient-funds declines with suggested waits of 1 hour, 24 hours, 2 days, 4 days, 6 days, 8 days and 10 days respectively. Reattempting a card-not-present transaction after MAC 03 or 21 on the same card, merchant and amount within 30 days is chargeable. Separately, the excessive authorization attempts element applies, per TabaPay’s summary, to attempts after 35 issuer-declined attempts on the same account number in 30 days.

The practical consequence: your retry scheduler must maintain per-card, per-merchant-ID, per-scheme counters with a rolling 30-day window, split by CIT and MIT, and it must persist MACs as first-class data. A PSP’s opaque smart-retry feature may do this for you on that PSP, but the moment you cascade across acquirers you need your own ledger of attempts.

Approval funnel maths (illustrative)

To decide where to invest, model the funnel. The numbers below are illustrative, chosen to show the mechanics; they are not benchmarks and your mix will differ.

Assume 1,000,000 monthly card-on-file renewals. On the first attempt, 88% approve, so 120,000 decline. Suppose the decline mix is 30% funds (36,000), 15% expired or replaced card (18,000), 10% SCA required (12,000), 5% technical (6,000), 12% hard (14,400) and 28% generic do-not-honor (33,600).

Now apply remediation rates, again illustrative. Funds declines retried on a MAC-aware or payday-aware schedule recover 35%: 12,600. Expired cards refreshed through an updater recover 60%: 10,800. SCA declines on MITs cannot be challenged, but if half were CITs and half of those complete 3DS, you recover 25%: 3,000. Technical declines cascaded to another acquirer recover 70%: 4,200. Generic declines retried once or twice recover 10%: 3,360. Hard declines recover zero by design.

Total recovered: 33,960, lifting the effective payment authorization rate from 88.0% to about 91.4%. The instructive part is the counterfactual. If 40% of the expired-card population had been on network tokens that the issuer had already updated, roughly 7,200 of those 18,000 declines would never have occurred, and the first-attempt rate would rise without a single retry or fee exposure. That is the prevention-over-recovery argument in numbers.

Network tokens and the account updater

Network tokens replace the PAN with a scheme-issued token bound to a token requestor and domain, plus a per-transaction cryptogram. Visa Token Service (VTS) and Mastercard Digital Enablement Service (MDES) handle issuance and, crucially, lifecycle management: when an issuer reissues a card after expiry or loss, the token can stay valid while the underlying PAN mapping changes. That is why tokenization tends to lift the network tokenization approval rate most on stored credentials and subscription renewals. Our deep dive on network tokenization architecture covers token requestor integration and cryptogram handling.

Published figures vary widely and should be read carefully. Visa’s own global figure is a six basis point uplift across Visa-processed transactions as of April 2024, a population that includes plenty of transactions where tokens would make no difference. Mastercard’s network tokenization page cites Checkout.com FY2025 data showing a 10.3 percentage point higher approval rate for network tokens versus cards on first attempts, excluding financial declines. The gap between those numbers is mostly denominator definition, which is exactly why you must run your own measured comparison.

A card account updater is the complement for PANs that are not tokenized. Visa Account Updater (VAU) lets issuers submit account changes, such as new expiry dates, new numbers after upgrade or loss, and closures, and lets enrolled merchants query them through acquirers; Visa’s merchant materials describe responses including account number or expiry updates, closed-account advices and contact-cardholder advices. Real Time VAU folds the lookup into the authorization itself, returning updated data in the response. Mastercard Automatic Billing Updater (ABU) offers pull inquiries, a push subscription model and bulk files, and its developer documentation recommends regular proactive queries, daily to weekly, with pull inquiries as a fallback after a decline (Mastercard ABU documentation).

Architecturally, both feed the credential resolver, and both lift the payment authorization rate on the first attempt rather than through retries. Batch updater responses update stored credentials asynchronously; real-time responses and token lifecycle notifications arrive as events. The resolver must apply them idempotently, keep the previous credential for dispute and refund handling, and record provenance, so analytics can attribute recoveries to the updater versus the token.

SCA exemptions and the soft decline loop

In the EEA and UK, the PSD2 regulatory technical standards (Commission Delegated Regulation (EU) 2018/389) define the exemptions acquirers can request. Article 16 covers low-value remote payments up to EUR 30, subject to cumulative limits of EUR 100 or five consecutive transactions since the last SCA. Article 18 transaction risk analysis (TRA) is tied to fraud-rate thresholds in the annex: for remote card payments, an exemption threshold value of EUR 100 requires a reference fraud rate of 0.13%, EUR 250 requires 0.06%, and EUR 500 requires 0.01% (RTS text on legislation.gov.uk). Article 13 covers trusted beneficiaries and Article 14 recurring transactions of the same amount.

Exemptions are requests, not rights. The issuer can refuse and return a soft decline, Visa 1A or Mastercard 65 in this context. Merchant-initiated transactions sit outside SCA scope when the initial mandate was authenticated, which is why correct MIT flagging matters so much for renewals.

Network tokenization approval rate and SCA soft decline step-up sequence with 3DS authentication and resubmission

Figure 3: The SCA soft decline loop. A declined exemption request triggers 3DS, and the authenticated resubmission carries the CAVV and ECI from the 3DS result.

The sequence shows why customer presence is the gating variable. The loop takes seconds when the shopper is still on the checkout page and is impossible for a background renewal. For deeper coverage of frictionless versus challenge flows and liability shift, see our guide to 3-D Secure 2 and PSD2 SCA authentication flows.

Building the Retry Scheduler, Data Model and Measurement

This is the walk-through: tables, the scheduler, and how to measure whether any of it works.

Data model

The core entities are payment intents, authorization attempts, credentials and retry counters. An intent is the business obligation (an order, an invoice); an attempt is one authorization message. Keeping them separate is the foundation of duplicate-charge prevention.

CREATE TABLE payment_intent (
  intent_id        UUID PRIMARY KEY,
  merchant_id      TEXT NOT NULL,
  customer_id      TEXT NOT NULL,
  amount_minor     BIGINT NOT NULL,
  currency         CHAR(3) NOT NULL,
  initiation       TEXT NOT NULL CHECK (initiation IN ('CIT','MIT_RECURRING','MIT_UNSCHEDULED','MIT_INSTALLMENT')),
  status           TEXT NOT NULL,           -- pending, authorized, failed_final, cancelled
  policy_id        TEXT NOT NULL,           -- retry policy by transaction type
  created_at       TIMESTAMPTZ NOT NULL DEFAULT now()
);

CREATE TABLE auth_attempt (
  attempt_id       UUID PRIMARY KEY,
  intent_id        UUID NOT NULL REFERENCES payment_intent,
  attempt_no       INT NOT NULL,
  idempotency_key  TEXT NOT NULL UNIQUE,     -- intent_id + attempt_no
  credential_id    UUID NOT NULL,
  credential_kind  TEXT NOT NULL,            -- network_token, pan, wallet
  acquirer         TEXT NOT NULL,
  scheme           TEXT NOT NULL,
  exemption        TEXT,                     -- low_value, tra, mit, none
  eci              TEXT,
  network_txn_id   TEXT,                     -- from initial CIT, reused on MITs
  raw_response     TEXT,                     -- ISO 8583 DE39 or equivalent
  mac              TEXT,                     -- Mastercard merchant advice code
  decline_class    TEXT,
  latency_ms       INT,
  requested_at     TIMESTAMPTZ NOT NULL,
  responded_at     TIMESTAMPTZ,
  UNIQUE (intent_id, attempt_no)
);

CREATE TABLE reattempt_counter (
  scheme           TEXT NOT NULL,
  merchant_id      TEXT NOT NULL,
  card_fingerprint TEXT NOT NULL,            -- stable hash across PAN and token
  initiation_kind  TEXT NOT NULL,            -- CIT or MIT, counted separately
  window_start     DATE NOT NULL,
  declines         INT NOT NULL DEFAULT 0,
  hard_stop_until  TIMESTAMPTZ,
  PRIMARY KEY (scheme, merchant_id, card_fingerprint, initiation_kind, window_start)
);

The card_fingerprint matters. A network token and its underlying PAN are the same card from the issuer’s perspective for counting purposes, so the counter key must be a stable fingerprint, not the credential string. Store daily buckets and sum the trailing 30 days rather than resetting a single counter, which avoids off-by-a-day cliffs.

The network_txn_id from the initial customer-initiated authorization must be stored and sent on subsequent merchant-initiated transactions. Missing or wrong stored-credential indicators are a common silent cause of declines and of SCA soft declines on renewals that should have been out of scope.

The scheduler

Below is a compact, runnable sketch of the router and scheduler logic. It omits the I/O layer but encodes the rules discussed above. The limits are configuration because they change.

from dataclasses import dataclass
from datetime import datetime, timedelta
import random

HARD_VISA_CAT1 = {"04", "07", "12", "14", "15", "41", "43", "46", "57", "R0", "R1", "R3"}
MAC_WAIT = {"24": timedelta(hours=1), "25": timedelta(hours=24), "26": timedelta(days=2),
            "27": timedelta(days=4), "28": timedelta(days=6), "29": timedelta(days=8),
            "30": timedelta(days=10)}

@dataclass
class Policy:
    max_attempts: int          # per intent, business limit
    funds_backoff: list        # fallback waits when no MAC is present
    allow_cascade: bool
    customer_present: bool

@dataclass
class Decline:
    scheme: str                # "visa" or "mastercard"
    code: str
    mac: str | None
    initiation: str            # "CIT" or "MIT"
    attempt_no: int

NETWORK_CAP_30D = {"visa": 20, "mastercard": 35}   # verify with acquirer; config, not code

def classify(d: Decline) -> str:
    if d.code in HARD_VISA_CAT1 or d.mac in {"03", "21"}:
        return "HARD"
    if (d.scheme == "visa" and d.code == "1A") or (d.scheme == "mastercard" and d.code == "65"):
        return "SCA"
    if d.code in {"54"} or d.mac == "01":
        return "CREDENTIAL"
    if d.code in {"N7", "82"}:
        return "DATA"
    if d.code in {"51", "61"}:
        return "FUNDS"
    if d.code in {"91", "96", "TIMEOUT"}:
        return "TECHNICAL"
    return "GENERIC"

def next_action(d: Decline, p: Policy, declines_30d: int, now: datetime):
    cls = classify(d)
    if cls == "HARD":
        return ("STOP", None)
    if d.attempt_no >= p.max_attempts:
        return ("OUTREACH", None)
    if declines_30d >= NETWORK_CAP_30D.get(d.scheme, 15):
        return ("PARK", None)
    if cls == "SCA":
        return ("STEP_UP", now) if p.customer_present and d.initiation == "CIT" else ("OUTREACH", None)
    if cls == "CREDENTIAL":
        return ("REFRESH_CREDENTIAL", now)
    if cls == "DATA":
        return ("OUTREACH", None) if not p.customer_present else ("RECOLLECT", now)
    if cls == "TECHNICAL":
        return ("CASCADE", now) if p.allow_cascade else ("RETRY", now + jitter(timedelta(minutes=5)))
    if cls == "FUNDS":
        wait = MAC_WAIT.get(d.mac) or p.funds_backoff[min(d.attempt_no - 1, len(p.funds_backoff) - 1)]
        return ("RETRY", now + jitter(wait))
    # GENERIC: one conservative retry, never immediate
    return ("RETRY", now + jitter(timedelta(hours=24))) if d.attempt_no < 2 else ("OUTREACH", None)

def jitter(base: timedelta, spread: float = 0.2) -> timedelta:
    return base * (1 + random.uniform(-spread, spread))

Three design choices are worth calling out. The hard-stop check runs before the attempt-count check, so no configuration change can make the system retry a revoked mandate. The network cap is looked up per scheme from configuration rather than hard-coded. And every delay is jittered, because thousands of renewals that failed at 02:00 should not all retry at exactly 02:00 the next day. Our post on retries, exponential backoff, jitter and retry budgets explains the queueing behaviour behind that last point.

For funds declines without a MAC, many teams use calendar features: retrying near common pay dates or at the start of a month. That can work, but it is a hypothesis to test, not a rule. Subscription dunning schedules, customer emails and grace periods are a separate discipline covered in our payment retries and dunning architecture post; this scheduler is the authorization-layer component such a system calls.

Guardrails around every attempt

Card account updater and retry scheduler guardrails with idempotency check, network counters, retry budget and issuer circuit breaker

Figure 4: Guardrails evaluated before every authorization the scheduler submits. Each check can only defer or drop an attempt, never create one.

Before a scheduled attempt is submitted, four checks run in order. The idempotency check confirms the intent is not already authorized through another path, such as a customer manually updating their card and paying. The network counter check enforces the per-card 30-day limits. A global retry budget caps retries as a fraction of first attempts, protecting acquirer relationships during incidents. A per-BIN-range circuit breaker stops hammering an issuer that is returning 91 or timing out en masse.

Idempotency deserves a separate note. Each attempt carries a key derived from intent and attempt number, and the acquirer call must use it so that a network timeout followed by a resend does not create two authorizations. The full pattern is in our guide to payment API idempotency keys and double-charge prevention.

Cascading across acquirers

Cascading means resubmitting a declined or failed authorization through a different acquirer. It is valuable for technical failures and, sometimes, for issuer-side risk declines where a domestic acquirer gets a different answer than a cross-border one. It is harmful when used on hard declines, which simply moves the fee to a second acquirer and still counts against the same card’s reattempt history at the network.

Rules of thumb that hold up: cascade on 91, 96 and timeouts; consider cascading on generic 05 only where you have measured that the alternate acquirer has a different outcome for that BIN range; never cascade on Category 1 codes or MAC 03 or 21. Routing cost also matters. A cascade to a cross-border acquirer may approve at a higher interchange and scheme-fee cost, which is analysed in our post on interchange fees and least-cost routing.

Issuer latency and timeouts

Authorization latency is part of the approval story. Slow issuers produce timeouts, and the scheme may then route to stand-in processing, where the network approves or declines on the issuer’s behalf according to issuer-set parameters. A merchant-side timeout that is shorter than the network’s can turn a would-be approval into a perceived failure, followed by a resend that creates a duplicate authorization.

The fix is to measure latency distributions per acquirer and BIN range, set client timeouts above the network’s expected response time, and always reverse an authorization that arrives late for an intent you have already abandoned. Store latency_ms on every attempt so you can detect issuer degradation before your approval chart shows it.

Measuring payment authorization rate uplift properly

Most payment authorization rate dashboards are wrong in the same way: they divide approvals by attempts, so a system that retries more looks worse, and one that suppresses retries looks better, even if it collects less money. Define three metrics and report them together.

The first-attempt approval rate is approvals on attempt one divided by intents. The intent-level approval rate is intents eventually authorized divided by intents, within a fixed horizon such as seven days. The attempts-per-approval ratio is total authorizations divided by approved intents. Prevention work should move the first metric; recovery work should move the second; and the third tells you what that recovery costs in fees and issuer goodwill.

To attribute uplift, use randomized holdouts at the intent level. For example, route 5% of eligible intents through the old logic, keyed by a hash of customer ID so a customer stays in one arm across retries. For tokenization, compare token-eligible cards in both arms, not tokenized versus non-tokenized cards in the wild, because issuers and card types that support tokens differ systematically from those that do not.

Sample sizes matter more than teams expect. Detecting a 0.5 percentage point difference around a 90% baseline with conventional significance and power needs on the order of tens of thousands of intents per arm (illustrative; compute for your baseline). Run tests for at least a full billing cycle so pay-date effects are balanced, and segment results by scheme, issuer country and initiation type before declaring a winner.

Trade-offs, Gotchas, and What Goes Wrong

Retry storms. A deploy that misclassifies 05 as funds-related, or a batch job restarted after a crash, can resubmit hundreds of thousands of authorizations in minutes. Issuers notice. Some respond with blanket risk declines for your merchant ID, which depresses the payment authorization rate for good traffic too. The global retry budget and per-BIN circuit breaker exist for this case, and the batch runner must be idempotent at the intent level.

Excessive retry fees. Fees accrue silently on processing statements, and engineering teams chasing a payment authorization rate target rarely see them. Pipe acquirer fee line items, such as excessive reattempt charges, into the same warehouse as your attempts table so a rising fee line triggers an alert alongside the approval metrics.

Duplicate charges. The classic sequence is a timeout, a resend, and two approvals. Customers see two pending holds even if only one captures. The defenses are idempotency keys at the acquirer, reversal of orphaned authorizations, and the rule that the intent, not the attempt, owns the “authorized” state.

Token gaps. Not every issuer or BIN supports tokenization, token provisioning can fail, and cryptograms expire. A credential resolver that falls back to the PAN without recording why will make the token rollout look more successful than it is. Track provisioning failure reasons and the share of attempts that actually carried a cryptogram.

Updater lag and false updates. Batch updater data can arrive days after a card reissue, and occasionally an update points to a card the customer has also closed. Treat updater results as hints that improve the next attempt, not as ground truth that overrides a fresh card the customer entered.

Exemption over-reach. Requesting TRA exemptions aggressively improves the frictionless rate until issuers start returning soft declines, at which point every exempted transaction costs an extra round trip. Monitor soft decline rate by exemption type and issuer, and back off per issuer before the payment authorization rate absorbs the extra round trips.

Mislabelled MITs. Flagging a customer-present purchase as merchant-initiated to avoid SCA breaks scheme rules and invites issuer declines. The reverse error, sending renewals as CITs without the original network transaction ID, triggers avoidable 1A and 65 responses.

Over-fitting to one PSP’s codes. If your taxonomy keys on PSP strings, a PSP’s silent remapping can reclassify a hard decline as soft overnight. Keep raw network codes and alert on sudden shifts in class distribution.

Practical Recommendations

Start with measurement, not retries, because a payment authorization rate you cannot decompose is a number you cannot improve. Instrument the attempts table with raw response codes, MACs, scheme, initiation type and credential kind, and publish the three metrics side by side. Until you can see first-attempt rate and intent-level rate separately, you cannot tell whether a change prevented a decline or merely recovered one at extra cost.

Then fix the first attempt. Correct stored-credential indicators and network transaction IDs on every MIT, enable network tokens for stored credentials, and wire account updater results into the credential resolver. These changes raise the payment authorization rate without spending reattempt budget.

Only then build the remediation router, with hard stops evaluated first, network limits held in configuration, and a single action per decline. Add cascading for technical failures, MAC-aware scheduling for funds declines, and 3DS step-up for SCA soft declines where the customer is present. Finally, protect the system with idempotency, global retry budgets and circuit breakers, and validate every change with intent-level holdouts.

A short checklist:

  • Store raw ISO response code, MAC, scheme and CIT or MIT on every attempt.
  • Report first-attempt rate, intent-level rate and attempts per approval together.
  • Send the original network transaction ID and correct indicators on every MIT.
  • Prefer network tokens for stored credentials; log every fallback to PAN with a reason.
  • Feed VAU and ABU results into one credential resolver with provenance.
  • Never retry Visa Category 1 codes or Mastercard MAC 03 and 21.
  • Keep per-card, per-scheme 30-day counters split by CIT and MIT, with caps as config.
  • Jitter every scheduled retry and cap retries with a global budget.
  • Cascade on technical failures only, unless data proves otherwise per BIN range.
  • Attribute uplift with randomized, customer-sticky holdouts over a full billing cycle.

Frequently Asked Questions

What is a good payment authorization rate?

There is no universal benchmark, because the rate depends on how you count retries, your card mix, region, card-present versus card-not-present share, and whether fraud-screen rejections are excluded. A domestic debit-heavy merchant and a cross-border digital-goods merchant can both be well run at very different rates. Compare against your own baseline segmented by scheme, issuer country and initiation type, and track first-attempt and intent-level rates separately. Benchmarks published by vendors usually use their own definitions, so treat them as context rather than as targets.

What is the difference between a soft decline vs hard decline?

A hard decline means the issuer will not approve the transaction no matter how often you retry: lost or stolen cards, invalid numbers, closed accounts and revoked recurring mandates. Visa’s Category 1 codes and Mastercard MACs 03 and 21 fall here, and retrying them can incur network fees. A soft decline means a later or modified attempt might succeed: insufficient funds, temporary issuer outages, or an SCA request. The useful refinement is to split soft declines by what fixes them, since time, authentication and a fresh credential are very different remediations.

Do network tokens really improve approval rates?

Generally yes, mainly for stored credentials, because token lifecycle management keeps credentials current after card reissue, and cryptograms give issuers stronger signals. The size of the effect is disputed and depends on definitions. Visa reported a six basis point global uplift across its processed transactions as of April 2024, while Mastercard cites Checkout.com data showing a 10.3 percentage point difference on first attempts excluding financial declines. Measure your own effect with a holdout on token-eligible cards rather than relying on either figure.

How does a card account updater work?

Issuers report account changes such as new card numbers, new expiry dates and closures to the scheme’s updater service, Visa Account Updater or Mastercard Automatic Billing Updater. Merchants enrolled through their acquirer query that data in batch files, through pull inquiries, through push subscriptions, or, with Visa’s Real Time VAU, inside the authorization response itself. The merchant then updates stored credentials before the next charge. It complements network tokens by covering PANs that are not tokenized or cards whose issuers do not support tokenization.

How many times can I retry a declined card payment?

Never for hard declines such as Visa Category 1 codes or Mastercard MAC 03 and 21. For other declines, Visa caps reattempts per card and merchant over a rolling 30-day window; processor documentation reports the limit rose from 15 to 20 from 25 May 2025, with separate CIT and MIT counters. Mastercard’s excessive attempts rule is reported to apply after 35 declined attempts in 30 days, and its MACs 24 to 30 specify wait times for funds declines. Confirm current limits with your acquirer and keep them in configuration.

Why does an issuer return code 1A or 65?

In the EEA and UK, these are soft declines asking for strong customer authentication. Visa uses 1A and Mastercard uses 65 in this context, though 65 means something different under Visa rules. They typically appear when an SCA exemption request is refused or when a transaction that should have been authenticated was not. The fix is to run 3-D Secure and resubmit with the authentication result if the customer is present. For merchant-initiated renewals, check that the initial mandate was authenticated and the network transaction ID is being sent.

Further Reading

By Riju — about

Comments

No comments yet. Why don’t you start the discussion?

Leave a Reply

Your email address will not be published. Required fields are marked *