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

# Clay and n8n

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

**What you have to buy first:** An n8n instance, and Clay Growth or above, because both halves of this pair are Growth features

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

## The short version

The pair you build when a step takes longer than Clay will wait. Clay has no n8n node and n8n has no Clay node, so both directions are plain HTTP: Clay calls out through an HTTP API integration, and n8n posts results back into a webhook source that becomes a table. What you are buying is n8n's Wait node, which parks an execution in the database and resumes it on an interval or on a callback URL, and that is the one thing a Clay column cannot do. The cost is that you are now paying for orchestration twice and running a server, which is the trade practitioners describe rather than regret.

## Which Clay plan can run this at all

Rows: Clay plan. Columns: What you are trying to do. This grid is not about n8n editions, because n8n does not gate anything: the community edition is free and self-hosted and every pair on its hub is metered rather than tiered. The only question is which Clay plan unlocks the two mechanisms this pair is made of, and the answer puts both of them in the same place.

| Clay plan | Receive rows by webhook | Call n8n over HTTP | Pass 50,000 submissions |
|---|---|---|---|
| Free | Not included | Not included | Not included |
| Launch | Not included | Not included | Not included |
| Growth | Included | Included | Not included |
| Enterprise | Included | Included | Included |

- **Included.** Clay lists webhook automation and HTTP API integrations among the features Growth adds over Launch, and the plan comparison row for "Automate any signal via webhooks" reads included on Growth and on Enterprise.
- **Not included.** Not available on that plan at any volume. The third column is a documented cap rather than a feature flag: 50,000 submissions per webhook source, lifted only by Enterprise Auto-delete.

Counted off that grid, of twelve pairings: five give you included, seven give you not included.

The first two rows read identically, which is the sentence this grid exists to say: Launch at $185 a month buys you nothing for this pair, so the upgrade that matters is the one to Growth and there is no cheaper step on the way. The Enterprise column differs from Growth on exactly one thing, and it is not a feature, it is a counter.

## What actually syncs

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

| What | Direction | What that means in practice |
|---|---|---|
| Enriched rows | One way, out | An HTTP API integration on the table calls your n8n webhook with whatever columns you map into the body. A Growth feature, and the same gate as every other HTTP call out of Clay. |
| A job to wait on | One way, out | Anything asynchronous: a live enrichment, a scrape, a model call. Clay sends the request and stops caring, which is the point of handing it to n8n rather than to a column. |
| Finished results | One way, in | n8n posts JSON to a Clay webhook source. The keys of the body become the columns, so the shape of the table is decided by what n8n sends rather than configured in Clay. |
| A resume callback | One way, in | The Wait node generates $execution.resumeUrl at runtime, unique to that execution, and n8n documents handing it to a third party. Whatever finishes the slow job calls it, and the workflow carries on from there. |
| Nothing on a schedule | One way, out | There is no polling of Clay from n8n, because Clay has no node and no documented read API on these plans. If n8n needs to know a table changed, Clay has to tell it. |

## Which field lands where

There is no field map to publish, and that is the finding rather than a gap. Both directions are generic HTTP, so what crosses is whatever you put in the body. What is fixed is the four things the two vendors define, and each one constrains the shape more than it looks.

| In Clay | In n8n | What to know about the match |
|---|---|---|
| JSON body keys, out of n8n | Columns in the Clay table | Clay creates the table from the payload, so the keys are the schema. Send a key once and the column exists; change the key later and you have two columns. |
| Auth token | A request header on the webhook | Optional, and shown only once when the source is created. Clay documents no way to read it back. |
| Mapped columns, out of Clay | The HTTP API integration body | A Growth feature. You choose which columns go into the request, which is the only place in this pair where Clay decides the shape rather than n8n. |
| $execution.resumeUrl | Whatever is doing the slow work | Generated at runtime and unique to one execution. n8n documents sending it to a third-party service, which is how a job that finishes in twenty minutes restarts the workflow. |

**What does not cross:**

- Clay rows, read from outside. There is no Clay node in n8n and no documented read API on these plans, so n8n cannot ask what a table contains. The table has to push.
- The webhook submission counter. It only goes up, it survives deleting rows, and nothing in the product exposes a reset.
- Anything schema-like. Neither side validates the payload, so a missing key is a blank cell rather than an error, in both directions.

