A verified app with three modules and an escape hatch for everything else.
A Make plan with enough operations, and a Reverse Contact API key
Contacts, Companies, one way, in.
The verified Make app is the second of the two no-code routes to Reverse Contact, and the one with the better escape hatch. Three named modules cover the common cases and Make an API Call covers the rest, so a scenario never hits a wall that forces a raw HTTP module and a second copy of the credentials. Against Zapier it trades named operations for generality and a cheaper meter. Against a direct API call it trades money for the fact that a non-engineer can open it and see what happened.
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 |
|---|---|---|
| Trigger | One way, in | Any Make trigger: a watch module on a CRM, a webhook, a schedule, a spreadsheet row. |
| Reverse Email Lookup | One way, out | Takes an email, returns the person and the company. The common case, and the module most scenarios use. |
| Make an API Call | One way, out | Any endpoint the named modules do not cover, authorised with the connection you already made. |
| Write-back | One way, in | Make's own app modules for the CRM or sequencer that owns the record. |
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.
Four modules, all of them actions, and the fourth is a generic authorised call rather than a named operation. Which of the three named ones you can use is decided by the identifier you hold, and everything else goes through the fourth.
| In Make | In Reverse Contact | What to know about the match |
|---|---|---|
| Reverse Email Lookup | Reverse lookup from an email, 2 credits | Takes an email and returns person and company data in one module. The common case and the module most scenarios are built on, and the only one of the three named modules that starts from something a CRM actually holds. |
| Get LinkedIn Profile | Cached lookup from a profile URL, 1 credit | Person data from a profile URL. Cheaper per call than the reverse lookup and unmetered from the $249 plan up, so it is the module to prefer wherever the URL is already on the record. |
| Get a LinkedIn Company | Cached lookup from a profile URL, 1 credit | The company equivalent, also from a profile URL rather than from a domain. A domain is a reverse lookup and needs the generic module. |
| Make an API Call | Any endpoint, on your connection | Performs an arbitrary authorised API call, which is the whole reason this app does not hit a wall. You still supply the path, the body and your own reading of the response, so this module needs somebody who has opened the API reference. |
| The free freshness check | No named module | Reachable only through Make an API Call. It costs nothing, says whether a profile is cached and when it was last updated, and is the call Reverse Contact recommends making before you spend anything. |
| People or company search | No named module | Also only through the generic call. Search is priced per profile delivered, and the count endpoint that sizes a query first is free, so make that call before the one that bills. |
| The write-back | Not Reverse Contact's job | Make's own module for whatever owns the record carries the mapped fields the rest of the way. Nothing travels back to Reverse Contact, because there is nothing in the product to write to. |
| Any trigger | Does not exist in this app | All four modules are actions. Reverse Contact never starts a scenario, so there is always a watch module, a webhook or a schedule in front of it. |
Every Reverse Contact response has the same five top-level keys whichever module produced it, and three of them are the ones scenarios ignore and then need. They are visible in the bundle and they are worth mapping into the scenario rather than reading in a dashboard afterwards.
| In the bundle | What it is for |
|---|---|
| success | True when the request worked. Not the same as a match: a successful request can carry no profile |
| data | The record itself, or null when nothing was confidently matched |
| error | Null on success, and populated on the failures that cost no credits |
| metadata.updatedAt | When this record was last updated. The field that decides whether a live refresh is worth 2 credits |
| quotas.creditsConsumed | What this call actually cost, which is how a scenario can log its own spend |
| quotas.workspace.credits.left | The balance after this call. Route on it and a scenario can stop itself before a 402 |
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 in the bundle rows and four documented exclusions, each one's note, and the seven 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 three named modules cover the two cheapest calls and the most common one, which is a sensible choice of three. What that leaves is a scenario where the interesting work, checking freshness before paying for it and sizing a search before running it, happens in the generic module, so the person who owns this scenario needs the API reference open whatever the app says about being no-code.
Reverse Contact maintains an app on both platforms and they are shaped differently rather than one being fuller. Zapier publishes nine named operations and no way to reach a tenth; Make publishes four and one of them reaches everything. This is the same table read from both sides. Pick one on each side and the grid marks the answer.
Pick one on each side.
| The call you need | A named Make module | Make an API Call | A named Zapier action |
|---|---|---|---|
| Freshness check, free | Not available | Available | Available |
| Person from a profile URL | Available | Available | Available |
| Company from a profile URL | Available | Available | Available |
| Person from an email | Available | Available | Available |
| Company from a domain | Not available | Available | Available |
| People or company search | Not available | Available | Available |
| Credit balance and usage | Not available | Available | Available |
| Live refresh | Not available | Buildable with a poll loop | Not available |
| A trigger, so it starts the run | Not available | Not available | Not available |
Counted off that grid, of 27 pairings: seventeen give you available, one gives you buildable with a poll loop, nine give you not available. The row that decides most of this is the last one, and it is identical on both sides: neither app has a trigger, so Reverse Contact is always a passenger. After that the split is clean: Zapier wins if your call is on its list of nine, because every one of them is a dropdown, and Make wins if it is not, because the generic module keeps it inside the app and on the same connection. For the live row and for volume, neither is the right answer and an n8n workflow is.
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.
Make: the app, All Modules
There are four: Reverse Email Lookup, Get LinkedIn Profile, Get a LinkedIn Company, and Make an API Call. Everything else Reverse Contact publishes, the free freshness check, company lookup from a domain, people and company search, the live endpoints, reaches you only through the generic call. Finding that out after the scenario is drawn is the common way this costs an afternoon.
The app that owns the record
Map into properties nothing else writes, prefixed so nobody types into one by hand. Make will faithfully write whatever you map, including an empty value from a lookup that matched nobody, and the field a rep maintains is the expensive one to get wrong.
Reverse Contact: Workspace, API Keys
Keys are created in Workspace then API Keys, and a per-key rate limit can hold one integration below the workspace maximum. A scenario with an iterator over a thousand rows is exactly the thing that should not be allowed to exhaust the workspace minute.
Make: the module, Connection
The app is listed as Verified with Reverse Contact as the Official Vendor, which means Make reviewed it and the developer is the vendor rather than a third party. One connection serves every module in the app, including Make an API Call, so the key is entered once rather than per module.
Make: the link between two modules
A Make filter sits on the connection between modules and stops the bundle travelling, so a filter in front of the enrichment is what keeps operations off rows that were never going to resolve. This is the cheapest line in the scenario and it is usually added last.
Make: a router, or a filter after the lookup
A lookup that matches nobody is a successful module run with nothing in it rather than an error, so the scenario carries on to the update. Route the empty bundles somewhere else, which is also where a second provider would go if you were building a waterfall.
Make: a repeater and a sleep module
Make can do what a Zap cannot here, because a repeater and a sleep module make a polling loop buildable. Reverse Contact documents polling as free and off the rate-limit clock, so the cost is entirely Make operations: every iteration of the loop is one, and the job can take tens of minutes.
Make: Run once, then the module output
Click into the module after the run and read the actual bundle. The execution log says the module succeeded, which it did, and the bundle is the only place the difference between a matched profile and an empty one is visible.
Two of those steps exist because of the same property of this app: a miss looks exactly like a success, both in the module and in the log. That is true of the Zapier app too, and it is the one thing to design around on either of the two no-code routes.
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/make-reverse-contact/SKILL.md https://www.reversecontact.com/integrations-hub/skills/make-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.
WhyA lookup that matches nobody is a successful run with no data rather than an error, because Reverse Contact returns null rather than a best guess.
Put a filter after the lookup testing that the field exists, or a router sending the empty bundles elsewhere. The scenario is otherwise working exactly as drawn.
WhyMake charges an operation per module per bundle, so an iterator over a hundred records multiplies every module behind it by a hundred.
Filter on the route before the enrichment rather than after it, and aggregate where a module accepts a batch. The arithmetic is the design on this route, the same as the task count is on Zapier.
WhyThe app publishes four modules. The freshness check, company lookup from a domain, search and the live endpoints are not among them.
Use Make an API Call on the same connection. It authorises with the credential you already made, so this is a module change rather than a second copy of the key.
WhyBelow 2 credits the free Check endpoints are paused too and answer 402 NO_CREDITS, because the fetch a check precedes can itself cost 2.
Route on quotas.workspace.credits.left, which is in every bundle, and stop the scenario before the balance reaches nothing. GET /v2/usage keeps answering when the checks do not.
WhyReverse Contact applies a minute limit per workspace, and the limit is shared with every other integration on it. An iterator runs as fast as Make will let it.
Read quotas.minuteRateLimit, which carries limit, used, left and the next reset, and set a per-key rate limit for this scenario so it cannot starve the rest of the workspace.
WhyA live job finishes when its status reads succeeded or errored, and Reverse Contact documents that this is usually seconds but can be tens of minutes.
Break on errored as well as succeeded, and cap the repeater. An uncapped loop on a job that will not finish is an operations bill rather than a hung scenario.
WhyWhere a callback URL is used instead of polling, Reverse Contact reports an unreachable or erroring URL as a succeeded job carrying a deliveryStatus, and states that delivery failures are not refunded because the data was fetched.
Poll GET /v2/webhooks/:webhookId to collect the result you already paid for. The job is not lost, only the delivery was.
WhyCredit packs are valid 3 months. A scenario that runs in bursts around a campaign can reach the end of a quarter holding credits it bought.
Size the pack to a quarter of real volume rather than to a discount, or move to an Unlimited plan, where the cached endpoints the plan names stop being metered.
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 2023 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.
I haven't checked what Zoho integrates with, but I don't see it having an integration with Apollo.io, for example, or other similar data enrichment providers. If it has no native integrations, then your best bet is a middleware integration & automation tool.
r/CRM·July 2024·1 points
The question it answers is the better half: somebody asking twice, in the same thread, for a way to enrich CRM leads automatically without using Zapier or Make, to keep expenses down. The answer is the one this directory keeps arriving at. A scenario here costs operations and an afternoon, and it is what exists when the CRM has no connector of its own.
Clay sounds strong for data work but I never fully ditched Zapier or Make. I keep Clay for heavy logic and data moves but use Zapier for quick CRM updates or Slack pings since it's simpler. From my experience, mixing tools based on task complexity saves headaches.
r/automation·November 2025·2 points
A straightforward division of labour, and it is the one this page assumes: the scenario moves records and something underneath it decides what they say. The four modules in this app are built for exactly that job, which is why three of them are a lookup and the fourth is an escape hatch.
The success with this all depends on how good the data sources you use for enrichment are. Are there any good alternatives to Clearbit, Zoominfo or Apollo? These can get very expensive.
r/GrowthHacking·October 2025·1 points
Asked under a long post about clever things teams do with an enrichment API, which is the right order to think about it: the use cases are all downstream of a provider choice nobody had made yet. Worth noting that the thread it sits in is itself an argument for this pair, because every use case in it starts from one email address.
in my experience enrichment's also great for auto-prioritizing outreach based on intent signals and firmographic fit, detecting title changes to trigger win-back or offboarding flows, and feeding real-time fit scores into SDR queues so reps know who to call first
r/GrowthHacking·October 2025·1 points
The middle clause is the one that changes a scenario's design. Detecting a title change means storing what the title was and comparing, which is a scenario that re-runs on a schedule rather than one that fires on creation, and it is the case where the update date on every Reverse Contact response earns its keep.
A unified workflow makes a big difference, especially for opt in lists. Fewer transfers means fewer chances of making mistakes
r/Emailmarketing·December 2025·1 points
Short, and it is the real case for Make an API Call over a raw HTTP module. A scenario that reaches an unsupported endpoint from inside the app has one connection and one credential; the same scenario with a generic HTTP module beside it has two of each, and the second copy is the one that goes stale.
Nobody discusses this pair by name, so the search was for the job: getting enriched data into a CRM without an engineer. The most useful thread is somebody trying hard to avoid a middle layer and being told there is not one, which is the argument of this page made by a stranger. The rest are about where the data under the automation comes from, which is the half the no-code tools do not supply.
The first quote is the page in one exchange: somebody wanted to enrich a CRM without a middle layer, asked twice, and was told to use one. That is still the honest answer for every CRM here with no HTTP step of its own, and the only CRMs that escape it are the ones that can make the call themselves, which the Attio comparison counts.
The useful way to read the Make app against the Zapier one is that they fail differently. The Zapier app has nine named operations and no way to reach a tenth, so a requirement it does not cover sends you to a raw Webhooks step with the key entered a second time. The Make app has four modules and one of them is a generic authorised call, so the same requirement is a module change. Neither is better in the abstract; the question is whether your scenario needs something off the list, and most do not.
Both apps exist in the same place in a stack, which is the part worth noticing. Reverse Contact maintains apps on Clay, Zapier and Make and nothing inside a CRM, so the pattern is that the enrichment step lives on the orchestration layer and reaches down into whatever owns the record. That is why the Zapier app and this one are the pages most of the others point at, and why a CRM with a thin automation builder like monday leans on them harder than one with a real HTTP block.
The exception is a CRM that can make the call itself. Zoho CRM runs Deluge inside a workflow function and can call an external API with invokeUrl on an Enterprise edition, which removes the middle layer and its meter entirely. Where that is available it is cheaper and has fewer moving parts; where it is not, a scenario here costs operations and takes an afternoon.
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 Make, 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.
Make lists it as Verified and marks Reverse Contact as the Official Vendor, which means Make reviewed it and the developer is the vendor itself rather than a third party. That is a stronger statement than an app merely existing in the catalogue.
Four, all actions and no triggers: Reverse Email Lookup, which returns person and company data from an email; Get LinkedIn Profile; Get a LinkedIn Company; and Make an API Call, which performs an arbitrary authorised call. The last one matters more than it looks, because it means the app covers endpoints the three named modules do not.
Zapier has more named operations, nine against four, including the free profile checks and the searches. Make has the generic API Call module, so anything missing is still reachable without leaving the app or re-entering a key. Make also bills operations rather than tasks, which is usually cheaper at volume. Pick on the meter and on which platform your team already runs.
Better than a Zap can, because a Make scenario has repeaters and sleep modules, so a poll loop is buildable. It is still more natural in n8n, and every operation in the loop is a Make operation you pay for.
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.