Signup Enrichment for B2B Products: How to Identify, Qualify and Route Users in Real Time (2026 Guide)

Signup enrichment turns a new user's email address into a scored, routed lead before they reach your dashboard.

Published

Written by

Chris Pisarski

Reviewed by

Manmohit Grewal

Read time

19

minutes

What an email lookup comes back with: matched, a person with a confidence score, enrich the profile it returns (1 credit); not found, nobody matched the identifier, leave the field empty (no credit); redacted, removed at the person's request, treat it as a permanent no (no credit).

Signup enrichment turns a new user's email address into a scored, routed lead before they reach your dashboard. Your code catches the signup, data API resolves the address to a person and a company, then your scoring rules decide where the lead goes, all while the user watches a loading screen.

Now, one billing detail shapes every design choice below. You pay for an address that resolves and nothing for one that doesn't, which meansa strict confidence threshold costs nothing when it refuses to answer. Accuracy stops being something you trade against coverage and becomes something you set.

The hard part sits upstream of the call. Most self-serve signups arrive with a first name and a personal email address, and a pipeline built for work addresses quietly guesses when it should return nothing.

This guide covers the three jobs, the latency budget, the architectures teams pick between, a worked build, and what to do when the lookup finds nobody. It takes about 15 minutes to read.

Quick answer: how does signup enrichment work?

When a user signs up, send their email address to a reverse email lookup that resolves it to a person, then enrich that person's profile to find their employer, title and company size. Score the lead on fit and intent separately, route it to self-serve or a sales queue, and write the decision back where a human can see it. Set a confidence threshold, treat an empty result as "unknown" rather than "poor fit", and enrich at the first real sign of intent rather than on every signup.

At a glance

  • Latency budget: two to three seconds is the ceiling in-product. A fraud gate needs under a second, and AE routing can take minutes.

  • Minimum useful score: four fields carry it, namely headcount, funding stage, person seniority and one technology or traffic signal.

  • What you are billed for: identifiers that resolve. Lookups that find nobody cost nothing.

  • The three outcomes: a lookup comes back matched with a confidence score, not found, or redacted.

  • Where to spend the credit: at the first real sign of intent, once the user has shown you one.

  • The failure that costs most: a confident wrong match sends a real lead to the wrong place, and nothing flags it.

What is signup enrichment?

Signup enrichment is a real-time lookup that fills in who a new user is at the moment they arrive. It's the inbound version of lead enrichment, and the answer has to drive a decision immediately, because that decision is already being made.

Three enrichment patterns sit next to each other, and only one works from an address it has never seen:

Pattern

What triggers it

What it starts from

Budget

CRM enrichment

A schedule

Records you already hold

Hours

Outbound prospecting

A list you chose in advance

Companies you picked

Hours

Signup enrichment

A user arriving

One arbitrary address

Seconds

The third row is the whole design problem. You can't pre-warm a cache for a domain you’ve never seen, and you can't take thirty seconds over it while someone waits.

What are the three jobs a signup enrichment pipeline does?

The pipeline identifies, qualifies and routes, and each step fails differently:

  • Identify. Turn the address into a person and a company. A work address carries its domain, so that half comes free, while a personal address carries only the person. The tool for this is any provider with a reverse email lookup, Crustdata's people enrichment API among them. Its limit is that it resolves people with a public professional presence.

  • Qualify. This is where PLG lead scoring happens. Score on headcount band, funding stage, person seniority and one technology or traffic signal. Score a missing field as unknown, with the rule that fired recorded beside it, because a score of 40 for a small company is a different decision from a score of 40 built on three empty fields.

  • Route. Send the lead where it belongs and write the decision back where a human sees it. Keep fit and intent as separate scores, because one blended number can't tell an enterprise tyre-kicker from a solo developer who called your API a hundred times.

An engineer at a payments platform told our team where they start: "When someone signs up, right, we only have their email, we have their company." On most self-serve forms, even the company half is missing. And an engineer at a developer infrastructure company named the field that moves their score most: "Funding info is quite frequently missing or wrong. And that's one of our bigger indicators in terms of if we're interested in talking to a company."

