---
name: n8n-reverse-contact-integration
description: Connect n8n 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 n8n and Reverse Contact together, or asks why data is not moving between them.
---

# n8n and Reverse Contact

> Generated from https://www.reversecontact.com/integrations-hub/n8n-integrations/n8n-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:** An n8n instance, self-hosted or cloud, and a Reverse Contact API key

**What moves:** contacts, companies, one way, into n8n.
**How it is built:** built on the api, zapier, make or n8n. **Effort:** hours.

## The short version

n8n is the only route in this directory that comfortably handles Reverse Contact's live endpoints, because those return a task to poll rather than a record. A HubSpot workflow cannot wait; an n8n workflow can, with a Wait node and a loop. Self-hosting also answers the question that stops several of these builds, which is whether customer records may leave infrastructure you control.

## Which route can do which part of this

Rows: Where the call runs from. Columns: What you need it to do. None of this is a Reverse Contact tier. Every endpoint is available on every plan, and the question this page exists to answer is which host can carry which call, because the live endpoints hand back a task rather than a record and most of the routes in this directory have nowhere to put the wait.

| Where the call runs from | Cached lookup inside one run | Live refresh, which returns a task | Records never leave infrastructure you control | A non-engineer can change it next month |
|---|---|---|---|---|
| n8n, self-hosted | Yes | Yes | Yes | No |
| n8n Cloud | Yes | Yes | No | No |
| A HubSpot or Salesforce workflow | With a caveat | No | With a caveat | With a caveat |
| A Clay column | Yes | No | No | Yes |
| A Zap or a Make scenario | Yes | With a caveat | No | Yes |

- **Yes.** Documented and straightforward on that route. A cached lookup answers inside the response on all of them, which is why four of the five are fine until the live column.
- **With a caveat.** A CRM workflow can make the cached call only where the edition carries an outbound call at all, which on HubSpot means Data Hub Professional and a 20-second ceiling, and it keeps the record inside a CRM you already trust rather than inside infrastructure you run. A Make scenario can reach a live endpoint through a repeater and a sleep module, at one operation per iteration.
- **No.** Not available on that route. A HubSpot workflow action cannot wait for an asynchronous job, a Clay column has nothing to poll with, and a Zap has no loop at all.

Counted off that grid, of twenty pairings: nine give you yes, four give you with a caveat, seven give you no.

Only the two n8n rows are complete, and the column that completes them is the live one. If you never need a live refresh and nobody is asking where the records go, a Clay column or the native Zapier app is less to look after and somebody who does not write code can own it. Those two conditions are the whole case for this page, and both of them are procurement questions rather than engineering ones.

## What actually syncs

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

| What | Direction | What that means in practice |
|---|---|---|
| Trigger | One way, in | A CRM webhook, a schedule, or a queue. n8n does not care which. |
| The call | One way, out | An HTTP Request node POSTs to /v2/enrich/persons with a Bearer token from credentials. |
| Async handling | One way, in | For /live, poll GET /v2/webhooks/:webhookId in a loop until status is succeeded. Polling is free and off the rate-limit clock. |
| Write-back | One way, out | The native HubSpot or Salesforce node updates the record with the mapped fields. |

## Which field lands where

There is no node to configure, so the mapping here is between a Reverse Contact behaviour and the HTTP Request node option that handles it. Three of these options are off by default and two of those three are the difference between a workflow that branches on a miss and one that stops on it.

