---
title: "Make and Reverse Contact integration: what syncs, and what it needs"
description: "Make 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/reverse-contact-integrations/make-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)

# Make and Reverse Contact

A verified app with three modules and an escape hatch for everything else.

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

## What you have to buy first

A Make plan with enough operations, and a Reverse Contact API key

## What moves

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.

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

## Which field lands where

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

### What the response carries besides the fields you mapped

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 |

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

- A trigger of any kind. All four modules are actions, which Make's own listing states by counting four modules and four actions, so something else always starts the scenario.
- A business email or a direct phone number. Those are separate endpoints at 3 and 20 credits, charged only when one is found, and neither has a named module here.
- The live endpoints, natively. They answer with a task id rather than a record, so live resolution is a repeater and a sleep module around Make an API Call, with every iteration costing an operation.
- Anything travelling back to Reverse Contact. This is a read layer and the direction only runs one way.

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.

## Which of the two no-code apps exposes which call

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.

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

- **Available** — A named operation on that platform, configured from a dropdown. Make's listing names four modules and Zapier's names nine, and the credit cost is Reverse Contact's either way.
- **Buildable with a poll loop** — No module answers this one on its own. The live endpoints reply with a task id and deliver afterwards, so Make can build it from a repeater, a sleep module and the generic call, at one operation per iteration.
- **Not available** — Not reachable on that platform without leaving the app. On Zapier that means a generic Webhooks step with the key entered a second time, which is the gap Make an API Call exists to close.

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](https://www.reversecontact.com/integrations-hub/n8n-integrations/n8n-reverse-contact-integration) is.

## How to connect Make 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** — Whoever can edit a scenario, plus whoever can create a Reverse Contact API key. No Make admin, and no approval queue like the HubSpot app has.
- **How long it takes** — Fifteen minutes for the scenario. Deciding whether a named module covers what you need is the part to do first.

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](https://www.reversecontact.com/integrations-hub/zapier-integrations/zapier-reverse-contact-integration) too, and it is the one thing to design around on either of the two no-code routes.

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/make-reverse-contact.md) 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

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

- **Operations are charged per module, per bundle** — A scenario that watches, enriches and updates spends three operations on every record, and an iterator over 100 records multiplies that. Make is generally cheaper per unit than Zapier and the arithmetic is the same shape, so do it before you design for volume.
- **There are no triggers in the app** — Reverse Contact never starts a scenario. Something else does, which is correct for a data layer and means the scenario always has a watch module or a webhook in front of it.
- **Make an API Call is not a free pass** — It authorises the call with your connection, which is the convenience, but you still have to know the endpoint, the body and what the response looks like. For anything beyond the three named modules this route needs somebody who has read the API reference, same as a raw HTTP module would.
- **Under 2 credits the free checks stop too** — When the Reverse Contact workspace has fewer than 2 credits left, even the free check endpoints return 402 rather than a result. A scenario built to check first and spend second fails at the check.

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.

### The module succeeded and the record got an empty field

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.

### The operations count is far higher than the number of records

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.

### The call you need has no module

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.

### Everything stopped, including the calls that cost nothing

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.

### A 429 from a scenario that worked on a smaller list

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.

### The poll loop runs forever

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.

### A webhook result arrived as a delivery failure

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.

### Credits expired before the scenario spent them

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](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

- A team already running Make rather than Zapier
- Scenarios that need an endpoint the named modules miss
- Volume where the operations meter beats a task meter

### Do not bother when

- Nobody owns the scenario after it is built
- The logic is one call and the CRM could make it itself
- Live resolution at volume, where every poll is an operation

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

### Somebody asking how to avoid the middle layer, and the answer

> 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](https://www.reddit.com/r/CRM/comments/1e67lf0/need_recommendations_for_a_data_enrichment_tool/) · 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.

### The no-code tools are the glue, and something else is the data

> 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](https://www.reddit.com/r/automation/comments/1oqxqoy/has_anyone_replaced_zapier_or_make_completely/) · 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 question this whole directory exists to answer, asked plainly

> 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](https://www.reddit.com/r/GrowthHacking/comments/1o6r4dn/everyone_talks_about_enrichment_but_heres_how/) · 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.

### A job change is a signal, not just a stale field

> 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](https://www.reddit.com/r/GrowthHacking/comments/1o6r4dn/everyone_talks_about_enrichment_but_heres_how/) · 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.

### Fewer handoffs beats better handoffs

> A unified workflow makes a big difference, especially for opt in lists. Fewer transfers means fewer chances of making mistakes

[r/Emailmarketing](https://www.reddit.com/r/Emailmarketing/comments/1pc4o43/has_anyone_found_a_clean_way_to_handle_enrichment/) · 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.

What the threads add up to

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](https://www.reversecontact.com/integrations-hub/attio-integrations/attio-reverse-contact-integration) counts.

## The longer answer

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](https://www.reversecontact.com/integrations-hub/zapier-integrations/zapier-reverse-contact-integration) and this one are the pages most of the others point at, and why a CRM with a thin automation builder like [monday](https://www.reversecontact.com/integrations-hub/reverse-contact-integrations/monday-reverse-contact-integration) 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](https://www.reversecontact.com/integrations-hub/reverse-contact-integrations/zoho-reverse-contact-integration) 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.

## 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 [data layer](https://www.reversecontact.com/integrations-hub/stack/data), which 26 of the 68 integrations here touch, and the [orchestration layer](https://www.reversecontact.com/integrations-hub/stack/orchestration), which 23 do.

[**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 Make**A Super Admin has to approve it, and a scope added to a connection can never be removed. Two-way sync](https://www.reversecontact.com/integrations-hub/hubspot-integrations/hubspot-make-integration)[**Salesforce and Reverse Contact**No AppExchange listing, and the callout limits are the real design constraint. One way, in](https://www.reversecontact.com/integrations-hub/salesforce-integrations/salesforce-reverse-contact-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** — 7 vendor documents
- **Paid placement** — None

### Read from

- [Reverse Contact app on Make](https://www.make.com/en/integrations/reversecontact)
- [Reverse Contact on Zapier](https://zapier.com/apps/reverse-contact/integrations)
- [Reverse Contact integrations](https://www.reversecontact.com/integrations)
- [Reverse Contact: credits](https://docs.reversecontact.com/guides/credits)
- [Reverse Contact: rate limits](https://docs.reversecontact.com/guides/rate-limits)
- [Reverse Contact API documentation](https://docs.reversecontact.com/getting-started)
- [Reverse Contact pricing](https://www.reversecontact.com/pricing)

## Make and Reverse Contact, asked and answered

### Is the Make and Reverse Contact integration official?

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.

### What modules does it have?

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.

### How does this compare with the Zapier app?

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.

### Can a scenario handle live resolution?

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.

Ask an assistant
