---
name: clay-reverse-contact-integration
description: Connect Clay and Reverse Contact: what syncs, which editions carry it, the setup order, and the failures to expect. Covers contacts, companies. Use when the user wants to set up, audit or troubleshoot Clay and Reverse Contact together, or asks why data is not moving between them.
---

# Clay and Reverse Contact

> Generated from https://www.reversecontact.com/integrations-hub/clay-integrations/clay-reverse-contact-integration
> Every tier requirement, sync direction and limit below was read from the vendors' own documentation on 2026-10-11.
> Vendors change these without notice. Re-check anything load-bearing before you rely on it.

**What you have to buy first:** A Clay account. Your own Reverse Contact key is optional and changes which meter you spend.

**What moves:** contacts, companies, one way, into Clay.
**How it is built:** native, built on the api. **Effort:** minutes.

## The short version

This is the shortest path in the directory between Reverse Contact and a CRM, and the only one that needs no Reverse Contact account to try. The app is one of four enrichment actions you pick from a menu, and from there Clay's own CRM integrations carry the result the rest of the way. It is also the right place to put Reverse Contact in a waterfall, because returning null with a confidence score gives the next step something honest to branch on. Build the HTTP column instead when you want an endpoint the four actions do not expose, or the raw response in front of you while you tune the request.

## Which Clay plan carries which half of this

Rows: Clay plan. Columns: What you are trying to do. Reverse Contact is not the gated part. Clay lists every one of its actions as Included in All Plans, so the lookup itself runs on a Free workspace, and the tiers begin on everything you would do with the answer afterwards.

| Clay plan | Run the four Reverse Contact actions | Schedule recurring enrichment runs | Reach an endpoint the actions miss, over HTTP | Write the result into HubSpot or Salesforce |
|---|---|---|---|---|
| Free | Included | Not included | Not included | Not included |
| Launch | Included | Included | Not included | Not included |
| Growth | Included | Included | Included | Included |
| Enterprise | Included | Included | Included | Included |

- **Included.** Clay's integration catalogue marks all four Reverse Contact actions Included in All Plans and offers each as Clay Credits or Bring Your Own Account. Its plan comparison puts Schedule recurring enrichment runs on Launch, and both HTTP API integrations and CRM integrations on Growth, which the pricing page header lists at $446 a month.
- **Not included.** Not available on that plan at any volume. The enrichment still runs, which is the trap worth naming: a team can prove Reverse Contact resolves its list on a Free workspace and only then find out that delivering the answer to a CRM is two tiers up.

Counted off that grid, of sixteen pairings: eleven give you included, five give you not included.

So this pair is free to evaluate and $446 a month to operate, and every gate in it belongs to Clay rather than to Reverse Contact. If that Growth line is the only thing between a working table and a populated CRM, an n8n workflow does the same write for the price of the instance and the native Zapier app does it by the task.

## What actually syncs

Direction is written from Clay's point of view: out means out of Clay, in means into it.

| What | Direction | What that means in practice |
|---|---|---|
| Clay to Reverse Contact | One way, out | The native action takes the row's email, name, company or profile URL. An HTTP API column POSTs to /v2/enrich/persons or /v2/enrich/companies instead. |
| Record back to the column | One way, in | The full structured profile lands as JSON, and you map the fields you want into their own columns. |
| Confidence and nulls | One way, in | A miss returns null with a confidence score rather than a guess, so a conditional run can decide what happens next. |
| Onward to the CRM | One way, out | Clay's HubSpot or Salesforce Update action writes the mapped fields back. |

## Which field lands where

Four actions, and which one you want is decided by the identifier you already hold rather than by what you want back. Two start from an email or a domain, two start from a profile URL, and Clay publishes a different output field list for each.

