---
name: clay-apollo-integration
description: Connect Clay and Apollo: 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 Apollo together, or asks why data is not moving between them.
---

# Clay and Apollo

> Generated from https://www.reversecontact.com/integrations-hub/clay-integrations/clay-apollo-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:** Any Clay plan, plus your own Apollo account. Clay's catalogue marks every Apollo action as needing one.

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

## The short version

Apollo is a native Clay provider, so this is a column rather than an integration project, and Clay lists the integration as included on all plans rather than behind Growth like the CRM ones. Its place in a stack is almost always the same: first step in a waterfall, because it resolves a large share of a normal list at the lowest unit cost of anything here, and whatever it misses goes to a specialist. What changed in 2026 is the metering: bringing your own Apollo key removes the Data Credit cost and still spends an Action per record, so the key is no longer the way to make a wide table cheap.

## What has to be true before each action will run

Rows: What you are asking Apollo to do. Columns: What has to exist first. There is no edition grid on this pair, because Clay lists the Apollo integration as included on all plans and Apollo gates none of these actions by tier. What does gate them is state: four prerequisites, and which ones apply depends entirely on which of the fourteen actions you picked.

| What you are asking Apollo to do | Your own Apollo account | The contact already in Apollo | The contact already enrolled | A sending mailbox in Apollo |
|---|---|---|---|---|
| Enrich a person or company | Required first | Not required | Not required | Not required |
| Find people, jobs or saved contacts | Required first | Not required | Not required | Not required |
| Find or create a contact | Required first | Not required | Not required | Not required |
| Add a contact to a sequence | Required first | Required first | Not required | Required first |
| Change a sequence status | Required first | Required first | Required first | Not required |

- **Required first.** The action will not run without it, and the failure is reported as a skip with a reason rather than as an error. The sending mailbox is the input people miss, because it is required on exactly one action and optional nowhere.
- **Not required.** Nothing to arrange. The first three rows are why Apollo is the default opening column in a Clay waterfall: a domain or a name is enough, and nothing has to exist in Apollo first.

Counted off that grid, of twenty pairings: nine give you required first, eleven give you not required.

The first column reads the same all the way down, and that is the finding: Clay's catalogue marks every one of the fourteen Apollo actions as requiring your own Apollo account, so there is no version of this pair you can evaluate on Clay's credits alone. The staircase only starts once you ask Apollo to do something rather than to tell you something.

## 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 Apollo | One way, out | A native enrichment column, configured in the table rather than through an API. |
| Records back | One way, in | Contact and company data into columns, ready to route into a CRM write. |
| Credits | Events only | Either drawn from Clay credits or from your own Apollo key, which changes the economics. |

## Which field lands where

Apollo in Clay is fourteen separate actions rather than one mapping, and which one you pick decides what you have to know first. The useful split is between the ones that take a string you already have and the ones that take an Apollo ID you have to fetch.

| In Clay | In Apollo | What to know about the match |
|---|---|---|
| Find People from Apollo | Job titles, optional domains, limit 1 to 1,000 | A table source rather than an enrichment column. This is the only Apollo action here that creates rows instead of filling them. |
| Enrich Person | Any of name, email, company, Apollo ID | Every input is optional, which means it will run on almost nothing and return almost nothing. Returns contact details, employment history, firmographics, department and seniority. |
| Enrich Company | Company domain, required | The one action with a single required input. Returns headcount by department, revenue, tech stack, offices, founded year and company type. |
| Find People at Company By Job Title | Job titles and company domains, limit up to 10 | A tighter limit than Find People. Include Contacts prioritises people already linked to your CRM when a limit is set, which changes what comes back rather than how much. |
| Find Open Jobs | Company ID or job search terms | Returns a postings array with title, URL, location, posted date and last seen date, plus a total count. Last seen is the field that makes this a signal rather than a snapshot. |
| Find Saved Contacts | Keywords, limit 1 to 10 | Searches your own Apollo workspace rather than the database. Clay recommends an email address as the keyword, and the output includes sequence enrolment status. |
| Find or Create Contact | Run Dedupe on by default, plus the fields | Dedupes on email, LinkedIn URL, or name plus organisation, and returns a was_existing flag. That flag is the only thing that tells you which of the two things the action did. |
| Add Contact to Sequence | Sequence ID, Contact ID, sending account ID | All three required, and the contact must already exist in Apollo. Five override flags default to false, and the output names the reason a contact was skipped. |

### What each Apollo action costs on Clay's two meters