Routing doesn't end at the first assignment either. A job change or a funding round is a reason to look again, and a watch pushes those to a webhook. Creating one costs nothing, and a run that finds no change costs nothing either.

How do product teams already do this?

Three patterns came up on calls, and they differ mainly in when they spend the money.

  • Backfill, then enrich continuously. A growth lead at a developer tools company wanted whole user base resolved once and then kept up to date. The table runs to tens of millions of rows, with name and email address the only reliable fields.

  • Wait for intent, then enrich once. A data science lead at a voice product holds off until a user has completed onboarding and used the product, because enriching every signup costs more than it returns.

  • Bulk-enrich the subset you care about. A team at a note-taking product enriches only the CRM records with an active user or workspace behind them. A contact-sales form fires an ad-hoc call on top.

The guide follows the second, because it is the one that survives a free tier. The build works the same for the other two.

How do you enrich a personal email address when all you have is a name?

Resolve the address itself, and let the lookup refuse when it isn't sure. A personal address carries no company domain, so the identify step has to match the person first and then read the employer off whoever it found.

Personal addresses are the normal case on a self-serve form, not the exception.A revenue operations lead at a B2B software company told our team that 70% of their inbound MQLs arrive with personal addresses their stack can't resolve. They have the name and the title, and no company.

A growth lead at a developer tools company put the constraint plainly: "We don't have any other fields. We don't have a consistent field of like, I work for this company or other information on that. We have the name and the email address and we need to go off that."

Send the address to an identify endpoint, which takes business and personal addresses alike:

curl --request POST \
  --url https://api.crustdata.com/person/identify \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "emails": ["maya.r.chen@gmail.com"]
  }'
curl --request POST \
  --url https://api.crustdata.com/person/identify \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "emails": ["maya.r.chen@gmail.com"]
  }'
curl --request POST \
  --url https://api.crustdata.com/person/identify \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "emails": ["maya.r.chen@gmail.com"]
  }'

Every identifier comes back with one of three statuses, and only one of them is billed:

What an email lookup comes back with: matched, a person with a confidence score, enrich the profile it returns (1 credit); not found, nobody matched the identifier, leave the field empty (no credit); redacted, removed at the person's request, treat it as a permanent no (no credit).

Status

What it means

Billed?

matched

Somebody matched, with a confidence_score you can threshold on

Yes

not_found

Nobody matched the identifier

No

redacted

The person asked for their data to be removed

No

That last column is the detail that makes the next section work.

I ran one call against three addresses to check this: a personal address and a work address belonging to real people, and one address I made up. The personal address resolved with a confidence score of 1.0, and the invented one came back not_found. The call was billed two credits, not three, and took 684 milliseconds.

To be clear about what that run shows: both addresses that matched belong to people already in our dataset, so they took the easy path. It shows how the endpoint behaves and how it bills, and it says nothing about how often an arbitrary personal address resolves. Measure that on a sample of your own signups before you size anything around it.

Once an address resolves, you have a profile URL, and the profile is where title, seniority and current employer come from:

curl --request POST \
  --url https://api.crustdata.com/person/enrich \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "professional_network_profile_urls": ["PROFILE_URL_FROM_IDENTIFY"],
    "fields": ["basic_profile", "experience"]
  }'
curl --request POST \
  --url https://api.crustdata.com/person/enrich \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "professional_network_profile_urls": ["PROFILE_URL_FROM_IDENTIFY"],
    "fields": ["basic_profile", "experience"]
  }'
curl --request POST \
  --url https://api.crustdata.com/person/enrich \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "professional_network_profile_urls": ["PROFILE_URL_FROM_IDENTIFY"],
    "fields": ["basic_profile", "experience"]
  }'

The same call handles a work address, because emails accepts both kinds. What a work address gives you on top is the company domain, for free, from the address itself. One thing to check before you design around this: identify is enabled per account, and a key without it gets a 403.

What are the ways a lookup can fail, and what should each one do?

