---
name: make-reverse-contact-integration
description: Connect Make and Reverse Contact: what syncs, which editions carry it, the setup order, and the failures to expect. Covers contacts, companies. Use when the user wants to set up, audit or troubleshoot Make and Reverse Contact together, or asks why data is not moving between them.
---

# Make and Reverse Contact

> Generated from https://www.reversecontact.com/integrations-hub/reverse-contact-integrations/make-reverse-contact-integration
> Every tier requirement, sync direction and limit below was read from the vendors' own documentation on 2026-10-11.
> Vendors change these without notice. Re-check anything load-bearing before you rely on it.

**What you have to buy first:** A Make plan with enough operations, and a Reverse Contact API key

**What moves:** contacts, companies, one way, into Make.
**How it is built:** native, zapier, make or n8n. **Effort:** minutes.

## The short version

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.

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

Rows: The call you need. Columns: How you reach it. 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.

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

## What actually syncs

Direction is written from Make's point of view: out means out of Make, in means into it.

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

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

## Connect it, in this order

**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:** Fifteen minutes for the scenario. Deciding whether a named module covers what you need is the part to do first.

### 1. Check whether a named module covers your call at all

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

### 2. Decide where the enriched value lands, before the mapping screen

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

### 3. Create a key for this scenario and cap it

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

### 4. Make the connection once and reuse it

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

### 5. Put the filter on the route, not inside the module

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

### 6. Handle the no-match case explicitly

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

### 7. Build the poll loop only if you actually need live data

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

### 8. Run the scenario once and read the bundle, not the log

*Where:* 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](pair:zapier+reverse-contact) too, and it is the one thing to design around on either of the two no-code routes.

## How to check it worked

- Run Reverse Email Lookup on an address you know matches nobody, and watch the module succeed. Doing it on purpose once is how you find out what your mapping writes when that happens in production.
- Check the credit balance either side of that miss. It should not move, because Reverse Contact charges 0 credits on a 4xx, while the Make operation was spent regardless.
- Point Make an API Call at the free freshness check and read the update date it returns. That proves the escape hatch works on your connection and tells you how stale the cached record is before you buy a refresh.
- Turn the scenario on, let one real record through, then open the record in the destination app rather than the Make history. The history reports what Make did; the record shows what landed.

## When it goes wrong

Each row is a symptom somebody reports, the documented reason, and the fix. Work down it before escalating to either vendor, because most of these are configuration.

| Symptom | Why it happens | What to do |
|---|---|---|
| The module succeeded and the record got an empty field | A 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 | Make 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 | The 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 | Below 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 | Reverse 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 | A 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 | Where 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 | Credit 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. |

## What breaks, from the vendors' own docs

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

## The APIs, if you are building around it instead

### Reverse Contact

- **Base:** `https://api.reversecontact.com/v2`
- **Auth:** `Authorization: Bearer rc_your_api_key`. Keys are created in Workspace > API Keys.

| Call | Request | What it does |
|---|---|---|
| `POST /v2/enrich/persons` | `{ "email": "j.okafor@northwind.io" }` | Resolve a person from an email, a name plus company, or a profile URL. Cached resolution, returns in the response. |
| `POST /v2/enrich/companies` | `{ "domain": "northwind.io" }` | Resolve a company from a domain or a name. |
| `POST /v2/fetch/persons` | `{ "linkedInUrl": "..." }` | Standard profile lookup from the database. |
| `POST /v2/fetch/persons/live` | `{ "linkedInUrl": "..." }` | Live on-demand resolution. ASYNCHRONOUS: returns a webhookId to poll, not a record. |
| `POST /v2/search/people` | `{ "filters": { "currentCompanyDomain": "northwind.io" } }` | Filtered people search. 1 credit a profile delivered, and /v2/search/people/count is free. It replaced /v2/search/persons, which returns 410 Gone since 13 October 2026. |
| `POST /v2/search/organizations` | `{ "filters": { "companyDomain": "northwind.io" } }` | Filtered company search. A domain can also go straight to a company through POST /v2/enrich/companies, or through the enrich_company MCP tool since November 2026. |
| `POST /v2/contact/email` | `{ "linkedInUrl": "..." }` | Find an email. ASYNCHRONOUS: returns a taskId to poll. 3 credits for a professional address, 5 for a personal one, 8 for both, refunded when neither is found. |
| `GET /v2/webhooks/:webhookId` | - | Poll an async job until status is "succeeded". Polling is free and does not count against the rate limit. |

Response shape:

```json
{
  "success": true,
  "data": {
    "person": {
      "fullName": "Jane Okafor",
      "headline": "VP Sales at Northwind",
      "location": "London, United Kingdom",
      "linkedInUrl": "https://linkedin.com/in/...",
      "currentPosition": { "title": "VP Sales", "companyName": "Northwind", "startDate": "2023-04" },
      "emails": [], "experience": [], "education": [], "skills": []
    },
    "company": { "name": "Northwind", "domain": "northwind.io",
                 "industry": "Software Development", "employeeCount": 220 }
  },
  "error": null,
  "metadata": { "requestId": "req_...", "executionTimeMs": 480, "updatedAt": "2026-09-01T..." },
  "quotas": { "creditsConsumed": 1, "workspace": { "credits": { "total": 10000, "used": 4521, "left": 5479 } } }
}
```

**Rules that will cost you time if you skip them:**

- A miss returns **null**, not a best guess. Every response carries a confidence score, and you can raise the precision threshold on the request. Branch on it: do not treat a low-confidence answer as a match.
- Use the cached endpoints anywhere that must answer inside one HTTP request. The `/live` endpoints return a task and need polling.
- `quotas.workspace.credits.left` is on every response. Log it, or you will find out about the balance from a 402.
- Credit costs per call are published and a dollar rate per lookup is not: 2 credits for a reverse lookup from an email, 1 for a cached profile lookup, 2 for a live refresh, 3 for a business email and 20 for a direct phone number, with the last two charged only when one is found. Checks and the search count endpoint are free. Credit packs expire after 3 months. Do not hard-code a dollar cost assumption.

**MCP server:** `https://api.reversecontact.com/mcp`

- Auth: OAuth 2.1 where the client supports it, otherwise `Authorization: Bearer rc_your_api_key`.
- Tools: `enrich_person`, `enrich_person_live`, `enrich_company`, `enrich_company_live`, `search_persons`, `search_companies`, `check_usage`, `check_task`
- Streamable HTTP, JSON-RPC 2.0. The `_live` tools return a task id that `check_task` polls.

Docs: https://docs.reversecontact.com/getting-started

## Sources

- 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
- 14 practitioner threads read on 2026-10-11, summarised on the page: https://www.reversecontact.com/integrations-hub/reverse-contact-integrations/make-reverse-contact-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/reverse-contact-integrations/make-reverse-contact-integration

---

*Published by Reverse Contact, which appears in this directory as a data provider.
No other vendor pays for placement. Where a vendor publishes no public figure, this file says so
rather than estimating. Reverse Contact costs are stated in credits, which it publishes; no dollar
rate per lookup appears here, because none is published and dividing a pack price is not their number.*
