Give us a first name, last name, and company domain. GTMData tests 16 naming conventions via real SMTP verification and returns the first confirmed match. No guessing, no databases of scraped emails -- every result is verified at the mail server.
curl -X POST https://api.gtmdata.co/v1/find \
-H "Authorization: Bearer gtm_live_..." \
-H "Content-Type: application/json" \
-d '{"first_name":"Tim","last_name":"Cook","domain":"apple.com"}'
{
"email": "tcook@apple.com",
"status": "valid",
"provider": "other",
"convention": "flast",
"confidence": 1
}One API call. Name in, verified email out. See the full API reference for details.
Most email finders guess an address and hope for the best. GTMData takes a fundamentally different approach: we test every possible email convention against the actual mail server before returning a result.
We first check if we already know the naming convention for the domain. If apple.com uses flast, we skip straight to verifying tcook@apple.com.
If the convention is unknown, we generate all 16 possible email patterns from the name you provide: first.last, flast, firstl, and 13 more.
Each candidate email is verified via a real SMTP handshake with the mail server. We connect, issue RCPT TO, and confirm the mailbox exists.
When we find a match, we store the convention for that domain. Next time someone queries the same domain, the lookup is nearly instant.
Most email finder tools maintain a static database of previously scraped email addresses. When you query for someone, they simply look up what they already have. If the person changed jobs, or was never in the database to begin with, you get nothing -- or worse, a stale, bouncing email. GTMData does not rely on a database of emails. Every single lookup performs a live SMTP verification against the target mail server. This means you get real-time results, not cached data from months ago. The email we return has been confirmed to exist at the exact moment you requested it.
Built for sales teams, recruiters, and growth engineers who need verified email addresses at scale.
Every email we return has been confirmed via SMTP handshake. We connect to the mail server, verify the mailbox exists, and only then return the result. Zero guessing. Zero stale database lookups.
From first.last to flast to last_first and everything in between. We test all 16 common B2B email conventions so you never miss a valid address just because the company uses an unusual pattern.
Every successful lookup teaches us the convention for that domain. The next query for the same company skips straight to the right pattern, returning results faster and using fewer server connections.
Catch-all domains accept any email address, making verification tricky. GTMData uses SMTP timing analysis and convention matching to assess whether a catch-all email is genuinely in use.
Not found? No charge. Catch-all with low confidence? No charge. You only spend 1 credit when we return a valid or valid_catchall result. Failed lookups are always free.
Use the synchronous API for instant lookups in your workflow, or upload a CSV with thousands of names and let our batch processor handle it. Either way, results are SMTP verified.
One POST request with first_name, last_name, and domain. Get back a verified email, status, provider, convention used, and confidence score. Integration takes minutes, not days.
We track which email conventions each domain uses and which providers power their email (Google Workspace, Microsoft 365, etc). This intelligence makes every subsequent lookup faster and more accurate.
Already have email addresses that need verification? Our email validation API performs the same SMTP-level verification for just 0.25 credits per check. Use both tools together for complete coverage.
When you search for an email by name and company, GTMData generates candidates using every common B2B naming convention. We prioritize by frequency, so the most likely pattern is tested first. Here is the complete list with approximate frequency across the millions of domains we have analyzed.
| # | Convention | Example | Frequency |
|---|---|---|---|
| 1 | first.last | tim.cook@apple.com | 35-40% |
| 2 | first | tim@apple.com | 15-20% |
| 3 | firstlast | timcook@apple.com | 10-12% |
| 4 | flast | tcook@apple.com | 5-7% |
| 5 | firstl | timc@apple.com | 4-6% |
| 6 | first_last | tim_cook@apple.com | 3-5% |
| 7 | last.first | cook.tim@apple.com | 2-4% |
| 8 | last | cook@apple.com | 2-3% |
| 9 | f.last | t.cook@apple.com | 2-3% |
| 10 | first.l | tim.c@apple.com | 1-2% |
| 11 | lastfirst | cooktim@apple.com | 1-2% |
| 12 | lastf | cookt@apple.com | 1-2% |
| 13 | last_first | cook_tim@apple.com | 0.5-1% |
| 14 | l.first | c.tim@apple.com | 0.5-1% |
| 15 | lfirst | ctim@apple.com | 0.3-0.5% |
| 16 | first.middle.last | tim.d.cook@apple.com | 0.2-0.5% |
Convention learning in action: Once GTMData discovers that a domain like apple.com uses the flast convention, all future lookups for that domain skip directly to the correct pattern. This reduces SMTP connections, speeds up results, and improves deliverability for your outbound campaigns.
A single API call is all it takes to find an email by name and company. Here are examples in popular languages.
curl -X POST https://api.gtmdata.co/v1/find \
-H "Authorization: Bearer gtm_live_your_key" \
-H "Content-Type: application/json" \
-d '{
"first_name": "Tim",
"last_name": "Cook",
"domain": "apple.com"
}'import requests
response = requests.post(
"https://api.gtmdata.co/v1/find",
headers={"Authorization": "Bearer gtm_live_your_key"},
json={
"first_name": "Tim",
"last_name": "Cook",
"domain": "apple.com"
}
)
data = response.json()
if data["status"] == "valid":
print(f"Found: {data['email']} (convention: {data['convention']})")const response = await fetch("https://api.gtmdata.co/v1/find", {
method: "POST",
headers: {
"Authorization": "Bearer gtm_live_your_key",
"Content-Type": "application/json",
},
body: JSON.stringify({
first_name: "Tim",
last_name: "Cook",
domain: "apple.com",
}),
});
const data = await response.json();
console.log(data.email); // "tcook@apple.com"
console.log(data.status); // "valid"See the complete API documentation for response fields, error handling, and batch endpoints.
About 20% of B2B domains are configured as catch-all, meaning they accept email to any address. Most email finders give up here. GTMData does not.
Even on catch-all domains, the mail server often responds differently to real vs fake mailboxes. GTMData measures response latency and behavioral patterns across multiple SMTP commands to determine if the address is genuinely in use. A real mailbox triggers additional server-side processing that produces measurable timing differences.
If we already know the naming convention for a catch-all domain from previous lookups, we apply that convention with high confidence. For example, if three previous queries to a domain all returned first.last, we know the next first.last candidate is almost certainly correct -- even on a catch-all domain.
validMailbox confirmed to exist via SMTP. Highest confidence.
valid_catchallCatch-all domain, but timing analysis or convention match indicates the address is real.
catchallDomain accepts all email. Could not confirm with high confidence. No charge.
not_foundNo valid mailbox found across all 16 conventions. No charge.
Learn more about statuses in the API documentation or read about email validation for verifying addresses you already have.
GTMData powers email discovery for sales teams, recruiters, marketers, and developers building data products.
Build verified prospect lists from LinkedIn exports or CRM data. Upload a CSV with names and company domains, download a list of SMTP-verified email addresses ready for outbound sequences. No more bounced emails tanking your sender reputation.
Find the work email for any candidate when you have their name and current employer. Perfect for reaching passive candidates who are not active on job boards. One API call gives you a verified contact method.
Build automated enrichment workflows that take a list of contacts and append verified email addresses. Use the batch API for bulk processing or the real-time endpoint for on-the-fly enrichment in your CRM or marketing automation platform.
Embed email discovery into your own product. Whether you are building a CRM, a prospecting tool, or an enrichment platform, the GTMData API gives you verified emails with a simple REST call. No infrastructure to maintain.
Not all email finder APIs are built the same. Here is what sets GTMData apart from tools like Hunter.io, Apollo, Snov.io, and other email lookup services.
| Feature | GTMData | Others |
|---|---|---|
| SMTP verification on every lookup | -- | |
| 16 naming conventions tested | -- | |
| Convention learning per domain | -- | |
| Catch-all timing analysis | -- | |
| Only charge for valid results | -- | |
| Real-time results (not cached) | -- | |
| Confidence score returned | Sometimes | |
| Batch CSV processing | ||
| REST API |
Most email finders rely on pre-existing databases and pattern guessing. GTMData performs live SMTP verification on every request, ensuring the email address exists at the moment you look it up. Read our blog for detailed comparisons.
You send a POST request with a first name, last name, and company domain. GTMData generates up to 16 email candidates based on common naming conventions (first.last, flast, firstl, etc.) and verifies each one via SMTP handshake against the company's mail server. The first verified match is returned with a confidence score.
Each successful email find costs 1 credit. You are only charged when we return a valid or valid_catchall result. Not found and low-confidence catch-all results are completely free. New accounts start with 100 free credits.
Most email finder tools search a static database of previously scraped emails. If the person is not in their database, you get nothing. GTMData performs a live SMTP verification for every lookup, meaning we can find emails for anyone -- even people who have never been indexed before. Every result is confirmed to exist at the mail server in real time.
Catch-all domains accept email sent to any address, which makes it impossible to confirm a specific mailbox via standard SMTP checks. GTMData goes further by analyzing SMTP response timing patterns and cross-referencing with known conventions for the domain. When we can confirm the email with high confidence, we return it as valid_catchall. When we cannot, we return it as catchall with no charge.
Yes. You can upload a CSV file with names and domains through the dashboard, or use the batch API endpoint for programmatic bulk lookups. Both methods process your list in parallel and deliver SMTP-verified results. See the batch documentation for details.
Every email we return as valid has been confirmed via SMTP handshake -- the mailbox exists on the mail server. Our accuracy for valid results approaches 99%. For valid_catchall results on catch-all domains, accuracy is typically 90-95% based on our timing analysis and convention intelligence.
You need three things: a first name, a last name, and the company domain (e.g., apple.com). The API handles the rest -- generating candidate emails, testing conventions, and verifying via SMTP.
100 free credits. No credit card required. Find your first email in under 2 minutes.
Questions? Read the API docs or follow the quickstart guide.