| In n8n | In Reverse Contact | What to know about the match |
|---|---|---|
| One HTTP Request node, POST | https://api.reversecontact.com/v2 | Every endpoint is reachable from the same node, which is why the absence of a dedicated node costs nothing. It also means no node update can break this workflow, and there is no predefined credential type to pick. |
| A Header auth credential | Authorization: Bearer rc_your_api_key | n8n's generic credential list carries Header auth alongside Basic, Digest, Query and the two OAuth types. Credentials live outside the workflow JSON, so the workflow stays safe to export and review. |
| Never Error, in Response options | A 404 or a 402, both of which cost nothing | The node reports success only on a 2xx by default, so a confident null stops the execution. Reverse Contact charges 0 credits on every 4xx and 5xx, so the miss was free and only the workflow needed telling about it. |
| Include Response Headers and Status | The status code, beside the body | Off by default, so the node hands back the body alone. With Never Error on you need the status to tell a miss from a rate limit, which makes these two options a pair rather than two independent choices. |
| Items per Batch and Batch Interval | The workspace minute limit | Reverse Contact applies a per-minute limit per workspace, reports it in quotas.minuteRateLimit on every response and answers 429 past it. Batching with an interval in milliseconds is how a bulk run stays underneath it. |
| A Wait node and a loop | POST /v2/fetch/persons/live, then GET /v2/webhooks/:webhookId | The live endpoints answer with a webhookId rather than a record. Poll until the status is succeeded, break on errored and read errorCode. Polling is free and does not count against the rate limit. |
| Pagination mode | POST /v2/search/people | Search answers in pages, and n8n exposes $pageCount and $response.body for the loop. People search is priced per profile delivered, so the free count endpoint should size the query before the pagination starts. |
| Timeout, in milliseconds | A published 500ms P95 on the cached calls | The node aborts a request that takes longer than this to begin responding. A short timeout is safe on the cached endpoints and wrong on the live ones, which are not slow so much as asynchronous. |

### The response shape, and the keys a workflow should be reading

Every endpoint answers with the same five top-level keys, which is what makes one node enough for all of them. Four of them are the ones workflows skip and then need, and reading them in the workflow beats reading them in a dashboard a month later.

| In the response | What the workflow does with it |
|---|---|
| success | True when the request worked. An IF node on this alone is not a match test |
| data | The record, or null when nothing was confidently matched. This is the match test |
| error | Null on success, populated on the 4xx and 5xx responses that cost 0 credits |
| metadata.executionTimeMs | What this call actually took, worth logging against the published 500ms P95 |
| metadata.updatedAt | When this record was last updated. Decides whether a 2-credit live refresh buys anything |
| quotas.minuteRateLimit | limit, used, left and nextReset. Read it to pace a batch rather than retrying into a 429 |
| quotas.workspace.credits.left | The balance after this call. Branch on it and the workflow stops itself before a 402 |

**What does not cross:**

- A dedicated node. Reverse Contact ships none, which is why there is no predefined credential type to pick and also why no node update can break this workflow.
- A trigger. Nothing in Reverse Contact starts an n8n workflow, so the trigger is a CRM webhook, a schedule or a queue. The one thing it will send you unasked is the callback POST to a webhookUrl you supply on the live and contact endpoints.
- A refund for a failed callback delivery. Reverse Contact documents that an invalid, erroring, timing-out or unreachable webhook URL is not refunded, because the data was fetched: the job reports succeeded with a deliveryStatus and the result is still there to poll for.
- Any write back into Reverse Contact. The direction runs one way, and there is nothing in the product to write to.

## Connect it, in this order

**Who has to do it:** Whoever owns the n8n instance, plus whoever can create a Reverse Contact API key. On self-hosted that is usually the same person, which is half the appeal.
**How long:** An hour for the cached path. The poll loop for the live endpoints is another hour and only some builds need it.

### 1. Decide self-hosted or cloud first, because it is the reason you are here

*Where:* n8n: deployment

The usual reason to choose this route over the Clay app or the Zapier app is that customer records may not leave infrastructure you control, and that is a deployment decision rather than a workflow one. The workflow is identical either way, so the question costs nothing to settle now and is awkward to revisit after a security review has started.

### 2. Decide where the enriched value is written, and what it may overwrite

*Where:* Your CRM: property names

The API returns a record and nothing writes it anywhere. That is more work than a marketplace app and it is exactly why this route never flattens a field a rep owns. Prefix the properties it writes, and promote a value into a human-maintained field with a separate rule or not at all.

### 3. Create a key for this workflow 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. This matters more here than on any other route: an n8n run goes as fast as the node allows, and the minute limit is shared with every other integration on the workspace.