A lookup fails in five ways, and none of them means the signup is a poor fit. Collapsing all five into one empty field is what produces confident wrong routing later, because your scoring rules can no longer separate a person you failed to find from a person who doesn't qualify.

  • Not found: nobody matched the identifier. Leave the field empty, mark the record as unresolved, and score it as unknown.

  • Redacted: the person asked to be removed. Treat it as permanent, stop re-trying them on every run, and never fall back to guessing from the name.

  • Low confidence: something matched, below your threshold. Discard the match and keep the record unresolved.

  • Conflicting: two sources disagree about the employer or the title. Store both with their sources and route on the one you trust, so the last writer doesn't win by default.

  • Provider error: the call failed. Retry it later, and keep the record in a queue so an empty result never overwrites a good one.

The rule that matters most: a failed lookup is a gap in your data and nothing more. A scoring rule that reads unknown as zero will send real buyers to the self-serve track on the strength of a missing field.

A growth lead at a developer tools company put it plainly: "We really want to minimize, we rather have no result than like a false positive." His reasoning was that searching on a common name and a location can return the wrong person, and a wrong person in the CRM is worse than an empty field.

Two more rules keep the record honest once results start arriving late:

  • Order your writes. An enrichment result that arrives after a user has corrected their own company should not overwrite it. Compare timestamps before you write, and let the human win.

  • Make the write-back replayable. Key each enrichment to the signup event, so a retry updates the same record and never creates a second one.

Where two sources really do disagree and you hold context the rules can't read, a language model is a reasonable adjudicator. Picking between two plausible employers is a judgment call that no filter makes, so give the model the candidate matches and whatever the user typed, and have it return the choice with a reason you can store.

Where in the funnel should you spend the enrichment credit?

Spend it at the first real sign of intent. Enriching everyone who signs up costs the most and tells you the least, because most free-tier signups never come back and the record is at its thinnest on day one.

Four moments in a free-tier funnel are candidates, and only one of them is worth the credit:

Where the enrichment credit gets spent: of four moments for the same person (signs up, finishes onboarding, first real use, pays), enrich at first real use; enrich at signup and you pay for everyone, including those who never come back, and wait for the invoice and you wait months for only a fraction of them.

Signup is too early and payment is too late, which leaves first real use as the moment worth paying for.

A data science lead at a voice product walked our team through both ends of that trade. On the cost of enriching at the top: "The reason for that is it also costs money if we try to enrich everyone that signs up." On waiting too long, he pointed out that users can become paying subscribers months after they join, and only a portion ever do, so an enrichment gated on payment arrives far too late to route anything.

His own rule was to wait until a user had completed onboarding and used the product for real. It's worth copying, because it filters on a signal your product already emits and costs nothing to compute.

Once you've chosen the moment, the arithmetic is simple. Resolving an address costs one credit when it resolves and nothing when it doesn't. Pulling the full profile on the people who resolved costs one credit each at the base rate. Company firmographics cost two credits per company, and you only need them for the leads you're actually routing to a human. The rates are on the pricing page.

There are two moments are exceptions to that rule. A fraud or abuse gate has to run at signup, because the decision is needed before the account exists. A contact-sales form is already intent, so enrich it immediately.

How fast does a signup enrichment API need to respond?

Three seconds is a workable ceiling for anything a user sees, and a fraud gate needs under a second. The budget comes from the decision the result feeds.

Where the result is used

Budget

Why

A fraud or abuse gate

Under 1 second

The account is created or refused on the answer

Rendered in-product on first login

2 to 3 seconds

The same window a user tolerates for a page load

AE or SDR routing in the CRM

Minutes

Nobody touches the record until the next working hour

A weekly bulk refresh

Hours

It happens in a job, with nobody waiting

Caching moves the number more than the API does, so measure what share of a month's signups came from domains you had already seen. When you can't meet the budget live, enrich in the background: show a generic welcome screen,call the lookup after the response, and update the routing when the answer arrives. For high-volume free-tier signups, make that asynchronous path the default.

What does the signup enrichment stack look like?

Four layers, and the fourth is the one teams skip:

Layer

What it decides

What it hands on

Capture

