---
title: "Salesforce and Reverse Contact integration: what syncs, and what it needs"
description: "Salesforce and Reverse Contact: what moves, in which direction, which plan carries it, and the limits that bite. Verified October 2026."
url: https://www.reversecontact.com/integrations-hub/salesforce-integrations/salesforce-reverse-contact-integration
format: markdown twin of the page above, generated at build time
---

New Unlimited plans are here. Fetch, search and enrich without counting credits. [See plans →](https://www.reversecontact.com/integrations-hub//pricing#plans)

Reverse Contact

### Products

Data

People Data

Company Data

Our Data Quality Standard

Delivery methods

API

Webhooks

CSV Enrichment

MCP

CLI

Integrations

### Use cases

[Sales Product](https://www.reversecontact.com/integrations-hub//use-case/sales-products)[Recruiting Product](https://www.reversecontact.com/integrations-hub//use-case/recruiting-products)[Internal Data Teams](https://www.reversecontact.com/integrations-hub//use-case/internal-data-teams)[AI Products](https://www.reversecontact.com/integrations-hub//use-case/data-for-ai)[CRM Enrichment](https://www.reversecontact.com/integrations-hub//use-case/crm-enrichment)

### Features

[Email Finder API](https://www.reversecontact.com/integrations-hub//feature/email-finder-api)[Phone Number Enrichment](https://www.reversecontact.com/integrations-hub//feature/phone-number-enrichment)[People Search API](https://www.reversecontact.com/integrations-hub//feature/people-search-api)[Agentic Search API](https://www.reversecontact.com/integrations-hub//feature/agentic-search-api)[People Lookalike API](https://www.reversecontact.com/integrations-hub//feature/people-lookalike-api)[Company Search API](https://www.reversecontact.com/integrations-hub//feature/company-search-api)[Person Enrichment API](https://www.reversecontact.com/integrations-hub//feature/person-enrichment-api)[Company Enrichment API](https://www.reversecontact.com/integrations-hub//feature/company-enrichment-api)[Person Social Data API](https://www.reversecontact.com/integrations-hub//feature/social-person-api)[Company Social Data API](https://www.reversecontact.com/integrations-hub//feature/social-company-api)

Security

Pricing

Docs

[Log in](https://app.reversecontact.com/auth/login) [Book a demo](https://www.reversecontact.com/contact?utm_source=integrations-directory&utm_medium=referral&utm_campaign=tool-integrations&utm_content=site-header) [Start for free](https://app.reversecontact.com/auth/signup?utm_source=integrations-directory&utm_medium=referral&utm_campaign=tool-integrations&utm_content=site-header)

# Salesforce and Reverse Contact

Featured

No AppExchange listing, and the callout limits are the real design constraint.

Checked by **Reverse Contact** · Verified 2026-10-11 · No paid placement

## What you have to buy first

A Reverse Contact API key and a Salesforce edition with API access

## What moves

Contacts, Companies, one way, in.

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.

## What actually syncs

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

Nothing in that table moves in both directions. Whichever system you treat as the source of record, the other one is downstream of it, and a correction made in the wrong place does not travel.

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

A few 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.

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

Every row above travels as a file: eight field mappings, six the shape of the job rows and four documented exclusions, each one's note, and the six 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 summary worth keeping is that the outbound half of this build is nearly unconstrained and the inbound half holds every number. One callout on creation spends nothing from the allocation and sits well inside a transaction; the same logic over an import meets the callout ceiling; and a result written back from outside the org spends the allocation twice, once to read the record and once to write it.

## Which route spends which Salesforce limit

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. Pick one on each side and the grid marks the answer.

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

## How to connect Salesforce to Reverse Contact

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.

- **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 it takes** — 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.

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.

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.

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.

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.

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.

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.

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.

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](https://www.reversecontact.com/integrations-hub/hubspot-integrations/hubspot-reverse-contact-integration) reads as a licence question and this one reads as an architecture question.

Hand it to an agent instead

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](https://www.reversecontact.com/integrations-hub/skills/salesforce-reverse-contact.md) and it has the whole pair without reading two sets of vendor docs first.

curl -o .claude/skills/salesforce-reverse-contact/SKILL.md https://www.reversecontact.com/integrations-hub/skills/salesforce-reverse-contact.md

## What breaks, and what nobody tells you

Every limit below is documented by one of the two vendors. They are here because they change decisions, not because they are flaws.

- **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.

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.

## The 8 failures people actually hit

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.

### System.LimitException: Too many callouts: 100

WhySalesforce 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

WhyThere 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

WhySalesforce 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

WhyThat 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

WhyA 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

WhyA 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

WhyThe 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

Why/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.

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](https://www.reversecontact.com/integrations-hub/errors) is often the same cause, so the directory indexes all of them by the message rather than by the integration.

## When this is the right integration

### Set it up when

- Enrichment on lead creation, inside the org, with no third vendor
- An org where an admin or developer already owns Flow and Apex
- A security review that wants the key in a Named Credential

### Do not bother when

- A one-off backfill across the whole database
- Nobody in the business can edit a Flow
- You wanted a managed package to install

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.

## What practitioners say about it

Searched for the problem this pair solves rather than for the pair itself, because the pair by name returns almost nothing. 14 threads from 2018 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 clearest answer anybody gives on who owns what

> Sounds like you already have the answer to your question. Sales owns the data. CRM owner owns the enforcement. Data owns the rules.

[r/salesforce](https://www.reddit.com/r/salesforce/comments/1qme1j6/who_actually_owns_salesforce_data_quality/) · January 2026 · 4 points

Answering a newly appointed Head of Data who could define what good looks like and could not fix any of it. Three sentences, and they are the reason a prefixed property matters: an enriched field that nobody on that list owns is the only kind that can be written automatically without a negotiation first.

### Input quality is a permanent battle, which is the case for not relying on inputs

> You apply for a job somewhere else (where the data quality is probably just as bad) But really, all companies face the problems you just described. It's improved very slowly and deliberately with very strict processes that don't allow users to input bad data. Users will always try and bypass your rules. Always. So it's a constant battle.

[r/salesforce](https://www.reddit.com/r/salesforce/comments/1b260v6/how_do_you_deal_with_poor_data_quality_in_a_crm/) · February 2024 · 52 points

The highest-scoring comment in the whole harvest, and the joke in the first line is why. The serious half is an argument for filling a field from outside rather than policing somebody into filling it, which is what a Flow callout on record creation does and what no validation rule can.

### The prescription people give starts with an enrichment tool and an owner

> 1. Get an account enrichment tool (like zoominfo) 2. Tie CRM master data to erp master data. Pick a source of truth and sync them 3. Budget 20k/year and find an architect to guide you 4. Tackle one process end to end per quarter.

[r/salesforce](https://www.reddit.com/r/salesforce/comments/1b260v6/how_do_you_deal_with_poor_data_quality_in_a_crm/) · February 2024 · 26 points

Four steps, and the first one is a product category rather than a product. Which tool fills that slot is the decision this page is about, and the budget line in step three is worth holding next to a route whose cost is credits and an afternoon of Flow configuration.

### Deleting fields beats enriching them, and the test is utilisation

> One thing I don't see people mentioning is start consolidating or deleting fields, and using Data loader a ton to just fix big segments of data at once and just mass update it. Look at field utilization, if there are some field where only 25 records are filled out and you have 15,000 records, maybe you can just delete it. \[...\] Wanna get fancy? Use a tool like Clay to have AI scan the website of the clients, and grab whatever data you need if it is publicly accessible.

[r/salesforce](https://www.reddit.com/r/salesforce/comments/1b260v6/how_do_you_deal_with_poor_data_quality_in_a_crm/) · February 2024 · 19 points

The field utilisation test is the one to run before any of this. A property filled on 25 of 15,000 records is not a field an enrichment route should be taught to fill, it is a field to delete, and doing that first is what stops a callout ceiling being spent on data nobody reads.

### The accountability has to sit above the person asking

> Your CRO needs to ultimately be accountable to own the data quality and their VP RevOps needs to align with you (Head of Data) on the specific KPIs and priorities on fields that need to be in the data warehouse. \[...\] you need to get them to prioritise the top 5 KPIs and get the ball rolling

[r/salesforce](https://www.reddit.com/r/salesforce/comments/1qme1j6/who_actually_owns_salesforce_data_quality/) · January 2026 · 5 points

Read alongside the first quote this is the same answer from the other direction, and the practical version for this page is the top five fields rather than the top five KPIs. Five properties an enrichment route is allowed to own, agreed once, is a smaller conversation than a data governance programme and it is the whole prerequisite for the build.

What the threads add up to

Nobody discusses this pair by name, so the search was for the job: keeping Salesforce records accurate without reps typing. The threads are almost entirely about ownership rather than tooling, which is the finding: every participant agrees the data is bad, and the argument is about whose job it is. An external call that fills a field nobody owns is a way out of that argument rather than a contribution to it.

All five are about ownership and none is about callouts, which is the honest shape of this pair: the mechanics are documented and the hard part is agreeing which fields a machine may write. The two tables above answer the mechanics, and the thing to take from the threads is to settle the field list before the architecture, because [the HubSpot build](https://www.reversecontact.com/integrations-hub/hubspot-integrations/hubspot-reverse-contact-integration) fails on a licence and this one fails on a disagreement.

## The longer answer

Every Reverse Contact page in this directory has to answer the same question, which is where the call happens, and Salesforce is the one CRM with a genuinely good answer in all three places. Inside the org a Flow HTTP Callout or Apex works and keeps the key in a Named Credential. Outside it, Clay and n8n work as they do everywhere. The decision is therefore about who maintains it rather than about what is possible, which is not true of most of the CRMs here.

The constraint that catches teams is the callout ceiling rather than anything to do with enrichment. A trigger that calls an external service once per record is fine until somebody imports a list, at which point the same code runs inside a bulk transaction and meets the 100-callout limit. The pattern that survives is to enrich on creation inside the org and do backfills somewhere with a queue, which in practice means the same place the [HubSpot build](https://www.reversecontact.com/integrations-hub/hubspot-integrations/hubspot-reverse-contact-integration) puts them.

The comparison worth making is with a CRM that has no Apex. [Attio calls the API itself](https://www.reversecontact.com/integrations-hub/attio-integrations/attio-reverse-contact-integration) from a workflow and reads the response, with a 20-second ceiling and no concept of a transaction, which is simpler and smaller. Salesloft, on the other side of the stack, has no in-product HTTP step at all, so [enriching before a cadence](https://www.reversecontact.com/integrations-hub/reverse-contact-integrations/salesloft-reverse-contact-integration) always goes through something else. Salesforce sits at the end of that range with the most control and the most rules.

## If this is not the one

The integrations people compare this against, or set up alongside it.

Split a stack into layers and this pair sits on two of them: the [CRM layer](https://www.reversecontact.com/integrations-hub/stack/crm), which 33 of the 68 integrations here touch, and the [data layer](https://www.reversecontact.com/integrations-hub/stack/data), which 26 do. It is also a step in [The Salesforce data layer](https://www.reversecontact.com/integrations-hub/workflows/salesforce-data-layer), one of the 8 worked stacks in this directory.

[**HubSpot and Reverse Contact**A whole record from an email or a domain, by four routes, and only the in-CRM one needs Data Hub. One way, in](https://www.reversecontact.com/integrations-hub/hubspot-integrations/hubspot-reverse-contact-integration)[**HubSpot and Salesforce**Two CRMs, one connector, and an edition requirement on both sides. Two-way sync](https://www.reversecontact.com/integrations-hub/hubspot-integrations/hubspot-salesforce-integration)[**Salesforce and LinkedIn**The original CRM Sync target, with the same Advanced Plus gate. Two-way sync](https://www.reversecontact.com/integrations-hub/salesforce-integrations/salesforce-linkedin-integration)

## [Reverse Contact](https://www.reversecontact.com)

We sell B2B people and company data, and we publish this directory. Every tier requirement, sync direction and limit on this page was read from a vendor's own knowledge base, developer documentation or pricing page on the date below. Nothing on it is restated from a press release or a third-party listing.

Where a vendor publishes no public figure, this page says so rather than estimating, which is why no page here prints a cost per enriched record. Reverse Contact appears in this directory as a data provider and publishes it. No other vendor pays for placement, and every link out of a listing or a citation carries nofollow, including the ones that point at Reverse Contact. The only followed links on this page are the two calls to action and the reviewer.

One fact about the publisher, stated here rather than in the page above it: Reverse Contact has no CRM marketplace app and no app inside a sequencer. Its three native apps are on Clay, Zapier and Make, and every other route is its API, its CLI or its MCP server. That is a deliberate shape for a data layer rather than a missing release, and it is what the routes on this page are describing.

Tier requirements, sync behaviour and documented limits change without notice. Confirm against your own contract before you budget. [What has changed since](https://www.reversecontact.com/integrations-hub/changes) · [How we checked](https://www.reversecontact.com/integrations-hub/methodology), and what we will not claim

[Eugene Suslov](https://www.linkedin.com/in/eysuslov/)

Researched and wrote every page in this directory, and checked every tier requirement, sync direction and documented limit against the vendor's own knowledge base, developer documentation or pricing page.

- **Verified** — 2026-10-11
- **Sources** — 6 vendor documents
- **Paid placement** — None

### Read from

- [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)

## Salesforce and Reverse Contact, asked and answered

### Is there a Salesforce and Reverse Contact integration on the AppExchange?

No. 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. For Salesforce that leaves four routes, and the right one depends on whether an engineer owns the org.

### Can a Flow call the API directly?

Yes, through an HTTP Callout action backed by External Services, with the API key held in a Named Credential rather than typed into the Flow. That keeps the key out of the metadata and out of a change set, which is the part a security review asks about.

### What are the callout limits?

A single Apex transaction may make at most 100 callouts, with a cumulative timeout of 120 seconds across all of them and a default of 10 seconds for each. For one enrichment call on record creation those are not limits you will feel. For a bulk update touching 200 records in one transaction they are the first thing you will hit, which is why a batch sits in Queueable Apex or outside the org entirely.

### Does this use our API allocation?

The write-back does, and the outbound call does not. Salesforce meters inbound daily API requests by edition and licence count across every integration in the org, so a tool reading and writing records row by row competes with Outreach, Gong and everything else already connected. An outbound callout to Reverse Contact is not an inbound request and does not count.

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.

Ask an assistant
