Skip to content

// guide

How to qualify inbound B2B leads from the email domain

For b2B SaaS founders, growth engineers and RevOps teams handling inbound leads · Updated · 6 min read

Sales spends the first ten minutes of every new lead googling the company to find out if it's worth a call.

To qualify an inbound B2B lead from the email domain, look the address up and score three things: what kind of domain it is (company, free, isp, educational, government), how big the company is (employee_size_estimate), and whether its industry is one you sell to. pingutil returns all three from one POST /v1/lookup call, plus a confidence value that tells you when to stop trusting the firmographics. A simple point model on top of that sorts most leads before a human looks at them.

This guide gives you the scoring model, the code, and the places where a domain-based score will mislead you.

What this problem costs you

Without a first-pass score, every inbound lead gets the same treatment, and that's expensive in both directions:

  • Sales time on poor fits. A rep researching a student project or a one-person agency before the first reply is time not spent on the lead that could close this quarter.
  • Slow responses to good fits. When leads are worked in arrival order, the 500-person company in your best industry waits behind ten free-webmail signups. Response speed matters to buyers comparing vendors.
  • Gut-feel routing. Without data, qualification depends on whoever picks up the lead. Two reps score the same lead differently, and you can't tune what you can't see.
  • Expensive enrichment for everything. Paying a large data contract to enrich leads you'll disqualify in two seconds anyway is waste. A cheap first pass decides which leads deserve deeper research.

How pingutil solves it

1. Look up the lead's email

Send the address to POST https://pingutil.com/v1/lookup without skip_enrichment. For company domains, the API returns a company object filled by an LLM that reads an excerpt of the company's homepage, validated against a strict schema before it's stored. The first lookup on a new domain takes a few seconds; after that the profile is cached and comes back fast.

You can see the shape of a response for any domain in the live demo.

2. Read the category first

category answers the first qualification question on its own:

  • company: custom domain. Firmographic scoring applies.
  • free: personal webmail (about 100 provider domains, see the free provider list). The person may still be a buyer, but you know nothing about the company.
  • isp: consumer ISP mail like comcast.net (see ISP domains). Almost always personal.
  • educational and government: schools and public bodies, which often buy differently.
  • disposable: drop it.

3. Score the company fields

For company domains, the fields that matter most for scoring are:

  • employee_size_estimate: one of 1-10, 11-50, 51-200, 201-500, 501-1000, 1001-5000, 5001-10000, 10000+.
  • industry and sub_industry: free-text labels like Financial Services.
  • funding_stage: bootstrapped, seed, series_a through series_d_plus, public, acquired or unknown.
  • headquarters.country: free text, so normalize before you compare.
  • confidence: the model's own 0 to 1 estimate of how sure it is.

4. Gate on confidence

If confidence is below about 0.5, score the lead on category alone and skip the firmographic points. A wrong "5001-10000" on a two-person startup does more damage than no size at all. How accurate LLM company enrichment is explains where these profiles go wrong.

Decision table: response field to points

Adjust the numbers to your ideal customer. The structure is what matters.

Field and value Points Why
category: "company" +30 Custom domain, firmographics available
category: "free" or "isp" +5 Could be a buyer, no company signal
category: "educational" or "government" +10 Different buying motion, route separately if you sell there
category: "disposable" or verdict.is_spam: true Disqualify Not a real lead
verdict.low_trust: true (role_based) -10 info@ and contact@ are shared inboxes, not a person
verdict.reason: "sales_outreach" -20 Usually a vendor pitching you
employee_size_estimate in your target band +25 Size fit
employee_size_estimate one band away +10 Near fit
industry in your target list +20 Industry fit
funding_stage in series_a...series_d_plus or public +10 Likely has budget
confidence below 0.5 Skip size, industry and funding points Don't score on a guess
meta.enrichment_error present Score on category only, re-check later Profile wasn't available this time

A lead at 60 or more goes to sales. Between 30 and 60 gets a nurture sequence. Below 30 goes to self-serve. Those cut-offs are placeholders until you've scored a few hundred real leads and compared them to closed deals. B2B lead scoring from the email domain covers how to calibrate them.

Complete example: a scoring function in Node.js

// score-lead.mjs (Node 18+)
const PINGUTIL_KEY = process.env.PINGUTIL_KEY; // pk_live_...

const TARGET_SIZES = ['51-200', '201-500', '501-1000'];
const NEAR_SIZES = ['11-50', '1001-5000'];
const TARGET_INDUSTRIES = ['software', 'financial services', 'healthcare'];
const FUNDED = ['series_a', 'series_b', 'series_c', 'series_d_plus', 'public'];

