How to Use GTMData as an Email Finder in Clay

Clay has become the go-to data orchestration platform for GTM teams. It lets you build enrichment workflows that pull data from dozens of providers, transform it, and push it to your CRM or outreach tools. One of Clay’s most powerful features is the HTTP API action, which lets you connect any REST API as a custom enrichment source.

In this guide, we will walk through exactly how to set up GTMData as an email finder and email validator inside Clay. By the end, you will have a working enrichment column that takes a first name, last name, and domain and returns a verified email address, all powered by GTMData’s API.

What Is Clay and Why GTM Teams Use It

Clay is a spreadsheet-like platform designed for go-to-market data workflows. Think of it as a smart spreadsheet where each column can pull data from an external API, run an AI prompt, or apply a formula. Teams use Clay to build prospecting lists, enrich contact data, score leads, and automate the data plumbing that typically requires custom scripts or Zapier workflows.

The core workflow in Clay is simple: you start with a table of prospects (imported from LinkedIn, a CSV, or another source), add enrichment columns that call external APIs to fill in missing data, and then export the enriched data to your CRM or outreach tool. Clay has built-in integrations with many data providers, but it also lets you connect any REST API through its HTTP API action.

This is where GTMData comes in. While Clay offers built-in enrichment credits for email finding, those credits are expensive and the results come from a waterfall of providers that you cannot control. By connecting GTMData directly, you get lower costs, consistent results from a single provider, and access to features like catch-all validation that Clay’s built-in enrichment does not offer.

Prerequisites

Before you start, make sure you have:

• A Clay account (any plan with HTTP API action access)
• A GTMData account with an active subscription
• Your GTMData API key (found in the GTMData dashboard under Settings > API Keys)
• A Clay table with columns for first name, last name, and domain (or company website)

Step 1: Set Up the Email Finder

The email finder takes a person’s first name, last name, and company domain and returns their work email address. Here is how to configure it in Clay.

Add an HTTP API Action Column

In your Clay table, click the “+” button to add a new column. Select “HTTP API” from the action types. This opens the HTTP API configuration panel where you will define the request.

Configure the Request

Set the following values in the HTTP API configuration:

For the request body, use Clay’s variable syntax to pull values from your table columns. The body should look like this:

{
  "first_name": "{{First Name}}",
  "last_name": "{{Last Name}}",
  "domain": "{{Domain}}"
}

Replace {{First Name}}, {{Last Name}}, and {{Domain}}with the actual column names from your Clay table. If your domain column contains full URLs like “https://acme.com”, you may need to use a formula column to extract just the domain portion first.

The Response

GTMData will return a JSON response that looks like this:

{
  "email": "jane.doe@acme.com",
  "confidence": 97,
  "status": "valid",
  "first_name": "Jane",
  "last_name": "Doe",
  "domain": "acme.com"
}

In Clay, you can map these response fields to individual columns. The most important fields are email, confidence, and status. Use Clay’s response path feature to extract these: for example, set the output path to $.email to populate the column with just the email address.

Step 2: Add Email Validation

If you already have email addresses and just need to validate them, or if you want to add a validation step after the finder, you can set up a separate HTTP API action column for the validation endpoint.

The configuration is similar to the finder:

The request body takes a single email field:

{
  "email": "{{Email}}"
}

The validation response provides detailed information about the email:

{
  "email": "jane.doe@acme.com",
  "status": "valid",
  "sub_status": "none",
  "is_catch_all": false,
  "catch_all_confidence": null,
  "domain": "acme.com",
  "mx_found": true,
  "smtp_provider": "google",
  "free_email": false,
  "disposable": false
}

Key fields to map in Clay:

• status - The validation result: valid, invalid, catch-all, or unknown
• is_catch_all - Whether the domain is a catch-all server
• catch_all_confidence - For catch-all domains, a 0-100 confidence score on deliverability
• disposable - Whether the email uses a disposable/temporary domain

Step 3: Handle Errors and Edge Cases

One of GTMData’s biggest advantages in Clay is its soft rate limiting. Most APIs return a 429 (Too Many Requests) error when you exceed the rate limit. In Clay, this causes the row to fail with an error, and you have to manually re-run it later. This is a common pain point when running large enrichment tables.

GTMData handles this differently. Instead of returning an error, the API introduces a small delay when you approach the rate limit. Your request still completes successfully, just a little slower. This means:

