// guide
Build a simple signup risk score from email and domain signals
For backend developers and trust and safety engineers who screen new accounts · Updated · 7 min read
Blocking only disposable domains lets most junk through, but blocking anything that looks odd keeps rejecting real customers, and I have no middle ground.
A useful signup risk score needs only a few inputs: the verdict and email_signals from a fast pingutil lookup, the domain_signals you get by adding check_dns: true, and, for borderline cases, the mailbox status from /v1/verify. Add points per signal, then map the total to four bands: allow, step up (confirm the email), review, block. Start with the weights below, log every decision, and tune them against your own fraud data.
This guide is for teams who already know a pure blocklist isn't enough and don't want to buy a full fraud platform to get a score.
What this problem costs you
Most products start with one rule: reject disposable domains. It catches the laziest abuse and nothing else. A script that registers kx8qzv21@gmail.com sails through, and so does an address on a domain registered last night with a mail server and no website.
So the next step is often a second rule that's too blunt, like "reject anything that looks random." Now you're turning away real customers with unusual names, privacy-relay addresses, and people who picked a handle at 14 and kept it.
Both failure modes cost money:
- Fake accounts eat free-trial compute, skew activation metrics, trigger outbound mail that bounces, and create work for support.
- False rejections cost you a customer at the moment they were most interested, and you rarely hear about it.
A score with bands fixes the binary problem. Strong combined evidence gets blocked. Mixed evidence gets friction. Weak evidence gets through. Most of that junk comes from scripts, trial farmers and people who don't want marketing email, and each leaves different traces.
How pingutil solves it
- Run a fast lookup on every signup.
POST /v1/lookupwithskip_enrichment: trueandcheck_dns: true. No model call, so it returns quickly; the DNS facts are cached for 7 days per domain. - Score the lookup. Add points from
verdict,email_signals,categoryanddomain_signalsusing the table below. - Verify the mailbox only in the middle band. If the score is ambiguous, call
POST /v1/verifyand add its result to the score. This keeps you inside the 300 verifications a day per account. - Map the total to an action. Allow, step up, review or block.
- Store the score and the reasons on the account. When a fraud report or a chargeback comes in later, you can see which signals were present and adjust the weights.
Why weights, not rules
Each signal alone is weak or noisy. A role address isn't fraud. A domain without a website might be a new company. A random-looking local part might be a relay alias. Points let two weak signals add up to a strong one without letting either one block a user by itself. That's also why verdict separates is_spam (block-worthy) from low_trust (worth a look).
Decision table: signals to points
These are starting weights we'd use for a B2B SaaS signup. They are not tuned on anyone's data. Change them.
| Signal | Points | Why |
|---|---|---|
verdict.reason: disposable_domain |
+100 | Known throwaway domain. Block on its own |
verdict.reason: randomized_local_part |
+45 | Machine-generated local part. Strong but has false positives |
email_signals.randomness_score 50 or higher, is_randomized: false |
+15 | Odd-looking, but not flagged as machine-generated |
email_signals.domain_looks_random: true |
+20 | Random-looking registrable label, often generated domains |
email_signals.is_role_based: true |
+10 | Shared inbox, no individual owner |
email_signals.is_system_generated: true |
+40 | noreply@, mailer-daemon@: nobody reads it |
domain_signals.domain_exists: false |
+100 | The domain doesn't resolve. Nobody can receive mail there |
domain_signals.can_receive_email: false |
+60 | No mail server, so no confirmation email can arrive |
domain_signals.has_website: false on a company domain |
+15 | Common for throwaway domains, also for new or mail-only domains |
category: free |
0 | Normal for consumer products. Add weight only if your product is B2B-only |
verify status: invalid |
+60 | Mailbox doesn't exist |
verify status: risky, reason: accept_all |
+5 | Can't confirm, common at real companies |
verify status: unknown |
0 | Server didn't answer. Not evidence either way |
verify status: valid |
-20 | A real mailbox exists |
And the bands:
| Score | Band | Action |
|---|---|---|
| 0 to 24 | allow | Create the account normally |
| 25 to 49 | step up | Require email confirmation before trial resources become available |
| 50 to 79 | review | Hold limits low, queue for a human or add a second check |
| 80 and above | block | Reject with a neutral message and log the reasons |
Only addresses that score 25 to 79 after the fast lookup get a mailbox check. Everything below 25 doesn't need one; everything 80 and above is already decided.
Complete example: a scoring function in Node
const BASE = 'https://pingutil.com/v1';
const KEY = process.env.PINGUTIL_KEY; // pk_live_...
async function call(path, body, timeoutMs) {
const res = await fetch(`${BASE}${path}`, {
method: 'POST',
headers: { authorization: `Bearer ${KEY}`, 'content-type': 'application/json' },
body: JSON.stringify(body),
signal: AbortSignal.timeout(timeoutMs),
});
if (!res.ok) throw new Error(`pingutil ${path} ${res.status}`);
return res.json();
}
function scoreLookup(d, reasons) {
let s = 0;
const add = (pts, why) => { s += pts; reasons.push(why); };
const sig = d.email_signals;
const dns = d.domain_signals;
if (d.verdict.reason === 'disposable_domain') add(100, 'disposable_domain');
if (d.verdict.reason === 'randomized_local_part') add(45, 'randomized_local_part');
if (sig) {
if (!sig.is_randomized && sig.randomness_score >= 50) add(15, 'odd_local_part');
if (sig.domain_looks_random) add(20, 'random_domain');
if (sig.is_role_based) add(10, 'role_based');
if (sig.is_system_generated) add(40, 'system_generated');
}
if (dns) {
if (!dns.domain_exists) add(100, 'domain_missing');
else if (!dns.can_receive_email) add(60, 'no_mail_server');
if (d.category === 'company' && !dns.has_website) add(15, 'no_website');
}
return s;
}
function scoreVerify(v, reasons) {
if (v.status === 'invalid') { reasons.push(`verify_${v.reason}`); return 60; }
if (v.status === 'risky' && v.reason === 'accept_all') { reasons.push('accept_all'); return 5; }
if (v.status === 'valid') { reasons.push('mailbox_exists'); return -20; }
return 0;
}
function band(score) {
if (score >= 80) return 'block';
if (score >= 50) return 'review';
if (score >= 25) return 'step_up';
return 'allow';
}
export async function signupRisk(email) {
const reasons = [];
let lookup;
try {
lookup = await call('/lookup', { input: email, skip_enrichment: true, check_dns: true }, 3000);
} catch {
return { score: null, band: 'step_up', reasons: ['lookup_unavailable'] }; // fail to friction, not to block
}
let score = scoreLookup(lookup, reasons);
if (score >= 25 && score < 80) {
try {
const v = await call('/verify', { email }, 15000);
score += scoreVerify(v, reasons);
} catch {
reasons.push('verify_unavailable');
}
}
return { score, band: band(score), reasons, category: lookup.category };
}
When pingutil is unreachable or slow, this falls back to step_up instead of blocking or waving the signup through. If you prefer to fail open (allow) for conversion reasons, change that one line, and keep the email confirmation step as your backstop.
You can also call /v1/verify on everyone if your volume fits in 300 a day. The verify response carries its own checks.randomized, checks.role_based and checks.disposable, but not domain_looks_random or the DNS website check, which is why this guide uses both endpoints.
Edge cases and limits
- Privacy relays look random. Apple Hide My Email, Firefox Relay and SimpleLogin generate local parts that can trip
is_randomized. Those are real people protecting their inbox. If relay domains matter to you, subtract points for them in your own code. Background: email relay services are not disposable email. - Some real names score as random. The randomness model includes an international first-name dictionary, but some non-English names still score high. That's one reason randomized is +45 here and not a block.
can_receive_emailtreats a null MX as mail-capable. A domain that publishes "I accept no mail" can still pass that flag. Mailbox verification catches it asinvalid/null_mx.- No domain age, WHOIS, SPF or DMARC. pingutil doesn't check those. If newly registered domains are your main problem, you need another source for that signal.
- Disposable lists lag. The disposable list is a community list re-synced weekly. A domain created this morning won't be on it yet, which is why the DNS and randomness signals carry weight too.
- Email signals aren't identity. A clean score means the address looks like a real person's. It says nothing about whether the same person already has five accounts. Combine it with your own device and payment signals.
- Budgets. On the Free plan, 2,000 lookups and 300 verifications a day per account (30,000 and 3,000 a month), 60 requests a minute. Past a budget you get
429 quota_exceeded; treat that the same as an outage in the code above.
For more on picking cheap signals, read an email risk score from signals you already have and detecting machine-generated addresses. The stop fake signups guide and the SaaS signup protection use case show where a score like this sits in the signup flow.
Next step
Paste a few suspicious addresses into the live demo and see which signals fire. Then create an API key on the dashboard, drop signupRisk into your signup handler, and log scores for a week before you turn on blocking. Schemas for both endpoints are in the API reference.
Questions people ask
- Should I block signups based on a risk score alone?
- Only at the very top of the range, where several strong signals agree. In the middle, ask for something extra, such as a confirmed email or a phone check, and send the uncertain cases to review instead of rejecting them.
- Does domain_signals change the pingutil verdict?
- No. domain_signals is returned only when you set check_dns to true, and it's purely informational. You decide how much weight a missing website or mail server gets in your own score.
- Do I need mailbox verification for every signup?
- No. Mailbox checks are slower and limited to 300 addresses a day (3,000 a month) per account on the Free plan, so run the fast lookup on everyone and save verification for signups that land in the middle of your score range.