// guide
Stop referral and promo-code farming at the email step
For growth engineers, e-commerce developers and trust and safety teams running referral programs or first-order discounts · Updated · 6 min read
One person keeps creating new accounts with throwaway and dotted Gmail addresses to claim the signup bonus again and again, and every reward is real money.
Referral and promo farming comes down to one person creating many identities to claim a one-time reward many times. You catch most of it at the email step with three checks: block rewards to disposable and machine-generated addresses (pingutil's verdict.is_spam), collapse address variants to one canonical inbox yourself (Gmail ignores dots and anything after +), and refuse a reward when that canonical inbox has already claimed it. Then delay the payout until a qualifying action, so whatever slips past still has to spend real money first.
This guide is for anyone paying out a signup credit, a referral bonus, a first-order discount or a "give $X, get $X" reward.
What this problem costs you
Promo abuse is attractive because the reward is direct and the cost of an identity is close to zero. A new email address takes seconds. The patterns repeat:
- Throwaway inboxes. A disposable service gives a fresh address per signup, receives the confirmation email, and is gone an hour later.
- Gmail variants.
jane.doe@gmail.com,janedoe@gmail.com,j.a.n.e.doe@gmail.comandjanedoe+promo7@gmail.comall land in the same inbox. To your users table they're four customers. - Generated addresses. Scripts register
kq7zv3mx@style local parts on webmail or on domains the abuser owns. - Self-referral loops. The farmer refers themselves from each new account, so every identity both gives and gets.
The cost is the reward times the number of fake identities, plus the side effects: inflated referral metrics that make the program look like it works, real customers seeing codes "already used", and support time sorting it out. Referral and promo abuse email signals goes through the patterns in more depth.
How pingutil solves it
pingutil handles the part that needs outside knowledge (which domains are disposable, which local parts look generated). Deduplication needs knowledge of your own users, so that part runs in your code.
- Look up the address when the reward is claimed.
POST /v1/lookupwithskip_enrichment: true. No model call, so it's fast enough to run inline. - Refuse the reward on
verdict.is_spam. That covers disposable domains (about 9,900 from the community list, re-synced weekly), reputation-flagged domains and randomized local parts. - Compute a canonical key. Lowercase, then for Gmail and Googlemail remove dots and anything after
+, and mapgooglemail.comtogmail.com. For other domains, strip the+tagonly. Store the key on the account. - Check the key against past claims. If the canonical inbox already claimed this reward, deny it. Count claims per domain too: ten new referrals from one small custom domain in an hour is a pattern worth a look.
- Hold the reward until a qualifying action. Pay the referrer after the referred account makes a first purchase or reaches a usage milestone, not at signup.
Why normalization is your job
pingutil normalizes the domain (lowercase, punycode, www. stripped, subdomains collapsed to the registrable domain), and that's what it classifies. It does not rewrite the local part and does not keep a record of your users, so it can't know that janedoe@gmail.com signed up last week. Those two facts live in your database. The Gmail dots and plus normalization post explains the provider rules. Google documents the dot behaviour in its Gmail help center, and plus tags follow the subaddressing convention described in RFC 5233.
Don't rewrite the address you send mail to. Keep the original for delivery and use the canonical key only for duplicate checks.
Decision table: signals to actions
| Signal | What it means | Action on the reward |
|---|---|---|
verdict.is_spam: true, reason: disposable_domain |
Throwaway inbox | Deny reward. Allow account only if your policy permits |
verdict.is_spam: true, reason: randomized_local_part |
Local part looks machine-generated | Deny automatic reward, offer manual review |
email_signals.randomness_score high but is_randomized: false |
Unusual but not flagged | Allow, but count toward velocity checks |
email_signals.domain_looks_random: true on a company domain |
Possibly a generated domain the abuser controls | Hold reward for review |
verdict.low_trust: true (role, system, sales address) |
Shared or automated inbox | Hold for review. Real people rarely claim a promo from noreply@ |
| Canonical key already claimed this reward | Same inbox, new account | Deny |
| Referrer's canonical key equals referee's | Self-referral | Deny both sides |
| Many claims from one non-webmail domain in a short window | Domain farm | Pause rewards for that domain, review |
category: free with no other signals |
Ordinary consumer address | Allow |
Complete example: a reward check in Node
db stands in for your own storage. The function returns a decision and the reasons, so you can log and review them.
const API = 'https://pingutil.com/v1/lookup';
const KEY = process.env.PINGUTIL_KEY; // pk_live_...
const GMAIL = new Set(['gmail.com', 'googlemail.com']);
export function canonicalKey(email) {
const at = email.lastIndexOf('@');
if (at < 1) return null;
let local = email.slice(0, at).trim().toLowerCase();
let domain = email.slice(at + 1).trim().toLowerCase();
const plus = local.indexOf('+');
if (plus > 0) local = local.slice(0, plus);
if (GMAIL.has(domain)) {
local = local.replaceAll('.', '');
domain = 'gmail.com';
}
return `${local}@${domain}`;
}
async function screen(email) {
const res = await fetch(API, {
method: 'POST',
headers: { authorization: `Bearer ${KEY}`, 'content-type': 'application/json' },
body: JSON.stringify({ input: email, skip_enrichment: true }),
signal: AbortSignal.timeout(3000),
});
if (!res.ok) throw new Error(`pingutil ${res.status}`);
return res.json();
}
export async function checkReward({ email, referrerEmail, rewardId }, db) {
const key = canonicalKey(email);
if (!key) return { decision: 'deny', reasons: ['bad_address'] };
const reasons = [];
let d;
try {
d = await screen(email);
} catch {
return { decision: 'hold', reasons: ['screening_unavailable'] }; // review later, don't pay blind
}
if (d.verdict.is_spam) return { decision: 'deny', reasons: [d.verdict.reason] };
if (d.verdict.low_trust) reasons.push(d.verdict.reason);
if (d.category === 'company' && d.email_signals?.domain_looks_random) reasons.push('random_domain');
if (referrerEmail && canonicalKey(referrerEmail) === key) {
return { decision: 'deny', reasons: ['self_referral'] };
}
if (await db.rewardClaimedBy(rewardId, key)) {
return { decision: 'deny', reasons: ['already_claimed'] };
}
if (d.category !== 'free') {
const recent = await db.claimsForDomainSince(rewardId, d.domain, Date.now() - 3600_000);
if (recent >= 5) reasons.push('domain_velocity');
}
await db.recordClaim(rewardId, key, d.domain);
return { decision: reasons.length ? 'hold' : 'pending_qualifying_action', reasons };
}
Note what counts as success here: pending_qualifying_action, not "paid". The reward is granted later, when the referred account does something worth paying for.
The velocity rule skips free domains on purpose. Thousands of real customers share gmail.com, so counting claims per webmail domain only produces noise. Per-domain velocity is useful on custom domains, where five strangers from the same tiny domain in an hour is unusual.
Edge cases and limits
- New disposable domains. The disposable list is a community list re-synced every Monday. A service that spun up a domain this week can get through. Randomness signals and delayed payouts cover some of that gap.
- Privacy relays. Apple Hide My Email, Firefox Relay and SimpleLogin produce random-looking addresses that can be flagged as randomized, and every alias is a separate key. A relay user is usually a real person, so route those to
holdwith review instead of denying. - Plus stripping on every domain is a choice. Most providers that support subaddressing use
+, but a few domains use+as an ordinary character. False merges are rare, and for a one-time reward check that trade-off is usually fine. - Other providers' rules differ. Dot-insensitivity is a Gmail rule. Don't remove dots for Outlook, Yahoo or custom domains.
- Email isn't the whole picture. A determined farmer uses distinct real inboxes. Combine the email check with payment fingerprints, device signals and shipping addresses, which pingutil doesn't provide.
- Budgets. On the Free plan, 2,000 lookups a day, 30,000 a month and 60 requests a minute per account. If a promo launch might exceed that, screen at reward time instead of at every signup.
For the wider picture, protect free trials covers the same farmers going after trial credits, and the e-commerce fraud use case shows the first-order discount version. The disposable domain category page explains what's on the list.
Next step
Try a throwaway address and a random-looking Gmail in the live demo to see verdict and email_signals change. Then create an API key on the dashboard and put checkReward in front of your payout logic. The full response schema is in the API reference.
Questions people ask
- Does pingutil detect that two Gmail addresses are the same inbox?
- No. pingutil classifies each address on its own and does not deduplicate across your users. Build a canonical key yourself, for example by removing dots and plus tags from Gmail local parts, and check it against your own database.
- Should I block disposable emails from claiming referral rewards?
- Yes for the reward, not necessarily for the account. Let the person sign up if your policy allows it, but don't pay a referral or apply a first-order code to a disposable or machine-generated address.
- Is a plus-tagged address a sign of fraud?
- Not by itself. Plenty of careful users tag addresses to filter mail or spot leaks. It only matters when the same canonical inbox claims the same one-time reward twice.