Fake email at checkout: catch typos and throwaway addresses without losing the sale
· Updated · 6 min read · Email validation
A fake or mistyped email at checkout costs you twice: the customer never gets their order confirmation or shipping updates (and contacts support, or files a chargeback because they think nothing happened), and throwaway addresses let the same person claim first-order discounts again and again. The fix is a background check when the email field loses focus: suggest a correction for typos like gmial.com, flag disposable domains, and decide what perks the address gets. The one rule: never make the payment wait on it.
Checkout is the worst place to add friction. Everything below is designed to be invisible to a customer who typed their address correctly.
Three different problems behind a bad checkout email
They look similar in your order table, but they need different handling.
| Problem | Example | Who's behind it | What it costs you | Right response |
|---|---|---|---|---|
| Typo | jane@gmial.com, jane@hotmail.con |
A real customer | Lost confirmation, support tickets, "where's my order" disputes | Suggest a fix inline |
| Throwaway address | x7@ a disposable inbox |
Someone avoiding marketing, or farming a discount | Repeat first-order coupons, no way to reach them | Take the order, withhold perks |
| Fake account identity | Many accounts on random-looking addresses | Promo abuse, reseller bots, card testing | Discount losses, fraud, inventory hoarding | Stricter rules on the account, not the order |
A typo is by far the most common in normal traffic, and it's the one where the customer actively wants your help.
Typos: suggest, don't correct
Format validation doesn't catch jane@gmial.com. It's a perfectly shaped address. What catches it is comparing the domain against the big providers people actually use and noticing that gmial.com is one transposition away from gmail.com.
pingutil's /v1/verify returns this as did_you_mean: the full corrected address when the domain looks like a typo of a major provider (otherwise null). It also checks whether the domain has a mail server at all, which catches hotmail.con-style TLD slips.
Show the suggestion as a link or button the customer can tap, next to the field:
Did you mean jane@gmail.com? [Use this]
Two things not to do. Don't change the address without asking: some people really do use unusual domains, and silently "fixing" one sends their receipt to a stranger. And don't block the order if they ignore the suggestion. Catching email typos at signup has more on wording and why silent correction backfires.
Disposable addresses: take the money, skip the perks
A disposable inbox at guest checkout usually means one of two things: someone who doesn't want your marketing (fair enough), or someone who wants a "10% off your first order" code for the fifth time.
You don't need to tell them apart. Just separate the order from the incentive:
- Accept the order. They're paying. Rejecting a paid order over the email domain is losing money to make a point.
- Don't issue first-order or welcome codes to a disposable address, and don't let one redeem them.
- Don't create a loyalty account or attach referral credit to it.
- Warn, softly, about delivery updates. "We may not be able to send shipping updates to this address" is honest and gives the privacy-minded customer a reason to switch.
The disposable list we use is on the disposable domains category page. It's based on a public community list, so it misses brand-new throwaway domains for a while. That's fine here: the cost of a miss is one extra coupon, not a fraud loss.
Account fraud: key promotions to a normalized identity
The bigger losses come from people creating many accounts to stack sign-up discounts, referral credit or limited-quantity drops. Disposable domains are one tool for that, but a free webmail account with a variation on the same address is easier:
jane.doe@gmail.com,janedoe@gmail.comandj.a.n.e.doe@gmail.comall reach the same Gmail inbox.jane+1@gmail.com,jane+2@gmail.comtoo, at providers that support plus addressing.
Normalize before you check "has this customer already used the welcome code": lowercase, strip +tags, remove dots for Gmail. Email normalization for Gmail dots and plus tags has the rules per provider. Then add the email signals as a second check: machine-generated local parts (verdict.reason: "randomized_local_part") across many accounts are a strong sign of scripted signups. Referral and promo abuse covers the pattern in depth.
The checkout check: server endpoint
Never call a verification API from the browser with your secret key. Put a thin endpoint on your server that the checkout page calls, and return only what the page needs. Node 18+ and Express:
// checkout-email.mjs
import express from 'express';
const app = express();
app.use(express.json({ limit: '4kb' }));
const KEY = process.env.PINGUTIL_KEY;
async function call(path, body, ms) {
const res = await fetch(`https://pingutil.com${path}`, {
method: 'POST',
headers: { authorization: `Bearer ${KEY}`, 'content-type': 'application/json' },
body: JSON.stringify(body),
signal: AbortSignal.timeout(ms),
});
if (!res.ok) throw new Error(`${path} ${res.status}`);
return res.json();
}
app.post('/api/checkout/email-check', async (req, res) => {
const email = String(req.body?.email ?? '').trim();
if (!email || email.length > 320) return res.json({ ok: true });
// Run both in parallel; whichever fails just contributes nothing.
const [verify, lookup] = await Promise.allSettled([
call('/v1/verify', { email }, 8_000),
call('/v1/lookup', { input: email, skip_enrichment: true }, 3_000),
]);
const v = verify.status === 'fulfilled' ? verify.value : null;
const l = lookup.status === 'fulfilled' ? lookup.value : null;
res.json({
ok: true,
suggestion: v?.did_you_mean ?? null,
// Only a hard "invalid" earns a visible warning; risky/unknown say nothing.
undeliverable: v?.status === 'invalid' && v.reason !== 'disposable_domain',
disposable: l?.category === 'disposable' || v?.reason === 'disposable_domain',
// For your order record, not for the customer.
risk: l?.verdict?.is_spam ? l.verdict.reason : null,
});
});
app.listen(3000);
And the page side, in plain JavaScript. It fires on blur, never blocks the form, and ignores stale responses if the customer edits the field again.
// checkout.js
const input = document.querySelector('#email');
const hint = document.querySelector('#email-hint');
let seq = 0;
input.addEventListener('blur', async () => {
const email = input.value.trim();
hint.textContent = '';
if (!input.checkValidity() || !email) return;
const mine = ++seq;
let r;
try {
const res = await fetch('/api/checkout/email-check', {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ email }),
});
r = await res.json();
} catch {
return; // network trouble: say nothing, let them pay
}
if (mine !== seq || input.value.trim() !== email) return;
if (r.suggestion) {
hint.textContent = `Did you mean ${r.suggestion}? `;
const btn = document.createElement('button');
btn.type = 'button';
btn.textContent = 'Use this';
btn.onclick = () => { input.value = r.suggestion; hint.textContent = ''; };
hint.append(btn);
} else if (r.undeliverable) {
hint.textContent = "We couldn't find a mail server for this address. Please double-check it so you get your receipt.";
} else if (r.disposable) {
hint.textContent = 'We may not be able to send shipping updates to this address.';
}
});
Store the risk value with the order on the server side when the order is placed (re-run the lookup there, since the browser can't be trusted to pass it along). Your promotion logic reads it from the order, not from the client.
Where to be careful
- Mailbox checks take time. An SMTP check can take several seconds when a mail server is slow, which is why it starts on
blurand the payment button never waits. If the check hasn't returned by the time they pay, let it finish in the background. - Catch-all and unknown are not warnings. Many company and some provider domains accept any address or won't answer; those come back
riskyorunknown. Showing a warning for them would scare off real customers. The code above only warns oninvalid. - Privacy relays are real customers. Apple Hide My Email and similar relay addresses can look randomized. They're legitimate, and the person can receive mail. Don't withhold perks on
randomized_local_partalone at checkout; combine it with repeat-account signals. - Budgets. Each verification counts toward your account's Free plan budget of 300 addresses a day (3,000 a month), and each lookup toward 2,000 a day (30,000 a month). Enterprise has custom limits. If checkout volume is high, verify on blur only once per distinct address, and cache the result in the session.
A checkout email checklist
- Validate format with
type="email"in the browser so obvious slips are caught instantly. - On blur, call your server: show
did_you_meanas a tap-to-fix suggestion. - Warn gently only when the address is
invalid(no mail server, mailbox not found). - Accept disposable addresses for paid orders; withhold coupons, referral credit and loyalty perks.
- Normalize addresses before any "one per customer" check.
- Store the risk reason with the order, server-side, for promotion and fraud rules.
For the fraud side beyond email, the ecommerce fraud use case shows how teams combine these signals with order data. You can try typos and disposable domains against the checker on the email verification page.
Questions people ask
- Should I block disposable emails at checkout?
- Not for a paid order. The customer is giving you money, and blocking them loses the sale. Let the purchase through, but don't attach first-order discounts, referral credit or account perks to a disposable address.
- How do I stop customers mistyping their email at checkout?
- Check the address when the field loses focus and show a suggestion like 'Did you mean jane@gmail.com?' with a one-tap fix. Don't auto-correct silently, and don't block the order if the customer keeps their spelling.
- Does email verification slow down checkout?
- It doesn't have to. Run the check in the background as soon as the email field is filled, while the customer types their address and card details, and never make the payment button wait on it.