Contact emails.
Graded on who published them.
The public address a website, social profile or YouTube channel publishes — as JSON, with the page it came from and a confidence grade you can check yourself.
Trusted by developers shipping real products.
2,561,010 served today
Request
$ curl -X POST \ https://api.fetchlayer.dev/email-finder/find-email \ -H "Authorization: Bearer ss-your-key" \ -H "Content-Type: application/json" \ -d '{"target":"python.org"}'
Response
{
"email": "psf@python.org",
"confidence": "high",
"emailSource": "website",
"sourceUrl": "https://www.python.org/about",
"onTargetDomain": true,
"status": "EMAIL_FOUND",
"complete": true, "incomplete": [],
"pagesCrawled": 16, "pagesFetched": 1
} Built for feedback workflows
Fetch the public signal. Use it wherever your team works.
One field in, a contact address out
Send a website, a social profile or a YouTube channel — nothing else to configure, and nothing to set up on the target's side. Back comes the public contact address that target publishes, the page it was read off, and how far to trust it.
Confidence graded on who published it
An address the target published on its own pages can grade high. An address found elsewhere cannot, however right the domain looks — stripe.com returned a genuine @stripe.com address found off Stripe's own pages and graded medium. That rule is what rules out a plausible address on a perfect domain that belongs to nobody.
Every grade is checkable
sourceUrl is the exact page the address was read off, and emailSource says how it relates to the target. You never have to take a grade on faith — open the page and see for yourself.
Triage a list before you spend on it
resolve-target normalises a target, says what kind it is and lists what a lookup would examine — fetching nothing and costing nothing. Sort a pasted list first, then spend lookups only where they are worth it.
Two MCP tools
Both routes are tools on the FetchLayer MCP server, so an agent can look up a contact mid-conversation and hand you the confidence grade and the source page with it, billed exactly like REST.
A clear answer when there is no address
Plenty of targets — large companies especially — publish no contact address anywhere. When that is the case you get a straight answer saying so, with a note naming what was examined, rather than a guessed address or a blank you have to run again. A target that genuinely could not be read comes back as a retryable error instead, so the two are never confused.
Turn a list of companies into a list you can act on.
Prefer not to write code? Paste the list into FetchLayer Research Chat and get a table back — with the targets that publish nothing marked plainly, rather than filled in with a guess.
- ✓Ask questions in plain English
- ✓Analyze themes, sentiment, and pain points
- ✓Download the structured results as CSV or JSON
No code or setup required · Uses your FetchLayer credits
Find the public contact email for each of these 40 companies. Tell me which ones publish nothing, and flag any address that was not published on the company's own pages.
Twenty-three publish an address on their own pages. Nine publish nothing at all — that is a real answer for each of them, not a miss. Six turned up an address elsewhere on the web, flagged medium or low with the page it came from so you can check it. Two could not be read and are worth retrying.
contact-addresses.csv
40 companies · 7 columns · ready to download
Solutions
Build the workflow around the feedback.
Find the businesses first
Search places with address, phone, website and rating, then turn each website into a contact.
Explore →Find who is hiring
Public freelance postings with budgets, skills and the clients behind them.
Explore →A creator’s whole outbound surface
Read a link page and follow every link to where it really lands.
Explore →From raw feedback to action
One request is the start of the workflow.
Store the structured response, run it on a schedule, pass it to an LLM, or feed it into the system your team already uses. FetchLayer handles retrieval so you can focus on the outcome.
- 01
Send a target
A bare domain, a social profile URL or a YouTube channel. One field, no configuration, and nothing to set up on the target's side.
- 02
Read the grade, not just the address
confidence tells you how far to trust it, emailSource and onTargetDomain tell you why, and sourceUrl lets you check it in one click. High means the target published it themselves.
- 03
Take the "no" as an answer
NO_EMAIL_LISTED with complete: true is a finished result — the target publishes nothing. Move on rather than re-running it. Keep your retries for the 503s, which are the ones that really could not be read.
One command.
Your agent does the rest.
Use the Email Finder endpoint directly from your MCP-compatible agent. Ask it to retrieve public feedback, identify patterns, and turn the result into a useful brief without writing integration glue.
1 Run one command, then sign in
$ npx fetchlayer
◇ Agents
│ Claude Code and Codex
◇ Signed in as you@company.com
◇ Connected
│ ✓ Claude Code ✓ Codex
It opens a sign-in page in your browser. New here? Signing in creates your free account.
2 Ask
›What's the contact email for python.org?
fetchlayer.email_finder_find_email
psf@python.org, graded high — published on the target’s own about page, which is the only way an address earns that grade. The search finished complete, with nothing left unchecked. If you want it verified by eye, sourceUrl points straight at the page.
No key to copy and nothing to install. New accounts are free, with no credit card.
Use cases
What teams build on an address they can trust.
One target in, one graded answer out — including the answer that there is nothing to find.
Lead list enrichment
One domain in, one graded address out — with the page it came from, so a rep can check it before sending rather than trusting a score.
Clean negative results
A target that publishes nothing comes back saying so, definitively. That is what lets you close a row out instead of re-running it every quarter.
Creator and partner outreach
Turn a YouTube channel or a social profile into a contact, with the grade and the source page attached so a low-confidence hit is treated as a lead, not a fact.
Deliverability protection
Sending to a plausible address nobody reads costs you reputation. Grading on who published an address is what keeps invented-looking addresses out of a send.
Local business outreach
Pair with a places search: find the businesses, then turn each website into the address it actually publishes, and see which ones publish none at all.
Data quality audits
Re-check a CRM against what targets publish today, and flag the rows whose address was never published by the company in the first place.
Compare approaches
Spend time on the insight, not the collection layer.
| What you need | FetchLayer | Official API | Build it yourself |
|---|---|---|---|
| Confidence graded on who published it | ✓ | n/a | You judge by domain |
| Source page returned with every address | ✓ | n/a | You track it |
| "Publishes nothing" vs "could not read" | ✓ | n/a | One failure bucket |
| Partial answers marked as partial | ✓ | n/a | You would not know |
| Ready for AI and MCP workflows | ✓ | n/a | Your integration |
FetchLayer provides access to publicly available data. It is not affiliated with, endorsed by, or sponsored by the platform.
Start free. Scale when ready.
Try it free, buy credits as you go, or take a monthly plan when your volume is steady.
Free
$0
30 requests
Enough to call the platforms you care about and read real responses before you pay anything.
- Every platform and endpoint
- REST and MCP
- No credit card
Pay as you go
$1.99
per 1,000
Buy credits when you need them. They stay on your account until you use them.
- Credits never expire
- No monthly commitment
- Same access as subscribers
- ∞ req/min, ∞ API keys
Monthly plan
Starter$25
per month
15,000 requests a month, about 500 a day.
$1.67 per 1,000, $5 less than credits each month
- ∞ req/min, ∞ API keys
1 page fetched is 1 credit
A normal call reads one page. Ask for more pages and each one is one more credit.
The same on every platform
No multiplier for harder targets, and no charge per result returned.
Nothing back, nothing billed
If a request does not return usable data, it costs 0 credits.
Not sure which volume fits?
15 minutes with the founder. Tell us the workload, we tell you what it needs.
Guaranteed throughput on the platform you run on
A dedicated platform from $400/mo, plus $500 for each ~21 req/s. Every other platform on the same key. 99.95% uptime, 24-hour support on Slack or Telegram.
API reference
Every parameter, documented.
All requests are POST with a JSON body and Bearer auth header.
POST /email-finder/find-email The public contact address a target publishes, with the exact page it came from and a confidence grade based on who published it. Answers either way: an address, or a plain NO_EMAIL_LISTED with a note naming what was examined.
target* string A website (python.org), a social profile URL, or a YouTube channel. format string 'json' (default) | 'markdown'. Markdown is rendered over MCP; the REST API returns JSON. POST /email-finder/resolve-target Parse a target and see what a lookup would examine, before spending one. Returns the kind of target, the page a lookup would start from and the list of what it would check. Free — it reports pagesFetched: 0.
target* string Any website, social profile URL or YouTube channel. Fields marked * are required. Full API reference →
Guides
Email Finder guides from our blog.
FAQ
Common questions.
What is the Email Finder API?
One endpoint that takes a website, a social profile URL or a YouTube channel and returns the public contact address that target publishes — with the page it was found on and a confidence grade. You send a target with a Bearer token; you get an answer either way, and you always know how good it is.
What does "NO_EMAIL_LISTED" mean? Did it fail?
No — it is a successful answer. It means the search ran and the target publishes no readable contact address. That is the common outcome for large companies, not an edge case: github.com, g2.com and ticketmaster.com all answer this way, each with a note naming what was checked. Stripe publishes a support portal rather than an address. Treat it as the answer it is; do not retry it.
Then how do I tell a real "no" from something going wrong?
They are different HTTP statuses, deliberately. A target that publishes nothing is a 200 with status NO_EMAIL_LISTED. A target that could not be read at all is a 503 — indeed.com returned one in 6.2 seconds, and so did a domain that does not resolve. Retry the 503 and trust the 200. That separation is the whole reason a "no" here is worth anything.
Am I paying for a "not found"?
Yes — one credit, the same as a hit. The search is the work, and it is identical whether or not it turns up an address: the same target is examined either way, and you get back a full account of what was looked at. What you are buying is a definitive answer about a target, not a lottery ticket on one. A "no" you can rely on is worth as much as a "yes" when you are working a list — it is the result that lets you stop.
What does the confidence grade actually mean?
It is graded on who published the address, not on what it ends in. An address the target published on its own pages can grade high. An address found elsewhere cannot, however right the domain looks. python.org returned psf@python.org from the target's own about page and graded high. stripe.com returned an address that genuinely is @stripe.com, found somewhere other than Stripe's own pages, and graded medium — right domain, still not high.
Why does the domain not decide it?
Because a plausible address on a perfect domain can belong to nobody. A lookup once returned jane.diaz@stripe.com at high confidence — Stripe's own fictional demo persona from their checkout examples. Grading on where an address was published rather than on what it ends in is what rules that class of answer out. Every response carries sourceUrl, so you can check the grade against the page yourself.
Which targets work best?
Websites and YouTube channels are the strong inputs — every one measured returned a complete answer. Social profiles are supported too: they can take longer, and may return a partial result, which the response marks as incomplete rather than presenting as whole.
How do I know whether an answer is complete?
Read complete. searched[] lists what was examined, incomplete[] lists anything that could not be finished, and complete summarises the two. A partial answer is always distinguishable from a whole one and from a failed one, without guessing and without inferring anything from how long the call took.
How long does a lookup take?
Between about 10 and 100 seconds, measured across websites, X profiles and YouTube channels. It is driven by how much there is to look through for a given target rather than by the kind of target, so it does not sort neatly by input type. Budget your timeouts against the top of that range and run lookups in the background rather than in a request/response cycle.
What is pagesCrawled for, if it is not the price?
Visibility. It says how big the search actually was — 1 on a target that answers immediately, 65 on one that does not — so you can see the difference in effort between two targets that both cost you one credit. It prices nothing. pagesFetched is the billing figure, and on a completed lookup it is always 1.
Can I check a list before spending credits?
Yes. resolve-target parses a target and tells you what kind it is and what a lookup would examine, without fetching anything and without costing a credit. Run a pasted list through it first to normalise and sort it, then spend lookups only on the ones worth it.
Can my AI agent use it?
Yes. Both routes are MCP tools on the same FetchLayer MCP server: email_finder_find_email and email_finder_resolve_target. Tool calls use the same key and are billed exactly like REST, and the agent sees confidence, sourceUrl and complete, so it can tell you how much to trust an address rather than just handing one over.
Start pulling Public contact addresses today.
Get a free API key, make your first request, and put public feedback to work in your own product or research workflow.
Used by developers at
Individual developers or teams — not official partnerships