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

# Clay and Outreach

> Generated from https://www.reversecontact.com/integrations-hub/clay-integrations/clay-outreach-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:** Clay Launch or above, an Outreach contract, and twelve read-write scopes you cannot refuse

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

## The short version

A deliberately small integration that closes the most useful loop in outbound: a Clay table builds and enriches the row, scores it, writes the personalisation, and then pushes it straight into an Outreach sequence without a CSV ever existing. Four actions cover it, create, update, look up and add to sequence, and all four are added as enrichment columns rather than configured in a settings screen. What it is not is a sync. Nothing comes back from Outreach, so reply and meeting data lives there and the table is a one-way feed.

## Which Clay plan reaches which kind of tool

Rows: Clay plan. Columns: What you are connecting. Clay bands every integration by plan rather than pricing them individually, and the bands run in an order worth knowing before you evaluate a chain: a data provider costs nothing extra, a sequencer starts one tier up, and a CRM starts two.

| Clay plan | Data providers, like Apollo | Sequencers: Outreach, Smartlead, lemlist | CRMs: HubSpot, Salesforce |
|---|---|---|---|
| Free | Included | Not included | Not included |
| Launch | Included | Included | Not included |
| Growth | Included | Included | Included |
| Enterprise | Included | Included | Included |

- **Included.** Read off Clay's own catalogue, which states a plan band per integration: Apollo is Included in All Plans, Outreach, Smartlead and lemlist are all Included in Launch+, and the pricing page marks CRM integrations as included from Growth.
- **Not included.** Not available on that plan at any volume. Every action on all four is additionally marked Bring Your Own Account Required, so your own contract with the other vendor is a separate prerequisite.

Counted off that grid, of twelve pairings: nine give you included, three give you not included.

Outreach is in the middle column, so the Clay gate here is the mild one. The gate that should slow you down on this pair is not a plan at all, it is the scope list above, and it applies identically on every Clay tier.

## 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 |
|---|---|---|
| New prospects | One way, out | Create prospect, taking email plus optional name, company, title, address, contact preferences, social links and campaign fields. |
| Existing prospects | One way, out | Update prospect, keyed on id or email, across the same field set. |
| Sequence enrolment | One way, out | Add to sequence, which is the action most tables are built to reach. Mailbox ids are looked up with their own action. |
| Prospect lookups | One way, in | Look up prospect by email or id, optionally including the sequences they are already in, which is how a table avoids re-enrolling somebody. |
| Personalised copy | One way, out | Email templates on the table send with custom field inputs, so the column that wrote the line is the thing that delivers it. |
| Replies, opens and meetings | Events only | Nothing comes back. Outreach is where performance lives and the table never learns what happened. |

## Which field lands where

Five actions and a permission grant that is wider than all five. The actions themselves are narrow and well behaved; the scopes they ask for are not, and both facts belong on the same page.

| In Clay | In Outreach | What to know about the match |
|---|---|---|
| Lookup prospect | Email or prospect ID, both optional | Include Sequences is the input worth setting: it returns what the person is already enrolled in, which is the only duplicate protection on this pair. |
| Create prospect | Email, everything else optional | Optional groups cover basics, address, contact preferences, social and websites, additional phone numbers, campaign and source fields like tags and event name, and personal details. |
| Update prospect | ID and email | The same optional groups as Create. The ID is required, so this action lives downstream of a lookup. |
| Add to sequence | Prospect ID, Sequence ID and Mailbox ID | All three required, and the sequence must be Active in Outreach. This is the action the integration exists for and the one with the most prerequisites. |
| Lookup mailbox by email address | An email address | Exists only to supply the third required input above. Its presence in a five-action integration tells you how often that input is the blocker. |
| Email templates | Columns on the table, sent with Create prospect | Clay documents adding templates to the table and sending them with custom field inputs, which is how the personalisation written in Clay reaches the first touch. |
| Replies, opens, meetings | Nothing comes back | There is no read action for engagement. Outreach holds performance and the table holds the list, and joining them is a job for the CRM both write to. |
| Sequence creation | Not an action | Like every sequencer pair on the Clay hub, the campaign is built in the sending tool first and Clay only populates it. |

