How to Build a Lead List Using Claude Skills: The 5-Step Email Finding Process

Source: a cold email agency's internal 5-step process for building verified lead lists at roughly 1 cent per email, distilled from over 20 million cold emails and hundreds of thousands of cold calls sent using this exact method.

The core insight: data providers like Apollo, Prospeo, and Better Contact charge the most per credit specifically for finding a verified email or phone number. If Claude can find the email itself from just a domain and a name, the expensive part of list building disappears. All you need to source cheaply is the company domain and the person's name, which costs a fraction of what the same platforms charge for a fully enriched contact.

5 steps, each with a full copy-paste Claude skill below:

1. Source raw company and contact data cheaply (domain + name only, no email lookup)
2. Filter the list against your ICP before spending anything on email discovery
3. Find or guess the email using Claude instead of a paid enrichment credit
4. Verify every email before sending anything to it
5. Score the finished list before it goes anywhere near a live sending domain

This playbook also pulls in the related list-sourcing skills already documented in the Cold Email Outbound Skills lead mag, since steps 1 and 2 of this process map directly onto that skill set.

Why this process is cheaper than the platforms themselves

Every major enrichment platform (Apollo, Prospeo, Better Contact, Clay) charges usage-based credits specifically when a search actually returns a verified email or phone number. The domain and the name are the cheap part of the data; the email lookup is the expensive part.

This process separates the two. Source domain-plus-name data from a cheap raw source (a Google Maps scrape, a domain list, an Apollo or Prospeo export limited to just names and domains), then let Claude do the actual email-finding step itself using the same logic these platforms use internally: common email patterns, domain structure, and iterative guessing refined against what is publicly knowable about how a company formats its addresses.

Result: roughly 1 cent per found email at 50 to 80% hit rate, versus the same volume costing meaningfully more through a platform's own paid lookup credits.

Model choice matters for cost

Use Haiku for the filtering and email-finding steps on any list of meaningful size. Using Opus or a frontier model for a bulk, repetitive task like this burns through credits fast for no quality benefit; the task itself is pattern-matching and iteration, not complex reasoning.

Sourcing cheaply means pulling only what is publicly available and free-to-cheap: the company domain and the person's name. Nothing else. No email lookup at this stage.

The sourcing options

For local businesses: a Google Maps scraper (via Apify or similar) returning business name, domain, and often an owner or contact name, at a cost of roughly $3 per 1,000 records.

For B2B software or services: Prospeo, Apollo, Clay, or Outscraper, restricted specifically to name-and-domain fields rather than paying for their built-in email lookup.

The raw output at this stage is intentionally minimal: just the company website (the domain) and the first and last name of the target contact. That is the entire cost base for this step.

Skill: /raw-list-source

/raw-list-source

Build a raw lead list at minimum cost: domain and name only, no email lookups.

Source: [Google Maps scraper / Prospeo / Apollo / Clay / Outscraper - specify which]
Search parameters:
- Business type or title: [e.g. marketing agencies, VP Sales, dental practices]
- Location or geography: [city, region, or country]
- Volume: [N records]

Explicitly restrict output fields to only:
- Company name
- Company domain / website
- Contact first name and last name (if available at this stage)

Do not enable or request any email or phone lookup at this step.
Output as raw-leads.csv.

If names are not available at this source, flag which rows are missing a name
so they can be researched separately before the email-finding step.