Which identifiers you ever hold. A work address carries both the person and the domain, an SSO identity needs no lookup at all, a free-text company field is useful and messy

The identifier, and whether you accept personal addresses

Enrichment

Direct API, aggregator or waterfall

The filled record, and which provider filled each field

Scoring and routing

Fit, intent and the destination

The score, the rule that fired, the owner

Observation

Nothing

Why a given signup was routed the way it was

Build the fourth early, or you won't be able to answer that last question when someone asks it. And you accept personal addresses at capture, measure the resolution rate on that path before building routing that assumes it.

Should you use a direct API, an aggregator or a waterfall?

Pick a direct API unless you have measured a coverage gap that a second provider actually closes.

Architecture

Latency

Traceability

Coverage

Best for

Direct API

Low, single hop

High, one provider per field

Bounded by one provider

Well-covered ICPs and tight latency budgets

Aggregator

Low to medium

Low, the source per field is hidden

Broader than one provider

Teams wanting one contract and no per-field provenance

Waterfall

Medium to high, several hops

Medium, needs explicit logging

Highest

A measured coverage gap a second provider closes

A waterfall's cost lands on the qualify step. Unless you log which provider answered each field, a value from the third in the chain reaches your scoring rules looking exactly like one from the first. Our guide to waterfall enrichment goes through the chaining.

Where should scoring and routing live?

Put scoring where you can change it without a deploy, which usually the CRM or a small service of your own. The practical split is a weekly bulk job plus an ad-hoc call when someone fills in a contact-sales form. Our page for product-led teams covers the data side.

How do you build a signup enrichment pipeline end to end?

Eight steps take you from the webhook to the decay window:

  • Capture the signup event.

  • Turn the signup into an identifier.

  • Resolve the identifier to a person.

  • Turn the person into a company.

  • Score what came back.

  • Route and write back.

  • Log the decision.

  • Decide when to enrich again.

One signup carries the example the whole way through: a user who arrives as the first name Maya and the address maya.r.chen@gmail.com, on a free tier, with nothing else attached.

Step 1: How do you capture the signup event?

Catch it as a webhook and hand it to a queue, because enriching inline ties your response time to someone else's API.

{
  "event_id": "evt_01HQ8M",
  "email": "maya.r.chen@gmail.com",
  "first_name": "Maya",
  "signup_source": "free_tier"
}
{
  "event_id": "evt_01HQ8M",
  "email": "maya.r.chen@gmail.com",
  "first_name": "Maya",
  "signup_source": "free_tier"
}
{
  "event_id": "evt_01HQ8M",
  "email": "maya.r.chen@gmail.com",
  "first_name": "Maya",
  "signup_source": "free_tier"
}

Key on the event id, because users double-click and webhooks retry.

Step 2: How do you turn the signup into an identifier?

Branch on the address type, because a work address hands you the company for nothing.

FREE_MAIL = {"gmail.com", "outlook.com", "yahoo.com", "icloud.com", "proton.me"}
FREE_MAIL = {"gmail.com", "outlook.com", "yahoo.com", "icloud.com", "proton.me"}
FREE_MAIL = {"gmail.com", "outlook.com", "yahoo.com", "icloud.com", "proton.me"}
def route_identifier(email):
    domain = email.split("@")[-1].lower()
    if domain in FREE_MAIL:
        return "person_only"
    return "person_and_company_domain"
def route_identifier(email):
    domain = email.split("@")[-1].lower()
    if domain in FREE_MAIL:
        return "person_only"
    return "person_and_company_domain"
def route_identifier(email):
    domain = email.split("@")[-1].lower()
    if domain in FREE_MAIL:
        return "person_only"
    return "person_and_company_domain"

An unlisted domain is treated as a company domain, which fails safely: the lookup finds nothing and you fall back to the person.

Step 3: How do you resolve the identifier to a person?

Call identify with the address and read the status before the match.

