---
name: salesforce-reverse-contact-integration
description: Connect Salesforce 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 Salesforce and Reverse Contact together, or asks why data is not moving between them.
---

# Salesforce and Reverse Contact

> Generated from https://www.reversecontact.com/integrations-hub/salesforce-integrations/salesforce-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 Reverse Contact API key and a Salesforce edition with API access

**What moves:** contacts, companies, one way, into Salesforce.
**How it is built:** built on the api, zapier, make or n8n, mcp server. **Effort:** hours.

## The short version

Salesforce is the CRM in this directory where the route is least constrained and the limits are most specific. A Flow with an HTTP Callout keeps the whole thing inside the org with the key in a Named Credential; Apex does the same with more control; Clay or n8n take it outside when a non-engineer owns the logic or the volume is a backfill rather than a trigger. What decides it is rarely the enrichment. It is the callout ceiling of 100 per transaction and 120 seconds cumulative, which quietly rules out doing a database backfill the same way you do a record trigger.

## Which route spends which Salesforce limit

Rows: Where the call runs from. Columns: What you get for it. No Reverse Contact plan gates any of this, and the Salesforce edition only decides whether the API exists at all. What decides the design is which route spends the daily inbound allocation and which route is bound by the callout ceiling, and those two pull in opposite directions.

| Where the call runs from | Free of the daily inbound allocation | Unbound by the 100-callout ceiling | Can handle the live endpoints | Keeps the key in a Named Credential |
|---|---|---|---|---|
| A Flow HTTP Callout inside the org | Yes | No | No | Yes |
| Apex, queued or batched | Yes | With a caveat | With a caveat | Yes |
| Clay reading and writing through the API | No | Yes | No | No |
| An n8n workflow with the Salesforce node | No | Yes | Yes | No |
| A Zap or a Make scenario | No | Yes | With a caveat | No |

- **Yes.** Documented and true on that route. Salesforce meters inbound API requests and an outbound callout is not one, so enrichment done inside the org spends none of the allocation and the write that follows is an internal update rather than an API call.
- **With a caveat.** Queueable and Batch Apex spread callouts across transactions rather than removing the ceiling, and a poll loop held open inside one transaction would spend the 120-second cumulative budget waiting. A Make scenario can reach a live endpoint through a repeater and a sleep module, at one operation per iteration.
- **No.** Not true on that route. Every external route reads and writes through the API, so each record it touches counts twice against the allocation that Outreach, Gong and every other connected tool is already drawing on, and none of them can hold the key in a Named Credential because the key is not in the org.

Counted off that grid, of twenty pairings: eight give you yes, three give you with a caveat, nine give you no.

The first column is the one teams do not expect, and it is the strongest argument for doing this inside the org: the enrichment costs nothing from an allocation that everything else is competing for. It reverses the moment the job stops being a trigger, because the second column is where a backfill lives, so a mature build usually ends up with both, a Flow on creation and something with a queue for the back catalogue.

## 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 |
|---|---|---|
| Email to full person record | One way, in | POST /v2/enrich/persons resolves an email into identity, current role, history, education, skills and location. 2 credits. |
| Domain to company record | One way, in | POST /v2/enrich/companies returns firmographics for a domain or a company name. 2 credits. |
| The callout | One way, out | A Flow HTTP Callout or an Apex callout, authorised by a Named Credential. Outbound, so it does not touch the inbound API allocation. |
| Anything back to Reverse Contact | One way, out | Nothing. This is a read layer, and your Flow decides which fields it may write. |

## Which field lands where

Which field goes out is decided by what the record holds, and the cheapest call is the one almost no Salesforce org can make: a cached lookup needs a profile URL, and most orgs only have an email. Everything coming back is yours to place, because nothing writes itself.