### The twelve scopes Clay requires, none of which can be switched off

| The action | How it reads on the record |
|---|---|
| prospects.all, recipients.all | Read and write every prospect and recipient. Expected, and the reason the integration exists |
| sequences.all, sequenceSteps.all, sequenceStates.all | Read and write every sequence, its steps and every prospect's state in it |
| mailboxes.all | Read and write every mailbox, which is what makes the mailbox lookup possible |
| opportunities.all, opportunityStages.all | Read and write every opportunity and stage, none of which any of the five actions touches |
| users.all, roles.all | Read and write every user and role in the Outreach org |
| stages.all, events.all | Read and write every prospect stage and every event |

**What does not cross:**

- Any way to refuse a scope. Clay describes these as permissions that cannot be disabled and are always requested, which is unusual: its HubSpot integration makes most scopes optional and ships three of them switched off.
- A sequence that is paused. Clay states sequences must be Active for a lead to be added successfully.
- Anything coming back from Outreach. The integration is a feed in one direction, so reply handling and meeting booking stay where they happen.

## Connect it, in this order

**Who has to do it:** Whoever owns the Clay workbook, and somebody willing to grant Outreach scopes across the whole org. In a governed Outreach instance that is a conversation, not a click.
**How long:** Ten minutes. The scope review is the part that should take longer.

### 1. Read the twelve required scopes before you authenticate

*Where:* Clay: the consent screen

Clay lists them as permissions that cannot be disabled and are always requested: users, stages, sequenceSteps, sequenceStates, sequences, roles, recipients, prospects, opportunityStages, opportunities, mailboxes and events. Every one is the .all variant, meaning read and write.

### 2. Check the Clay plan band

*Where:* Clay: pricing

Clay's catalogue puts Outreach at Included in Launch+, so the Free plan does not reach it. Every action is also marked Bring Your Own Account Required, which here means your own Outreach contract rather than anything Clay resells.

### 3. Connect the Outreach account from the enrichment panel

*Where:* Clay: Add enrichment, Outreach

Search Outreach, pick one of the actions under Integrations, then Select Outreach account or + Add account to authenticate. The connection is made where the column is built rather than in a workspace settings screen.

### 4. Make sure the target sequence is active

*Where:* Outreach: Sequences

Clay notes it on the action itself: sequences must be Active in Outreach for a lead to be added successfully. A paused sequence takes the call and does not enrol anybody.

### 5. Fetch the mailbox ID once and hold it in a column

*Where:* Clay: Lookup mailbox by email address

Add to sequence requires a Mailbox ID alongside the prospect and sequence, and that action exists purely to turn a sending address into one. Resolve it once rather than per row.

### 6. Look up before you create

*Where:* Clay: Lookup prospect

It takes an email or a prospect ID, both optional, and has an Include Sequences switch that tells you what the person is already enrolled in. That switch is the one thing standing between your table and double-enrolling somebody.

### 7. Create or update, then enrol as a separate column

*Where:* Clay: Create prospect, Update prospect

Create takes an email plus optional basics, address, contact preferences, social links, extra phone numbers, campaign and source fields, and personal details. Update takes the same plus an ID. Neither enrols anybody; Add to sequence is its own action.

### 8. Put the condition on the enrolment column, not the enrichment

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

The expensive columns are upstream and the irreversible one is downstream. Gating the enrolment on the score keeps the research you paid for and stops the email you would regret.

Seven of these eight steps are ordinary, and the first one is not: this is the broadest permission grant any pair in this directory asks for, and it is presented as a connect button. The [Outreach and Salesforce pairing](pair:salesforce+outreach) shows what Outreach's own permission model looks like when somebody has thought about it.

## How to check it worked

