Skip to content

// guide

Enrich new signups with company data for onboarding and sales

For saaS founders, growth engineers and RevOps teams who want to know which company each signup works for · Updated · 7 min read

Hundreds of people sign up every week and all I know about them is an email address, so sales can't tell which ones matter and onboarding treats everyone the same.

Send each new signup's email to POST https://pingutil.com/v1/lookup and, when the domain belongs to a company, you get back a structured profile: name, industry, employee_size_estimate, headquarters, funding_stage, linkedin_url and more. Use it to pick an onboarding path and to alert sales about signups that match your ideal customer. Do it in a background job, check company.confidence before acting on it, and treat webmail signups as individuals.

This guide is for product-led teams where the signup form asks for an email and not much else. You don't want a longer form. You want to know who just walked in.

What this problem costs you

When every signup looks the same, you make the same mistakes over and over:

  • Sales finds good accounts late. Someone from a 500-person company signs up, pokes around for a day, and leaves. Nobody noticed because their row in the users table looked like everyone else's.
  • Onboarding is generic. A solo developer and an ops team at a hospital chain get the same welcome email and the same empty-state screens. Neither feels the product was built for them.
  • Your form gets longer to compensate. Asking for company name, size and industry on the signup form adds friction, and the answers are often blank or made up.
  • Reporting is blind. You can't answer "which industries convert from trial?" if you never recorded industry.

Knowing the company behind an address fixes most of this without asking the user a single extra question. Personalize onboarding from the email domain covers the product side in more detail.

How pingutil solves it

  1. Get an API key on the dashboard and store it as a server-side secret. Never call the API from the browser with your key.
  2. Queue the lookup after signup. A first-seen company domain takes a few seconds because a model reads the homepage and fills the profile. Don't make the signup request wait on that. Push the email onto a job queue and process it right after the account is created.
  3. Branch on category. Only company domains get a profile. free (Gmail, Outlook and around 100 other webmail domains), isp, educational and government come back with company: null. disposable means the address is a throwaway, which is a fake-signup problem, not an enrichment one.
  4. Check that enrichment actually happened. If meta.enrichment_error is set, there's no fresh profile. If meta.served_stale is true, you got the previous cached profile instead.
  5. Check confidence. company.confidence is the model's own estimate between 0 and 1. Below 0.5 the response also carries meta.low_confidence: true.
  6. Write the fields you trust to your user record and CRM, then let your onboarding and alerting rules read from there.

Why the cache matters for your budget

Profiles are cached per registrable domain. jane@stripe.com, bob@stripe.com and ops@mail.stripe.com all resolve to stripe.com and share one row. On the Free plan each account gets 50 fresh profiles per UTC day and 500 a month, and only fresh enrichments count. A cache hit, whether it's your first lookup of a domain someone else already looked up or your tenth signup from the same company, costs a lookup and nothing from the profile budget.

If you have more than 50 new company domains in a day, the extra lookups still return 200 with the category and signals, plus meta.enrichment_error: "daily_enrichment_limit". Put those back on the queue for after 00:00 UTC.

Decision table: fields to actions

Field and value What it tells you Action
category: company and company not null A company profile exists Store it and run your onboarding and sales rules
category: free or isp Personal address, no company to enrich Individual onboarding path. Ask about their team later, in product
category: educational University or school domain Education path, or your academic pricing flow
category: government Public-sector domain Route to whoever handles public-sector deals
category: disposable or verdict.is_spam: true Throwaway or machine-generated address Don't enrich. Apply your fake-signup policy
meta.enrichment_error: "daily_enrichment_limit" Daily profile budget used Re-queue for the next UTC day
meta.enrichment_error: "domain_unresolvable" The domain doesn't resolve in DNS No profile will ever come. Treat the signup as suspect
meta.served_stale: true Enrichment failed, previous profile returned Use it, and retry later if the data matters
meta.low_confidence: true (confidence below 0.5) The model wasn't sure Show to humans as a hint, don't automate on it
employee_size_estimate A size band, as a string Map to your segments (for example "1-10" to self-serve)
industry, sub_industry Free-text industry labels Map to your own list of verticals with a lookup table
funding_stage, total_funding_usd Funding as of when the profile was built Use as a soft sales signal, not a hard filter
headquarters.country Free text, not an ISO code Normalize before you use it for routing or tax logic

Complete example: a Node worker that enriches signups

This runs in a job queue consumer. It takes the new user's id and email, looks up the company, and writes a small, trusted subset of fields back. db and notifySales stand in for your own code.

