No AppExchange listing, and the callout limits are the real design constraint.
A Reverse Contact API key and a Salesforce edition with API access
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.
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 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. |
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 |
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.
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.
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.
Pick one on each side.
| 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 |
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.
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.
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 reads as a licence question and this one reads as an architecture question.
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-reverse-contact/SKILL.md https://www.reversecontact.com/integrations-hub/skills/salesforce-reverse-contact.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.
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.
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.
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.
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.
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.
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.
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.
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 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 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.
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·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.
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·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.
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·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.
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·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.
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·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.
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 fails on a licence and this one fails on a disagreement.
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 puts them.
The comparison worth making is with a CRM that has no Apex. Attio calls the API itself 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 always goes through something else. Salesforce sits at the end of that range with the most control and the most rules.
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, Reverse Contact 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.
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.
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.
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.
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.