| In Salesforce | In Reverse Contact | What to know about the match |
|---|---|---|
| Lead or Contact Email | POST /v2/enrich/persons, 2 credits | The usual starting point, and the dearer of the two person calls. Returns identity, the current role, history, education, skills and location on one schema, which is what makes it safe to write into typed fields rather than into a note. |
| Account Website, or a domain on the Lead | POST /v2/enrich/companies, 2 credits | Firmographics from a domain or a company name. Worth running on the Account rather than per Contact, because one call covers every Contact attached to it. |
| A profile URL already on the record | POST /v2/fetch/persons, 1 credit | Half the price, and unmetered from the $249 plan rather than the $699 one. If any part of your stack already collects a profile URL, routing those records to this call instead is the single largest saving available on this pair. |
| The free freshness check | POST /v2/fetch/persons/check, 0 credits | Says whether a profile is cached and when it was last updated. One extra callout against a 100-callout ceiling, in exchange for not paying to refresh a record that was updated last week. |
| A Named Credential | Authorization: Bearer rc_your_api_key | Referenced by name from the callout, so the key is never in the Flow, the Apex or the change set. This is the specific reason this route can clear a security review that an external one cannot. |
| An External Services registration | The endpoint, as a Flow action | What turns the API into something an admin can drag into a Flow. Register the path you actually intend to call: a registration made against a path that later changes fails at runtime rather than at save. |
| Queueable or Batch Apex | One callout per transaction instead of 200 | The documented way around the ceiling rather than a workaround. Each record becomes its own transaction, so neither the 100-callout count nor the 120-second cumulative timeout binds. |
| Anything outbound to Reverse Contact | Nothing at all | This is a read layer. No Salesforce record, field or event is sent anywhere, and there is nothing in the product to send it to. |

### Which of the three Salesforce ceilings each shape of this build meets first

Salesforce publishes three separate limits and they bind different halves of this build. Knowing which one you are near is what decides whether the answer is a queue, a batch, or moving the job out of the org, because two of the three cannot be bought your way out of.

| The shape of the job | The limit it meets first |
|---|---|
| One enrichment when a Lead is created | None of them. A single callout in a trigger-sized transaction is comfortable, and the cached endpoints publish a 500ms P95 |
| The same trigger during a 200-row import | The 100-callout ceiling on one Apex transaction, with 120 seconds cumulative across all of them and 10 seconds the default on each |
| A backfill across the whole database | The same ceiling, which is why this belongs in Queueable or Batch Apex, or outside the org entirely |
| Clay or n8n writing results back row by row | The daily inbound allocation, which is shared with every other connected tool and counts calls from managed packages too |
| A slow inbound integration running beside it | The concurrent limit on inbound calls of 20 seconds or longer: 25 in a production org or sandbox, 5 in Developer Edition or a trial |
| A live refresh from inside the org | No documented limit stops the call. The task it hands back simply has nowhere in a Flow to be polled from |

**What does not cross:**

- An AppExchange package. There is no managed package and no listing, which is consistent rather than an oversight: Reverse Contact maintains apps on Clay, Zapier and Make and nothing inside any CRM or sequencer.
- The live endpoints, from a Flow. They answer with a task id rather than a record, a Flow cannot wait, and holding a transaction open to poll would spend the 120-second cumulative callout budget on waiting.
- A business email or a direct phone number. Both are separate endpoints at 3 and 20 credits, charged only when one is found, and the email finder is asynchronous as well.
- Any field mapping shipped by the vendor. There is no mapping screen, because there is no app: your Flow decides which field each value lands in and whether it may overwrite what is there, which is more work and is also why this route never flattens a field a rep owns.

## Connect it, in this order

**Who has to do it:** A Salesforce admin for the Named Credential and the External Service, plus whoever can create a Reverse Contact API key. A developer only if the job is a backfill.
**How long:** Half a day for the Flow route. The edition check and the trigger-or-backfill decision are the two things to settle before any of it.

### 1. Confirm the edition carries API access, because everything here rests on it

*Where:* Salesforce: Setup, Company Information