| In Clay | In Reverse Contact | What to know about the match |
|---|---|---|
| Find Professional Profile | Reverse lookup from an email, 2 credits | Takes any combination of Email, Full name, Company name and Company domain, and Clay states that more fields improve match accuracy. Returns the ID, Public ID, LinkedIn URL, first and last name, headline, current position title, current company name and ID, and an update date. |
| Find company professional profile | Reverse lookup from a domain, 2 credits | Company domain is the only required input. Returns the company ID and name, industry, tagline, website URL, employee count and count range, follower count, an update date, and a city and country. |
| Enrich professional profile | Cached lookup from a profile URL, 1 credit | Clay lists ID, Public ID, Member ID, LinkedIn URL, first and last name, headline and summary, while the action description also promises experience, education and skills. Open the action in your own table before designing a column around the longer list. |
| Enrich company profile | Cached lookup from a profile URL, 1 credit | The fullest output of the four: description, tagline, logo and background URLs, employee count and range, followers, headquarter, specialities, locations, founded date and a phone number. |
| An HTTP API column | Any endpoint, on your own key | The route to everything the four actions do not expose, including the free freshness check and the live endpoints. Clay's plan comparison puts HTTP API integrations on Growth and above, so this is the one half of the pair with a real tier gate. |
| Only run if | A condition, not a field | Where the waterfall is actually built. The column runs only where the condition holds, so a second provider is charged for the rows this one left empty rather than for the whole table. |
| The write into a CRM | Not Reverse Contact's job | Clay's own HubSpot or Salesforce Update action carries the mapped columns the rest of the way, and Clay marks CRM integrations as a Growth feature. Nothing travels back to Reverse Contact from here at all. |
| A phone number or a verified email | Separate endpoints, not Clay actions | Reverse Contact prices a direct phone at 20 credits and a business email at 3, each charged only when one is found. Neither is one of the four actions, so both need an HTTP column or a different route entirely. |

### What each call costs, and which meter forgives a miss

The credit price per call is published and a dollar rate per lookup is not, so the credit is the only unit this page prints. On the native app you are usually spending Clay credits instead, and the figures below are what you spend from the moment you connect your own key.

| The call | What it costs, and what that buys |
|---|---|
| Freshness check, /fetch/*/check | Free. Says whether a profile is cached and when it was last updated, which is the call Reverse Contact recommends making before you spend anything |
| Cached lookup from a profile URL, /fetch/* | 1 credit. The two Enrich actions |
| Reverse lookup from an email, a name or a domain, /enrich/* | 2 credits. The two Find actions |
| Live refresh, /fetch/*/live | 2 credits, and not reachable from a column: it answers with a task id rather than a record |
| A lookup that matches nobody, or any other 4xx | Nothing. Reverse Contact charges 0 credits on every 4xx and 5xx response |
| That same miss, paid in Clay credits | One Action. Clay counts each record enriched as 1 Action regardless of data source or provider |

**What does not cross:**

- The live endpoints. They answer with a webhookId to poll rather than a record, and a column has nothing to poll with. Reverse Contact aims to deliver a live result in under 15 seconds and documents that it can take tens of minutes, which is why this belongs in a workflow rather than in a table.
- The free freshness check. It is not one of the four actions, so the only route to it from Clay is an HTTP API column, which needs Growth.
- Anything travelling the other way. This is a read layer: no Clay column writes to Reverse Contact, and there is nothing in the product for it to write to.

## Connect it, in this order

**Who has to do it:** Whoever owns the Clay workbook. No admin on either side, and no Reverse Contact account at all unless you want the lookups on your own key.
**How long:** Ten minutes for the column. The two decisions in front of it are the part worth taking slowly.

### 1. Check which Clay plan you are on, because the enrichment is not the gated part

*Where:* Clay: pricing

Clay's catalogue marks every Reverse Contact action Included in All Plans, so the lookup runs on a Free workspace. Its plan comparison puts CRM integrations and HTTP API integrations on Growth, listed at $446 a month. You can therefore measure the match rate for nothing and still have nowhere to deliver the answer.

### 2. Decide which meter the lookups bill to, before you add a column

*Where:* Clay: Add enrichment, Select Reverse Contact account

The modal asks you to pick an account. Leave it on the Clay-provided key and the lookups spend Clay credits. Click + Add account and authenticate, and they bill your own Reverse Contact workspace instead. Both work on every plan, and the choice decides which bill grows and whose usage dashboard shows the calls.

### 3. Pick the action that matches the identifier you already hold

*Where:* Clay: Integrations, Reverse Contact

Find Professional Profile starts from an email, Find company professional profile from a domain, and the two Enrich actions from a profile URL. Clay documents a different required input and a different output list for each, so they are not interchangeable, and the wrong one returns a thinner record rather than an error.

### 4. Write to columns nothing else owns

*Where:* Clay: column names

