The same read, enrich, write loop, against an org with stricter rules.
Clay Growth or above, a Salesforce edition with API access, and a full user licence to authenticate
Contacts, Companies, Deals, Lists, two-way sync.
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.
Object by object, with the direction each one moves in. This is the table to read before the feature list, because a capability that only moves one way is a different product from the one you think you are buying.
| 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 | Event 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 | Both ways | Auto-update on a schedule turns the backfill into a maintained field. |
One of those four rows moves in both directions. The two that do not are Salesforce to Clay and Clay to Salesforce, and those are the rows that decide how you design around this rather than the ones in the brochure.
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. |
Three things are worth knowing before you plan around this mapping, because each one is a decision somebody has to own rather than a setting to find.
Every row above travels as a file: eight field mappings and three documented exclusions, each one's note, and the four vendor documents behind them. The CSV opens in a spreadsheet, the JSON is the shape an agent wants, and the Markdown is the table to paste into a ticket.
The table above is why this pair is rated at hours rather than minutes: six of those eight actions need a key that does not exist in a typical org until somebody creates it. A normalised domain on every account is the single piece of work that makes the other seven behave, which is also what makes Salesforce the hub rather than the thing being enriched.
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. Pick one on each side and the grid marks the answer.
Pick one on each side.
| 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 |
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.
Every step below is from the two vendors' own setup documentation, in the order they document it. Two of them cost you an afternoon if taken late, so the order is the useful part rather than the clicks.
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.
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.
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.
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.
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.
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.
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.
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, where the whole authorisation is one consent screen and the only org-level decision is which scopes to refuse.
The same sequence, the sync table, the documented limits and the error list ship as one agent skill. Point Claude Code, Cursor or anything that reads a file at this pair as a skill and it has the whole pair without reading two sets of vendor docs first.
curl -o .claude/skills/salesforce-clay/SKILL.md https://www.reversecontact.com/integrations-hub/skills/salesforce-clay.md
Every limit below is documented by one of the two vendors. They are here because they change decisions, not because they are flaws.
Each of those is documented behaviour rather than a fault, so none of them is going to be fixed by a support ticket. The ones that produce a symptom you would misread are below.
Each one below is a symptom somebody reports, the documented reason behind it, and the fix. Most are configuration rather than faults, which is why they survive a support ticket.
WhyClay 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.
WhyThe 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.
WhyThe 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.
WhyA 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.
WhyThat 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.
WhyNo 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.
WhyValidation 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.
WhyThe 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.
If none of those is it, the next thing to check is the thing most pairs fail on: whether the plan you are on carries the feature at all, which the grid above answers. The same symptom on another pair is often the same cause, so the directory indexes all of them by the message rather than by the integration.
The right-hand column is the one worth being honest about, because every item in it is a reason to spend the budget somewhere else in the stack rather than a reason to configure harder.
Searched for this pair by name, in the words a person would use. 14 threads from 2024 to 2026 were read in full on 11 October 2026, and the 5 below are the ones that carry a point. Each is one person's experience rather than a measurement, and the vendors' own documentation is what the rest of this page rests on.
The integration's fuzzy matching is hit or miss. I'd say it matches to the correct account 50% of the time. So, I ended up adding a SOQL action column instead to create my own "fuzzy" match with LIKE and wildcard operators.
r/gtmengineering·November 2025·2 points
Written by somebody four years into the job at that company. It is also the clearest argument for why Lookup records via SOQL exists as a separate action from Lookup record, and why the setup order above puts the match before the enrichment.
It helped shifting the matching logic into Clay instead of relying on Salesforce to guess. Clay lets you line up multiple checks (domain, name similarity, location, employee count, etc.) so you can control the order and avoid those false positives.
r/gtmengineering·November 2025·11 points
The highest-scoring comment in the set that is about the pair rather than about pottery. The same comment is careful to say it is not fully hands-off and that they only run it on new leads, which is the scoping decision that keeps the action bill proportionate.
Build a simple score: exact domain match = 50, website root match = 25, name similarity >90 = 15, city/state match = 5, employee range overlap = 5, ticker match when present = 20. Hard blocks: free email domains, generic names, and conflicting domains. If score [...] 75, auto-associate to the top account; 50-74 goes to a review queue
r/gtmengineering·November 2025·1 points
One point, and the most specific thing anybody said in fourteen threads. The weights are that team's rather than a standard, but the shape is the point: three bands and a review queue, because auto-converting a lead onto the wrong account is expensive and silent.
I was a Clay enterprise customer for a quite a bit, and their GTM ops team helped me with matching, but it was just a SOQL query as well. Enriching domain on all accounts, then SOQL query within lookup records gave the best result.
r/gtmengineering·November 2025·1 points
Worth more than its score. An Enterprise customer with vendor support on the problem landed on the same two steps in the same order: get a domain onto every account first, then query against it. That is also exactly what the Upsert action needs an external ID for.
Over the past two months I've implemented clay "Starter" at my company. I'm working to develop a proof of concept for the Growth plan, using HTTP to trigger enrichments from Salesforce and give user a flow to automatically create Accounts/Contacts from the Clay interface.
r/gtmengineering·April 2026·1 points
A Salesforce developer building the business case for the tier that carries the integration, which is the grid above described from inside a company. A reply in the same thread suggests putting a spreadsheet and an external automation tool in the middle to test the idea without the upgrade, and notes that even that route needs a paid tier on the automation side.
Two subjects dominate, and neither is whether the connection works. The first is matching: Salesforce's own fuzzy account matching is described as roughly half right, and every practitioner who solved it moved the matching into Clay as a SOQL query with a confidence score in front of it. The second is the plan, raised by somebody implementing on Starter and building a proof of concept for Growth, which is the gate above seen from the inside. The jokes about pottery outscore both.
The matching quotes are four people agreeing on a method rather than four measurements, and the 50% figure is one org's. They are here because the vendors document the actions and not the problem the actions exist for, which is the gap the Clay hub exists to close on every pair.
Everything true of Clay and HubSpot is true here, and then the org gets a vote. That is the whole difference. A HubSpot portal will generally accept what you send it. A mature Salesforce org has opinions encoded in validation rules and triggers that were written years ago by someone who has left, and those opinions will reject your writes in ways that are entirely correct and completely opaque.
The practical sequence is therefore inverted from the HubSpot version. Start in a sandbox, write ten records, read the errors, and only then design the table around what the org will actually accept. Teams that build the table first and discover the rules afterwards usually rebuild it.
Reverse Contact resolves an email, a domain or a profile URL into a verified people and company record, through one API with a consistent schema. It sits under Salesforce, Clay and everything else in this directory, and it returns null with a confidence score rather than a guess.
Free trial, no card required, and 500 credits to start.
Growth or Enterprise. Clay's plan comparison marks "CRM integrations" and "HTTP API integrations" as included from Growth and not on Free or Launch, and the Salesforce integration documentation names no plan at all. Practitioners on the lower tiers describe routing through a Google Sheet or an external automation tool instead, which is a workaround rather than the integration.
Yes, with Create, Update and Upsert actions, subject to everything your org enforces. Validation rules, required fields, duplicate rules and Apex triggers all still apply, and a write that fails in Salesforce is not always loud in Clay. Check the error column rather than assuming a completed run also succeeded.
Almost always a rule somebody wrote years ago: a required field the table is not populating, a validation rule the value breaks, or a duplicate rule catching the row. Start in a sandbox, write ten records, read the errors, and design the table around what the org will actually accept.
Yes. Salesforce meters daily API requests by edition and licence count across every integration in the org, so a large table writing row by row competes with your existing connectors. The symptom of running out is other people's integrations failing, which makes it an unpopular way to find out.
Mechanically, no: Lookup reads, enrichment fills, Update writes, a schedule keeps it current. What changes is that a mature Salesforce org has opinions encoded in it. The first hour goes on reading what the org enforces rather than on building the table.
Tier requirements, sync behaviour and limits read from each vendor's own documentation in September, October and November 2026. Vendors change these without notice.
Reverse Contact appears in this directory as a data provider and publishes it. Every other tool is here on merit and nobody pays for placement.