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

# Salesforce and Clay

> Generated from https://www.reversecontact.com/integrations-hub/salesforce-integrations/salesforce-clay-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 Growth or above, a Salesforce edition with API access, and a full user licence to authenticate

**What moves:** contacts, companies, deals, lists, both ways.
**How it is built:** native, built on the api. **Effort:** hours.

## The short version

Mechanically this is the HubSpot pair again: Lookup reads, enrichment fills, Update writes, a schedule keeps it current. What changes is the environment. Salesforce orgs carry validation rules, required fields, duplicate rules and triggers that will reject a write the table thought succeeded, so the first hour goes on reading what the org enforces rather than on building the table. The second thing that changes is matching: Salesforce has no single clean key for a company, which is why the useful action on this pair is the SOQL lookup rather than the object lookup.

## The Salesforce licence that can actually authorise this

Rows: The licence you connect with. Columns: How Clay authenticates. Clay's side of the gate is a plan: CRM integrations start on Growth. Salesforce's side is not a plan at all, it is which licence the person clicking Allow is holding, and that catches teams who correctly decided to use a dedicated integration user.

| The licence you connect with | User Sign In (OAuth) | Client Credentials |
|---|---|---|
| Full user licence | a working connection | a working connection |
| Integration User licence | an approval error | a working connection |
| API Only licence | an approval error | a working connection |

- **a working connection.** The flow completes, provided the profile carries Approve uninstalled connected apps and the connected app is pre-approved at the org level. Client Credentials additionally has to be enabled on both the app's Settings tab and the org's Policies tab, with Run As set to the integration user.
- **an approval error.** Clay documents OAUTH_APPROVAL_ERROR_GENERIC for this. The same error also appears when the connected app is not pre-approved, when SSO enforcement blocks the approval screen, or when the profile is missing that permission, so the message does not tell you which of the four it is.

Counted off that grid, of six pairings: four give you a working connection, two give you an approval error.

The whole right-hand column works, which is the finding: the dedicated integration user most Salesforce admins would reach for first is exactly the licence that cannot complete the browser flow, and the route that does work for it is the one nobody enables by default.

## What actually syncs

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

| What | Direction | What that means in practice |
|---|---|---|
| Salesforce to Clay | One way, in | Read a filtered set of leads, contacts, accounts or opportunities into a table. |
| Enrichment | Events only | Any provider or HTTP API as a column, including ones with no AppExchange listing. |
| Clay to Salesforce | One way, out | Create and Update write back. Validation rules and required fields apply, and will reject rows. |
| Refresh | Two-way sync | Auto-update on a schedule turns the backfill into a maintained field. |

## Which field lands where

Salesforce exposes far more object types than HubSpot and Clay reads the list from your own org, so the dropdown is your schema including every custom object and field. The actions are also different in kind: this is the only integration in the directory where one of them takes a query.

| In Salesforce | In Clay | What to know about the match |
|---|---|---|
| A list view | Import records from a Salesforce list | Takes the object and the view. A view that is not SOQL-compatible is capped at 2,000 records, and nothing on the view says which kind it is. |
| A report | Import records from a Salesforce report | Tabular and matrix reports only, 2,000 records maximum. Set Uniqueness fields, because without them Clay identifies a row by the whole row and near-identical rows arrive twice. |
| Any object, by query | Lookup records via SOQL | A full SOQL query as the input. This is the action people end up using for account matching, with LIKE and wildcards doing the work Salesforce's own fuzzy matching does badly. |
| Accounts, contacts, leads | Lookup record | Takes the object and an optional Exact match switch. Exact match on a normalised domain is reliable; anything looser is where the false positives come from. |
| Any object with an external ID | Upsert object | The external ID is required, which is the whole reason teams write a cleaned domain back to the account first. Without one, this action has nothing to match on. |
| Any object, by record ID | Update record | Takes the record ID, the object, and an optional Ignore blank values switch. The record ID is the only key here that cannot be ambiguous. |
| Any object | Create record | Takes the object and a Duplicate rule override. Overriding your own duplicate rules from a table is a decision somebody should make deliberately. |
| Leads | Convert lead | Takes the lead ID and a converted status, with optional account ID, contact ID, an opportunity switch, opportunity ID and name. Leave the name blank and the lead's name is used. |

**What does not cross:**

