Refund fraud and the platform side of Radar
Radar fights fraud at payment time; refund-path losses come from configuration and process. Two loss categories, two owners, two different fixes.
Refund fraud and the platform side of Radar
Two losses look identical on a budget line: the bad actor who slipped through at payment time, and the correct actors whose money moved wrongly because of refund flags and process gaps. This article separates the categories, states exactly what Radar evaluates, and assigns each loss an owner.
Two loss categories, one budget line
The monthly report shows one number: money lost. That number merges at least two populations with nothing in common except the sign of their effect.
The first population is fraud loss. Someone pays with a stolen card, you ship the goods or deliver the service, the real cardholder disputes the charge, and the dispute is decided against you. Every dollar in this category traces back to a decision you made when you accepted the payment. The buyer of record was never a legitimate counterparty.
The second population is configuration loss. Every human in the story behaves correctly: a real buyer purchases, a real seller fulfills, the buyer asks for a refund, support grants it. But your integration returns the wrong set of dollars. On a destination charge, the platform balance eats the entire refund because nobody passed reverse_transfer=true. The application fee stays collected because nobody passed refund_application_fee=true. A dispute claws back funds from the platform and no recovery flow ever reverses the seller's transfer. No bad actor exists anywhere in this story. The defect is in defaults, flags, and unowned processes.
Both categories surface as "we lost money," so teams buy more fraud tooling to fix both. That purchase cannot work, because the root causes are disjoint. The table below contrasts the two categories so you can route each loss to the system that actually governs it.
| Property | Fraud losses | Configuration losses |
|---|---|---|
| Actor | Bad actor at payment time | Correct actors at every step |
| Decision point | Charge authorization | Refund issuance, transfer reversal, fee handling |
| Governing tooling | Radar rules, reviews, block lists | Flag policy, refund paths, expectation audits |
| Typical fix | Tighter rules, allow and block lists, 3DS challenges | Explicit refund_application_fee and reverse_transfer choices, reconciliation |
| Natural owner | Risk team | Payments engineering and finance ops |
Route a loss to the wrong owner and it repeats forever. A risk team told to reduce "refund losses" tightens rules against buyers who did nothing wrong. An engineering team handed a fraud problem builds refund plumbing that a stolen card sails straight through. Separation first, spending second.
What Radar actually evaluates
Stripe describes Radar as a way to evaluate transactions, accounts, and customers in real time, using AI algorithms to assess the risk of fraud (Radar overview). Its documented surface is entirely about the moment money tries to enter your platform:
- Each payment receives a risk score used to evaluate risk level in real time.
- Custom rules instruct Radar to allow, block, review, or request 3DS authentication for matching payments.
- Suspicious payments land in a manual-review queue for a human decision.
- Transaction fraud alerts notify you when Stripe detects unusual fraud patterns.
- Lists of trusted or blocked customers drive automatic allow and block decisions.
On a Connect platform, the evaluation configuration depends on the shape of the charge (Radar with Connect). Direct charges are evaluated solely under the collecting connected account's Radar configuration and rules. Transferred charges — destination charges and separate charges and transfers — are evaluated solely under the platform account's configuration and rules. If your platform pays the fees for connected accounts, you can choose whether those accounts run Radar Lite instead of their own Radar tiers.
Two boundary statements from the same page matter more than anything else in this section. First, when you use Radar with connected accounts, it checks only external charges; it does not check fund transfers between Stripe accounts. Second, Stripe charges Radar account fees to the platform always, with transaction fees based on the rate of the account that collected the payment.
Read those together and Radar's domain is precise: it decides whether a charge completes. Everything that happens to already-collected money sits outside it. For more on where Radar ends, see the site's Radar notes.
What Radar never evaluates
After a charge succeeds and is later refunded or disputed, three mechanical questions arise:
- Did the transfer to the seller get reversed?
- Was the application fee returned?
- Was a dispute loss recovered from the party that still holds the funds?
None of these objects carries a fraud score. A Refund object records an amount, a status, and a charge linkage. A Transfer object records movement between balances; a Reversal records pulling some of it back. An ApplicationFee records amount and amount_refunded. A Dispute records evidence state and outcome. Radar attaches its evaluation to payments, accounts, and customer signals — not to any post-payment money movement.
This is not a gap in your Radar tier. The Connect Radar page states the boundary mechanically: Radar checks only external charges and does not check fund transfers between Stripe accounts. No rule you can write changes what happens after a refund on a destination charge, where the default is that the destination account keeps the transferred funds and the platform covers the refund unless you pass reverse_transfer=true, and the application fee is kept unless you pass refund_application_fee=true (destination charge refunds).
So the honest sentence is: Radar never sees refund-time money movement, therefore no amount of fraud-tooling spend moves the configuration-loss number at all.
Refund abuse is a process problem
Some refund-path losses do involve deception, but the deception targets people and process, not scoring models. Three shapes recur:
- Social-engineered over-refunds. An attacker convinces a support agent to refund more than the entitlement: a full refund on a partially delivered order, a second refund on an order already refunded, a refund plus a reshipment.
- Duplicate refunds across channels. The Dashboard supports individual and bulk refunds; your API issues refunds; Connect lets platforms enable connected accounts to issue refunds to customers from their own sites through embedded components such as the payments or payment details component (refunds). Multiple doors, one pot of money.
- Refund-as-dispute-preemption. A buyer requests a refund through support while simultaneously filing a bank dispute, collecting twice if your systems do not notice each other.
Scoring does not fix any of these, because the payment itself was legitimate. Process controls do:
- Entitlement check. Before issuing anything, compute the maximum refundable amount from the object:
charge.amount - charge.amount_refunded, capped further by your written policy for partial delivery. Record who approved deviations. - Single refund path. Exactly one service should own calls to the Refunds API. Dashboard access scoped by role. Embedded components either off or behind the same entitlement logic.
- Dispute-state gate. No refund proceeds while an open dispute exists on the charge. The next section shows why this gate is not optional on bank debit methods.
One flag deserves special care. The Refunds API accepts reason with values duplicate, fraudulent, and requested_by_customer, and the documentation is explicit: if you believe the charge to be fraudulent, specifying fraudulent as the reason will add the associated card and email to your block lists (Refunds API create). Marking routine goodwill refunds as fraudulent poisons those lists and future payment decisions for real customers. Reserve the value for actual believed fraud, and treat who may set it as a permission, not a habit. When a review closes because a payment was refunded as fraud, the review.closed event fires with reason refunded_as_fraud — useful signal, worth routing to the risk team.
Write these controls down once, centrally. A refund policy design that assigns defaults per charge type beats per-agent judgment every time; the pattern is laid out in the platform refund policy design guide.
The double-credit hazard on bank debits
Card refunds and bank disputes are separate rails. A buyer can ask you for a refund and separately ask their bank for a dispute, and both requests can succeed. On bank debit methods, Stripe documents the collision directly:
For bank debit payment methods such as SEPA Direct Debit, Bacs Direct Debit, ACH Direct Debit, ACSS (Canadian PADs), AU BECS Direct Debit, and NZ bank account debits, there's a risk of double refund. If you proactively issue a refund while the customer's bank also initiates a dispute, the customer might receive two credits for the same transaction. Refer to the refund guidelines for each payment method to avoid this situation. (Refunds)
Walk the sequence. Buyer writes to support: please refund. Support obliges immediately. Days later the buyer's bank completes a dispute on the same transaction. The refund credits the buyer; the dispute also credits the buyer. You have paid twice, and no fraud model intervened at any step because every instrument used was real.
Stripe gives you two handles. First, a proactive refund can fail with failure_reason set to charge_for_pending_refund_disputed, meaning a customer disputed the charge while the refund was pending — and Stripe's guidance there is to accept or challenge the dispute instead of refunding, to avoid duplicate reimbursements. Handle refund.failed and branch on that reason rather than retrying blindly. Second, build the gate before the money moves: subscribe to charge.dispute.created and make "no open dispute on this charge" a precondition inside your single refund path. A refund attempt that arrives while a dispute is open should route to whoever owns disputes, not to the payment network.
This is a configuration-and-process fix in the exact sense of this article: the hazard lives in ordering and gating decisions your code makes, invisible to payment-time scoring.
One hundred dollars lost two ways
To see the separation cleanly, put the same headline number under two different causes and watch the controls diverge.
Assumptions, stated up front:
- US platform, USD, destination charges created with
transfer_data.destination. - Charge $100.00 = 10000 cents; application fee $10.00 = 1000 cents.
- Assume Stripe's standard US card pricing of 2.9% + $0.30, per Stripe's published pricing, giving a processing fee of $3.20 = 320 cents.
- Transfer to seller $90.00 = 9000 cents.
- Case A: the buyer is a thief using a stolen card; the charge succeeds; the cardholder disputes; the dispute is lost.
- Case B: the buyer is completely legitimate; a full refund is issued through a support channel with neither
reverse_transfernorrefund_application_feeset.
The table below shows which system should have caught each case, which control applies, and who owns the residual.
| Dimension | Case A: stolen card, dispute lost | Case B: refund with default flags |
|---|---|---|
| Event sequence | Bad charge authorized, fulfilled, disputed, lost | Legitimate purchase, refund requested, refund granted |
| Layer that should catch it | Payment-time evaluation (Radar) | Refund configuration and policy |
| Control that applies | Rules, review queues, block lists, 3DS | reverse_transfer=true, refund_application_fee=true, entitlement checks |
| Money effect | Disputed amount plus dispute fee debited from platform | Full refund debited from platform; transfer untouched; fee kept |
| Residual owner | Finance ops recovers from seller | Engineering fixes flags; ops audits outcomes |
Case A arithmetic, step by step:
- Sale: platform nets +$96.80 from the charge ($100.00 − $3.20 processing fee), pays the transfer −$90.00, margin $6.80. Seller holds +$90.00. Stripe keeps $3.20.
- Dispute lost: Stripe debits the disputed amount and the dispute fee from the platform balance for destination charges (disputes on Connect).
- Platform position before recovery: $6.80 − $100.00 = −$93.20, minus the dispute fee (its amount varies by country).
- Recovery is manual: reversing the transfer returns +$90.00, leaving the platform at −$3.20 minus the dispute fee, with the seller back to zero.
Case B arithmetic, step by step:
- Same sale numbers: platform margin $6.80, seller +$90.00, Stripe $3.20.
- Default full refund: Stripe debits the platform balance −$100.00. The transfer is not reversed; the fee is not returned.
- Platform position: $6.80 − $100.00 = −$93.20. Seller unchanged at +$90.00. Buyer whole.
- Check the ledger closes: −93.20 + 90.00 + 3.20 = 0.00. The missing dollars sit entirely in the unreversed transfer and unreturned fee.
- With both flags set, the reversal returns +$90.00 and the fee refund moves −$10.00 platform-side, leaving the platform at −$13.20 — exactly the non-returned processing fee, the irreducible cost of the refund.
Notice the uncomfortable symmetry: both cases leave the platform at −$93.20 on the same sale. Case A is Radar's job, and the residual is a recovery task. Case B is a flags-and-policy job, and the residual is an engineering task plus an audit trail. Tools for one are inert against the other. A detector that pairs findings with their underlying objects — such as the disputes-the-platform-paid-for detector — exists precisely because Case-B-style losses announce themselves nowhere.
Who owns which control
Once separated, ownership stops being political and becomes clerical. The matrix below assigns each recurring control to a team, with the handoff that moves work between them.
| Control area | Owner | Standing inputs | Hands off to |
|---|---|---|---|
| Radar rules, review queues, allow/block lists | Risk team | Fraud alerts, review outcomes, reason=fraudulent usage | Payments engineering when a block-list hit reveals a refund-path gap |
Refund flag policy (refund_application_fee, reverse_transfer), single refund path, dispute-state gate, webhook handlers | Payments engineering | Written refund policy, charge-type matrix, incident tickets | Finance ops when flag changes alter expected seller payouts |
| Expectation audits, recovery execution, seller communication | Finance ops | Audit findings, dispute outcomes, payout schedules | Risk team when recovered evidence indicates organized abuse |
Three handoffs deserve standing agendas. Risk-to-engineering: every confirmed fraud that ended in a refund teaches something about defaults, not just about the thief. Engineering-to-ops: whenever flag policy changes, the audit expectations change with it, or the next month's report manufactures false positives. Ops-to-risk: a recovery case that uncovers repeated social-engineering attempts belongs in the risk team's training data for reviews and lists, since fraudulent refunds feed those very block lists (Refunds API).
Recovery itself is owned work with a documented method — locating the transfer, computing the proportional reversal, executing it, recording it. The end-to-end procedure for the dispute variant lives in the dispute-loss clawback playbook.
FeeGuard monitors platforms built on Stripe Connect for exactly the configuration half of this article: unreversed transfers, missing application-fee refunds, and uncovered dispute losses, each reported with the Stripe evidence attached. Ownership still matters; tooling only shortens the loop.
Frequently asked questions
Does a higher Radar tier protect us from refund-related losses?
No. Radar evaluates transactions, accounts, and customers to assess fraud risk, and its rules act on charges — allowing, blocking, reviewing, or requesting authentication. On Connect, transferred charges are evaluated under the platform's Radar configuration and direct charges under the collecting account's, but in every case the evaluation happens at payment time. Whether a later refund reverses the transfer and returns the application fee is governed entirely by the parameters your code passes and the processes around them.
Should we set reason=fraudulent on every refund to be safe?
No. Setting fraudulent adds the associated card and email to your block lists, per the Refunds API documentation. Applied indiscriminately, it blocks real customers from future payments and corrupts the signal quality of your lists. Set it when you believe the charge was fraudulent; use requested_by_customer or duplicate otherwise.
Can Radar rules reverse a transfer or return an application fee?
No. The Connect Radar documentation states that Radar checks only external charges and does not check fund transfers between Stripe accounts. Rule actions operate on charge decisions. Reversals happen when your code calls for them — directly through the Transfers API or implicitly through reverse_transfer=true on a refund — and fee refunds happen through refund_application_fee=true or the Application Fees Refund API.
We lost a dispute on a direct charge. Why did the platform pay the dispute fee?
It depends on how fee responsibility is configured. For direct charges, the payer of the dispute fee follows the account configuration — under v1 controller.fees.payer or v2 defaults.responsibilities.fees_collector, a value of application means the platform pays the dispute fee, while account and stripe variants put it on the connected account. For destination charges and separate charges and transfers, with or without on_behalf_of, Stripe debits both the disputed amount and the dispute fee from the platform balance regardless.
Run the 90-day audit
FeeGuard exists because the arithmetic in this article runs silently on every refund your platform issues. The free audit reads your last 90 days of Connect activity through a restricted, read-only API key and reports every unreversed transfer, missing application-fee refund, and uncovered dispute loss with the amounts attached. You get the answer first; ongoing monitoring is optional afterward.
FeeGuard is an independent product and is not affiliated with, endorsed by, or sponsored by Stripe, Inc.