If names are missing entirely: Claude can research the likely decision-maker name for a given company domain (checking the company's own team or about page, LinkedIn company page, or public leadership listings) before the list moves to filtering.

The 3 related list-building skills for B2B specifically

From the existing Cold Email Outbound Skills library, these three cover the B2B equivalent of step 1 depending on how you already have your target list defined:

/prospeo-full-export: title-first lead search using the Prospeo API, for when you are searching by job title and criteria rather than a pre-existing account list. Handles pagination automatically for exports above 25,000 records.

/blitz-list-builder: domain-first contact discovery, for when you already have a specific list of company domains you want to penetrate and need to find the right contact inside each one.

/google-maps-list-builder: the direct implementation of the Google Maps sourcing method described above, scraping business name, address, phone, website, and review data for local SMB targeting.

Run /icp-prompt-builder before any of these three, since it produces the exact filter string and qualification criteria the other skills need as input.

/icp-prompt-builder

Load my client-profile.yaml.

Produce the ICP search prompt for list building:
1. Exact titles to search (primary list and fallback list)
2. Seniority levels to include and exclude
3. Company size range (employees)
4. Industry or vertical filters
5. Geography filters
6. Technologies or tools they must use (if applicable)
7. The one disqualifier that rules someone out immediately
8. The exact Prospeo filter string to use

Filter before you spend anything on email discovery. There is no reason to pay for an enrichment step (even a cheap one) on a contact you were never going to email in the first place.

Why this step exists before email finding, not after

Claude can use sub-agents to work through an entire raw list, opening each company's website to check for ICP fit, and dropping anyone who does not match. Doing this before the email-finding step means you never spend even the roughly 1-cent cost of finding an email for someone who was never going to be a real prospect. Given lists of thousands of records, this compounds meaningfully.

The filtering step requires one thing to work well: a written, specific set of ICP criteria you can hand to Claude, not a vague sense of who you are targeting. The clearer the criteria, the more accurate the filtering pass.

Skill: /icp-filter-pass

/icp-filter-pass

Filter this raw lead list against my ICP before any email lookup happens.

List file: raw-leads.csv
ICP criteria (be specific, this determines filtering accuracy):
- Company type: [e.g. B2B SaaS, agencies, local professional services]
- Company size: [employee range]
- Industry or vertical: [specific niche]
- Geography: [target region]
- Disqualifiers: [anything that rules someone out immediately, e.g. already a customer, wrong company size, wrong vertical]

For each row:
1. Visit the company website (using the domain field)
2. Check against the ICP criteria above
3. Mark as KEEP or DROP with a one-line reason for each DROP

Model: use a fast, low-cost model for this pass (Haiku or equivalent), not a frontier model.
Output: filtered-leads.csv containing only KEEP rows, plus dropped-leads.csv
with the DROP rows and reasons, so you can spot-check the filtering logic.

Use sub-agents to process the list in parallel batches if the list exceeds 500 rows.

This is the core skill the entire process is built around: Claude finds or guesses the verified email itself, using the same underlying logic every paid email-finder platform runs internally, at a fraction of the cost.

How the email finder actually works

Every commercial email-finding tool works the same way underneath: it generates the most likely email patterns for a given domain (first.last@, firstlast@, first@, f.last@, and so on), checks which pattern the company's existing publicly-known emails follow if any are visible, and iterates through the most probable candidates. This skill runs that same logic directly.

Expect roughly a 50 to 80% hit rate depending on the size and formality of the target companies (larger, more established companies tend to have more predictable, discoverable patterns than very small businesses). Even at the conservative end of that range, the cost per found email stays dramatically below what a platform charges per credit.

Skill: /email-finder

/email-finder

Find or infer the verified email address for each contact in this list.

List file: filtered-leads.csv
Available fields per row: company domain, first name, last name

For each row:
1. Check the company domain for any publicly visible email addresses
   (team pages, about pages, press contacts, footer, privacy policy) to identify
   the company's actual email format if one is discoverable
2. If no pattern is directly visible, generate the most probable candidates
   in this priority order:
   a. first.last@domain
   b. firstlast@domain
   c. first@domain
   d. f.last@domain
   e. flast@domain
3. For each candidate, note your confidence level (high / medium / low)
   based on how many independent signals support that pattern
4. Select the single highest-confidence candidate per contact

Output: prospect-list-with-emails.csv with columns:
company, domain, first name, last name, guessed email, confidence level, pattern used

Flag any row where confidence is low so it can be prioritised for manual
verification or excluded from a first sending batch.

Model: use a fast, low-cost model (Haiku or equivalent) for this step.
This is a pattern-matching and iteration task, not a reasoning-heavy one.

What to do with low-confidence guesses

Do not send to low-confidence guesses without running them through the verification step in Step 4 first. A wrong guess sent at volume is exactly what damages sender reputation and domain health, which is the one real risk this entire cost-saving method introduces if the verification step gets skipped.

This is the one step in the process that is genuinely worth paying for, and the one step you should never skip if you are actually going to send cold email at any volume.

Why verification cannot be skipped

A guessed email, even at high confidence, is still a guess. Sending to invalid addresses at volume causes bounces, and bounces are what burn domain reputation and sending infrastructure, the exact damage that makes future campaigns (even to genuinely good prospects) land in spam. This is the trade-off of the entire cost-saving method: the sourcing and finding steps are cheap specifically because they are probabilistic, and verification is what converts a probabilistic guess into something safe to actually send to.

A dedicated email verification tool (categorising each address as valid, catch-all, unknown, or invalid) is the correct tool for this step rather than trying to have Claude verify deliverability itself, since actual mailbox-level verification requires infrastructure Claude does not have direct access to.

Skill: /verify-and-segment

/verify-and-segment

Process this list through email verification and segment by result.

List file: prospect-list-with-emails.csv
Verification tool: [name your verifier, e.g. a dedicated bulk email verification API]

Steps:
1. Submit all emails for verification via [verifier] API
2. Retrieve results and categorise each row: valid, catch-all, unknown, invalid
3. Split into separate output files:
   - valid-leads.csv (safe to send to directly)
   - catch-all-leads.csv (deliverable but higher risk, review before sending)
   - unknown-leads.csv (hold, do not send without additional verification)
   - invalid-leads.csv (discard or attempt an alternate email pattern)
4. For invalid-leads.csv: attempt one additional email pattern per contact
   (from the priority list in the email finder step) before discarding

Return a summary: total processed, count and % in each category,
and the final safe-to-send count.

Use [YOUR_VERIFIER_API_KEY] from .env.

The final gate before a list touches a live sending domain. Catching a bad list here is dramatically cheaper than catching it after it has already damaged your sender reputation.

Skill: /list-quality-scorecard

From the Cold Email Outbound Skills library. Grades a finished lead CSV across 8 dimensions before it goes anywhere near a sending platform, giving one final structured check on top of the verification step in Step 4.

/list-quality-scorecard

Grade this lead list before I upload it.

List file: valid-leads.csv
ICP criteria: [load from client-profile.yaml]

Score across 8 dimensions:
1. Email validity: % with valid email format
2. Title match: % where title matches my ICP criteria
3. Company size fit: % within my target size range
4. Geography match: % in my target geographies
5. Duplicate rate: % that are duplicates of each other or my existing database
6. Missing fields: % with missing name, company, or email
7. Role seniority: % at Director level or above
8. Domain health: % on domains not flagged as high-bounce risk

Return:
- Score per dimension (0-100)
- Overall list grade (A/B/C/D/F)
- The top 3 issues to fix before uploading
- Whether this list is safe to use as-is or needs cleaning first

Only a list scoring a B grade or above on this scorecard should move to a live sending platform. A C grade or below should go back through Steps 2 to 4 rather than being used as-is.

Two related list-expansion skills worth having in the same folder

For when a validated ICP list needs to be expanded beyond the obvious first pass, from the same library:

/disco-like: lookalike company discovery from a seed list of your best-fit customers, for expanding a list once the obvious targets are exhausted.

/competitor-engagers: finds people actively engaging with competitor LinkedIn content, arguably the single strongest buying-window signal available, since someone commenting on a competitor's product post is actively researching your exact category right now.

/disco-like

Find lookalike companies for my ICP.

Seed: [paste 5-10 domains of your best-fit customers OR describe your ICP in plain language]

Find [N] companies similar to these. For each company:
1. Company name and domain
2. Why it matches: what makes it similar to my seed list
3. Size estimate (employees)
4. Geography
5. Whether I have already contacted them (check against [existing leads CSV])

Exclude any company already in my leads database.
Output as lookalike-companies.csv ready for the sourcing step.

---

/competitor-engagers

Find people engaging with competitor content on LinkedIn.

Competitor LinkedIn profiles to monitor: [list URLs]
Posts to scrape: [recent posts showing product features, pricing, or use cases]

For each post:
1. Scrape all commenters and reactors
2. Filter for ICP matches (load client-profile.yaml for criteria)
3. Find verified email for each ICP match
4. Return: name, title, company, email, LinkedIn URL, which post they engaged with

Output as competitor-engagers.csv.
For outreach: the connection note should reference the specific post they engaged with.

The full 5-step pipeline, every skill in order, one process.

The full pipeline, run in order

# STEP 1: Source cheaply (domain + name only, no email lookup)
/icp-prompt-builder          # produces the exact filter criteria first
/raw-list-source             # or /prospeo-full-export, /blitz-list-builder,
                              # /google-maps-list-builder depending on source

# STEP 2: Filter against ICP before spending anything on email discovery
/icp-filter-pass

# STEP 3: Find or guess the email (the core cost-saving skill)
/email-finder

# STEP 4: Verify every email before it goes anywhere near a sending domain
/verify-and-segment

# STEP 5: Final quality gate
/list-quality-scorecard

# OPTIONAL: expand the list once the obvious targets are exhausted
/disco-like
/competitor-engagers

The economics, end to end

Step	Typical cost	What you are paying for
1. Source	~$3 per 1,000 records	Domain and name only, no email lookup
2. Filter	Model tokens only (use Haiku)	Dropping non-ICP contacts before any email cost
3. Find email	Model tokens only (use Haiku)	Claude finding/guessing the email instead of a paid credit
4. Verify	Verification API cost, per email	Confirming deliverability before sending
5. Score	Model tokens only	Final safety gate before live sending

Total effective cost per found, verified email: roughly 1 cent, versus the meaningfully higher per-credit cost of finding the same verified email through a platform's own built-in lookup.

What to build first if starting from nothing

Write your client-profile.yaml (or equivalent ICP definition file) first. Every skill in this pipeline reads from it. Without a specific, written ICP, the filtering step in particular produces inconsistent results regardless of how good the underlying skill logic is.

Then run the pipeline once, end to end, on a small test batch (50 to 100 records) before scaling to a full list. Confirm the hit rate and the filtering accuracy on a batch you can manually spot-check before trusting the same pipeline on a list in the thousands.