- Enrol one prospect into an active sequence and confirm it in Outreach. Then pause the sequence and try again: the failure is the one most teams meet in production.
- Run Lookup prospect with Include Sequences on somebody you know is already being worked. If the table cannot see that, it will enrol them a second time.
- Check the mailbox ID resolves to the address you expect. Add to sequence sends from whatever mailbox that ID names, and a wrong one is a rep sending from a colleague's address.
- Have an Outreach admin review the granted scopes after connecting. All twelve are read and write, and opportunities and roles are on the list.

## 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 lead was not added to the sequence | The sequence is not Active in Outreach. Clay states this requirement on the Add to sequence action itself. | Activate the sequence, then re-run the column. A paused sequence is the most common cause and it produces no obvious error on the Clay side. |
| Add to sequence will not run at all | It needs three inputs and most tables only have two. Prospect ID, Sequence ID and Mailbox ID are all required. | Run Lookup mailbox by email address once to resolve the mailbox, and carry the prospect ID forward from Create or Lookup prospect. |
| The same person was enrolled twice | Nothing in the push checks existing enrolment unless you ask. Lookup prospect has an Include Sequences switch and it is not on by default. | Add a lookup column with Include Sequences on, and gate the enrolment column on what it returns. There is no de-duplication setting to turn on instead. |
| Update prospect is failing on rows that have an email | Update requires the ID as well as the email. An email alone is enough for Create and not for Update. | Look the prospect up first and map its ID into the Update column. This is the same lookup-before-write shape every Clay sequencer pair needs. |
| Emails went out from the wrong address | Add to sequence sends from whatever mailbox the Mailbox ID names, and a single hard-coded ID applies to every row. | Resolve the mailbox per owner rather than once for the table if reps send from their own addresses. The lookup action takes an email, so the owner column can drive it. |
| An Outreach admin is asking why Clay can see opportunities | Because it can. opportunities.all and opportunityStages.all are in the required scope list, alongside users.all and roles.all, and Clay documents all twelve as not disableable. | There is no configuration answer. Either the grant is acceptable or the integration is not, and that is a decision to take before connecting rather than after. |
| Nothing is coming back from Outreach | By design. The five actions write and look up; there is no engagement read. | Read performance in Outreach, and join it to the list in whichever CRM both tools already write to. |
| Credits went on rows that were never enrolled | The enrichment columns upstream run before the enrolment column decides anything, and each one spends an Action per record. | Move the qualifying condition as far up the table as it will go. Clay bills per record enriched regardless of what happens downstream. |

## What breaks, from the vendors' own docs

- **It is a feed, not a sync.** Clay writes to Outreach and reads only what you explicitly look up. No reply, open, bounce or meeting data returns to the table, so a Clay table cannot suppress on engagement unless you build the lookup yourself. Any reporting that spans list quality and sequence performance has to happen somewhere both tools write, which usually means the CRM.
- **Check before you enrol, or you will double-enrol.** The lookup action can include the sequences a prospect is already in, and it exists because the create and add-to-sequence actions will happily act again on somebody already being sequenced. A table that pushes without that check produces the duplicate-outreach problem the integration is supposed to prevent.
- **Credits are spent above the action, not on it.** Pushing to Outreach is cheap; filling the row is not. A waterfall that tries several providers for an email and a phone number is where a Clay bill comes from, so test on ten rows before running five hundred and decide what a row is worth before you decide what a sequence is worth.
- **Authentication is per table, not per workspace.** The Outreach account is selected inside the enrichment modal, so different tables can point at different Outreach accounts and nothing warns you that they do. In a team running several tables that is a real source of prospects landing in the wrong place, and it is worth a naming convention rather than a discovery in week three.

## 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: Outreach integration: https://university.clay.com/docs/outreach-integration-overview
- Clay integrations: Outreach: https://www.clay.com/integrations/data-provider/outreach
- Clay pricing: the plan comparison: https://www.clay.com/pricing
- Outreach support: Outreach and CRM connection overview: https://support.outreach.io/support/solutions/articles/159000426014
- 14 practitioner threads read on 2026-10-11, summarised on the page: https://www.reversecontact.com/integrations-hub/clay-integrations/clay-outreach-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/clay-integrations/clay-outreach-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.*