[
  {
    "matched_on": "maya.r.chen@gmail.com",
    "match_type": "email",
    "match_status": "matched",
    "matches": [
      {
        "confidence_score": 0.93,
        "person_data": {
          "basic_profile": {"name": "Maya Chen", "current_title": "Staff Platform Engineer"},
          "social_handles": {"professional_network_identifier": {"profile_url": "..."}}
        }
      }
    ]
  }
]
[
  {
    "matched_on": "maya.r.chen@gmail.com",
    "match_type": "email",
    "match_status": "matched",
    "matches": [
      {
        "confidence_score": 0.93,
        "person_data": {
          "basic_profile": {"name": "Maya Chen", "current_title": "Staff Platform Engineer"},
          "social_handles": {"professional_network_identifier": {"profile_url": "..."}}
        }
      }
    ]
  }
]
[
  {
    "matched_on": "maya.r.chen@gmail.com",
    "match_type": "email",
    "match_status": "matched",
    "matches": [
      {
        "confidence_score": 0.93,
        "person_data": {
          "basic_profile": {"name": "Maya Chen", "current_title": "Staff Platform Engineer"},
          "social_handles": {"professional_network_identifier": {"profile_url": "..."}}
        }
      }
    ]
  }
]

Set a threshold and hold to it: 0.9 and above where the result writes to the CRM unseen, and 0.7 to 0.8 where somebody reviews it first. Anything below is unresolved. The min_similarity_score parameter lets you set the floor on the request itself, so matches below it never come back at all.

Step 4: How do you turn the person into a company?

Identify returns the person and a profile URL, nothing about where they work. The experience group fills that in.

curl --request POST \
  --url https://api.crustdata.com/person/enrich \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "professional_network_profile_urls": ["PROFILE_URL_FROM_STEP_3"],
    "fields": ["basic_profile", "experience"]
  }'
curl --request POST \
  --url https://api.crustdata.com/person/enrich \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "professional_network_profile_urls": ["PROFILE_URL_FROM_STEP_3"],
    "fields": ["basic_profile", "experience"]
  }'
curl --request POST \
  --url https://api.crustdata.com/person/enrich \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "professional_network_profile_urls": ["PROFILE_URL_FROM_STEP_3"],
    "fields": ["basic_profile", "experience"]
  }'

The employer and its size come back in experience.employment_details.current.name and .company_headcount_range, as a band rather than a count: Example Fintech, "201-500". That band is already enough to score Maya.

Go further only for leads you're routing to a human. Company enrich adds the funding round in funding.last_round_type. It takes a domain, so resolve the employer's name with /company/identify first, which costs 0.2 credits per match:

curl --request POST \
  --url https://api.crustdata.com/company/identify \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "names": ["Example Fintech"]
  }'
curl --request POST \
  --url https://api.crustdata.com/company/identify \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "names": ["Example Fintech"]
  }'
curl --request POST \
  --url https://api.crustdata.com/company/identify \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "names": ["Example Fintech"]
  }'

Matches come back ranked by confidence, and the domain you accept feeds the next call. At two credits this is the most expensive call in the chain:

curl --request POST \
  --url https://api.crustdata.com/company/enrich \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "domains": ["example-fintech.com"],
    "fields": ["basic_info", "funding", "headcount"]
  }'
curl --request POST \
  --url https://api.crustdata.com/company/enrich \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "domains": ["example-fintech.com"],
    "fields": ["basic_info", "funding", "headcount"]
  }'
curl --request POST \
  --url https://api.crustdata.com/company/enrich \
  --header 'authorization: Bearer YOUR_API_KEY' \
  --header 'content-type: application/json' \
  --header 'x-api-version: 2025-11-01' \
  --data '{
    "domains": ["example-fintech.com"],
    "fields": ["basic_info", "funding", "headcount"]
  }'

Step 5: How do you score what came back?

Score fit and intent separately and record which rules fired. The function reads the shapes the calls above return, a band and a round type, and keeps unknown distinct from zero. It covers headcount, funding and seniority; add your technology or traffic signal as a fourth rule in the same pattern.