## Connect it, in this order

**Who has to do it:** Whoever owns the Clay workbook, plus whoever owns the n8n instance. No admin on either side, but somebody has to be willing to run a server.
**How long:** An hour or two for the first one, most of it deciding the JSON shape rather than clicking.

### 1. Check the Clay plan before anything else

*Where:* Clay: pricing

Webhook automation and HTTP API integrations are both listed as Growth features, and the plan comparison shows webhooks as not included on Free and not included on Launch. If you are below Growth, stop here: there is no partial version of this pair and no volume at which it becomes available.

### 2. Create the webhook source in Clay

*Where:* Clay: a workbook

In a workbook, click Add at the bottom, search for Webhooks and choose Monitor webhook. Clay gives you a URL and an equivalent cURL command. The URL is the one you paste into n8n; the cURL is there so you can send a row by hand before any workflow exists, which is the fastest way to see what the table does with your JSON.

### 3. Add the auth token and write it down

*Where:* Clay: the webhook source

Optionally secure the webhook with a token sent in the request header. Copy it immediately: Clay states that tokens are only accessible once, so this is the one step in the sequence that cannot be undone by looking it up again later.

### 4. Post to it from n8n with the HTTP Request node

*Where:* n8n: HTTP Request node

There is no Clay node, so this is a plain POST with a JSON body and the token as a header. Send one row first and look at the table: the keys of the body become the columns, so this request is where you are deciding the schema whether you mean to or not.

### 5. Add the Wait node where the slow step is

*Where:* n8n: Wait node

Choose the resume condition: after a time interval, at a specified time, or on a webhook call. For a job that reports back, use On Webhook Call and pass $execution.resumeUrl to whatever is doing the work. Turn on Limit Wait Time so an execution cannot sit waiting forever for a callback that is never coming.

### 6. Call back out of Clay, if the pair is two-way

*Where:* Clay: HTTP API integration

To start the chain from Clay rather than from n8n, add an HTTP API integration to the table and point it at an n8n webhook trigger. This is the Growth feature from step one, and it is the half that lets a Clay row ask for work rather than only receive it.

Nothing here is installed, so there is nothing to uninstall. Both ends are a URL and a credential, which is also why this pair needs documenting somewhere other than the two tools: in six months the only record of what the JSON was supposed to look like is the workflow itself.

## How to check it worked

- Send one row into Clay before building anything on top. A new row should appear with a column per key in your JSON body. If it arrives as a single column holding the whole payload, the body was sent as a string rather than as JSON, and that is the fix rather than anything in the table.
- Call out of Clay once and read the n8n execution list. The run should carry the columns you mapped into the request body, which is the only place in this pair where Clay decides the shape rather than n8n.
- Test the Wait node with a deliberately slow job rather than a fast one. A workflow that resumes correctly in two seconds tells you nothing about one that has to resume in twenty minutes, and the resume URL is unique per execution.
- Check the submission count on the webhook source while it is still new, so you know where the 50,000 ceiling sits relative to your volume. The number only goes up and deleting rows does not move it, so this is a capacity decision rather than a maintenance one.

## 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 webhook accepted rows for months and has quietly stopped | The source has reached 50,000 submissions. Clay documents the cap per webhook source and states it persists even after deleting rows, so an empty-looking table can still be at the limit. | On Enterprise, enable Auto-delete on the source so Clay processes and deletes rows and the webhook takes unlimited submissions. On every other plan, create a new webhook source and change the URL in the n8n workflow. There is no reset. |
| There is no Clay node to add in n8n | n8n does not publish one. Its documentation sitemap has no Clay entry and n8n.io/integrations/clay returns a 404, whatever a forum answer says. | Use the HTTP Request node for anything going to Clay and a webhook trigger for anything coming from it. If you want the work to look like a node, build it once as a sub-workflow and call that. |
| Clay has no option to call an external URL | HTTP API integrations are a Growth feature. On Free and Launch the capability is absent rather than limited. | Upgrade to Growth, or invert the direction so that n8n starts the chain on a schedule and posts into a Clay webhook source, which needs the same plan. If neither is possible the pair cannot be built. |
| The row arrives in Clay as a single column holding everything | The body reached Clay as a string rather than as JSON, so there was one value to make a column from. | Send the body as JSON from the HTTP Request node and set the content type accordingly. Clay builds columns from the keys of a JSON object, so the fix is in the request rather than in the table. |
| The webhook returns an authentication error after working yesterday | The token on the source was rotated or the header was dropped. Clay shows a webhook token once and documents no way to read it again. | Generate a new token on the source, paste it into the n8n credential, and store it where the rest of your secrets live. Nothing can recover the old one. |
| An execution has been waiting for days | A Wait node set to resume On Webhook Call, with no Limit Wait Time, and a callback that never came. The execution is parked in the database rather than failed. | Turn on Limit Wait Time with an interval or a maximum date so the workflow resumes and can take the failure branch. Then make the slow job report failure as well as success, because an absent callback and a failed job look identical from n8n. |