| The action | How it reads on the record |
|---|---|
| Any enrichment, on Clay's key | One Action per record, plus Data Credits for the data itself |
| Any enrichment, on your own Apollo key | One Action per record, and no Data Credits |
| A row that returned nothing | The Action regardless, because it is charged per record rather than per result |
| Find People from Apollo as a source | Sourcing contacts does not consume an Action, by Clay's own list of what is free |
| A run stopped halfway | Requests already sent still consume their Data Credits |

**What does not cross:**

- Anything about a CRM. Apollo in Clay returns columns, and getting those columns into HubSpot or Salesforce is a separate write action on a separate integration with its own plan gate.
- An Apollo ID you have not fetched. Find Account by ID and Find Contact by ID both require one, so they belong after a search rather than at the start of a table.
- A sequence enrolment for somebody Apollo has never seen. The action will not create the contact for you, which is what Find or Create Contact is for.

## Connect it, in this order

**Who has to do it:** Whoever owns the Clay workbook, plus somebody with an Apollo account to connect. No admin on either side.
**How long:** Five minutes to connect. The thinking is about where in the waterfall it goes.

### 1. Connect your own Apollo account first

*Where:* Clay: + Add account

Clay's integration catalogue marks all fourteen Apollo actions as needing your own account, and the setup is one click and an authentication. The integration itself is listed as included on all Clay plans, unlike the CRM integrations, which start on Growth.

### 2. Decide whether the key or Clay's credits pay for the data

*Where:* Clay: Settings, Connections

A key added in Settings under Connections, or from Add Account in the enrichment panel, removes the Data Credit cost for that provider. The Action is charged either way, which is the part that changed when Clay split one meter into two.

### 3. Put Apollo at the front of the waterfall, not the middle

*Where:* Clay: column order

A waterfall is only cheap if the cheap provider runs first. Apollo resolves a large share of a North America heavy list at the lowest unit cost here, so a specialist ahead of it inverts the economics of the table without changing anything a reader of the interface would notice.

### 4. Qualify before you enrich

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

Clay's own credit guide puts this first: reorder so disqualified rows are filtered out before the enrichment runs, and use Only run if on the column. A filtered view enriches only the rows in view, which is the same lever with less setup.

### 5. Use Enrich Person for a known individual and Find People to discover them

*Where:* Clay: Add enrichment

Enrich Person takes any of name, email, company or Apollo ID, all optional, and returns contact details, employment history and firmographics. Find People from Apollo takes job titles and optional domains with a limit of 1 to 1,000, and is a table source rather than a column.

### 6. Run Find or Create Contact before anything touches a sequence

*Where:* Clay: Find or Create Contact

It dedupes by default, on email, LinkedIn URL, or name plus organisation, and returns a was_existing flag telling you which happened. That flag is what a sequence step should branch on, because Add Contact to Sequence requires a contact that already exists.

### 7. Give the sequence action a sending mailbox

*Where:* Clay: Add Contact to Sequence

Sequence ID, Contact ID and Send Email From Email Account ID are all required. Five override flags default to false: add without email, add unverified email, add with job change, add active in other campaigns, add finished in other campaigns. Leaving them off is why rows come back skipped.

### 8. Test on ten rows before auto-update

*Where:* Clay: Auto-run

Clay recommends about ten rows for a new integration, and recommends turning auto-run off while building so rows added too early do not spend anything. The toolbar button reads Manual once it is off.

The order above is almost entirely about money rather than about plumbing: the connection is one click, and the other seven steps exist because every row costs an Action whether Apollo finds anything or not. That is the same discipline the [Clay and HubSpot write loop](pair:hubspot+clay) needs for a different reason, and it is the whole skill of working in this layer.

## How to check it worked

- Check the was_existing flag on a Find or Create Contact run. If every row comes back as new, the dedupe is matching on nothing useful and you are creating duplicates in Apollo rather than in Clay.
- Add one contact to a sequence and read the output rather than the row status. The action returns the reason a contact was skipped, which is usually a missing email or an existing enrolment.
- Run Enrich Person on twenty rows you know the answer for and count the hits. That number is your match rate, and the Action cost of the full table divides by it.
- Open the Clay billing view after the test and check which meter moved. If Data Credits went down on a provider you brought a key for, the key is not attached to that action.