const API = 'https://pingutil.com/v1/lookup';
const KEY = process.env.PINGUTIL_KEY; // pk_live_...

async function lookup(email) {
  const res = await fetch(API, {
    method: 'POST',
    headers: { authorization: `Bearer ${KEY}`, 'content-type': 'application/json' },
    body: JSON.stringify({ input: email }),
    signal: AbortSignal.timeout(20_000), // first-seen domains take a few seconds
  });
  if (res.status === 429) {
    const body = await res.json();
    const err = new Error(body.error);
    err.retryAfter = body.retry_after_seconds ?? 60;
    throw err;
  }
  if (!res.ok) throw new Error(`pingutil ${res.status}`);
  return res.json();
}

function sizeSegment(band) {
  if (!band) return null;
  const low = parseInt(band, 10); // "51-200" -> 51, "10001+" -> 10001
  if (Number.isNaN(low)) return null;
  if (low >= 1000) return 'enterprise';
  if (low >= 51) return 'mid_market';
  return 'smb';
}

export async function enrichSignup({ userId, email }, { db, notifySales, requeue }) {
  const data = await lookup(email);
  const update = { category: data.category, domain: data.domain };

  if (data.verdict.is_spam) {
    await db.users.update(userId, { ...update, flagged: data.verdict.reason });
    return;
  }

  if (data.meta.enrichment_error === 'daily_enrichment_limit' && !data.company) {
    await requeue({ userId, email }, { at: 'next_utc_day' });
  }

  const c = data.company;
  if (data.category === 'company' && c) {
    const trusted = !data.meta.low_confidence;
    Object.assign(update, {
      company_name: c.name,
      industry: trusted ? c.industry : null,
      size_band: c.employee_size_estimate,
      segment: trusted ? sizeSegment(c.employee_size_estimate) : null,
      hq_country: c.headquarters?.country ?? null,
      funding_stage: c.funding_stage,
      linkedin_url: c.linkedin_url,
      enrichment_confidence: c.confidence,
    });
    if (trusted && update.segment !== 'smb') {
      await notifySales({ userId, email, company: c.name, segment: update.segment });
    }
  }

  await db.users.update(userId, update);
}

Two choices in that code are deliberate. Low-confidence profiles still store the company name and size band, which a human can sanity-check, but they don't set industry or trigger a sales alert. And a spam verdict stops the job before any enrichment, so throwaway signups never use up your profile budget.

If you only need the category and spam verdict at signup time (for example, to block disposable addresses in the request itself), add skip_enrichment: true. That path makes no model call and answers in milliseconds, and it still returns a cached company profile when one already exists.

Edge cases and limits

  • The model can be wrong. Enrichment is a language model filling a schema from the company's homepage. It does well on established companies with clear websites. It does worse on stealth startups, holding companies, agencies with vague homepages and domains that host several brands. We wrote up the failure modes in how accurate LLM company enrichment is.
  • confidence is self-reported. It's the model's estimate, not a measured accuracy. Treat it as a ranking signal.
  • Funding and headcount go stale. A cached profile reflects the company when it was built. Pass refresh: true to rebuild one (counts against the 50, and refreshes within 60 seconds of the last one return the cached row).
  • No person-level data. pingutil tells you about the company behind the domain, not the person: no job title, no seniority, no phone number.
  • Subsidiaries and parents. parent_company is filled when the model found one, but a subsidiary on its own domain gets its own profile.
  • Shared and consumer domains. Webmail, ISP and university addresses never get a company profile, by design.
  • One lookup per call. There's no bulk lookup endpoint. To backfill existing users, loop through them at a pace under the 60 requests a minute account limit and within 2,000 lookups a day (30,000 a month).

When you want to go further than onboarding, qualify B2B leads by email and route inbound leads build on the same response. The CRM enrichment use case shows where these fields usually end up.

Next step

Type a work address into the live demo to see a real profile, then create a key on the dashboard and wire the worker above into your signup queue. Every field is documented in the API reference.

Questions people ask

How many company profiles can I enrich per day?
On the Free plan each account gets 50 fresh company profiles per UTC day and 500 a month. Lookups answered from the cache don't count toward that, so several signups from the same company cost one fresh profile.
How accurate is the company data?
It comes from a language model reading the company's homepage and filling a strict schema, so it's usually right on well-known companies and weaker on small or new ones. Each profile carries a confidence value between 0 and 1, and anything below 0.5 is flagged with meta.low_confidence.
What happens when someone signs up with Gmail?
Gmail and other webmail domains come back with category free and no company profile. There is no company behind the domain to enrich, so treat them as individual users unless they tell you otherwise.