Clay enrichment and lead routing for SaaS: the part of the GTM stack where most teams either burn credits or miss revenue, and usually both. Here is the playbook, including the step that quietly ruins CRMs, which is the write back into HubSpot.
Build three Clay tables, one per job: trial enrichment, outbound TAM and expansion. Enrich each signup with a company match and ICP score, route hot leads to sales via Slack and warm leads to a PLG sequence. Write back to HubSpot with Update keyed on the record ID, never Create.
Updated November 2026 with the HubSpot write-back section: which Clay action to use, why HubSpot's own deduplication does not cover an API write, what to gate the create step on, and how to clean the duplicates already in the portal.
The three jobs Clay actually does for SaaS
Before any workflow gets built, separate the work:
- Inbound enrichment for free trial signups. An email and maybe a company name, and you need to know whether this is a serious buyer, fast enough that the right rep (or no rep) gets pinged.
- Outbound enrichment for TAM building. A fit-list of target accounts, each carrying firmographics, technographics, signals and decision-maker contacts.
- Expansion enrichment for existing customers. The customer grew, hired, funded or changed stack. Does that open a tier-up conversation?
Each job has a different latency requirement, a different cost profile and a different best set of providers. Build one table per job.
Job 1: free trial signup enrichment (the lead routing piece)
This is the highest-impact workflow for any product-led B2B SaaS. A user gives you their email on signup, and within a minute you want a verified work email, a company match, size and stage, an ICP fit score and a routing decision. Here is the pattern we run.
The key design decisions:
- Only enrich on signup, not on every login. Re-enrichment burns credits and rarely changes the routing decision. Enrich once, then re-enrich only on a signal.
- Skip the deep enrichment for trial signups. You need a routing decision, not a research dossier. Deep enrichment is Job 2 territory.
- Cache aggressively. If the same domain shows up twice in a month, reuse the stored answer rather than buying it again. The write-back section below covers how Clay's saved enrichment data does this and where it refuses to.
- Default to PLG, overlay sales. Let sales inherit only the rows that cross a threshold, rather than letting sales decide which leads to take, because sales will decide to take all of them. Where the ACV justifies a sales-led default instead, the handoff is in the founder-led-sales-to-AE guide.
One budgeting note since Clay's 11 March 2026 repricing: a signup flow spends from two pools, with provider lookups drawing data credits and the trigger, scoring, CRM write and Slack push drawing actions (Landbase). We expect actions to bind first at volume, because every signup runs the full set of steps whether or not the enrichment finds anything.
Job 2: outbound enrichment for TAM building
Start with a structured table, one row per account, sourced from a Sales Navigator export, a Crustdata filter, a bought list or your own CRM filtered by an ICP signal. Resist starting with twenty thousand rows: pruning at the start is the cheapest place to prune. Then run the waterfall, querying providers in order and paying only for the first success, with each one firing only if the previous missed the field. The full build order is in our Clay enrichment waterfall guide, and the credit discipline is in the Clay credits guide.
Each enriched row then gets an ICP fit score, an intent score and a one-sentence reason. Push the top slice to your sequencer and leave the rest in a holding queue until a signal fires. The holding queue is the part teams skip, and it is the difference between a list you work and a list you burn.
This is also the job where Clay is least obviously the right tool. A team with a strong engineer interested in GTM work often does better with an API-first pipeline over a warehouse, which is the shape of the Deepline stack, and on Clay against n8n the best stacks use both, which we work through in the Clay and n8n launch playbook.
Job 3: expansion enrichment for existing customers
The least-used pattern and the one with the highest return for established SaaS companies. A Clay table watches your customer base and fires a signal whenever something meaningful changes: a new hire in a buyer persona role, a funding milestone, a stack change that opens a use case. Customer Success gets the context and opens the conversation while the customer is already thinking about the problem, not at the next QBR.
For customers inside a larger group, the biggest expansion list is the sibling entities you are not in yet. Clay's account hierarchy enrichment gives you that tree, and our guide to Clay account hierarchies in HubSpot covers how to model it as parent and child companies and read whitespace across the group.
How do you sync Clay enriched data into HubSpot without creating junk contacts?
Look the record up first, write with Update keyed on the HubSpot record ID, and let Create run only when the lookup came back empty. That order is the whole answer, and almost every junk-contact problem is a table that skipped the first step.
Clay's HubSpot integration exposes the write side as separate actions rather than as one sync: Look up object, Create object, Update object, Create association, Find owner, Add record to list and two sequence actions (Clay docs). There is no upsert in that list. Create-or-update is something you assemble, not something you select.
Clay University's lesson draws the line in the same place: Lookup actions pull data into Clay and change nothing, so you can test them freely, while Create and Update make permanent changes every user in the portal sees. The sequence it documents is enrich, look up, create selectively for what was not found, then update what was (Clay University). Clay's own sync guide names the failure directly as writing with Create instead of Update, because a Create run over contacts that already exist duplicates every record (Clay). The lookup column is not a nicety. It is the deduplication.
The thing to get right is the lookup key. Look up object asks for fields to filter by, and the docs put HubSpot Object ID at the top of that list because matching on the record ID is the most precise option. Without the ID, filter on email for contacts and domain for companies, set the search operator deliberately (AND is the default with two or more fields), and note the result limit defaults to 10 and caps at 200.
Why does HubSpot's own deduplication not cover a Clay write?
Because the automatic deduplication HubSpot documents applies to records created in the CRM, and for companies the knowledge base states the exception plainly: companies created through the API are not deduplicated by the Company domain name property, and that explicitly includes installed third-party sync apps (HubSpot).
The rest of that article, last updated 2 October 2026, is worth reading before you design the sync. HubSpot automatically deduplicates contacts by matching the Email property and companies by matching the primary Company domain name, and the places it names for this are manual creation, form submissions and imports. On import, a contact with a matching email updates the existing record rather than creating a new one, and only mapped properties change. Where several records already share that email, the import throws an error and skips the row instead of guessing.
Two consequences. You cannot delegate company deduplication to HubSpot at all on an API write, so the lookup has to do it. And domain normalisation happens in two places, so know which one you are leaning on: Clay's Create object action has a "Keep subdomains in Company domain" switch that is off by default, so a domain written to a company is reduced to its root and shop.example.com arrives as example.com, while HubSpot's import documentation separately states the Company domain name property only accepts values up to the top-level domain and strips anything after it (HubSpot). A lookup filtering on an un-normalised domain will miss a record that already exists.
How do you write enriched data to existing contacts only?
Use Update object, key it on the HubSpot Object ID, leave Ignore blank values on, and do not put a Create object column in the table at all.
Update object takes exactly two required inputs, the object type and the HubSpot Object ID, which is why carrying the record ID on every row from the import is not optional (Clay docs). Clay's import source pulls objects from HubSpot with an optional list filter, and the ID that comes back on each row is the key the write-back lands on.
Ignore blank values is the second switch that matters, and it is on by default. With it on, a blank coming out of a failed enrichment is left alone and the populated HubSpot value survives; turn it off and blanks overwrite what is there. Clay's sync guide lists letting blanks overwrite good data as one of its named failure modes, and there is almost never a reason to turn it off on an enrichment column.
The permission layer can enforce the same intent. Clay's required HubSpot scopes are all reads: lists, contacts, companies, leads, owners and the contact and company property schemas. Every write scope is optional, including the contacts and companies write access requested by default. Where the sync's job is enrichment and nothing else, reconnect the account with those switched off and the table cannot create a record even if someone adds the column later.
What should gate the create step?
A conditional formula on the lookup result, plus a test that HubSpot's own required properties are actually present. One without the other is what produces the junk.
Every HubSpot enrichment in Clay carries an "Only run if" condition in its run settings, and Clay University is unambiguous about what belongs in it: for Create actions, use conditional formulas to only create new records if nothing was found during the lookup phase (Clay University). The same lesson lists four patterns for gating Update actions, worth stealing wholesale: update only where the field is empty, only where the new data is more recent, only above a confidence threshold, and only where the new source outranks the one on the record.
The second gate is the one most tables are missing. HubSpot requires the Email property to create a contact, and at least one of Name or Company domain name to create a company (HubSpot). A row where the waterfall found no email is not a row to create a contact from; it is a row to hold back for a second pass. The pattern we see is a table gated on lookup-empty and nothing else, which faithfully creates one thin, unmatchable contact for every enrichment that failed, and that is precisely the junk the question is about.
Build order matters as much as the conditions. Clay University's advice is to turn auto-update off while building a Create or Update workflow and trigger it manually on small batches once you have checked what it intends to do. In a HubSpot rebuild the first write goes to a handful of known records, or to a sandbox portal, and gets read back by hand before anything is scheduled.
What do you do about the duplicates already in the portal?
Clean them with HubSpot's duplicates manager before you connect the write, not after, and check the tier first because the tool is not on every plan.
The duplicates manager requires a Professional or Enterprise subscription on Marketing Hub, Sales Hub, Service Hub, Data Hub or Smart CRM, and at those tiers it handles individual pairs and displays up to 10,000 of them. Bulk management and the higher ceilings need Data Hub specifically, which raises the display to 30,000 pairs on Professional and 100,000 on Enterprise (HubSpot).
What it matches on is wider than the automatic deduplication. By default HubSpot compares contacts on First Name, Last Name, Email address, IP country, Phone number, Zip Code and Company Name, and companies on Company Domain Name, Company Name, Country/Region, Phone Number and Industry, recalculating as records are created and at least once a day otherwise. Custom rules are supported.
Two limits to plan around, both in that article, last updated 23 October 2026. Merges cannot be reverted. Rejections roll back for 14 days, and only if nothing on either record changed in the meantime. So the order is audit, merge, then wire the sync: our guide to auditing a B2B CRM covers the duplicate and broken-association sweep, and the CRM data enrichment guide covers what should fill the fields afterwards.
How do you stop the sync from spending twice for the same answer?
Turn on reuse of saved enrichment data for the columns that tolerate it, normalise your inputs so reuse actually hits, and accept that the write steps will always be live.
Clay stores what a provider returns and can serve it back instead of buying it again, with saving and reuse as separate switches. Saving is on by default and costs nothing extra, because the answer is already paid for. Reuse is opt-in and is the half that saves credits. Saved values expire after a window, 30 days unless you change it, with 7, 30, 60 and 90 day options, and the feature is documented as still in beta (Clay docs).
Three details decide whether it pays. A reused value costs no data credits but still spends one action, so it cuts one pool and not the other. Reuse only triggers when the same action runs with the same inputs, so a column that trims whitespace and lowercases a domain hits saved values more often, and that same normalisation is what makes the deduplication lookup match. And an empty result is recorded too, so you do not pay twice to learn the same blank.
The exception matters here: actions that write to another tool cannot save data at all, because a CRM update served from a stored value would silently skip the update. Reads therefore get cheaper over time and writes do not, which is an argument for filtering in HubSpot before importing rather than pulling the whole portal into Clay.
Where does lead routing fall apart?
Enrichment is half the work. The logic that turns "this lead is hot" into "the owning AE has a Slack ping with the context" has to answer four questions per lead: real buyer or noise, which team owns it, which rep specifically, and what the first touch is. Pick one ownership model and stick to it, and give each route its own messaging.
We typically run routing as a separate n8n workflow listening to Clay's output: Clay handles enrichment and scoring, n8n handles orchestration, and neither tries to do both. That split is worth more since the repricing, because routing rules are orchestration and orchestration is what the actions pool bills for. Clay can handle simple routing in the table, with a breakeven around five rules.
Two patterns to avoid: routing on data you do not actually have, since technographic routing only works if the technographic data is reliable, and forgetting the negative cases, because a rule that stops sales being routed a lead from a competitor domain is the cheapest rule in the table.
Want a Clay setup that enriches, scores and routes without polluting the CRM? That is one of the builds we run.
Talk to usFrequently asked questions
Can Clay update existing HubSpot contacts without creating any new ones?
Yes, and it is the safer default. Build the table with a Look up object column and an Update object column and no Create object column at all: Update object requires the HubSpot Object ID, so the write can only land on a record that already exists (Clay docs). For the guarantee at the permission layer rather than the table layer, reconnect the account with the contacts and companies write scopes disabled, since every write scope in the integration is optional.
Does HubSpot deduplicate the contacts and companies Clay creates?
Not reliably, and for companies the documentation says so outright: companies created through the API, including installed third-party sync apps, are not deduplicated by the Company domain name property (HubSpot). Contact deduplication by email is documented for records created in the CRM through manual creation, forms and imports. So the duplicate check belongs in Clay, as a lookup before the write, and HubSpot's automatic matching is a backstop you do not design around.
What is the right unique identifier for a Clay to HubSpot write?
The HubSpot record ID, every time it is available, which is why you import it and carry it on the row. HubSpot's guidance for updating records without creating duplicates is to include a unique identifier property, naming Record ID or a custom property that requires unique values, with Email available for contacts and Company domain name for companies (HubSpot). Note the catch on the custom-property route for companies: using one means Company domain name no longer has to be unique, so duplicate domains can get in.
Why did a Clay run create duplicate companies in HubSpot?
Almost always one of three things, in this order. The table used Create object where it should have used Update object keyed on the record ID. The lookup filtered on an un-normalised domain and missed a record HubSpot stores at the root domain. Or the create step was gated on nothing but an empty lookup, so rows with no usable domain got written anyway. Fix it before the next scheduled run rather than after, because merges in HubSpot's duplicates manager cannot be reverted (HubSpot).
Why did connecting Clay to HubSpot fail with an authorization error?
If authorization stops with a generic message about an unexpected error during the app authorization process, the usual cause is the three custom object permissions. Clay's documentation states they are available on HubSpot Enterprise portals, cannot be granted on other plans, and stop authorization rather than being skipped, which is why all three arrive switched off. Reconnect with them off and the rest go through (Clay docs).
How do I price out a Clay subscription for free trial enrichment?
Count two pools, not one: provider lookups against data credits, and the trigger, scoring, CRM write and notification steps against actions. The plans, allowances and rollover rules that go with that are in the Clay for GTM post, and confirm current numbers at clay.com/pricing before you sign anything.
How do I avoid burning Clay credits on bad data?
Validate emails before enrichment, because a verifier is cheaper than wasting an enrichment on a fake address. Filter the list in HubSpot before importing, which is Clay University's own advice. Gate the waterfall so expensive providers only fire when the cheap ones missed. Full breakdown in the Clay credits guide.
How does Clay handle GDPR for European prospects?
Clay enriches public data through providers that document GDPR-compliant sources, and the data lives in Clay's infrastructure during processing. Where EU residency is a hard requirement, the pattern is to push enriched data straight to the EU-hosted CRM rather than persisting it in Clay tables. Add the suppression check before you scale, because a Clay run condition that reads the opt-out list is far cheaper at one table than at nine.
Can Ziel Lab build this for us?
Yes. The three-job Clay setup and its HubSpot write-back is one of the patterns we run in our Clay agency service, alongside our go-to-market work. Typical engagement is the 90-day pilot, fully built and handed over with documentation. Book a call if you want to scope it.