Webhook out of the table, into a workflow that can wait for an async job.
An n8n instance, and Clay Growth or above, because both halves of this pair are Growth features
Contacts, Companies, two-way sync.
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.
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 |
|---|---|---|
| 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. |
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.
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. |
Three things are worth knowing before you plan around this mapping, because each one is a decision somebody has to own rather than a setting to find.
Every row above travels as a file: four field mappings and three documented exclusions, each one's note, and the four 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 practical consequence is that the contract between these two tools lives in your head until you write it down. A field map exported from this page is a reasonable place to keep it, because neither vendor will hold it for you.
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. Pick one on each side and the grid marks the answer.
Pick one on each side.
| 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 |
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.
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.
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.
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.
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.
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.
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.
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.
The same sequence, the sync table, the documented limits and the error list ship as one agent skill. Point Claude Code, Cursor or anything that reads a file at this pair as a skill and it has the whole pair without reading two sets of vendor docs first.
curl -o .claude/skills/clay-n8n/SKILL.md https://www.reversecontact.com/integrations-hub/skills/clay-n8n.md
Every limit below is documented by one of the two vendors. They are here because they change decisions, not because they are flaws.
Each of those is documented behaviour rather than a fault, so none of them is going to be fixed by a support ticket. The ones that produce a symptom you would misread are below.
Each one below is a symptom somebody reports, the documented reason behind it, and the fix. Most are configuration rather than faults, which is why they survive a support ticket.
WhyThe 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.
Whyn8n 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.
WhyHTTP 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.
WhyThe 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.
WhyThe 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.
WhyA 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.
If none of those is it, the next thing to check is the thing most pairs fail on: whether the plan you are on carries the feature at all, which the grid above answers. The same symptom on another pair is often the same cause, so the directory indexes all of them by the message rather than by the integration.
The right-hand column is the one worth being honest about, because every item in it is a reason to spend the budget somewhere else in the stack rather than a reason to configure harder.
Searched for this pair by name, in the words a person would use. 14 threads from June 2025 to April 2026 were read in full on 28 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.
did the full clay to n8n migration last quarter. the savings are real but don't underestimate the maintenance overhead you're taking in
r/gtmengineering·April 2026·4 points
The clearest one-line statement of the trade on this page, from somebody reporting a finished migration rather than a plan. It matches what the n8n hub says about every pair on it: the gate is never the plan, it is who owns the instance.
Don't rip it out entirely, that's more work than it's worth. Pull the heavy enrichment steps out first, the ones burning the most Actions, replace those with direct API calls, keep Clay for the orchestration layer where it actually earns its cost. Hybrid model still works if you're surgical about it
r/gtmengineering·April 2026·3 points
This is the recommendation this page would make on its own, arrived at independently by somebody paying the bill. It is also why the pair is two-way rather than a migration guide: the point is to move the expensive steps, not the workbook.
what is the point of using n8n when you can just a webhook directly to a Clay table?
r/n8n·June 2025·1 points
Left unanswered in the thread, and it is the right question. The answer is the Wait node: a webhook into Clay is enough when the work is instant, and useless when the work takes ten minutes, because a Clay column has nowhere to wait. If your steps are fast, this commenter is correct and you do not need the pair.
yes you definitely can do the researcb with ai agents on n8n and then pass the results to clay using its native node ,
r/n8n·August 2025·1 points
Confidently wrong, and worth including for that reason. n8n publishes no Clay node: there is no entry in its documentation sitemap and the integration page 404s. Somebody acting on this answer would spend an afternoon looking for a node before reaching for the HTTP Request node they needed all along.
It's not great but I send to Clay with webhook which works ok and then to a google sheet from Clay and then pull the sheet in the n8n
r/n8n·November 2025·1 points
A three-hop round trip through a spreadsheet, described by the person running it as not great. It is the honest consequence of the gap in the field map above: n8n cannot read a Clay table, so getting data back out means Clay exporting somewhere n8n can reach. Worth knowing before you design something that depends on reading state.
This is one of the few Reverse Contact adjacent pairs that practitioners do discuss by name, because Clay's Actions pricing made moving steps into n8n a live question in 2026. The useful threads are not the ones arguing about whether Clay is overpriced. They are the ones where somebody has already done it and is describing what it cost them.
Four of these five describe cost or mechanics that the two vendors document, which is the corroboration this section is for. The fifth is included because it is wrong, and because the correction is the thing a reader needs.
The honest reason to build this is latency rather than money. A Clay column runs an enrichment and waits for an answer, which is fine when the answer takes a second and impossible when it takes ten minutes. n8n is the only tool in this directory that can park a job and come back to it, because the Wait node writes the execution to the database and resumes on a timer or a callback. Everything else in the chain has to be told the answer rather than ask for it.
The money argument is real but it is not the one people describe. Clay bills Actions per step, so the cost of a workflow is the number of steps multiplied by the rows, and moving a step to n8n removes it from that meter. Three things are true at once, and practitioners on r/gtmengineering say all three:
That is also the shape this page recommends. Ripping Clay out entirely is a bigger project than the bill justifies, and the pair exists precisely so that you do not have to choose one tool.
Read the direction of this pair carefully, because it is asymmetric in a way the facets do not show. Out of Clay you get a configured HTTP call with retries and error handling you did not write. Into Clay you get a URL that accepts JSON and turns keys into columns, with a lifetime cap of 50,000 submissions and no way to reset it. The outbound half is a feature and the inbound half is a counter you will eventually hit.
Reverse Contact resolves an email, a domain or a profile URL into a verified people and company record, through one API with a consistent schema. It sits under Clay, n8n and everything else in this directory, and it returns null with a confidence score rather than a guess.
Free trial, no card required, and 500 credits to start.
Not as a node on either side, which is the first thing to know. n8n publishes no Clay node: there is no entry in its documentation sitemap and n8n.io/integrations/clay returns a 404. Clay lists no n8n integration in its catalogue either. What exists instead is a working n8n Clay integration built from generic parts: a Clay webhook source that turns posted JSON into table rows, and an HTTP API integration on the Clay side that calls n8n. Both are documented and both are Growth features.
Growth. 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 what Growth adds. Because both directions of this pair are gated by the same plan, Launch buys you nothing here: there is no half version to run while you decide. Growth is listed at $446 a month on an annual commitment and $495 billed monthly.
Because a Clay column has nowhere to wait. If your step returns in a second, the commenter asking this question on r/n8n is right and you do not need n8n at all. The pair earns its keep when something takes minutes or tens of minutes: n8n's Wait node parks the execution in the database and resumes it after an interval, at a set time, or when a callback hits a URL unique to that execution. That is the one capability Clay does not have and cannot be configured into.
It stops accepting data, and the counter does not reset. Clay documents the cap per webhook source and says explicitly that it persists even after deleting rows, so emptying the table does not help. Enterprise plans can enable Auto-delete, also called passthrough tables, so Clay processes and deletes rows and one webhook takes unlimited submissions. On every other plan the documented remedy is to create a new webhook source, which means changing the URL in your n8n workflow.
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.