## 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 |
|---|---|---|
| Enrich Person returns almost nothing on a lot of rows | Every input on that action is optional, so it runs on whatever is populated. A row carrying only a first name is a valid call that cannot resolve. | Require a column before the action runs, with Only run if. An email or a company domain plus a full name is the combination that resolves; a name alone is an Action spent on nothing. |
| Rows come back skipped from Add Contact to Sequence | The output names the reason, and it is usually one of two: the contact has no email address, or they are already in that sequence. Five override flags govern the edge cases and all five default to false. | Read the skip reason rather than the row status, and decide each override deliberately: add without email, add unverified email, add with job change, add active in other campaigns, add finished in other campaigns. |
| Add Contact to Sequence will not run at all | Send Email From Email Account ID is a required input and it is the one people leave blank. The contact also has to exist in Apollo before this action, which is a separate prerequisite. | Fetch the sending account ID once and hold it in a column, then run Find or Create Contact ahead of the sequence step and branch on its was_existing flag. |
| Apollo filled up with duplicate contacts | Run Dedupe was turned off, or the rows carry none of the three things it matches on: email, LinkedIn URL, or name plus organisation. | Leave Run Dedupe on, which is the default, and make sure one of those three is populated before the action. The was_existing flag in the output is how you check whether it is working. |
| A Find Account by ID or Find Contact by ID column is empty | Both require an Apollo ID, and nothing earlier in the table produced one. These are follow-up actions rather than entry points. | Run a search or an enrichment first and carry the ID forward. If you only have an email, Find Saved Contacts with the email as the keyword is the documented route into your own workspace. |
| The bill went up after bringing your own Apollo key | A key removes the Data Credit cost and not the Action. Clay's documentation says an Action is still consumed, and Actions neither roll over nor can be bought as top-ups. | Cut the row count rather than the data cost. Filtered views, Only run if, and a Lookup column against a table you already enriched are the three levers Clay documents for this. |
| Find People at Company By Job Title returns fewer people than expected | That action caps the limit at 10, where Find People from Apollo goes to 1,000. They read like the same action and are not. | Use Find People from Apollo as a table source for discovery, and keep the per-company action for filling in a list you already have. |
| A table stopped mid-run and the credits are gone | Clay documents that requests already sent still consume their Data Credits when actions are stopped partway through. | Stop by turning auto-run off before adding rows rather than by halting a running table. The toolbar reads Manual when it is off, which is the state to build in. |

## What breaks, from the vendors' own docs

- **Your own key saves credits, not actions.** Clay documents it in one sentence: connecting your API keys eliminates the Data Credit cost, and an Action is still consumed. So an Apollo key removes the data half of the bill and leaves the platform half, which is the half that scales with the number of rows rather than the number of hits.
- **One Action per record, whatever the provider.** Clay's own wording is that each record enriched or exported counts as 1 Action regardless of data source or provider, and that CRM syncs and HTTP calls count too. A miss costs the same Action as a hit, so the effective cost of a wide table is set by the row count rather than the match rate.
- **Actions do not roll over and cannot be topped up.** Unused Actions expire at the end of the month and there is no top-up to buy, while unused Data Credits accumulate to twice the monthly limit on a monthly plan and can be topped up at a 30% premium. The two meters behave differently enough that running out of one is a different problem from running out of the other.
- **Coverage is a geography question.** Apollo is strongest on North American data. On a European list the same waterfall wants a different first step, and assuming otherwise is how a table returns half-empty.
- **The sequence actions have prerequisites, not defaults.** Add Contact to Sequence needs the contact to exist in Apollo already and takes a sending email account ID as a required input. Update Contact Status in Sequence needs the contact to be enrolled as well. Neither will create what it is missing.

## 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

## Filling the record this integration moves

The integration above moves a record between two systems. Neither of them creates what is in it, so a sync that works perfectly still carries whatever gaps the record arrived with. Reverse Contact resolves an email, a domain or a profile URL into a verified people and company record through one API, and returns null with a confidence score rather than a guess.

### 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

- Clay docs: Apollo.io integration overview: https://university.clay.com/docs/apollo-io-integration-overview
- Clay docs: actions and data credits: https://university.clay.com/docs/actions-data-credits
- Clay docs: ways to save Clay credits: https://university.clay.com/docs/clay-credit-conservation
- Clay integrations: Apollo.io: https://www.clay.com/integrations/data-provider/apollo-io
- Clay University: importing from your CRM: https://university.clay.com/lessons/importing-from-your-crm-crm-enrichment
- 14 practitioner threads read on 2026-10-11, summarised on the page: https://www.reversecontact.com/integrations-hub/clay-integrations/clay-apollo-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/clay-integrations/clay-apollo-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.*
