How to Build a Contact Enrichment Waterfall in Claude (2026 Guide)
A contact enrichment waterfall asks one email or phone source after another and stops at the first verified result. Sources such as Apollo, FullEnrich and Crustdata sit in a fixed order, and a log records which one answered.
Published
Written by
Chris Pisarski
Reviewed by
Manmohit Grewal
Read time
19
minutes

A contact enrichment waterfall asks one email or phone source after another and stops at the first verified result. Sources such as Apollo, FullEnrich and Crustdata sit in a fixed order, and a log records which one answered.
In Claude, your code calls each source in order, applies the stop rule and writes the log. Claude picks between people with the same name, judges addresses at a second company domain and reads bounce replies, the three jobs code handles badly.
Waterfalls have a reputation for being clever, but when we look at how teams actually run them, most of the work is deciding when to stop. If the waterfall stops on any email a source returns, a guessed address from source 1 ends the search before source 2 is ever asked. A GTM operator we talked to put it plainly: "the main issue with the waterfall is you rely on the coverage and the accuracy of the first one." We’ve come to think the stop rule is the whole game, and the order of the sources is the part everyone argues about instead.
We also tested the identity step ourselves, on 4 sales leaders with common names. A web search on name and company didn’t return the right profile for any of them, which was a little humbling for the open web. A people search on exact name plus current employer found each one exactly once, for under 1 credit at list price (pricing). All 4 came from the same database, so this checks the method on known people and doesn’t give you a recall rate.
To be upfront about the rest: we ran the identity step and Crustdata’s verified email lookup, on 20 sales leaders. Everything else here, from the other vendors to the CRM write, is the build as we’d set it up, so read those parts as instructions and not as results.
What you'll need:
Pick a route: Claude Code with MCP servers suits a first test, and the Claude API with tool use suits a product build.
Get an API key for each source: you need one for every source in your spec.
Pull a test list of about 200 contacts: include some where you know the right email.
Find somewhere safe to write: use a CRM sandbox, or a test list in HubSpot or Salesforce.
The guide takes about 15 minutes and builds the example waterfall one step at a time.
At a glance:
What it does: asks contact sources in order and stops at the first deliverable email or mobile number.
What Claude adds: decides between same-name people, judges addresses at a second company domain and reads bounce replies.
Stop rule: a deliverable email at the current employer's domain. A catch-all email is kept as a fallback and used only when no source finds a deliverable one.
Phones: stop on the first number with a mobile line type, then judge each source by connect rate.
Billing: FullEnrich and Crustdata's contact lookup charge nothing without a result. Apollo charges 1 credit for a matched person, even with no email.
CRM push: a webhook into n8n or Zapier, then a create-or-update by email.
When one source is enough: when source 2 adds only a handful of deliverable emails on a 200-contact test, such as 6.
What is a contact enrichment waterfall, and when do you need one?
A contact enrichment waterfall is a fixed order of contact sources, asked one at a time until one answers. Each source is asked for an email or phone. Clay describes the setup as querying providers in a set order, usually starting with the most cost-effective, until the data is found.
For the method outside Claude, and when one aggregated source replaces it, see our guide to waterfall enrichment.
You need one when a single source leaves gaps you can measure on your own list. The gaps buyers describe to our team fall into three groups:
Region: one AI sales platform routes US contacts to one source and UK contacts to another.
Persona: founders at small companies and people who sign up with a personal email address come up as gaps.
Phones: several teams describe mobile numbers as harder to source and check than work emails.
How does a contact enrichment waterfall built on Claude work?
It’s a short pipeline, and each stage hands the next one something to check:
Part | Who does it | What it produces |
|---|---|---|
Spec | You, with Claude asking follow-up questions | A file your code and Claude both read |
Identity | A people search, then Claude when the search returns zero or several people | One profile URL per contact, or a flag |
Lookups and stop rule | Your code, calling each source | A work email and a mobile, or "not found" |
Addresses at a second company domain | Claude | Keep or reject, with a reason |
Log | Your code | One line per field: source, status, credits |
CRM write | n8n or Zapier | Created or updated contacts |
Weekly review | Your code for the totals, Claude for the bounce replies | Rates by source, plus which source supplied addresses for people who left |
Claude stays out of the per-contact loop unless a contact needs judgment. A waterfall over 5,000 contacts makes thousands of API calls, and sending each one through a model adds tokens without adding accuracy.
Step 1: How do I write the waterfall spec Claude follows?
Write the spec as a plain file that names every field, source, rule and limit before the first lookup. We’d rather argue with a file than with a running pipeline. The example below follows a waterfall an AI sales platform described to us, where customers set up the order in plain language and review it after a week.
Each line goes to code or to Claude:
Spec line | Handled by | Why |
|---|---|---|
Fields, order, limit | Code | Fixed rules that behave the same way every time |
Stop rule and catch-all policy | Code | A status check and a domain match |
Identity with zero or several matches | Claude | Reading titles, locations and past roles to pick a person |
An address at a domain that isn't on file | Claude | Judging whether the domain still belongs to the person's employer |
Weekly totals | Code | Bounce, connect and cost per source |
Bounce replies | Claude | Reading why each address failed |
CRM write | n8n or Zapier | A webhook and a create-or-update step |
Tip: before you write the file, ask Claude to grill you about the list. It should keep asking until every line above has an answer, including the limit per contact.
Step 2: How do I find the right person before looking up contacts?
Resolve each contact to one profile URL first, then pass that URL to every source. Each source accepts different inputs, so one confirmed identifier saves a wrong match at every step:
Source | What it accepts | Source page |
|---|---|---|
Crustdata contact enrich | A profile URL or a business email, up to 25 per request | |
Apollo people match | A name with a domain, or other identifiers. A name alone may come back with no record enriched | |
FullEnrich | First and last name with a company, or a profile URL |
Can't I just search the web for the name and the company?
Not really, because common names collide on the open web and that makes a web search a poor identity step. In our test of 4 sales leaders with common names, the top profile result was a different person with the same name for three of them.
Search on exact name plus current employer instead, and use it as the default identity step. At list price, the body below costs 0.23 credits per result (pricing).
{ "filters": { "op": "and", "conditions": [ {"field": "basic_profile.name", "type": "[.]", "value": "Jordan Blake"}, {"field": "experience.employment_details.current.company_name", "type": "[.]", "value": "Northstar Analytics"} ] }, "fields": ["basic_profile.name", "experience.employment_details.current.title", "social_handles.professional_network_identifier.profile_url"], "limit": 5 }
{ "filters": { "op": "and", "conditions": [ {"field": "basic_profile.name", "type": "[.]", "value": "Jordan Blake"}, {"field": "experience.employment_details.current.company_name", "type": "[.]", "value": "Northstar Analytics"} ] }, "fields": ["basic_profile.name", "experience.employment_details.current.title", "social_handles.professional_network_identifier.profile_url"], "limit": 5 }
{ "filters": { "op": "and", "conditions": [ {"field": "basic_profile.name", "type": "[.]", "value": "Jordan Blake"}, {"field": "experience.employment_details.current.company_name", "type": "[.]", "value": "Northstar Analytics"} ] }, "fields": ["basic_profile.name", "experience.employment_details.current.title", "social_handles.professional_network_identifier.profile_url"], "limit": 5 }
Send that body to Person Search at POST /person/search.
What does Claude do when the search returns zero or several people?
Claude reads each candidate's title, location and start date, and picks only a clear match. Otherwise it flags the contact for a human, and we think that’s the right instinct for a model to have. Give it a short rule:
A flagged contact costs nothing further. A wrong match costs a credit at every source and puts the wrong person in your CRM, which is the kind of mistake you only discover when a rep emails a stranger and gets a very confused reply.
Step 3: What counts as verified, and when does the waterfall stop?
Stop only on an email marked deliverable at the person's current employer domain. Every source labels emails differently, so map each label to one rule:
Source | Labels it returns | Stop on | Source page |
|---|---|---|---|
Crustdata contact enrich | deliverable, catch_all, invalid, unknown | deliverable | |
Apollo people match | verified, unverified, likely to engage, unavailable | verified, after your own check | |
FullEnrich | DELIVERABLE, HIGH_PROBABILITY, CATCH_ALL, INVALID | DELIVERABLE | |
ZeroBounce (as your own check) | valid, catch-all, unknown, invalid and others | valid |
Crustdata's verified: true option re-checks cached addresses marked deliverable or unknown at request time and drops the ones that fail. It keeps catch_all addresses as they are, so your stop rule has to filter on deliverable (contact enrich docs). When nothing passes, the response says no verified emails found, and the waterfall moves to the next source.
Many teams we talk to add a separate email checker after the waterfall, so every source is judged by the same rule. A benefits software team told us they send anything their own engine can’t verify on to an outside checker, which is a sensible way to avoid trusting any one vendor’s idea of “verified.”
The stop rule in code:
import requests CRUSTDATA = {"authorization": "Bearer YOUR_CRUSTDATA_KEY", "x-api-version": "2025-11-01"} APOLLO = {"x-api-key": "YOUR_APOLLO_KEY"} def domain(email): return email.split("@")[-1].lower() def apollo_email(c): r = requests.post("https://api.apollo.io/api/v1/people/match", headers=APOLLO, params={"first_name": c["first_name"], "last_name": c["last_name"], "domain": c["company_domain"]}) p = (r.json() or {}).get("person") or {} # Apollo's "verified" goes through your own checker before it can stop the waterfall if p.get("email") and p.get("email_status") == "verified": return [{"email": p["email"], "status": check_email(p["email"])}] return [] def crustdata_email(c): r = requests.post("https://api.crustdata.com/person/contact/enrich", headers=CRUSTDATA, json={"professional_network_profile_urls": [c["profile_url"]], "fields": ["contact.business_emails"], "verified": True}) matches = r.json()[0].get("matches") or [] if not matches: return [] return matches[0]["person_data"]["contact"].get("business_emails") or [] def fullenrich_email(c): # same pattern with FullEnrich's bulk endpoint; results arrive by webhook ... def check_email(email): # call your email checker here and map its answer to deliverable, catch_all or invalid ... def find_work_email(c, sources, log): fallback = None for name, lookup in sources[:3]: # at most 3 sources per field for e in lookup(c): log.append({"contact": c["id"], "field": "work_email", "source": name, "email": e["email"], "status": e["status"]}) if e["status"] == "deliverable" and domain(e["email"]) == c["company_domain"]: return e["email"], name, "deliverable" # stop if e["status"] == "catch_all" and fallback is None: fallback = (e["email"], name, "catch_all_risky") return fallback or (None, None, "not_found")
import requests CRUSTDATA = {"authorization": "Bearer YOUR_CRUSTDATA_KEY", "x-api-version": "2025-11-01"} APOLLO = {"x-api-key": "YOUR_APOLLO_KEY"} def domain(email): return email.split("@")[-1].lower() def apollo_email(c): r = requests.post("https://api.apollo.io/api/v1/people/match", headers=APOLLO, params={"first_name": c["first_name"], "last_name": c["last_name"], "domain": c["company_domain"]}) p = (r.json() or {}).get("person") or {} # Apollo's "verified" goes through your own checker before it can stop the waterfall if p.get("email") and p.get("email_status") == "verified": return [{"email": p["email"], "status": check_email(p["email"])}] return [] def crustdata_email(c): r = requests.post("https://api.crustdata.com/person/contact/enrich", headers=CRUSTDATA, json={"professional_network_profile_urls": [c["profile_url"]], "fields": ["contact.business_emails"], "verified": True}) matches = r.json()[0].get("matches") or [] if not matches: return [] return matches[0]["person_data"]["contact"].get("business_emails") or [] def fullenrich_email(c): # same pattern with FullEnrich's bulk endpoint; results arrive by webhook ... def check_email(email): # call your email checker here and map its answer to deliverable, catch_all or invalid ... def find_work_email(c, sources, log): fallback = None for name, lookup in sources[:3]: # at most 3 sources per field for e in lookup(c): log.append({"contact": c["id"], "field": "work_email", "source": name, "email": e["email"], "status": e["status"]}) if e["status"] == "deliverable" and domain(e["email"]) == c["company_domain"]: return e["email"], name, "deliverable" # stop if e["status"] == "catch_all" and fallback is None: fallback = (e["email"], name, "catch_all_risky") return fallback or (None, None, "not_found")
import requests CRUSTDATA = {"authorization": "Bearer YOUR_CRUSTDATA_KEY", "x-api-version": "2025-11-01"} APOLLO = {"x-api-key": "YOUR_APOLLO_KEY"} def domain(email): return email.split("@")[-1].lower() def apollo_email(c): r = requests.post("https://api.apollo.io/api/v1/people/match", headers=APOLLO, params={"first_name": c["first_name"], "last_name": c["last_name"], "domain": c["company_domain"]}) p = (r.json() or {}).get("person") or {} # Apollo's "verified" goes through your own checker before it can stop the waterfall if p.get("email") and p.get("email_status") == "verified": return [{"email": p["email"], "status": check_email(p["email"])}] return [] def crustdata_email(c): r = requests.post("https://api.crustdata.com/person/contact/enrich", headers=CRUSTDATA, json={"professional_network_profile_urls": [c["profile_url"]], "fields": ["contact.business_emails"], "verified": True}) matches = r.json()[0].get("matches") or [] if not matches: return [] return matches[0]["person_data"]["contact"].get("business_emails") or [] def fullenrich_email(c): # same pattern with FullEnrich's bulk endpoint; results arrive by webhook ... def check_email(email): # call your email checker here and map its answer to deliverable, catch_all or invalid ... def find_work_email(c, sources, log): fallback = None for name, lookup in sources[:3]: # at most 3 sources per field for e in lookup(c): log.append({"contact": c["id"], "field": "work_email", "source": name, "email": e["email"], "status": e["status"]}) if e["status"] == "deliverable" and domain(e["email"]) == c["company_domain"]: return e["email"], name, "deliverable" # stop if e["status"] == "catch_all" and fallback is None: fallback = (e["email"], name, "catch_all_risky") return fallback or (None, None, "not_found")
The sources list comes from the spec. For a US contact, it reads [("apollo", apollo_email), ("crustdata", crustdata_email), ("fullenrich", fullenrich_email)].
What do I do with catch-all emails?
Hold a catch-all email as a fallback and send to it only when no source finds a deliverable address. A catch-all domain accepts mail for any address you throw at it, which is why ZeroBounce notes these emails are impossible to validate without sending a real email and waiting for a bounce.
Vendors treat them differently, and that’s exactly why the rule belongs in your code and not in someone else’s:
Clay counts catch-all emails as valid by default. A setting lets you mark only "Safe to Send" emails as valid.
FullEnrich charges 1 credit for a catch-all email. It bills the same for deliverable and high-probability ones (credits).
Tag these addresses catch_all_risky in the CRM so your sequencer can treat them apart. One commenter in an r/gtmengineering thread on bulk email verification suggests putting them in a lower-priority segment with capped sends. And an outbound lead at a B2B SaaS company told us one vendor’s “verified” label was counting catch-all addresses as verified, which is the sort of thing you’d much rather catch in your own rule than in your bounce rate.
What if an address doesn't match the employer's domain on file?
Claude decides whether an address at an unknown domain belongs to the person's employer. Your code's domain check fails on companies with two domains, a parent company's domain or a new name. Send Claude the profile and the company's known domains, and it keeps the address only when the domain clearly belongs to the current employer.
In our team's test of 20 sales leaders, two people came back with two deliverable addresses at their own employer. One had the .com and .io versions of the company's domain, and one had two formats of the same name. Keep the address that matches the format the company's other contacts use, and log the second one.
Check the domain before you stop, every time. An address at a former employer's domain can still pass a deliverability check while the person works somewhere else.
How do I handle phone numbers, which can't be verified before you dial?
Stop the phone waterfall on the first mobile number, and judge each source later by connect rate. Two published details shape the phone step:
Crustdata returns a line type for each number. Request contact.phone_numbers, and each entry in phone_numbers_info carries a type of mobile, home, work or other (contact enrich docs).
Apollo sends phone numbers later, to a webhook. A webhook_url is required with reveal_phone_number, and the numbers arrive after the main response (people enrichment).
Put Apollo's phone step at the end of the order, because your waterfall has to wait for its webhook before it knows whether to go on. A sales lead at a software testing company summed up the gap for our team: "Email address you can verify very easily." Then: "For phone number it is not possible."
Step 4: How do I log which source supplied each field?
Write one log line per field per source, misses included, because the weekly review counts hit rate and cost by source from it. A line looks like this:
{"contact_id": "003Hs00000xYz", "field": "work_email", "source": "crustdata", "status": "deliverable", "credits": 1.5, "stopped": true, "checked_at": "2026-01-15T10:14:00Z"}
{"contact_id": "003Hs00000xYz", "field": "work_email", "source": "crustdata", "status": "deliverable", "credits": 1.5, "stopped": true, "checked_at": "2026-01-15T10:14:00Z"}
{"contact_id": "003Hs00000xYz", "field": "work_email", "source": "crustdata", "status": "deliverable", "credits": 1.5, "stopped": true, "checked_at": "2026-01-15T10:14:00Z"}
The log is easily the least glamorous part of the build, and it’s also the one we’d miss first if it weren’t there. A buyer at a mobile-data company told us they couldn’t see how their credits were being used, and a log like this is the fix. Three rules keep it useful:
Log the credits each call reported: Crustdata returns the cost of every call in an X-Credits-Used header (pricing). Store the vendor's own credit count, and convert to dollars later on your own contract prices.
Key every line on the profile URL: one person often sits in the CRM twice, and the profile URL is how you spot the second copy.
Skip contacts you've enriched recently: before a lookup, check the log for a deliverable result on the same person in the last 90 days, and reuse it.
Step 5: How do I choose the order?
Put the source with the most verified emails per dollar first, then order the rest by how many extra verified emails each one adds on your own list. Three numbers decide it:
Hit rate on your list: the share of contacts where the source returns a deliverable email at the current employer's domain.
Cost per hit: what a found email or mobile costs, in that vendor's credits and in your contract's dollars.
Bounce rate after sending: the real test of accuracy, measured by your sequencer weeks later.
The published prices per hit:
Source | Work email found | Phone found | Nothing found | Source page |
|---|---|---|---|---|
Crustdata contact enrich | 1 credit, plus 0.5 with verified: true | 2 credits for phone numbers of any line type | Free | |
Apollo people match | 1 credit | 8 more credits for a mobile | Free when no data is found. A matched person with no email still costs 1 credit | |
FullEnrich | 1 credit, including catch-all | 10 credits for a mobile | Free |
A credit costs a different amount at each vendor, so compare dollars on your own contracts. Crustdata credits cost $0.30 to $0.01 per credit, lower depending on plan.
The order decides two things. First, it decides how many contacts each source is billed for: source 1 sees every contact, and each later source sees only the contacts the earlier sources missed, so a source that bills matches without an email costs least near the end, unless you've already paid for its credits.
The second is whose answer gets accepted first. If source 1 returns a deliverable address at a former employer and your code checks only the status, the waterfall stops there and source 2 is never asked.
How do I test which source adds the most?
Send the same 200 contacts through each source alone, then count each source's extra verified emails. A recruiting firm owner described the same test to our team, telling Claude to use only one source at a time on the same people.
Source | Deliverable emails on its own | Extra deliverable emails after source 1 | Credits spent |
|---|---|---|---|
Source 1 | your count | not applicable | your count |
Source 2 | your count | your count | your count |
Source 3 | your count | your count | your count |
The middle column is the one that decides the order. A source that finds 120 of the 200 on its own but adds only 6 after source 1 belongs last, or out of the waterfall.
How do I review the order after a week?
Total the bounces and connects by source in code, then have Claude read the bounce replies. The AI sales platform behind the running example described a similar loop, where an agent compares bounces and connects with the usual rate after a week and suggests changes to the order.
The review has two parts:
Your code computes the rates: bounce rate and connect rate per source come from your sequencer and dialer, with the number of contacts behind each, plus the cost per deliverable email.
Claude reads the replies: bounce and auto-reply text says why an address failed, such as a mailbox that no longer exists or a person who left. Claude groups those reasons by source and proposes one change to the order.
Make the change yourself, though, and only when there’s enough behind it. A source with 30 contacts behind its bounce rate hasn’t earned a move yet.
When is one source enough?
One source is enough when a second source adds only a handful of deliverable emails on your own list. If source 2 adds 6 deliverable emails to a 200-contact test, it reaches 3% more of the list, and there’s something slightly humbling about building a three-source waterfall only to find that the second source is doing 3% of the work.
If source 2 charges nothing without a result, those 6 cost only its price per hit, plus any catch-alls it bills for. A source that bills matches without an email, as Apollo does, also charges for the contacts it sees and misses. Against those extra emails, you weigh one more contract and one more integration to maintain.
Drop the second source when it adds only a handful of deliverable emails after the first, checked on at least 200 contacts. Keep the waterfall in three cases:
Phones matter: your reps call, and source 1 leaves mobiles missing. A sales lead at a software testing company told our team phones are why they can't drop their second source.
Your list spans regions: US and UK contacts need different sources in the running example and routing by country is one of the reasons buyers give us a second source.
You've paid for credits elsewhere: credits you've already bought are spent either way, so use them before you buy more.
A recruiting search firm asked us outright whether there’s still a need for a waterfall at all. Managing many sources has a cost of its own too, and a startup buyer told us they were tired of managing a whole bunch of providers.
How do I push results to Salesforce or HubSpot without a native integration?
Send finished records to a webhook in n8n or Zapier, then create or update each contact by email. The flow for a batch looks like this:
Start the batch with a webhook: Crustdata's batch contact enrich takes up to 300 profile URLs per job and calls a webhook_url when the job finishes (batch docs). Results come as a gzipped file, and the link lasts 5 days.
Catch it in n8n or Zapier: n8n's Webhook node starts a workflow, and Zapier's Catch Hook does the same. n8n gives each webhook a test URL and a production URL, so switch to the production one before you go live.
Finish the waterfall in the workflow: contacts with no deliverable email go on to your next source from inside n8n.
Create or update by email: n8n's Salesforce node and HubSpot node both create a contact or update the one that exists. HubSpot's API also takes batch upserts by email, up to 100 records at a time.
Write the source and status to two custom CRM fields, such as email_source and email_status, so your reps can see a catch-all address before they send to it. To keep those contacts accurate after the first push, see our guide to a CRM enrichment workflow that stays up to date.
How do I connect it to Claude?
Claude Code and the Claude API both reach the same sources, so the choice is mostly about how far along you are. Use Claude Code for a first test and the API for a product build.
Option A: Claude Code with MCP servers
MCP is the protocol Claude uses to call outside tools. Add Crustdata's MCP server from your terminal, then run /mcp inside Claude Code, pick crustdata and sign in (MCP docs):
claude mcp add --transportclaude mcp add --transportclaude mcp add --transportAdd your other sources as MCP servers where the vendor offers one, or as small scripts Claude can call. Claude Code adds remote servers the same way (Claude Code MCP docs). Add --scope project to share the setup with your team through a committed .mcp.json.
Then give the waterfall its own skill, a file at .claude/skills/contact-waterfall/SKILL.md:
Our guide to automating lead enrichment with Claude builds a similar skill for company and people enrichment.
Option B: The Claude API with tool use
Keep the lookups in your own code, and call Claude with tool use only for the contacts that need judgment.
Give Claude one tool, search_people, that takes a name and a company and returns each candidate's title, location and profile URL. Claude asks for the tool, your code calls the people search and sends back the result, and the loop ends when Claude returns its pick as JSON.
Put the identity rule from Step 2 in the system prompt. Use the same pattern for addresses at an unknown domain and for reading bounce replies.
How much does a contact enrichment waterfall cost?
You pay each source for the emails and phones it finds, plus Claude tokens for judgment calls. The per-hit prices are in the Step 5 table.
The identity search adds little. It costs 0.03 credits per result, plus 0.1 for filtering on experience fields and 0.1 for returning them, so 0.23 per result for the Step 2 body (pricing).
How can I cut the bill?
Ask only for the fields you'll use, and only for the contacts who need them:
Request one contact type at a time: Crustdata bills per type, so contact.business_emails alone costs 1 credit, where all three types cost 5 (contact enrich docs).
Ask for mobiles only above a title cut-off: In the spec above, only VPs get a phone lookup.
Put sources that bill for catch-all later: a catch-all result costs 1 credit at FullEnrich and doesn't stop a deliverable-only waterfall.
Reuse recent results: check the log before every lookup.
Your account's own Crustdata rates come back from GET /account/endpoints, which is free (pricing).
Where do I start this week?
Start with the spec and the identity step, then add sources one at a time, because the temptation is to wire up all three vendors on day one and we’d gently advise against it. A good order is:
Write waterfall.md with Claude asking the questions, and agree the stop rule before anything else.
Resolve 200 contacts from your CRM to profile URLs, and read every one Claude flags.
Send the 200 through each source on its own and fill in the Step 5 table.
Set the order from the table, connect the n8n workflow to a CRM sandbox, and review the log after a week.
A free Crustdata account covers the people search step. The contact lookup is on enterprise plans (pricing). You can start on a free account or book a demo at crustdata.com.
Contact enrichment waterfall FAQ
If one source doesn't have an email, does the waterfall keep going?
A waterfall moves on whenever a source returns no deliverable address at the employer's domain. It stops at the limit in your spec. Treat a timeout or a rate-limit error as an error and retry it. Otherwise you end up paying the next source for an email the first one would have found. Apollo returns a 429 response past its rate limit.
Do I need catch-all verification?
Catch-all verification can sort some catch-all domains, but it can't confirm a single mailbox. ZeroBounce, for example, returns accept_all for domains it has vetted as historically delivering, and catch-all for the rest (ZeroBounce status codes). Ask your checker whether it makes that split, because accept_all addresses are safer to send to.
Are phone numbers verified?
Phone numbers can't be verified before you dial, so log what the dialer records after each call. Store the call outcome, such as connected, wrong number or disconnected, next to the source of the number. After a few hundred dials, those outcomes show which source to trust for phones.
If an email hard bounces, do I get the credit back?
Credits are spent when a lookup returns data, so agree bounce terms with each vendor.
Apollo, FullEnrich and Crustdata all bill at lookup time (Apollo, FullEnrich, Crustdata). Keep the source of every address in your log, so you can show a vendor the bounces their addresses caused.
If I want to push the results to HubSpot, is that another prompt in Claude?
For a one-off list, you can ask Claude to write a CSV for HubSpot's import. For a standing flow, use the webhook path above, so contacts reach HubSpot without anyone opening Claude.
How is this different from a Clay waterfall?
A Clay waterfall lives inside Clay's tables, with its own validation step (Clay University). Clay also refunds credits when a provider finds nothing. A waterfall in Claude uses your own code and API keys. Pick Clay if your team works in Clay tables every day.
