// 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
- 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.
- 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.
- Branch on
category. Onlycompanydomains get a profile.free(Gmail, Outlook and around 100 other webmail domains),isp,educationalandgovernmentcome back withcompany: null.disposablemeans the address is a throwaway, which is a fake-signup problem, not an enrichment one. - Check that enrichment actually happened. If
meta.enrichment_erroris set, there's no fresh profile. Ifmeta.served_staleis true, you got the previous cached profile instead. - Check confidence.
company.confidenceis the model's own estimate between 0 and 1. Below 0.5 the response also carriesmeta.low_confidence: true. - 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.
confidenceis 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: trueto 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_companyis 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.