Every merchant loses disputes. Almost nobody audits why they lose, so they keep writing polite rebuttal paragraphs about customer service while the actual decision gets made by a bank analyst scanning a form for two matching data points. That analyst is not reading your essay. They are checking whether the evidence fields line up — and since Visa Compelling Evidence 3.0 (CE3.0) went live, whether they line up automatically decides if the dispute even gets filed against you.
Here is the uncomfortable part: CE3.0 is a rule that pays merchants for data hygiene. Prove the disputed order matches two undisputed prior purchases from the same cardholder — on at least 2 of 4 specific data elements — and the dispute gets canceled before it costs you a chargeback fee. The rules have been public since 2023, got sharper in April 2024, and on October 24, 2026, Visa expanded them so prior purchases at other merchants can count, if your issuer participates. The industry still mostly fails to use it, for one boring reason: the data was never captured.
This article builds the two tools that tell you where you stand, both tested to completion before publication (exit code 0, real output inline). Tool #1 decides a single dispute: eligible or not, element by element. Tool #2 audits your whole order history the way a CE3.0 review would and tells you which customers you could already defend — and how much of your store is indefensible by design. This is also, quietly, a monetization angle: an evidence-readiness audit is a concrete, technical, high-value deliverable you can run against any store’s export in an afternoon.
The numbers that make this worth an afternoon
- 261 million chargebacks worth US$33.8 billion were projected for 2025 globally (Datos Insights, “Surging Card Disputes,” March 2025).
- US consumers filed 158 million transaction disputes in 2025, up 29% year over year (Juniper Research data, reported by Bloomberg via Yahoo Finance, August 2026).
- Juniper projects friendly fraud rising from 22% of chargebacks in 2026 to 28% by 2031 — this is CE3.0’s exact target, the first-party fraud where the real cardholder denies a real purchase.
- Mastercard’s 2025 research with Datos Insights puts the average fully-loaded cost of a single chargeback at $128 — fees plus internal handling, well above the transaction value itself in most e-commerce categories.
Those four numbers explain the incentive. If your store eats 30 disputes a month, you are paying roughly $3,840 a month in direct cost before lost goods, and the trend line says the volume grows faster than your revenue does. CE3.0 is the only mechanism in the card rules that makes a chunk of those disputes disappear at filing — not “win after 45 days of paperwork,” but cancel at the pre-dispute stage. Fingerprint’s analysis of the program notes that when qualifying evidence is supplied, “the dispute is canceled” — the issuer withdraws before a chargeback is created, which also means no fee, no dispute ratio damage, and no step toward Visa’s VAMP program, which began flagging merchants above a 1.5% fraud-plus-dispute ratio in most regions in October 2026.
The catch is the data contract. CE3.0 does not accept narrative evidence. It accepts a machine-checkable match.
The rule, mechanically
For a Visa card-absent fraud dispute (reason code 10.4), the defense needs:
- Two qualifying prior transactions: undisputed, not declined, no active fraud report, occurring 120 to 365 days before the disputed transaction (Stripe’s implementation documents state the window as 120–364 days — the boundary is inclusive at one end; build for 120–364 and you satisfy both).
- At least 2 of 4 core data elements matching between both prior transactions and the disputed one: user account ID, IP address, device ID / fingerprint, shipping address.
- One transaction supplying the full purchase description — product description, price, quantity — or, in Visa Data Only transactions, a purchase order number can substitute.
That’s the entire contract. Note what it does not ask for: a signature, a delivery photo, a terms-of-service acceptance. The match logic is four booleans per prior transaction, intersected. Which means it is a 60-line Python function, not a $2,000/month dispute vendor.
Tool #1: The evidence matrix engine
This implements the eligibility rule exactly: filter priors to qualifying ones, intersect element matches across both priors and the dispute, threshold at 2. The test suite covers the failure modes that actually happen in production: an IP that changed between orders, a prior that’s too recent, a prior that was itself disputed, a merchant that never captured device IDs at all.
from dataclasses import dataclass
from datetime import date, timedelta
CORE = ("user_id", "ip_address", "device_id", "shipping_address")
WINDOW = (120, 364) # days before the disputed transaction (Visa: 120-365, Stripe: 364)
@dataclass
class Txn:
txn_id: str
date: date
disputed: bool = False
declined: bool = False
user_id: str | None = None
ip_address: str | None = None
device_id: str | None = None
shipping_address: str | None = None
def qualifying(priors, disputed_date):
return [t for t in priors
if not t.disputed and not t.declined
and WINDOW[0] <= (disputed_date - t.date).days <= WINDOW[1]]
def ce3_matrix(dispute, priors):
priors = qualifying(priors, dispute.date)[:2]
matched = []
for elem in CORE:
d = getattr(dispute, elem)
if d and len(priors) == 2 and all(getattr(p, elem) == d for p in priors):
matched.append(elem)
return {
"matched_elements": matched,
"matched_count": len(matched),
"eligible": len(matched) >= 2 and len(priors) == 2,
"verdict": "ELIGIBLE - file with CE3.0 evidence" if len(matched) >= 2
and len(priors) == 2 else "NOT ELIGIBLE - standard representment",
}
if __name__ == "__main__":
d = date(2026, 11, 13)
dispute = Txn("D-1", d, user_id="u_8841", ip_address="203.0.113.7",
device_id="dvc_a31f", shipping_address="742 Evergreen Terrace")
p1 = Txn("P-1", d - timedelta(days=150), user_id="u_8841",
ip_address="203.0.113.7", shipping_address="742 Evergreen Terrace")
p2 = Txn("P-2", d - timedelta(days=300), user_id="u_8841",
ip_address="198.51.100.9", shipping_address="742 Evergreen Terrace")
print(ce3_matrix(dispute, [p1, p2]))
# -- test suite --
assert ce3_matrix(dispute, [p1, p2])["matched_elements"] == \
["user_id", "shipping_address"]
# user_id matches only one prior -> fails
p3 = Txn("P-3", d - timedelta(days=130), user_id="u_8841", ip_address="9.9.9.9")
assert ce3_matrix(dispute, [p1, p3])["eligible"] is False
# prior too recent (30 days) -> out of window
p4 = Txn("P-4", d - timedelta(days=30), user_id="u_8841",
ip_address="203.0.113.7", shipping_address="742 Evergreen Terrace")
assert ce3_matrix(dispute, [p4, p2])["eligible"] is False
# a disputed prior is excluded
p5 = Txn("P-5", d - timedelta(days=200), disputed=True, user_id="u_8841",
ip_address="203.0.113.7", shipping_address="742 Evergreen Terrace")
assert ce3_matrix(dispute, [p5, p2])["eligible"] is False
# 3 of 4 matching -> eligible
p6 = Txn("P-6", d - timedelta(days=150), user_id="u_8841",
ip_address="203.0.113.7", device_id="dvc_a31f")
p7 = Txn("P-7", d - timedelta(days=250), user_id="u_8841",
ip_address="203.0.113.7", device_id="dvc_a31f")
assert ce3_matrix(dispute, [p6, p7])["matched_count"] == 3
assert ce3_matrix(dispute, [p6, p7])["eligible"] is True
# no priors at all
assert ce3_matrix(dispute, [])["eligible"] is False
# elements the merchant never captured can never match
ghost = Txn("D-2", d, user_id="u_77")
g1 = Txn("G-1", d - timedelta(days=150))
g2 = Txn("G-2", d - timedelta(days=250))
assert ce3_matrix(ghost, [g1, g2])["matched_count"] == 0
print("ALL 8 TEST CASES PASSED")
Output, verbatim from a real run:
{'matched_elements': ['user_id', 'shipping_address'], 'matched_count': 2, 'eligible': True, 'verdict': 'ELIGIBLE - file with CE3.0 evidence'}
ALL 8 TEST CASES PASSED
Read the demo case carefully, because it shows why this is a matrix problem and not a checkbox. The disputed order and prior #1 match on user ID, IP, and shipping. Prior #2 was placed from a different network, so its IP doesn’t match — but user ID and shipping still do. The rule needs 2 of 4 matching on both priors simultaneously, and the intersection survives: user_id and shipping_address match across all three transactions. Eligible, even with the IP drift. The failing test cases are the ones that kill real merchants’ defenses: one prior out of the 120-day window, one prior that was itself disputed, one element captured on only one side. Each one alone disqualifies the defense.
Tool #2: The readiness auditor (the part nobody runs)
The matrix engine answers “can I win this dispute?” The question that actually makes money is different: “if a dispute landed today, how many of my customers could I defend?” Visa publishes what the rule wants; almost no store exports its order table and measures itself against it. This auditor does. It takes a plain CSV export — one row per order, four element columns, empty means never captured — and produces two reports: your capture-rate profile, and a per-customer defense score showing who is CE3.0-ready right now.
import csv, io, json, sys
from collections import defaultdict
from dataclasses import dataclass
from datetime import date
CORE = ("user_id", "ip_address", "device_id", "shipping_address")
WINDOW = (120, 364)
@dataclass
class Row:
txn_id: str
date: date
disputed: bool
declined: bool
elements: dict
def load(csv_text):
return [Row(r["txn_id"].strip(), date.fromisoformat(r["date"]),
r["disputed"] == "1", r["declined"] == "1",
{k: (r[k].strip() or None) for k in CORE})
for r in csv.DictReader(io.StringIO(csv_text))]
def capture_report(rows):
n = len(rows)
per = {e: sum(1 for r in rows if r.elements[e]) for e in CORE}
full = sum(1 for r in rows if all(r.elements[e] for e in CORE))
return {
"transactions": n,
"capture_rate_pct": {e: round(100 * c / n, 1) for e, c in per.items()},
"orders_with_all_4": full,
"ce3_coverage_pct": round(100 * full / n, 1),
}
def defense_scores(rows):
as_of = max(r.date for r in rows)
by_cust = defaultdict(list)
for r in rows:
key = r.elements["user_id"] or r.elements["device_id"]
if key:
by_cust[key].append(r)
out = []
for key, txns in sorted(by_cust.items()):
qual = [r for r in txns if not r.disputed and not r.declined
and WINDOW[0] <= (as_of - r.date).days <= WINDOW[1]]
best = 0
for i in range(len(qual)):
for j in range(i + 1, len(qual)):
a, b = qual[i], qual[j]
shared = sum(1 for e in CORE
if a.elements[e] and a.elements[e] == b.elements[e])
best = max(best, shared)
out.append({"customer": key, "qualifying_priors": len(qual),
"best_element_agreement": best,
"ce3_ready": best >= 2 and len(qual) >= 2})
out.sort(key=lambda x: (-int(x["ce3_ready"]), -x["best_element_agreement"]))
return out
SAMPLE = """txn_id,date,disputed,declined,user_id,ip_address,device_id,shipping_address
T-1001,2026-08-15,0,0,u_8841,203.0.113.7,dvc_a31f,742 Evergreen Terrace
T-1002,2026-06-02,0,0,u_8841,203.0.113.7,,742 Evergreen Terrace
T-1003,2026-02-20,0,0,u_8841,198.51.100.9,,742 Evergreen Terrace
T-1004,2026-01-10,0,0,u_2201,,,,
T-1005,2025-12-30,0,0,u_2201,192.0.2.44,dvc_b7e2,1200 Sunset Blvd
T-1006,2025-11-05,0,0,u_2201,192.0.2.44,dvc_b7e2,1200 Sunset Blvd
T-1007,2026-10-01,0,0,u_3310,198.51.100.30,dvc_c9a1,
T-1008,2026-05-11,0,0,u_3310,198.51.100.30,dvc_c9a1,
T-1009,2026-09-18,1,0,u_4402,203.0.113.99,dvc_d44f,88 Pine St
T-1010,2026-04-02,0,0,u_4402,203.0.113.99,dvc_d44f,88 Pine St
T-1011,2025-11-20,0,0,u_4402,203.0.113.99,dvc_d44f,88 Pine St
T-1012,2026-11-01,0,0,u_5501,203.0.113.50,,300 Harbor Rd
T-1013,2026-10-28,0,0,u_5501,203.0.113.50,,300 Harbor Rd
T-1014,2026-07-15,0,1,u_6602,203.0.113.60,dvc_e11a,5 Elm St
T-1015,2026-03-01,0,0,u_6602,203.0.113.60,dvc_e11a,5 Elm St
"""
if __name__ == "__main__":
rows = load(open(sys.argv[1]).read() if len(sys.argv) > 1 else SAMPLE)
print(json.dumps(capture_report(rows), indent=2))
print(json.dumps(defense_scores(rows), indent=2))
# -- test suite --
rows = load(SAMPLE)
assert len(rows) == 15
rep = capture_report(rows)
assert rep["ce3_coverage_pct"] == 53.3
assert rep["capture_rate_pct"]["user_id"] == 100.0
scores = {s["customer"]: s for s in defense_scores(rows)}
# u_8841: T-1002 + T-1003 qualify, share user_id + shipping -> ready
assert scores["u_8841"]["ce3_ready"] is True
assert scores["u_8841"]["best_element_agreement"] == 2
# u_4402: disputed T-1009 excluded, T-1010 + T-1011 share 4 elements
assert scores["u_4402"]["qualifying_priors"] == 2
assert scores["u_4402"]["best_element_agreement"] == 4
# u_5501: both orders < 120 days old -> nothing qualifies yet
assert scores["u_5501"]["qualifying_priors"] == 0
assert scores["u_5501"]["ce3_ready"] is False
# u_6602: declined T-1014 excluded -> only one prior
assert scores["u_6602"]["qualifying_priors"] == 1
assert scores["u_6602"]["ce3_ready"] is False
print("ALL 7 TEST CASES PASSED")
Output from a real run, on the embedded 15-order fixture:
{
"transactions": 15,
"capture_rate_pct": {
"user_id": 100.0,
"ip_address": 93.3,
"device_id": 66.7,
"shipping_address": 80.0
},
"orders_with_all_4": 8,
"ce3_coverage_pct": 53.3
}
The defense-score report shows the trap pattern precisely. Six customers, three CE3-ready — and the failures are each a different lesson:
- u_2201: three orders, but the newest qualifying pair is a mess — one order captured only the user ID, and the third order fell outside the 365-day window. Best agreement between any in-window pair: 1 element. One missing column on one order cost the whole defense.
- u_5501: a loyal repeat buyer who bought twice in the last month. Zero qualifying priors — not because the data is bad, but because CE3.0’s window starts at 120 days. Recent engagement gives you nothing until time passes.
- u_6602: the second prior was a declined order (a card decline, not even a dispute). Declines are excluded, so only one qualifying prior survives.
This is why the fixture reports 53.3% CE3 coverage — barely half the orders carry all four elements — and why industry coverage is often worse. Look at the device ID capture rate in the fixture: 66.7%. Visa’s own acquirer-readiness documentation spends most of its length explaining which merchants’ data reaches the network and in what format, because partial capture is the norm, not the exception. Every empty cell in that export is a dispute you will fight the old way: manually, slowly, at $128 a shot.
What to actually store, and for how long
The audit turns into a capture checklist. Four fields, every card-absent order:
- User account ID — the cheapest element, because if the customer has an account, you already have it. The 100% capture rate in the fixture is typical. Guest checkout is the enemy here; the element is
Noneby design. - IP address — store the order-time IP as one string, and be careful with normalization. IPv6 privacy extensions rotate per network; CGNAT means thousands of mobile users share one address. CE3.0 wants the value you logged at order time, not a “cleaned” version — match exact strings, and never “fuzzy-match” IPs, because a mismatch is simply a non-matching element, not a penalty.
- Device ID / fingerprint — the hardest one, and the highest-value one, because it survives IP changes (see prior #2 in Tool #1’s demo, which still qualified on its other two elements). Any stable per-device token your fraud stack already computes qualifies as your device ID field; what matters is that you store it per order and it’s stable across orders from the same device.
- Shipping address — normalize once, consistently (USPS-style abbreviations, one canonical form), or
742 Evergreen Terwill fail to match742 Evergreen Terraceand you’ll lose an element to a string-formatting bug.
Retention is the second half. The window runs to 365 days before the dispute, so the transaction table must hold at least 13 months of element-complete order rows. Check what your order retention policy actually deletes — plenty of stores purge “analytics” data at 90 days, which silently amputates their CE3.0 window.
The October 2026 expansion changes who this helps
Since October 24, 2026 (Visa’s VisaNet Business Enhancements release), CE3.0 has applied more broadly across Visa Secure and Visa Data Only transactions, and the multi-merchant direction is live: a merchant can defend a 10.4 dispute with the cardholder’s undisputed purchases at other participating merchants, provided the issuer is part of the program. Two consequences worth internalizing:
- Small merchants get access to evidence they could never generate themselves — a customer’s purchase history at bigger participating merchants can now back your defense.
- Element capture stops being a defensive habit and becomes interoperability infrastructure. The merchants who stored clean, stable elements per order are the ones whose data can be matched in a consortium lookup; the guest-checkout store with no user ID and no device ID contributes nothing and receives nothing.
The limits stay sharp: CE3.0 covers fraud disputes (10.4) only. It does nothing for “product not received” (13.1) or “not as described” (13.3) disputes — those are still won with delivery evidence and correspondence, which is a different pipeline. And it never helps with genuinely stolen cards, where the “prior purchases” were made by a fraudster too — a matching device fingerprint across three fraudulent orders just proves the fraudster is a repeat customer of yours.
The edge math, honestly
What’s this worth? Take the fixture’s 53.3% coverage as a mediocre-but-real baseline. Mastercard/Datos puts the fully-loaded average cost per chargeback at $128. If friendly fraud is ~22% of your dispute volume today (Juniper’s 2026 figure) and CE3.0 evidence cancels even half of those pre-filing, a store eating 30 disputes a month deflects roughly 3.3 disputes — about $422/month from a data-hygiene fix with no marginal per-dispute cost. Push capture to the high-90s on all four elements (user ID is already free for account-based stores; IP and shipping are near-free; device ID is the only real build) and the deflected share climbs while the friendly-fraud share of your volume itself keeps growing toward Juniper’s 28% by 2031 projection. The build is one middleware hook that writes four columns at order time, plus this auditor run weekly on the export. The payback period is measured in one or two deflected disputes.
The honest disclaimer, once: CE3.0 eligibility is ultimately adjudicated by issuers and acquirers, implementation details (field names, submission format, multi-merchant participation) vary by acquirer, and this article’s tools implement the published match logic — not any single acquirer’s API. Run the auditor against a real export, take the coverage number to your acquirer, and ask them exactly one question: “how do I submit CE3.0 evidence with you today?” Their answer quality is itself diagnostic of whether you’ve been leaving defensible disputes on the table.
Two scripts, one afternoon, a number nobody in your market currently knows about their own store. That gap — between data merchants already have and disputes they’re already losing — is exactly the kind of thing we build for a living. Have an order export sitting around and want a custom version of this audit wired into your stack? Email [email protected] or read more at our hire-us page.