- The org's rules. Validation rules, required fields, duplicate rules and Apex triggers are enforced on the Salesforce side and reported quietly on the Clay side, so a run that completed is not a run that landed.
- Picklist labels. A picklist takes the API name rather than the display label, and multi-select values are separated with semicolons rather than commas.
- More than 2,000 records from a report, or from a list view that is not SOQL-compatible, however many the view itself shows you.

## Connect it, in this order

**Who has to do it:** A Salesforce admin, plus whoever owns the Clay workbook. The admin half is not optional here, because three of the settings are org-level.
**How long:** An afternoon, most of it in Salesforce Setup rather than in Clay.

### 1. Check the Clay plan and the Salesforce edition together

*Where:* Clay: pricing, and Salesforce: your contract

CRM integrations start on Clay Growth, which the Salesforce integration documentation does not mention. On the Salesforce side you need an edition with API access, because every read and write here spends from the org's daily API allocation.

### 2. Decide which licence Clay will authenticate as

*Where:* Salesforce: Setup, Users

Clay documents that Integration User and API Only licences cannot complete the OAuth sign-in flow. Either authenticate with a full user licence, or use the Client Credentials flow with Run As set to the integration user. Picking this wrong is the one failure that looks like a Clay bug.

### 3. Grant the profile permission before the first attempt

*Where:* Salesforce: Setup, Profiles

The authenticating user's profile needs Approve uninstalled connected apps. Without it the approval screen refuses, and the error Salesforce returns names nothing about the permission.

### 4. Pre-approve the connected app at the org level

*Where:* Salesforce: Setup, Connected Apps OAuth Usage

Set IP Relaxation to Relax IP Restrictions and Permitted Users to All users may self-authorize. If you are using Client Credentials instead, enable the flow in two places: the app's Settings tab and the org's Policies tab. One without the other fails.

### 5. Import from a list view rather than a report

*Where:* Clay: Import records from a Salesforce list

Reports are capped at 2,000 records and only tabular and matrix reports are supported. A list view that is not SOQL-compatible carries the same 2,000 cap. Clay recommends list views for anything larger, and a report import without uniqueness fields uses the whole row as the identifier, which duplicates rows.

### 6. Build the match before you build the enrichment

*Where:* Clay: Lookup records via SOQL

The object Lookup action has an Exact match switch and nothing more. The SOQL lookup is where a real match goes, with LIKE and wildcard operators against a domain you have normalised first. This is the step practitioners describe rebuilding, and the order above is what saves it.

### 7. Write with Upsert where you have an external ID, Update where you have the record ID

*Where:* Clay: Upsert object, Update record

Upsert requires an external ID on the Salesforce object, which is what a normalised domain is for. Update takes the record ID and has the Ignore blank values switch. Create takes a Duplicate rule override, which is a decision rather than a default.

### 8. Run it against a sandbox, read the errors, then schedule it

*Where:* Clay: run settings

Validation rules, required fields, duplicate rules and Apex triggers all still apply, and a rejected row is quieter in Clay than it is in Salesforce. Ten rows in a sandbox tells you what the org enforces, which is the thing the table has to be designed around.

Five of those eight steps happen in Salesforce Setup and none of them is about Clay. That is the honest shape of this pair, and it is the difference from the [HubSpot and Clay loop](pair:hubspot+clay), where the whole authorisation is one consent screen and the only org-level decision is which scopes to refuse.

## How to check it worked

- Authenticate once with the licence you intend to use in production. A full user licence that works tells you nothing about the integration user you were planning to switch to later.
- Import a list view you know holds more than 2,000 records and count what arrives. That tells you whether the view is SOQL-compatible, which is not stated anywhere in the view itself.
- Write ten records in a sandbox and read the error column, not the run status. A completed run with ten rejected rows looks exactly like a successful one from the table.
- Run your SOQL match against twenty accounts you know the answer for and count the false positives. A matcher that is right 50% of the time is the documented starting point rather than a misconfiguration.

