Skip to content

// 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

  1. Run a fast lookup on every signup. POST /v1/lookup with skip_enrichment: true and check_dns: true. No model call, so it returns quickly; the DNS facts are cached for 7 days per domain.
  2. Score the lookup. Add points from verdict, email_signals, category and domain_signals using the table below.
  3. Verify the mailbox only in the middle band. If the score is ambiguous, call POST /v1/verify and add its result to the score. This keeps you inside the 300 verifications a day per account.
  4. Map the total to an action. Allow, step up, review or block.
  5. 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_email treats a null MX as mail-capable. A domain that publishes "I accept no mail" can still pass that flag. Mailbox verification catches it as invalid/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.