TARGET_BANDS = ("51-200", "201-500", "501-1000", "1001-5000")
SENIOR = ("head", "director", "vp", "chief", "founder")
TARGET_BANDS = ("51-200", "201-500", "501-1000", "1001-5000")
SENIOR = ("head", "director", "vp", "chief", "founder")
TARGET_BANDS = ("51-200", "201-500", "501-1000", "1001-5000")
SENIOR = ("head", "director", "vp", "chief", "founder")
def score_fit(person, company):
    score = 0
    applied = []
def score_fit(person, company):
    score = 0
    applied = []
def score_fit(person, company):
    score = 0
    applied = []









Maya scores 55. The band and the round type both fire, and her title carries no senior word, so seniority does not.

Store rules_applied next to the score. When a rep asks why an enterprise signup went to self-serve, the list answers in one line, and a funding_unknown entry says the score was built on a gap.

Step 6: How do you route and write back?

Write the fields, both scores and the rule list back, then assign an owner. The intent score comes from your own product events rather than from enrichment. Include the resolution status too, so the next system can tell a low score from an unresolved one.

{
  "person_title": "Staff Platform Engineer",
  "company_headcount_band": "201-500",
  "company_funding_stage": "series_b",
  "fit_score": 55,
  "intent_score": 80,
  "rules_applied": ["headcount_band", "funding_stage"],
  "resolution_status": "matched",
  "match_confidence": 0.93,
  "routing_track": "ae_queue"
}
{
  "person_title": "Staff Platform Engineer",
  "company_headcount_band": "201-500",
  "company_funding_stage": "series_b",
  "fit_score": 55,
  "intent_score": 80,
  "rules_applied": ["headcount_band", "funding_stage"],
  "resolution_status": "matched",
  "match_confidence": 0.93,
  "routing_track": "ae_queue"
}
{
  "person_title": "Staff Platform Engineer",
  "company_headcount_band": "201-500",
  "company_funding_stage": "series_b",
  "fit_score": 55,
  "intent_score": 80,
  "rules_applied": ["headcount_band", "funding_stage"],
  "resolution_status": "matched",
  "match_confidence": 0.93,
  "routing_track": "ae_queue"
}

Compare timestamps first: if the user edited their own company since the signup fired, keep theirs.

Step 7: What do you log?

Log the provider, cache state, confidence score, latency and routing decision, and keep it 90 days: the first question you get will be about last quarter.

Step 8: When do you enrich again?

Re-resolve companies after about 90 days and people after about 30, and let a watch override both when something changes sooner.

How do you know when signup enrichment stops working?

The number to alert on is the write rate. The common failure here is a pipeline that keeps returning 200s while it fills in nothing, and no alert fires on a successful call that found nobody. A provider change, an expired key and a renamed field all look identical from the outside: records flowing through with empty columns.

Track four numbers, and alert on the first two:

  • Enrichment write rate is the share of signups that end up with a resolved company. Alert when it falls outside its normal band for an hour.

  • Unresolved rate by input type splits work addresses from personal ones, because one can collapse while the other looks fine.

  • Latency at the 95th percentile tells you whether you're still inside your budget.

  • Cache hit rate explains your bill, and a sudden drop in it explains a sudden rise.

Set the band from your own two weeks of history. When the alert fires, check the provider status first, then a single known-good address, then whether the field names in the response have changed.

Then backfill. Every signup that arrived while enrichment was down is sitting in your CRM scored on empty fields, and those are exactly the records most likely to have been misrouted. Re-enrich them before you close the incident, because nothing else will go back for them.

Which edge cases will you hit?

Four cases break a pipeline that works on everything else, and each one needs a different answer.

What about brand-new and stealth companies?

Expect blanks, and expect them to arrive as successful calls. Providers index what has been published, so a company with no funding record looks the same as one that never existed, and the newest companies (sometimes the ones that become large within a year) are exactly the ones nothing has on file yet. Two things help:

  • Add a web-search fallback. It reads the company's own site when the structured lookup comes back empty.

  • Score the blank as unknown. A young company shouldn't be punished for being young.

Then check a sample of your newest signups against their own websites to see how wide the gap is.

What about fraud and trial abuse?