## 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 |
|---|---|---|
| OAUTH_APPROVAL_ERROR_GENERIC on sign in | Clay documents four causes for this one message: an Integration User or API Only licence, a connected app that is not pre-approved, SSO enforcement blocking the approval screen, or a profile missing Approve uninstalled connected apps. | Work through all four rather than guessing, because the error names none of them. If the licence is the cause, Client Credentials with Run As is the documented route rather than a licence upgrade. |
| Bad value for restricted picklist | The text Clay sent does not match a picklist option. Spelling and case both count. | Match the option exactly. If the value came from an enrichment, map it through a formula column rather than writing the provider's wording straight into a restricted field. |
| A multi-select picklist writes only the first value | The wrong delimiter. Salesforce expects semicolons between values and Clay will happily send commas. | Use semicolons. This is the one error on the list where the symptom looks like a truncation rather than a format problem. |
| A field refuses a value that looks correct | A display label was used where the API name is required. The two are different strings and only one of them works. | Read the API name in Salesforce Setup and use that. A field somebody renamed years ago is the usual case. |
| A report import stopped at 2,000 rows | That is the documented cap, and it applies to a list view that is not SOQL-compatible as well. | Import from a SOQL-compatible list view instead. For anything larger than that, the SOQL lookup action is the route rather than a second report. |
| The same records arrived twice from a report | No uniqueness fields were set, so Clay identified each row by the entire row. Two rows differing in one whitespace character are two records. | Set Uniqueness fields on the report source. The account ID or a normalised domain is what belongs there. |
| The run completed and Salesforce has none of it | Validation rules, required fields, duplicate rules or an Apex trigger rejected the rows. The rejection is loud in Salesforce and quiet in Clay. | Read the error column on the write action rather than the run status, and rehearse in a sandbox. A Create action carries a Duplicate rule override, which is sometimes the right answer and should never be the default. |
| Lead conversion associated the wrong account | The match was fuzzy rather than exact. Practitioners put Salesforce's own matching at roughly half right on an org with naming variations and older imports. | Score the match in Clay and only auto-convert above a threshold, with everything below it going to a review queue. The alternative is normalising a domain on every account first and matching on that exactly. |

## What breaks, from the vendors' own docs

- **The org will reject writes.** Validation rules, required fields, duplicate rules and Apex triggers all still apply. A write that fails in Salesforce is not always loud in Clay, so check the error column rather than assuming a run that completed also succeeded.
- **API calls are an allocation.** Salesforce meters daily API requests by edition and licence count. A large table writing row by row consumes that allocation alongside every other integration in the org.
- **Actions bill on the attempt.** Same economics as everywhere else in Clay: a miss costs the same as a hit, so effective cost per filled field is the action rate divided by your match rate.

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

### Salesforce

- **Base:** `https://{instance}.my.salesforce.com/services/data/v60.0`
- **Auth:** OAuth 2.0 through a connected app. **API access is an edition feature**: editions without it cannot run any of this.

| Call | Request | What it does |
|---|---|---|
| `PATCH /sobjects/Contact/{id}` | `{ "RC_Title__c": "VP Sales" }` | Update a record. Custom fields carry the __c suffix. |
| `POST /composite/sobjects` | `{ "allOrNone": false, "records": [...] }` | Batch up to 200. `allOrNone: false` so one bad row does not roll back the batch. |
| `GET /query?q=SELECT+Id,Email+FROM+Contact+WHERE+Title=null` | - | SOQL for the filtered slice. |

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

- **Validation rules, required fields, duplicate rules and Apex triggers all apply to your writes.** A completed run is not a successful write. Read the per-record errors.
- **The daily API allocation is shared across the whole org**, set by edition and licence count. A row-by-row job competes with every other integration; the symptom of exhausting it is other people's integrations failing.
- Test in a sandbox with ten records before production. The rules you will hit were written years ago by somebody who has left.
- Installing anything usually needs Modify Metadata, Download AppExchange Packages and Customize Application. That is an admin on their own schedule.

Docs: https://developer.salesforce.com/docs/apis

### 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 University: importing from your CRM: https://university.clay.com/lessons/importing-from-your-crm-crm-enrichment
- Clay docs: Salesforce integration overview: https://university.clay.com/docs/salesforce-integration-overview
- Clay pricing: the plan comparison: https://www.clay.com/pricing
- Salesforce: app and API limits cheat sheet (PDF): https://resources.docs.salesforce.com/latest/latest/en-us/sfdc/pdf/salesforce_app_limits_cheatsheet.pdf
- 14 practitioner threads read on 2026-10-11, summarised on the page: https://www.reversecontact.com/integrations-hub/salesforce-integrations/salesforce-clay-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/salesforce-integrations/salesforce-clay-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.*