Prefix them, the way the CRM pairs prefix a property. The column a later Update action maps into your CRM is what decides whether a rep ever loses a field they typed, and renaming columns after the write step is mapped is tedious rather than hard.

### 5. Run ten rows and open the raw response on one of them

*Where:* Clay: the cell, Expand

This is the whole reason to use a table rather than a pipeline. The response carries an update date and a confidence score alongside the fields, and reading those on ten real rows of your own list tells you more than any published match rate can.

### 6. Chain the second action if you need history

*Where:* Clay: a second enrichment column

Find Professional Profile returns identity, the current title and the current company. Experience, education and skills come from Enrich professional profile, run on the LinkedIn URL the first action returned. Two columns, and 3 credits in total on your own key.

### 7. Put Only run if on every column that costs money

*Where:* Clay: run settings, Only run if

This is what makes a waterfall a waterfall: the next provider touches only the rows this one left empty. Reverse Contact returning null rather than a best guess is what gives the condition something honest to test, so the two features suit each other exactly.

### 8. Turn on Auto-update last

*Where:* Clay: run settings, Auto-update

Clay documents it as re-running the enrichment when the source data changes, so an edit to any column it reads is a re-run and a 2-credit action becomes a standing cost. Turn it on once the upstream columns have stopped moving.

Six of those eight are decisions rather than clicks, and the two that cost money if taken late are the first two. That is the usual shape on the [orchestration layer](layer:orchestrate), where the tool is ten minutes and the economics are the design.

## How to check it worked

- Run Find Professional Profile on your own work email. You already know the right answer, so it is the one row where a wrong match is obvious rather than plausible.
- Run it on an address you know resolves to nobody, a role mailbox like info@ or a personal alias. The cell should come back empty rather than populated with a confident stranger, and watching that happen once is what tells you the null is real.
- Open the raw response on a matched row and find the update date. That one field decides whether you ever need the live endpoints, and it is the one nobody checks before buying a refresh.
- Note your balance, run ten rows, note it again, then count how many rows actually matched. The two numbers will not agree on Clay credits, because Clay bills the attempt, and the gap is your real cost per filled field.

## When it goes wrong

Each row is a symptom somebody reports, the documented reason, and the fix. Work down it before escalating to either vendor, because most of these are configuration.

| Symptom | Why it happens | What to do |
|---|---|---|
| The column came back empty on somebody you know is real | Reverse Contact returns null rather than a best guess when it is not confident, and puts a confidence score on every response. An empty cell is the documented answer rather than a failure. | Treat empty as a branch instead of an error. Put Only run if on the next provider's column so it picks up exactly the rows this one left blank, which is the whole mechanism of a waterfall. |
| Find Professional Profile returned a person with no work history | Clay documents a different output list per action, and the one that starts from an email returns identity, the current title and the current company rather than experience, education and skills. | Chain Enrich professional profile onto the LinkedIn URL the first action returned. Two columns, and 3 credits in total once you are on your own key. |
| The enrichment works and nothing ever reaches the CRM | Clay's plan comparison marks CRM integrations as a Growth feature while the Reverse Contact actions are Included in All Plans, so the lookup and the delivery are gated at different tiers. | Check the plan before you debug the mapping. On Free or Launch the write action is not there to configure, which presents as a broken column rather than as a missing tier. |
| The bill is bigger than the number of rows that got enriched | Clay states that each record enriched or exported counts as 1 Action regardless of data source or provider, so a miss costs the same Action as a hit. | Filter the import step down to the rows actually missing the field, and connect your own Reverse Contact key if misses dominate: a 4xx costs 0 credits there, so on that meter a miss is free. |
| There is no freshness check in the action list | The Clay listing carries four actions, the two Find and the two Enrich ones. The free check endpoints are not among them. | Reach them through an HTTP API column, which Clay puts on Growth and above. Checking first and fetching second is the sequence Reverse Contact's own documentation recommends for saving credits. |
| A live call never returns a record | The live endpoints are asynchronous by design. They reply with a webhookId and deliver the result afterwards, and Reverse Contact documents that this usually takes seconds and can take tens of minutes. | Keep the cached actions in the table and run live resolution where a poll loop is ordinary. Polling is free and off the rate-limit clock wherever you do it, so the cost of moving it is the workflow rather than the call. |
| Everything stopped at once, including the calls that were free | When a Reverse Contact workspace drops below 2 credits the free Check endpoints are paused too and answer 402 NO_CREDITS, because the fetch a check precedes can itself cost 2. | Watch quotas.workspace.credits.left, which rides on every response. GET /v2/usage and webhook polling keep working whatever the balance, so a balance check never fails for the same reason the lookup did. |
| The table re-ran and spent credits on rows that were already done | Auto-update is documented as re-running the enrichment whenever the source data changes, so an edit to any column it reads counts as a change. | Turn auto-update on last, after the upstream columns have settled, and leave Only run if on the column so even a re-run stays conditional. |