Use a firmographic existence check as a cheap first gate. It runs before any identity verification and asks two things: does the claimed company exist at the claimed domain, and does the domain's age fit the story. Run this one at signup, the exception to spending the credit later, because the decision can't wait.

What if a signup never resolves at all?

Some signups will not resolve however you call the API, because the person keeps no public professional presence for anyone to index, ours included. Registry data or a vertical directory is the fallback.

What matters more is that your score separates a person nobody has indexed yet from one who leaves no public trace at all, because otherwise both land in the same bucket. Run a sample of your unresolved signups past someone who knows the market to see which you are looking at.

What if you are reselling enrichment to your own customers?

Check the licensing terms first, because showing enriched data to your customers is a different grant from using it internally. An engineering lead at an authentication platform wanted exactly this, the fields landing "right inside the user table and the user profiles" their own customers look at.

Reselling shifts three constraints:

  • Speed. It is your customer's page load you are slowing down, not your own.

  • Consistency. Their product is built on the field names you return, so a change you treat as cosmetic breaks their UI.

  • Licensing. Your contract has to permit onward display, which an internal-use grant does not.

Get the redistribution clause in writing before you ship, and time the render inside a customer's dashboard rather than your own.

What does it cost to run?

Cost comes from the four calls on the signup path, and only the first one touches every signup. The rates below are list rates from the pricing page.

Call

When it runs

Rate

Person identify

Every enriched signup

1 credit per address that resolves

Person enrich

Signups that resolved

1 credit base per profile

Company identify

Leads with a company name but no domain

Free

Company enrich

Leads being routed to a person

2 credits per company

Watch run

On a change, after setup

5 credits per notification

Three things cut the bill without costing you accuracy:

  • Gate enrichment on intent. You stop paying for signups who never come back.

  • Cache by domain. The saving scales with how often the same company signs up twice.

  • Enrich the company last. It is the two-credit call in the chain.

Lookups that find nobody aren't billed either, so a high threshold costs you nothing except the matches you decided not to trust.

Where do I start this week?

  • Measure your input mix first. Count what share of last month's signups arrived with personal addresses. The answer decides whether identify is your main road or an edge case.

  • Build the identify step and nothing else. One call, one threshold, one unresolved status written back, before any scoring rules.

  • Pick the moment. Find the event in your product that means a user is real, and put the enrichment behind it.

  • Add the write-rate alert before the second provider. You can't tell whether a waterfall helped without measuring what the first provider filled in.

You can build the first version on a free Crustdata account and find out what your own signups resolve to. To see what it looks like finished in a product rather than how to build it, our page on signup enrichment for product-led teams covers that.

Signup enrichment FAQ

What is the difference between signup enrichment and lead enrichment?

Lead enrichment is the whole category of filling in missing data on a lead record. Signup enrichment is the real-time, inbound-triggered version: the lookup fires as a user arrives, the input is sparser and the result has seconds to be useful. For the broader category, see our guide to lead enrichment tools.

Can you enrich a signup from a personal email address?

Yes, by resolving the person behind the address, which an identify endpoint does by taking the address directly. There is no company domain to fall back on, so set a confidence threshold and let unresolved records stay unresolved. Measure the rate on your own signups before building routing that assumes it.

What data do you actually need to score a B2B signup?

Fewer than you would guess, and the first version should use flat weights. What moves accuracy is a rule that tells an empty field apart from a bad one, which costs nothing in data. Add tuned weights once you have enough converted signups to set them from, which for most products takes a year.

Do you need a waterfall, or is one provider enough?

One provider is enough when your unresolved rate is acceptable on your own signups. A waterfall pays off once you have measured a gap that is systematic rather than random. Measure first, because a waterfall costs you the ability to trace which source filled each field.

What should the pipeline do when it cannot identify a signup?

Leave it on the self-serve track and mark it unresolved, which is a different state from scored and rejected. The cost of getting that wrong shows up later, because an unresolved record never gets re-enriched unless something tells it to. Pair the status with a retry window, or a signup that failed during an outage stays invisible for good.

Crustdata is now live in Claude!

Find the best leads, candidates and companies with only a prompt.

Sign In