Rule payment_fingerprint, read from the engine code

Affiliate fraud rings, found by shared buyers

Affiliate fraud rings are groups of affiliates who cycle the same buyers through each other's links. The engine counts how many of an affiliate's buyer emails also bought through another affiliate, and holds the sale at 2.

By the AffiliateTracking teamUpdated 5 min read

Fraud page on demo data: held commissions, each with the rule that held it and Release and Uphold buttons, above the verdicts that explain each hold.

The fraud queue in the product, running on demo data.

The short answer

The rule fires when 2 or more of the affiliate's buyer emails also appear on another affiliate's commissions. It compares lowercased emails across your whole install. It holds the commission being screened.

How the rule works

Read from internal/fraud/rules3.go. The code fixes the thresholds. No setting changes them.

  1. 01Buyer emails, compared everywhere

    The engine lists the affiliate's distinct buyer emails. For each, it checks whether any other affiliate earned a commission from the same email.

  2. 02Two shared buyers is the line

    One shared buyer happens in real programs. Two or more is the pattern of the same people buying round a ring.

  3. 03No time window

    The check reads every commission the affiliate has ever earned. A ring that bought slowly over months still adds up.

The exact logic

// internal/fraud/rules3.go, PaymentFingerprint (condensed)
for each distinct buyer_email on this affiliate's commissions:
    if another affiliate has a commission with the same buyer_email {
        shared++
    }
if shared >= 2 { hold(commission) }
// buyer_email is stored lowercased and trimmed

Condensed from the Go source in v0.5.0 (main 4f87f77). Comments are ours.

The signals

  • 2 or more buyer emails shared with other affiliates
  • Compared across every program in the install
  • All history, no window
Hold scope. It holds only the commission being screened. Nothing else in the affiliate's balance moves.

Our data

We ran the rule at its threshold

We ran 2 fixtures through the real engine on 3 Oct 2026: 1 below the line, 1 at or past it. These are the results and the engine's own words.

payment_fingerprint · 2 fixtures · fresh SQLite each
Each fixture run through the real engine, and whether shared buyers fired
FixtureResultThe engine's reason
1 buyer email also bought via another affiliateSilentNo verdict
2 buyer emails also bought via another affiliateFired2 buyers also bought through other partners, a sign of the same people cycling purchases
Each fixture also had one buyer unique to the affiliate. It never counts toward the threshold.
Shared buyers: where the rule fires Threshold chart: buyer emails shared with other affiliates. The engine stayed silent at 1 and fired at 2. The line sits at 2. Buyer emails shared with other affiliates Fires at 2 Green: 1, silent Red: 2, fires 05
Where shared buyers fires, from the fixtures above. Engine v0.5.0 (main 4f87f77), run 3 Oct 2026.

Method: one Go test against engine v0.5.0 (main 4f87f77), a new SQLite database per fixture, dry run so nothing was held. Re-run with go test ./internal/fraud/ plus the fixture list above.

What lands in your queue

When shared buyers fires, the verdict shows the rule, who it's about and what it saw. Release or uphold is your call, not the engine's.

Fraud queue · payment_fingerprint · demo dataMade-up numbers, real wording
Example held commission after shared buyers fired, on demo data, with the engine's reason text
PartnerWhat it sawCommissionResult
Affiliate 122 buyers also bought through other partners, a sign of the same people cycling purchases$204.10Commission held
heldWaits for youThe commission stays out of payouts until you decide.
releasedPaid normallyIt goes into the next payout.
upheldNot paidThe engine cancels it and takes the money back. Already paid? Use a refund.

In the wild

Affiliate networks pay for fake activity until someone checks.

Each item re-read against its linked source on . Items we couldn't verify were cut.

Limits, and how attackers try to beat it

  • Plus tags beat it. Unlike the self-referral check, this one compares emails exactly, so buyer+1@ and buyer+2@ count as two people.
  • It only sees emails your billing tool sends. A sale without a buyer email can't count.

A ring can rotate fresh buyer emails, but each new email costs a real inbox. Rings that hijack each other's customers with a shared code show up in coupon credit taken from bound customers. And a ring member buying through their own link meets the buyer-equals-affiliate email check.

Related rules

Thresholds checked against the code on . Windows roll with each sale.

Shared buyers questions

Will two affiliates with the same loyal customer trip it?

Only if they share 2 or more buyers. One shared customer stays silent. Two produce a hold you can release with one click.

Does it look at card numbers?

No. The engine never sees card data. It compares the buyer emails your billing tool sends.

When does the rule run?

On every credited sale, in the same database transaction as the credit. A sweep every 5 minutes also re-checks affiliates active in the last hour.

What does a hold cost me?

Nothing but time. A held commission stays out of payouts. Release it and it pays in the next payout. Uphold it and the engine cancels it and takes the money back.

Can I test it without holding anything?

Yes. Set AE_FRAUD_DRYRUN=1. The engine records each verdict and holds nothing.

Who wrote this

The AffiliateTracking team writes these pages from the engine's own code. Every threshold here is pinned by a test in the repository. Spot a mismatch? Tell us and we'll fix the page or the code.

This rule, on every sale,
before the payout.

Self-host for free, or let us run it for you.