## What breaks, from the vendors' own docs

- **Clay bills the attempt, whichever meter you chose.** The native app spends Clay credits by default and your own Reverse Contact credits once you connect a key, so this is one meter rather than two unless you build the HTTP column and bring your own key to it. What does not change is that Clay bills the attempt rather than the result, so rows that miss still cost. Put the cheapest, highest-hit-rate source first in any waterfall for that reason.
- **Live resolution returns a task.** The /live endpoints are asynchronous: they hand back a task id to poll. Inside a Clay column the cached endpoints are the straightforward choice, and the live path belongs in n8n where polling is natural.
- **The credit cost is published, the dollar rate is not.** Reverse Contact publishes 2 credits for a reverse lookup from an email and 1 for a cached profile lookup, and no dollar rate per lookup. On the native app you are usually spending Clay credits rather than theirs, so the number that decides this route is Clay's price per action.
- **An unconfident match is an empty cell.** Reverse Contact returns the best-scored profile first where there are namesakes, with the associated profiles alongside it, and leaves the cell empty when it is not confident. That is the behaviour you want from a data layer and it means your table needs a rule for empty, not just for wrong.
- **HTTP columns and the CRM write both start at Growth.** Clay's plan comparison puts HTTP API integrations and CRM integrations on Growth, listed at $446 a month, while the four Reverse Contact actions are Included in All Plans. So the enrichment runs on a Free workspace and neither the endpoints the actions miss nor the write-back into HubSpot or Salesforce is reachable from one. Evaluate on Free, budget for Growth.

## The APIs, if you are building around it instead

### Clay

- **Base:** `Configured in the table, not through an API`
- **Auth:** Per-integration, set in the workbook.

| Call | Request | What it does |
|---|---|---|
| `ACTION HubSpot / Salesforce Lookup` | - | Read-only. Pulls records into the table and changes nothing in the CRM. |
| `COLUMN HTTP API` | `POST https://api.reversecontact.com/v2/enrich/persons\nHeaders: { "Authorization": "Bearer rc_...", "Content-Type": "application/json" }\nBody: { "email": "/Work Email" }` | `/Work Email` is a column reference, so each row posts its own value. This is how a provider with no native listing becomes a column. |
| `ACTION HubSpot / Salesforce Update` | - | Writes back. Immediately live to every CRM user. Turn on "ignore blank values" and exclude rep-owned properties. |

**Rules that will cost you time if you skip them:**

- **Clay bills per action on the attempt, not the result.** Effective cost per filled field is the action rate divided by your match rate. Order a waterfall cheapest-first and use conditional runs so the expensive source only sees the residue.
- Import a filtered slice, never the whole portal. Filter on the gap you are filling.
- Run read-only until the columns look right, write to ten rows, open them in the CRM, and only then schedule.

Docs: https://university.clay.com/docs/hubspot-integration-overview

### Reverse Contact

- **Base:** `https://api.reversecontact.com/v2`
- **Auth:** `Authorization: Bearer rc_your_api_key`. Keys are created in Workspace > API Keys.