API access is included from Enterprise and is a paid add-on on Professional. The allocation that comes with it is worth reading at the same time: Developer Edition gets a flat 15,000 inbound calls a day, while Enterprise gets 100,000 plus 1,000 for each Salesforce licence plus any API Call Add-Ons purchased.

### 2. Decide whether this is a trigger or a backfill, because it changes the architecture

*Where:* A whiteboard, not Setup

One callout when a Lead is created is comfortable. The same logic running inside a bulk import meets the 100-callout ceiling on a single Apex transaction, and that is a count rather than a duration, so no timeout setting fixes it. A backfill belongs in Queueable or Batch Apex, or outside the org.

### 3. Create the fields the enrichment is allowed to own

*Where:* Salesforce: Object Manager, Fields and Relationships

Prefix them and leave the ones your reps type into alone. This is the step that cannot be undone quietly: a Flow pointed at a field somebody maintains by hand will keep overwriting it, and the damage only surfaces when a rep notices their own entry has gone.

### 4. Put the key in a Named Credential, never in a Flow variable

*Where:* Salesforce: Setup, Named Credentials

A key pasted into a Flow variable or an Apex constant is metadata, and metadata travels through change sets and version control. A Named Credential holds it in org configuration and lets the callout reference it by name, which is the part a security review actually asks about.

### 5. Register the endpoint so a Flow gets an action

*Where:* Salesforce: Setup, External Services

External Services turns the registered endpoint into an HTTP Callout action a Flow can call, which is what keeps this route in the hands of an admin rather than a developer. Apex is the alternative and buys control rather than capability.

### 6. Build the no-match path before the happy path

*Where:* Flow: a Decision element after the callout

Reverse Contact returns null with a confidence score rather than a best guess, so a lookup that matched nobody is a normal outcome. Decide what the Flow does on that branch, which is usually nothing at all, before you wire the branch that writes.

### 7. Turn on API Usage Notifications while you remember

*Where:* Salesforce: Setup, API Usage Notifications

It emails a named user when inbound API requests pass a percentage of the allocation you set. Worth doing whichever route you pick, because calls from installed managed packages count against the same number and the thing that exhausts it is rarely the thing you just built.

### 8. Test in a sandbox and watch the limits rather than the result

*Where:* Salesforce: Developer Console, or the debug log

The question is not whether one record enriches, which it will. It is how many callouts the transaction used and how close the cumulative time came to 120 seconds, because those are the numbers that decide whether this survives an import.

Two of those eight are decisions about shape rather than configuration, and they are the ones that cost a rebuild if taken late. Salesforce is the CRM here with the most routes and the most rules, which is why the [HubSpot build](pair:hubspot+reverse-contact) reads as a licence question and this one reads as an architecture question.

## How to check it worked

- Run the Flow once on a Lead whose answer you know, and once on an address that resolves to nobody. The second is the real test: the Flow should take the empty path, write nothing, and cost no credits.
- Import 150 rows into a sandbox with the trigger active. If you are going to meet the 100-callout ceiling, this is where it should happen, rather than in production on the morning of a list upload.
- Read the org API usage in Setup before and after a hundred records are enriched from Clay or n8n, then do the same hundred from a Flow. The first moves the number and the second does not, which is the whole argument for the in-org route.
- Search your metadata for the key string after everything works. Finding it anywhere is the failure the Named Credential step exists to prevent, and it is easier to find now than in a change set.