## What breaks, from the vendors' own docs

- **A webhook source stops at 50,000 submissions, for good.** Clay documents the cap per webhook source and states that it persists even after deleting rows, so a table you have emptied is still full as far as the counter is concerned. On Enterprise you can turn on Auto-delete, also called passthrough tables, and one webhook then takes unlimited submissions. On every other plan the documented remedy is to create a new webhook once you hit the number, which means the URL in your n8n workflow changes.
- **Neither tool has a node for the other.** n8n publishes no Clay node: there is no entry in its documentation sitemap and n8n.io/integrations/clay returns a 404. Clay has no n8n integration in its catalogue either. Both directions are therefore the generic HTTP Request node and a generic webhook, which is why this pair is hours rather than minutes and why nothing about it upgrades itself when either vendor ships something.
- **Both halves are Growth features.** Clay's plan comparison marks "Automate any signal via webhooks" as not included on Free and not included on Launch, and lists HTTP API integrations among the things Growth adds. So the inbound half and the outbound half are gated by the same plan, and a team on Launch at $185 a month cannot run either direction at any volume.
- **The auth token is shown once.** A webhook source can be secured with a token sent in the request header, and Clay's guide says to copy it immediately because tokens are only accessible once. There is no documented way to read it back, so losing it means a new token and an edit to the n8n credential.
- **Waiting is cheap, but it is yours to bound.** The Wait node offloads execution data to the database while paused, so a long wait costs storage rather than a held connection. It resumes after a time interval, at a specified time, or on a webhook call, and Limit Wait Time is what stops an execution waiting forever for a callback that never arrives. Nobody sets that until the first job hangs.

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

### Clay

- **Base:** `Configured in the table, not through an API`
- **Auth:** Per-integration, set in the workbook.

| Call | Request | What it does |
|---|---|---|
| `ACTION HubSpot / Salesforce Lookup` | - | Read-only. Pulls records into the table and changes nothing in the CRM. |
| `COLUMN HTTP API` | `POST https://api.reversecontact.com/v2/enrich/persons\nHeaders: { "Authorization": "Bearer rc_...", "Content-Type": "application/json" }\nBody: { "email": "/Work Email" }` | `/Work Email` is a column reference, so each row posts its own value. This is how a provider with no native listing becomes a column. |
| `ACTION HubSpot / Salesforce Update` | - | Writes back. Immediately live to every CRM user. Turn on "ignore blank values" and exclude rep-owned properties. |

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

- **Clay bills per action on the attempt, not the result.** Effective cost per filled field is the action rate divided by your match rate. Order a waterfall cheapest-first and use conditional runs so the expensive source only sees the residue.
- Import a filtered slice, never the whole portal. Filter on the gap you are filling.
- Run read-only until the columns look right, write to ten rows, open them in the CRM, and only then schedule.

Docs: https://university.clay.com/docs/hubspot-integration-overview

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

## Filling the record this integration moves

The integration above moves a record between two systems. Neither of them creates what is in it, so a sync that works perfectly still carries whatever gaps the record arrived with. Reverse Contact resolves an email, a domain or a profile URL into a verified people and company record through one API, and returns null with a confidence score rather than a guess.

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

- Clay: webhook integration guide: https://university.clay.com/docs/webhook-integration-guide
- n8n: HTTP Request node: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest
- n8n: Wait node: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.wait
- Clay pricing: https://www.clay.com/pricing
- 14 practitioner threads read on 2026-10-28, summarised on the page: https://www.reversecontact.com/integrations-hub/clay-integrations/clay-n8n-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/clay-integrations/clay-n8n-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.*
