Waterfalls that don't burn credits. Bidirectional sync that doesn't race. Documentation your team actually keeps. Built for RevOps teams who want the stack to work, not another vendor relationship.
Most RevOps teams pick their CRM first, then shoehorn enrichment around it. You get rigid pipelines, lossy data imports, and a house of cards that collapses the moment your lead model changes. Clay + Attio flips this: you start with a data structure that actually matches your business, then fill it with enrichment that stays clean.
Clay's waterfall logic and provider stacking — pulling from 8+ data sources per row — means your enrichment data arrives in one shape, not fragmented across vendor APIs. Attio's API-first design and custom-attribute fidelity mean that data doesn't get truncated or remapped on arrival. Your formula attributes can compute ICP scores, territory assignments, or buying-stage signals directly from Clay outputs, all inside Attio. No ETL glue. No data gravity pulling toward a third system.
Compare this to the alternatives: Apollo + HubSpot forces you into canned lifecycle stages and loses nuance in every sync. Cognism + Salesforce means paying enterprise weight for RevOps workflows. ZoomInfo prices for outbound blitzes, not teams iterating on their model. We've run 23 implementations on Clay + Attio stacks. In every case the cost-per-decision and time-to-activation beat the orthodoxy. Your data flows in clean, lives in clean, stays clean.
You pick how data flows between Clay and Attio. Each path has different tradeoffs. Your choice depends on whether you need transformation logic or just a fast, direct pipe.
Clay publishes raw enrichment data — company size, funding, tech stack, decision-maker emails — into Attio. Attio reports back changes: stage updates, owner assignments, close dates. The two systems sync those changes bidirectionally.
The fastest path. Clay launched native Attio support in March 2026. You authorize once in Clay settings, map your enrichment fields to Attio columns, and data flows immediately. Bidirectional sync out of the box. No code. Setup takes 15 minutes. The limit: you can't transform data mid-flight. Best fit for teams enriching contacts into Attio without heavy custom logic.
You point Clay at Attio's HTTP API directly. Each enrichment result triggers a POST to Attio's /people or /companies endpoint. You control the payload — add transformation logic in between, split one Clay record into multiple Attio records, or fan enrichments out to multiple destinations. Full control, no monthly fees beyond Attio. You maintain it; Attio rate limits apply (300 req/min per API key). Best fit: teams with 50+ enrichments/month or custom transformation needs.
Visual, non-technical-friendly. Each action costs a Zapier task; bills add up fast. Attio supports bidirectional sync natively, so Zapier adds latency without benefit. We avoid this for any volume above ~50 records/month.
For most teams, the native integration is the right call. Teams transforming data mid-flight should use the HTTP API webhook.
A waterfall is a fallback chain. Cheap providers run first; expensive ones only fire if cheap ones return null. Your entire cost structure hinges on hit rate and provider order.
Here's the canonical B2B person enrichment stack. Tier 1starts with Clay's native Find Email by Name + Domain — 0.25 credits per row, 60–70% hit rate. You hit this first on every record. Tier 2 fills the gaps: Datagma, ContactOut, or Dropcontact run next at 1–2 credits each, pushing combined hit rate to 85–90%. Tier 3 is the premium fallback — Lusha, Apollo, Hunter — at 3–5 credits per row. These only execute if tier 2 returned null. Tier 4, the last resort, is manual research or a Claygent agent at 5–15 credits.
The math moves fast. A typical 1,000-row enrichment across email, phone, and company runs $8–15 if your waterfall is built right. The same workflow without a waterfall — calling premium APIs on every row — costs $60–120. A waterfall built wrong burns 10x the credits a waterfall built right does. Same result, same hit rate. Just different cost.
The principle is deterministic. You're not guessing. You know exactly which provider will run for each record based on what tier 1 and tier 2 returned. You can predict cost before you run enrichment. Teams that build waterfalls right ship 10x faster and 10x cheaper than teams that treat enrichment as a black box.
We publish every waterfall we configure as Loom walkthroughs. Your team iterates after we leave. No proprietary voodoo. Just transparent credit math.
| Tier | Provider | Field returned | Credits / row | Hit rate |
|---|---|---|---|---|
| 1 | Clay native | Email, name | 0.25 | 65% |
| 1 | Clay company lookup | Domain, size, industry | 0.5 | 92% |
| 2 | Datagma | Email, LinkedIn | 1.0 | 70% of misses |
| 2 | Dropcontact | Email, phone | 1.5 | 60% of misses |
| 2 | ContactOut | Email, LinkedIn | 1.5 | 65% of misses |
| 3 | Lusha | Direct phone, email | 3.0 | 55% of misses |
| 3 | Apollo | Email, sequenceable status | 3.5 | 60% of misses |
| 3 | Hunter | Email pattern fallback | 2.5 | 40% of misses |
| 4 | Claygent agent | Anything not above | 5–15 | Variable |
Your team runs inbound, outbound, and account operations together. Clay plugs into all three. Here are the integrations we build most.
Form submission hits your website. Clay catches it, enriches across LinkedIn, company databases, and intent platforms, then lands a 12-field Person record directly into Attio — within 90 seconds. Your SDRs see email, company size, job title, and buying signals before they pick up the phone.
Define your territory once: industry, employee count, geography. Clay queries data providers against those filters and builds a table of 500–5,000 Companies matching your ICP. Push the list into Attio as a fresh campaign. Start dialing the same day.
Clay polls intent platforms — 6sense, Bombora, G2 — for accounts showing buying behavior. Signals land on existing Attio Company records with a score. SDRs get instant Slack alerts when an account hits hot intent. Inbound routing becomes data-driven, not guesswork.
Every Company in Attio gets enriched with 12–15 signals: firmographics (headcount, revenue, industry), technographics (tools they use), and behavioral data (website visits, content engagement). Attio formula attributes compute the score inside the CRM. No external scoring tool tax.
A weekly Clay sweep over every Person in Attio. Fill missing emails, titles, and LinkedIn URLs. Detect and flag duplicates. Mark records inactive when they've gone dark for 180+ days. Your database stays clean without hiring a data ops person.
How each one is wired:
| Use case | Trigger | Source | Destination | Cost / 1K rows |
|---|---|---|---|---|
| Inbound enrichment | Form submission webhook | Web form / Typeform | Attio People + Slack alert | $8–12 |
| TAM sourcing | Manual run / monthly cron | Clay providers + filters | Attio Companies (campaign list) | $10–15 |
| Intent routing | Daily 6sense / Bombora poll | Intent providers | Attio Companies + Slack | $15–25 |
| Account scoring | Weekly cron over Attio Companies | Firmographic + behavioral providers | Attio formula attribute | $10–15 |
| CRM hygiene | Weekly cron, null-field filter | Tier 1–3 waterfall | Attio People (update only) | $5–8 |
| Sales sequence handoff | Attio Stage = Working trigger | Apollo / Lemlist enrichment | Lemlist sequence + Attio note | $3–6 |
| LinkedIn URL fill | Daily cron on Attio People | Datagma + Hunter fallback | Attio People (update only) | $2–4 |
| Duplicate detection | Weekly cron | Clay dedup logic on email + domain | Attio merge queue | $1–2 |
What Clay POSTs to Attio when a tier-3 fallback hits. Every record carries a Clay run ID and a source so you can audit the lineage.
# Clay → Attio HTTP API (POST /v2/objects/people/records)
Authorization: Bearer $ATTIO_API_KEY
Content-Type: application/json
{
"data": {
"values": {
"name": [{ "first_name": "Alex", "last_name": "Reyes" }],
"email_addresses": [{ "email_address": "alex@northwind.io" }],
"linkedin": [{ "value": "https://linkedin.com/in/alexreyes" }],
"title": [{ "value": "Head of GTM" }],
"company": [{ "target_object": "companies",
"target_record_id": "rec_8f2..." }],
"lead_score": [{ "value": 84 }],
"source": [{ "option": "clay-waterfall-tier-3-lusha" }],
"clay_run_id": [{ "value": "run_2026-04-28T11:42:08Z_a7c" }]
}
}
}We've shipped 23 of these. Here's what reliably breaks if you don't watch for it.
| Issue | Cause | Fix |
|---|---|---|
| Credit blowout on weekly re-runs | Clay re-enriches every record on every sync, even ones already enriched. Monthly bill doubles or triples. | Add a "only if X is null" filter at the table top. Skip records already enriched within the last N days. |
| Bulk write-back fails silently | Attio caps at 5 req/sec per API key. A 200-record write dumps 50 records on the floor with no error. | Batch in chunks of 50 with a 10-second pause between. Add a retry loop on 429 responses. |
| Type mismatch on custom attributes | Clay returns "Technology" as raw text; Attio expects a single-select option that doesn't exist yet. | Pre-create dropdown options in Attio. Map Clay values to exact strings. Add an "Other" fallback for unknowns. |
| Owner-by-email match fails | Sarah's Attio email is sarah@company.com; the form returns sarah.smith@company.com. The match fails silently, owner stays unassigned. | Add a secondary email lookup at the Clay step. Or fall back to domain matching for owner assignment. |
| Bidirectional sync race conditions | Attio Stage updates while Clay table is mid-enrichment. Writeback overwrites the fresh Stage with cached data. | Use Clay's "Skip if Updated < 1h" filter on writeback. Or push Attio updates as a separate webhook. |
| Duplicate records on inbound | Same person fills out two forms in a week. Clay creates two Attio People records, breaking your ownership. | Match on email at the Clay step. If duplicate, update existing record instead of creating new. |
You get a mapped Clay table structure aligned to your Attio data model, a three-tier provider stack budgeted to your monthly credit pool, bidirectional sync via HTTP API or native connector with rate-limiting and retry logic, three to five enrichment workflows wired to your stack (inbound lead scoring, TAM expansion, data hygiene, intent signals, account scoring — you pick), a written runbook with Loom walkthroughs for every workflow, and 30 days of support to tune and troubleshoot.
We don't manage your Clay credits month over month — you keep full account ownership. We also don't ghost-write outbound sequences in Lemlist or Instantly; that's your team's voice, not ours. What we do is architect the plumbing so your sales and marketing tools talk cleanly, data stays fresh, and your team can focus on conversations instead of data ops.
This ships as part of our Migration + Wire tier ($7,500) when paired with an Attio migration — or as a standalone Clay+Attio engagement starting at $4,500. Already migrating from HubSpot? See the HubSpot to Attio migration page. Starting fresh with Attio? Check Attio implementation.
Don't see yours? Get a fixed quote and ask in the notes.
Twenty minutes on a screen-share. We'll scope your Clay + Attio stack and send a fixed quote within 24 hours. No deck, no pitch.