## 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 |
|---|---|---|
| System.LimitException: Too many callouts: 100 | Salesforce caps a single Apex transaction at 100 callouts. A trigger that calls out once per record meets it the moment more than a hundred rows arrive in one transaction, which an import does by default. | Move the work into Queueable or Batch Apex so each record is its own transaction, or run the backfill outside the org. Raising a timeout changes nothing, because this is a count and not a duration. |
| The transaction died partway through a batch of records | There is a cumulative timeout of 120 seconds across every callout in one transaction, on top of the 10-second default on each individual call. | Reduce the callouts per transaction rather than lengthening each one. Reverse Contact publishes a 500ms P95 on the cached endpoints, so arriving anywhere near 120 seconds means the count is the problem. |
| You have exceeded your daily API call limit | Salesforce meters total inbound API requests per 24 hours per org: 15,000 on Developer Edition, and on Enterprise 100,000 plus 1,000 for each Salesforce licence plus any add-ons. Calls made from installed managed packages count against the same number. | Turn on API Usage Notifications so somebody is told at a percentage rather than at the wall, and batch the write-backs. The outbound call to Reverse Contact is not an inbound request and is not what spent it. |
| REQUEST_LIMIT_EXCEEDED while nowhere near the daily number | That is the concurrent limit rather than the daily one. A production org or sandbox allows 25 simultaneous inbound requests lasting 20 seconds or longer, and Developer Edition or a trial allows 5. | Find the slow caller rather than the busy one. There is no limit at all on concurrent requests shorter than 20 seconds, so this is almost always one long-running integration instead of volume. |
| The Flow failed on a contact who is not in the database | A confident null is the documented answer rather than an error: Reverse Contact returns null rather than a best guess and attaches a confidence score to every response. | Add a Decision element on the field being present and write nothing on the empty path. The call cost no credits either way, because every 4xx and 5xx is free. |
| The API key turned up in a change set | A key pasted into a Flow variable or an Apex constant is metadata, and metadata travels through change sets, retrieves and version control. | Move it into a Named Credential and reference it by name from the callout. That is also the answer a security review is looking for, and it is the reason this route can pass one that an external route cannot. |
| A live refresh never came back | The live endpoints are asynchronous: the response carries a webhookId rather than a record, and Reverse Contact documents the wait as usually seconds and possibly tens of minutes. | Do not run live resolution from a Flow at all. Run it in n8n, which polls with a Wait node, and let the Salesforce node write the answer back when it arrives. |
| An endpoint that worked last week returns nothing | /v2/resolve was replaced by /v2/enrich and /v2/search/persons by /v2/search/people, with the old pair documented as live only until 13 October 2026. | Search the org for both old paths: in Apex, in every External Services registration, and in any Named Credential URL. A registration made against the old path fails at runtime rather than when you save it. |

## What breaks, from the vendors' own docs

- **100 callouts and 120 seconds per transaction.** Salesforce caps a single Apex transaction at 100 callouts, with a cumulative timeout of 120 seconds across all of them and 10 seconds by default on each. One call on record creation is comfortable. A trigger firing over a 200-record bulk update is not, and the fix is Queueable or Batch Apex rather than a larger timeout.
- **The daily API allocation is shared and finite.** Salesforce meters inbound daily API requests by edition and licence count across the whole org. The write-back half of this build competes with every other connected tool for the same number. Outbound callouts are exempt, which is a meaningful difference between doing the enrichment inside the org and doing it from Clay.
- **Professional needs the API add-on.** API access is included from Enterprise and is a paid add-on on Professional. Every route on this page except a manual CSV depends on it, so confirm the edition before designing anything.
- **Live resolution will not fit a Flow.** The live endpoints return a task id to poll rather than a record. A Flow cannot wait, and holding a transaction open to poll would spend the 120-second cumulative budget. Run live resolution in n8n and let it write back through the Salesforce node.
- **The key belongs in a Named Credential.** An API key pasted into a Flow variable or an Apex constant travels in metadata, change sets and version control. A Named Credential keeps it in the org configuration where it belongs and lets the callout reference it by name.

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

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

- Salesforce: callout limits and limitations: https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_callouts_timeouts.htm
- Salesforce developer limits and allocations quick reference (PDF): https://resources.docs.salesforce.com/latest/latest/en-us/sfdc/pdf/salesforce_app_limits_cheatsheet.pdf
- 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
- 14 practitioner threads read on 2026-10-11, summarised on the page: https://www.reversecontact.com/integrations-hub/salesforce-integrations/salesforce-reverse-contact-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/salesforce-integrations/salesforce-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.*