• Zero failed rows in your Clay table
• No need for retry logic or manual re-runs
• Enrichment jobs complete fully without intervention
• You can run overnight batch jobs with confidence

When a lookup genuinely fails (for example, no email found for a given person), the API returns a clear response:

{
  "email": null,
  "confidence": 0,
  "status": "not_found",
  "message": "No email found for this person at this domain"
}

In Clay, you can use a formula column to check the status field and handle not-found results appropriately. For example, you might flag those rows for manual research or route them to a secondary enrichment provider. Importantly, a not-found result does not consume a credit.

Cost Comparison: GTMData vs Clay Built-In Credits

Clay offers built-in enrichment credits that let you find emails through Clay’s own waterfall of providers. This is convenient but expensive. Clay credits are priced at a premium because they include Clay’s margin on top of the underlying provider costs. The exact pricing depends on your Clay plan, but teams typically report paying $0.02-0.05 per enrichment credit for email finding.

By comparison, GTMData’s email finder costs $0.0065-0.0196 per credit depending on your tier, and you only pay for successful results. Here is a quick comparison:

At the 10K tier, GTMData is roughly 74% cheaper than Clay’s built-in enrichment. Even accounting for variation in Clay’s pricing across plans, the savings are substantial. For teams running high-volume enrichment, connecting GTMData via HTTP API action instead of using Clay credits can save thousands of dollars per month.

Tips for Batch Processing in Clay

Here are some practical tips for getting the most out of GTMData in Clay:

1. Clean Your Domain Column First

GTMData’s finder endpoint expects a bare domain like “acme.com”, not a full URL. If your data has URLs like “https://www.acme.com/about”, add a formula column in Clay to extract the domain before passing it to the API. A simple formula that strips the protocol, www prefix, and path will ensure clean inputs and better match rates.

2. Use the Finder First, Then Validate Separately if Needed

The email finder endpoint returns emails that have already been initially validated. For most outbound use cases, the finder result is sufficient. However, if you are building a list over time and want to re-validate before sending, you can add a validation column that runs on the found emails. This is especially useful for lists that sit for weeks before being used, as email addresses can go stale.

3. Filter by Confidence Score

GTMData returns a confidence score (0-100) with each found email. Use a Clay filter or formula column to segment results by confidence. A common approach is to include emails with 90+ confidence in your primary outreach sequence and route lower-confidence results to a secondary verification step.

4. Run Large Tables Overnight

Because GTMData’s soft rate limits prevent errors, you can confidently kick off a 50,000-row enrichment table before leaving for the day and come back to a fully completed table in the morning. No failed rows, no manual re-runs. This is one of the most practical benefits of soft rate limits in a real-world workflow.

5. Combine Find + Validate for Catch-All Domains

If you are targeting companies with catch-all domains (common in mid-market and enterprise), use the finder to get the email, then run a separate validation column to get the catch-all confidence score. This two-step approach gives you the most data to make a send/no-send decision on each prospect.

Full Clay HTTP API Configuration Reference

Here is the complete configuration for both endpoints, ready to copy into Clay:

Email Finder

Method: POST
URL: https://api.gtmdata.com/v1/find

Headers:
  Content-Type: application/json
  Authorization: Bearer YOUR_API_KEY

Body:
{
  "first_name": "{{First Name}}",
  "last_name": "{{Last Name}}",
  "domain": "{{Domain}}"
}

Response Path (email):  $.email
Response Path (status): $.status
Response Path (score):  $.confidence

Email Validator

Method: POST
URL: https://api.gtmdata.com/v1/validate

Headers:
  Content-Type: application/json
  Authorization: Bearer YOUR_API_KEY

Body:
{
  "email": "{{Email}}"
}

Response Path (status):     $.status
Response Path (catch-all):  $.is_catch_all
Response Path (confidence): $.catch_all_confidence
Response Path (disposable): $.disposable

Wrapping Up

Connecting GTMData to Clay takes about five minutes and can save your team significant money compared to Clay’s built-in enrichment credits. The soft rate limits mean zero errors and zero manual re-runs. The pay-per-result model means you only pay for emails that are actually found and validated. And the catch-all validation gives you data that most other email finders simply cannot provide.

If you are already using Clay for your GTM workflows, adding GTMData as a custom enrichment source is one of the highest-ROI changes you can make. Lower cost, better data, fewer errors. Start with the email finder configuration above, run it on a test batch of 100 prospects, and compare the results and cost against what you are currently using.