| Call | Request | What it does |
|---|---|---|
| `POST /v2/enrich/persons` | `{ "email": "j.okafor@northwind.io" }` | Resolve a person from an email, a name plus company, or a profile URL. Cached resolution, returns in the response. |
| `POST /v2/enrich/companies` | `{ "domain": "northwind.io" }` | Resolve a company from a domain or a name. |
| `POST /v2/fetch/persons` | `{ "linkedInUrl": "..." }` | Standard profile lookup from the database. |
| `POST /v2/fetch/persons/live` | `{ "linkedInUrl": "..." }` | Live on-demand resolution. ASYNCHRONOUS: returns a webhookId to poll, not a record. |
| `POST /v2/search/people` | `{ "filters": { "currentCompanyDomain": "northwind.io" } }` | Filtered people search. 1 credit a profile delivered, and /v2/search/people/count is free. It replaced /v2/search/persons, which returns 410 Gone since 13 October 2026. |
| `POST /v2/search/organizations` | `{ "filters": { "companyDomain": "northwind.io" } }` | Filtered company search. A domain can also go straight to a company through POST /v2/enrich/companies, or through the enrich_company MCP tool since November 2026. |
| `POST /v2/contact/email` | `{ "linkedInUrl": "..." }` | Find an email. ASYNCHRONOUS: returns a taskId to poll. 3 credits for a professional address, 5 for a personal one, 8 for both, refunded when neither is found. |
| `GET /v2/webhooks/:webhookId` | - | Poll an async job until status is "succeeded". Polling is free and does not count against the rate limit. |

Response shape:

```json
{
  "success": true,
  "data": {
    "person": {
      "fullName": "Jane Okafor",
      "headline": "VP Sales at Northwind",
      "location": "London, United Kingdom",
      "linkedInUrl": "https://linkedin.com/in/...",
      "currentPosition": { "title": "VP Sales", "companyName": "Northwind", "startDate": "2023-04" },
      "emails": [], "experience": [], "education": [], "skills": []
    },
    "company": { "name": "Northwind", "domain": "northwind.io",
                 "industry": "Software Development", "employeeCount": 220 }
  },
  "error": null,
  "metadata": { "requestId": "req_...", "executionTimeMs": 480, "updatedAt": "2026-09-01T..." },
  "quotas": { "creditsConsumed": 1, "workspace": { "credits": { "total": 10000, "used": 4521, "left": 5479 } } }
}
```

**Rules that will cost you time if you skip them:**

- A miss returns **null**, not a best guess. Every response carries a confidence score, and you can raise the precision threshold on the request. Branch on it: do not treat a low-confidence answer as a match.
- Use the cached endpoints anywhere that must answer inside one HTTP request. The `/live` endpoints return a task and need polling.
- `quotas.workspace.credits.left` is on every response. Log it, or you will find out about the balance from a 402.
- Credit costs per call are published and a dollar rate per lookup is not: 2 credits for a reverse lookup from an email, 1 for a cached profile lookup, 2 for a live refresh, 3 for a business email and 20 for a direct phone number, with the last two charged only when one is found. Checks and the search count endpoint are free. Credit packs expire after 3 months. Do not hard-code a dollar cost assumption.

**MCP server:** `https://api.reversecontact.com/mcp`

- Auth: OAuth 2.1 where the client supports it, otherwise `Authorization: Bearer rc_your_api_key`.
- Tools: `enrich_person`, `enrich_person_live`, `enrich_company`, `enrich_company_live`, `search_persons`, `search_companies`, `check_usage`, `check_task`
- Streamable HTTP, JSON-RPC 2.0. The `_live` tools return a task id that `check_task` polls.

Docs: https://docs.reversecontact.com/getting-started

## Sources

- Reverse Contact API documentation: https://docs.reversecontact.com/getting-started
- Reverse Contact: credits: https://docs.reversecontact.com/guides/credits
- Reverse Contact: rate limits: https://docs.reversecontact.com/guides/rate-limits
- Reverse Contact pricing: https://www.reversecontact.com/pricing
- Clay integrations: ReverseContact: https://www.clay.com/integrations/data-provider/reversecontact
- Clay docs: Reverse Contact integration: https://university.clay.com/docs/reverse-contact-integration
- Clay pricing: the plan comparison: https://www.clay.com/pricing
- Clay docs: HubSpot integration overview: https://university.clay.com/docs/hubspot-integration-overview
- 14 practitioner threads read on 2026-10-11, summarised on the page: https://www.reversecontact.com/integrations-hub/clay-integrations/clay-reverse-contact-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/clay-integrations/clay-reverse-contact-integration

---

*Published by Reverse Contact, which appears in this directory as a data provider.
No other vendor pays for placement. Where a vendor publishes no public figure, this file says so
rather than estimating. Reverse Contact costs are stated in credits, which it publishes; no dollar
rate per lookup appears here, because none is published and dividing a pack price is not their number.*