### 4. Make a Header auth credential rather than typing a header into the node

*Where:* n8n: Credentials, Header Auth

n8n recommends a Predefined Credential Type wherever one exists, and there is none for Reverse Contact, so this is the generic case: Header auth, with the name Authorization and the value Bearer followed by your key. Credentials are stored apart from the workflow JSON, which is what keeps the workflow safe to export, review and commit.

### 5. Turn on Never Error and Include Response Headers and Status

*Where:* n8n: the node, Options, Response

Both are off by default. The node reports success only on a 2xx, so a lookup that matched nobody stops the execution, and without the status code you cannot tell that miss from a rate limit. Together these two turn an empty answer into a branch, and this is the step to take before the first real run rather than after it.

### 6. Check before you fetch, on the endpoint that costs nothing

*Where:* POST /v2/fetch/persons/check

Reverse Contact recommends this sequence itself: the check says whether a profile is cached and when it was last updated, so the workflow picks a 1-credit cached read or a 2-credit live refresh on evidence rather than on a guess. It is free, and the decision it enables is the main lever on this bill.

### 7. Set Items per Batch and a Batch Interval before the first bulk run

*Where:* n8n: the node, Options, Batching

Items per Batch takes a count and Batch Interval takes a wait in milliseconds. Pacing a five-thousand-row run under the workspace minute limit is a two-field change here, and discovering the limit instead is a wall of 429s with a retry storm behind it.

### 8. Build the poll loop only for the calls that need one

*Where:* n8n: a Wait node and an IF

Only the live and contact endpoints answer with a task. Read data.webhookId, then poll GET /v2/webhooks/:webhookId until the status reads succeeded, breaking on errored. Polling is free and off the rate-limit clock, so the loop costs wall clock and nothing else.

Steps five and seven are what separate a workflow that survives a bulk run from one that stops on row forty, and neither is about Reverse Contact. They are the HTTP Request node's own defaults, which assume an API that treats a miss as a failure. This one treats it as an answer, which is the point of it, and the node has to be told.

## How to check it worked

- Call the free check endpoint on your own profile URL and read the update date. It costs nothing, it proves the credential works, and that date is the number the rest of your cost model rests on.
- Point the node at somebody who does not exist and run it with Never Error still off. Watching the execution stop is the clearest demonstration of why it goes on, and the call costs no credits either way.
- Start one live job and poll it by hand, timing it. The published aim is under 15 seconds and the documented ceiling is tens of minutes, and your own figure is what decides whether that loop can sit anywhere near a request path.
- Run twenty rows with Batch Interval at 0 and read quotas.minuteRateLimit on the last response. If left is already near zero on twenty rows, an unpaced run over five thousand was never going to finish.

