Terminal
Terminal/Skill
Finds and verifies a person's work email from their name and company or LinkedIn URL, rejecting role addresses and guessed patterns.
By Clay
Works with
npx skills add clay-run/clay-skill-creator --skill find-work-emailThe insight that separates this from typing first.last@company.example and hoping: found is
not the same as sendable. A pattern-guessed or unverified address burns sender reputation
when it bounces. So verification is part of the find, not an afterthought — and an honest
"not found" beats a fabricated address every time. And the deeper version of the trap: on a
catch-all domain, verification itself lies — the domain answers "deliverable" for every
address, real or invented, so a validator can neither confirm nor deny the mailbox. Those
domains need a different find, not a stronger validator.
Nothing here ships with a value. Each one is the installer's, not the author's: ask for it, never substitute a plausible default, and where an answer does not exist say which step becomes unavailable rather than guessing. Where a default IS defensible it is named below, and using it means saying so in the output.
| Input | What the installer supplies | If it is missing |
|---|---|---|
| What they have per row | a profile URL plus name, a name plus domain, or a name plus company name only | no default. Quality descends in that order, and the third route resolves the domain first — a wrong domain poisons every lookup, silently |
| A known personal email | if they have one | optional, and it raises the waterfall's hit rate. Pass it through when present |
| Cost ceiling | credits, and whether misses are acceptable | state per-row cost before running, and say plainly that a waterfall bills for attempts, not only for hits |
If an answer sheet is present beside this skill, load it and ask only for what it does not cover. A partial sheet is normal; a value it is missing gets asked for on its own rather than restarting the interview. Say which values came from the sheet before using them — a sheet applied silently is a wrong field nobody catches. If there is no sheet, say nothing about sheets — the check is a file lookup, not a question, so run the interview as though the feature did not exist rather than reporting an absence. At delivery, offer to save the answers back (identifiers only — never a token or a password), private and never published — and phrase the offer so it explains itself: "want me to save your answers to a file, so the next person on your team doesn't have to answer these again?"
Run clay whoami; echo "exit_code=$?". If it fails or Clay tools are missing, run the Clay
plugin's setup skill (or follow
https://raw.githubusercontent.com/clay-run/agent-plugins/main/GETTING_STARTED.md), restart
the agent if setup says to, and re-run this skill. Tell the user which workspace you're in.
Best → worst input quality:
A personal email, if known, improves the waterfall's hit rate — pass it through.
Screen the domain before the first paid lookup — a domain that fails here costs nothing and poisons nothing downstream:
not found (dead domain) free, skip every paid step. Null MX (a single record
0 .) → the domain declares it takes no mail — same verdict, even though a record
"exists". Real MX → proceed.blocked: trap domain — never find, never email. These
are honeypots; one send can burn the sender's whole domain reputation.Use the workspace's managed Work Email function (confirm it exists with
clay routines list / get — never promise a function you haven't confirmed). It cascades
providers and stops at the first valid result. Check its estimatedCreditCost and the
workspace balance (clay credits); for anything beyond a handful of lookups, state the
total cost and get explicit approval first.
clay routines runs start, or the Clay
MCP). The CLI input envelope is {"items":[{"id":"<your-key>","inputs":{...}}]} piped via
--input -; discovery note — clay routines list paginates and can omit managed
functions, but clay routines get function:<id> fetches any of them directly.Set time expectations: a hit returns in seconds (the waterfall stops early), but a not-found takes minutes — the cascade exhausts every provider before giving up. A batch containing bad rows finishes at the speed of its misses.
Detect it cheaply: run a validator (~0.1 credits, catalog action) on the found address —
ZeroBounce status: valid + sub_status: catch_all, or Enrichley result: catch_all,
marks the domain, not just the address. (A deliberately-invalid probe like
test1234@ + domain validating as deliverable is the same diagnostic — the one place this
skill ever constructs an address, and it never ships: probes diagnose domains, only found
addresses ship.) One trap verified live: catch-all is a per-validator verdict, not a
domain fact — one validator resolved a specific mailbox as not-found on the very domain
another graded catch-all. Stay inside one validator's vocabulary end to end: detect with
the same validator whose mailbox probe you'll use for recovery, and never read one
validator's catch-all verdict into another's fields.
On a catch-all domain the normal machinery breaks in both directions: validator-interleaved find arms discard real addresses (every candidate comes back "unconfirmable"), and naive acceptance blesses bounces. The production answer is a dual track, not a caveat:
result: catch_all_validated means confirmed live (ship as valid, probe-confirmed);
plain catch_all stays unconfirmable. This recovers a meaningful share (production
builds see 20–40%) of addresses the interleaved track would have thrown away.valid / valid, catch-all (probe-confirmed) / catch-all (found, unprobed — risky)
so the send side can throttle instead of treating all addresses alike.Checking a single address you already have is verify-email-deliverability's job — this
branch exists because on catch-all domains the find itself changes shape.
Before shipping, check that the local-part plausibly belongs to the person — a provider
that returns info@company.example for "Jordan Lee" found the company, not the person:
jordan.lee, jlee, jordanl, jordan — → pass.rejected: role address, never ship it in
the email column.first.last@domain) —
that's fabrication with a bounce risk attached. And know the shape: a no-hit run returns
status: complete with an empty result object — completion is not data; gate on the
presence of an actual address.info@, sales@…)
as a person's email.Per person: name · company domain · email · status (valid / valid, catch-all probe-confirmed / catch-all risky / rejected: role address / not found / blocked: dead or trap domain) · source (track + provider), plus what identified them (LinkedIn URL or
name+domain). For multi-person runs, add a summary line: found-valid %, probe-confirmed %,
risky %, rejected %, not found %.
Ask: "Get me a verified work email for Jordan Lee at northfield.example."
MX check: real records — proceed. Work Email function with full name + domain (+ LinkedIn
URL if on file) → waterfall stops at the second source, verification passes, local-part
jordan.lee matches the contact → jordan.lee@northfield.example · valid · source: managed waterfall.
Catch-all case: "and Casey Park at initech-consulting.example" — the found address validates
as catch_all: the domain accepts everything. Switch tracks: validator-free find pass
returns casey.park@initech-consulting.example; Enrichley mailbox probe →
catch_all_validated → valid, catch-all (probe-confirmed) · source: catch-all track + provider name. Had the probe stayed catch_all, the address ships flagged risky — the
user decides.
Counter-example: "someone called Alex at initech-consulting" → resolve domain first; the
waterfall returns only info@initech-consulting.example → rejected: role address, and with
nothing person-matched left → report not found — do not offer
alex@initech-consulting.example as a fallback.