export async function lookup(email) {
  const res = await fetch('https://pingutil.com/v1/lookup', {
    method: 'POST',
    headers: {
      authorization: `Bearer ${PINGUTIL_KEY}`,
      'content-type': 'application/json',
    },
    body: JSON.stringify({ input: email }),
    signal: AbortSignal.timeout(20000),
  });
  if (!res.ok) throw new Error(`pingutil ${res.status}`);
  return res.json();
}

export function score(data) {
  const reasons = [];
  if (data.category === 'disposable' || data.verdict.is_spam) {
    return { score: 0, tier: 'disqualified', reasons: ['spam or disposable'] };
  }

  let points = 0;
  const add = (n, why) => {
    points += n;
    reasons.push(`${n > 0 ? '+' : ''}${n} ${why}`);
  };

  if (data.category === 'company') add(30, 'company domain');
  else if (data.category === 'free' || data.category === 'isp') add(5, `${data.category} domain`);
  else if (data.category === 'educational' || data.category === 'government')
    add(10, data.category);

  if (data.verdict.reason === 'role_based') add(-10, 'role address');
  if (data.verdict.reason === 'sales_outreach') add(-20, 'sales/outreach address');

  const c = data.company;
  if (c && (c.confidence ?? 0) >= 0.5) {
    if (TARGET_SIZES.includes(c.employee_size_estimate)) add(25, `size ${c.employee_size_estimate}`);
    else if (NEAR_SIZES.includes(c.employee_size_estimate)) add(10, `size ${c.employee_size_estimate}`);

    const industry = (c.industry ?? '').toLowerCase();
    if (TARGET_INDUSTRIES.some((t) => industry.includes(t))) add(20, `industry ${c.industry}`);

    if (FUNDED.includes(c.funding_stage)) add(10, `funding ${c.funding_stage}`);
  } else if (c) {
    reasons.push('low confidence profile, firmographics skipped');
  }
  if (data.meta.enrichment_error) reasons.push(`no profile: ${data.meta.enrichment_error}`);

  const tier = points >= 60 ? 'sales' : points >= 30 ? 'nurture' : 'self_serve';
  return { score: points, tier, reasons, company: c?.name ?? null };
}

// Usage: node score-lead.mjs jane@stripe.com
if (process.argv[2]) {
  const data = await lookup(process.argv[2]);
  console.log(score(data));
}

Store reasons with the lead. When a rep disagrees with a score, the reasons tell you which rule to change.

Edge cases and limits

  • The domain isn't the person. A lead from a 5,000-person company might be an intern. Email-domain scoring gets you company fit; title and intent need another source, usually the form itself or product behaviour.
  • Profiles can be wrong. The model reads the homepage and fills a schema. For large, well-known companies it's usually right. For small, new or ambiguous companies, employee_size_estimate and industry can be off. Respect confidence.
  • Industry labels are free text. "Software", "SaaS" and "Computer Software" may all mean your target. Match on substrings or keep a mapping table rather than exact equality.
  • Fresh profiles are budgeted. On the Free plan each account gets 50 fresh company profiles a day and 500 a month; cached profiles don't count. Over the budget, the lookup still returns 200 with meta.enrichment_error: "daily_enrichment_limit", so your code should score on category and retry the profile the next day.
  • Domains without DNS never get a profile. A lead whose domain doesn't resolve comes back with meta.enrichment_error: "domain_unresolvable". That's a strong negative signal on its own.
  • No bulk lookup endpoint. Lookups are one per call, 60 a minute per account. To score a backlog, loop with a small delay. There are no webhooks, so scoring runs when you call it.
  • Subsidiaries. parent_company is filled when the model finds one, but a subsidiary's own size may be what the profile reports. If you sell to enterprises, check both.

Next step

Sign in at the dashboard to get an API key, run your last 50 closed-won leads through score(), and adjust the weights until the good ones land in sales. All CompanyInfo fields are listed in the API reference. Once leads are scored, routing inbound leads shows how to send each tier to the right place.

Questions people ask

Can you qualify a lead from just an email address?
You can get a useful first pass. The domain tells you whether it's a company, free webmail, an ISP, a school or a government body, and for company domains an enrichment API can add size, industry and location. It won't tell you the person's role or intent, so treat it as a filter, not a final score.
Should leads with Gmail addresses be scored as zero?
No. Plenty of founders, consultants and buyers at small companies use personal addresses. Score them lower on firmographic fit, then let behaviour such as product usage or a demo request raise the score.
How accurate is company data from an email domain?
It's good for well-known companies with a clear homepage and weaker for tiny, new or ambiguous ones. pingutil returns a confidence value with each profile, and you should ignore size and industry when it's low rather than score on a guess.