## 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 workflow stops on a contact who is not in the database | The HTTP Request node reports success only on a 2xx by default, and a confident null is not a 2xx. | Turn on Never Error in the node's Response options and branch on the body with an IF node. The call cost 0 credits either way, so nothing was wasted except the execution. |
| A 429 on a run that worked fine on a shorter list | Reverse Contact applies a minute limit per workspace, shared with every other integration on it, and answers 429 past it. | Set Items per Batch and a Batch Interval rather than adding a retry, and read quotas.minuteRateLimit for limit, used, left and nextReset. A per-key rate limit stops this workflow starving the rest of the workspace. |
| The poll loop never finishes | A live job ends at succeeded or errored, and Reverse Contact documents the wait as usually seconds and possibly tens of minutes. | Break on errored as well as succeeded, read errorCode, and cap the loop. An uncapped Wait loop on a job that will not finish is an execution running until something external kills it. |
| A live call returned nothing to map | The live endpoints are asynchronous by design. The response carries a webhookId rather than a record, which is what the documentation means by built to feed async pipelines rather than to block a request. | Read data.webhookId from the first call, poll GET /v2/webhooks/:webhookId until the status is succeeded, then take data.result. The polling is free and off the rate-limit clock. |
| The result never arrived and the credit was spent anyway | Where a webhookUrl is used instead of polling, Reverse Contact keeps the credit on a delivery failure because the data was fetched, and reports the job as succeeded with a deliveryStatus naming the problem. | Poll the webhook id and collect the result you have already paid for. The four documented delivery failures are webhook-url-invalid, webhook-url-errored, webhook-url-timeout and webhook-url-unreachable. |
| Everything failed at once, including the calls that were free | Below 2 credits the free Check endpoints are paused as well and answer 402 NO_CREDITS, because the fetch a check precedes can itself cost 2. | Branch on quotas.workspace.credits.left, which rides on every response. GET /v2/usage, GET /v2/flags and webhook polling keep answering whatever the balance, so a balance check never fails for the reason the lookup did. |
| An endpoint that worked last week returns nothing | Reverse Contact replaced /v2/resolve with /v2/enrich and /v2/search/persons with /v2/search/people, and documented the old pair as live only until 13 October 2026. | Search the workflow JSON for both old paths and change them. A workflow exported before that date and imported after it fails on its first run rather than at deploy time, which is the worst moment to find out. |
| A search cost far more than the number of requests suggested | People search is priced per profile delivered rather than per request, while company search is priced per page of up to 100 results, so the two are not the same arithmetic. | Call the free count endpoint to size a people search before you run it, and set the pagination limit deliberately. An unbounded pagination mode on a broad query is the expensive mistake on this endpoint. |

## What breaks, from the vendors' own docs

- **There is no dedicated node.** Reverse Contact ships no n8n node, so this is the HTTP Request node plus credentials. That is five minutes of work and it means no node update can break your workflow.
- **You own the uptime.** Self-hosting removes the third-party meter and hands you the pager. For most teams a small managed instance is the right compromise.
- **The credit cost is published, the dollar rate is not.** A reverse lookup from an email is 2 credits, a cached lookup 1, a live refresh 2, and a poll is free. No dollar rate per lookup is published, so the money figure depends on the pack or plan the credits came from.

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

### n8n

- **Base:** `Self-hosted or n8n Cloud`
- **Auth:** Credentials are stored in n8n, not in the workflow JSON, so the workflow stays safe to export and review.

| Call | Request | What it does |
|---|---|---|
| `NODE HTTP Request` | `Authentication: Generic > Header Auth. Name: Authorization. Value: Bearer rc_your_api_key` | There is no dedicated Reverse Contact node and you do not need one. Five minutes to configure, and no node update can break it. |
| `NODE HubSpot Trigger` | - | Authenticates with a **developer API key from a HubSpot developer account**, not a private app token, because that is how HubSpot exposes the webhooks API. Free to create, and nobody expects it. |
| `NODE Wait + IF` | - | The polling loop for Reverse Contact's /live endpoints: Wait 5s, GET the webhook id, IF status != succeeded loop back. |

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

- HubSpot allows **one webhook URL per app**. Route several object types through one subscription and branch inside n8n with a Switch node.
- Self-hosting is usually the reason this route was chosen: records never leave infrastructure you control. Do not quietly move it to a third-party cloud.
- n8n must be reachable by HubSpot for webhook triggers to fire.

Docs: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest

### 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 API documentation: https://docs.reversecontact.com/getting-started
- Reverse Contact: credits: https://docs.reversecontact.com/guides/credits
- Reverse Contact: rate limits: https://docs.reversecontact.com/guides/rate-limits
- Reverse Contact pricing: https://www.reversecontact.com/pricing
- Reverse Contact integrations: https://www.reversecontact.com/integrations
- n8n docs: HTTP Request node: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest
- HubSpot developers: custom code workflow actions: https://developers.hubspot.com/docs/api-reference/legacy/automation/workflow-actions/custom-code-actions
- 14 practitioner threads read on 2026-10-11, summarised on the page: https://www.reversecontact.com/integrations-hub/n8n-integrations/n8n-reverse-contact-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/n8n-integrations/n8n-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.*
