.svg)
Overview
Clay and Instantly have become the default pairing for teams running cold email at scale. Clay handles the upstream research and enrichment. Instantly handles the downstream sending and deliverability. Together, they give you a pipeline that takes a raw list of target accounts and turns it into personalized campaigns hitting inboxes within hours instead of days.
But wiring these two tools together well is harder than most tutorials suggest. The gap between "Clay table with enriched data" and "Instantly campaign with high reply rates" is where personalization breaks down, leads get misrouted, and deliverability suffers. This guide covers the full integration architecture: how to structure Clay tables for Instantly consumption, map enrichment data to personalization variables that actually improve reply rates, automate campaign triggering without manual CSV exports, and build the feedback loops that let you optimize over time.
If you're already running a basic Clay-to-Instantly workflow and want to tighten it up, or if you're building one from scratch and want to avoid the common mistakes, this is the practical reference.
Why Clay + Instantly Is the Default Outbound Stack
The popularity of this pairing isn't accidental. Clay and Instantly each solve a specific problem well, and their combined capabilities cover the two hardest parts of cold email: knowing enough about your prospect to say something relevant, and actually landing in their inbox.
What Clay Brings
Clay is a data enrichment and research platform that aggregates 75+ data providers into a single spreadsheet-like interface. Instead of buying separate subscriptions to Apollo, ZoomInfo, Clearscope, and a dozen other tools, you run waterfall enrichment in Clay that tries multiple providers sequentially until it finds the data you need. The result is richer, more complete prospect records at a lower per-lead cost than any single provider.
More importantly, Clay's AI columns let you synthesize raw enrichment data into personalization-ready outputs. A company's job postings, tech stack, recent funding, and leadership changes get distilled into a one-sentence research insight or a pain-point hypothesis that your email can reference directly.
What Instantly Brings
Instantly is a cold email sending platform built around deliverability. Its core differentiators are unlimited sending accounts, automated warm-up, inbox rotation, and sending schedule optimization. For teams sending thousands of cold emails per week, Instantly's infrastructure handles the deliverability mechanics that would take weeks to configure manually.
Instantly also supports custom variables (beyond basic first name and company name), A/B testing across email variants, and campaign-level analytics that track opens, replies, and positive response rates.
The Combined Value
When connected properly, Clay feeds Instantly the enriched data that makes personalization possible, and Instantly feeds back engagement data that tells you which enrichment signals actually matter. It's a research-to-execution pipeline where the quality of input directly determines the quality of output.
Clay determines what to say and who to say it to. Instantly determines how it gets delivered. Every decision about your integration architecture should reinforce this separation of concerns.
Building the Clay-to-Instantly Pipeline
There are three primary ways to move data from Clay into Instantly. Each has tradeoffs in complexity, reliability, and automation level.
Method 1: CSV Export/Import
The simplest approach. Export your enriched Clay table as a CSV, then upload it into an Instantly campaign. This works for small-volume or one-off campaigns, but it's a non-starter for teams running ongoing outbound operations.
The problems compound quickly: manual exports create version control issues, there's no automatic deduplication between campaigns, and you lose the ability to trigger campaigns based on real-time enrichment events. Use this method for testing your variable mapping, not for production workflows.
Method 2: Clay's Instantly Integration (HTTP Action)
Clay supports pushing leads directly to Instantly via an HTTP request action step. You configure the Instantly API endpoint, map your Clay columns to Instantly's lead fields (including custom variables), and the action fires automatically when a row reaches the final step of your enrichment workflow.
This is the recommended approach for most teams. It eliminates manual exports, supports real-time lead pushing as enrichment completes, and can be gated by data quality checks that prevent incomplete records from reaching your campaigns.
Method 3: Webhook + Middleware (Zapier/Make/n8n)
For more complex routing logic, some teams use Clay webhooks to trigger a middleware automation that processes the data before pushing to Instantly. This adds flexibility: you can route leads to different campaigns based on enrichment results, add CRM checks to prevent duplicate sends, or fan out to multiple sending tools simultaneously.
The tradeoff is added complexity and latency. Every middleware step introduces a potential failure point. For teams already comfortable with multi-tool orchestration, this approach offers the most control. For everyone else, Method 2 is sufficient.
Personalization Variable Mapping
This is where most Clay + Instantly integrations either shine or fall apart. Getting data from Clay to Instantly is the easy part. Getting the right data into the right variables so your emails read naturally is where the real work happens.
Standard Variables
Instantly's built-in variables map to standard lead fields. These should always be populated from Clay's enrichment output.
| Instantly Variable | Clay Column Source | Fallback Strategy |
|---|---|---|
| {{first_name}} | Contact First Name | Use "there" or omit greeting |
| {{last_name}} | Contact Last Name | Omit; never guess |
| {{company_name}} | Company Name (cleaned) | Use domain-derived name |
| {{email}} | Verified Email | No fallback; skip the lead |
| {{website}} | Company Domain | Derive from email domain |
Custom Variables: Where Personalization Gets Real
Standard variables get you "Hi Sarah at Acme Corp" personalization, which is table stakes. The real differentiation comes from custom variables populated by Clay's enrichment and AI columns. These are the fields that make your emails feel researched rather than templated.
Here's a practical variable mapping schema that balances personalization depth with maintainability:
| Custom Variable | Clay Source | Example Value | Email Usage |
|---|---|---|---|
| {{pain_point}} | AI column: pain hypothesis based on role + industry | "scaling outbound without adding headcount" | Opening line or value prop |
| {{company_insight}} | AI column: synthesized from funding, hiring, news | "your recent Series B and the 5 open SDR roles" | Research proof point |
| {{relevant_metric}} | AI column: industry benchmark or company-specific data | "teams your size typically see 40% of rep time on manual research" | Problem quantification |
| {{tech_stack_ref}} | Enrichment: technographics | "since you're already using HubSpot and Outreach" | Relevance anchor |
| {{personalized_cta}} | AI column: CTA matched to persona | "walk you through how we handle this for other Series B teams" | Closing line |
Use snake_case for all custom variables and keep names descriptive. In Instantly, custom variables must match exactly between your lead data and your email templates. A mismatch between {{company_insight}} in your template and "Company Insight" in your CSV header means the variable renders blank at send time. Standardize naming in Clay before pushing to Instantly.
Handling Missing Data
Not every lead will have complete enrichment data. A prospect's company might not have recent news. Their tech stack might be unknown. Your AI column might fail to generate a usable pain hypothesis. You need a strategy for this, because blank variables in sent emails are worse than no personalization at all.
Instantly supports fallback values using the syntax {{variable_name | fallback text}}. But relying entirely on fallbacks produces generic-sounding emails for your lowest-quality leads, which are exactly the leads that need the most compelling outreach.
The better approach is to segment in Clay before pushing to Instantly. Create a quality score column that counts how many personalization variables have usable values. Route leads with 4-5 populated variables to your high-personalization campaign. Route leads with 2-3 to a simpler template that doesn't rely on custom variables. Leads with fewer than 2 go back through enrichment or get deprioritized.
Campaign Triggering and Automation
Moving from manual campaign management to automated triggering is the difference between running outbound as a weekly batch process and running it as a continuous pipeline.
Event-Based Triggering from Clay
The most effective Clay + Instantly workflows trigger campaign enrollment based on enrichment events rather than manual review. When a lead meets your qualification criteria in Clay, it automatically flows into the appropriate Instantly campaign.
Here's what a production triggering workflow looks like:
Multi-Campaign Routing
Most teams outgrow a single Instantly campaign quickly. You'll want different campaigns for different personas, verticals, or stages of your funnel. Clay's conditional logic handles this routing by evaluating enrichment data and directing leads to the appropriate campaign.
A practical routing schema might look like this:
| Segment | Clay Criteria | Instantly Campaign | Template Style |
|---|---|---|---|
| High-fit VP+ | ICP score > 80, title contains VP/Director/C-level | Enterprise Decision Makers | Short, insight-led, meeting ask |
| High-fit IC | ICP score > 80, title contains Manager/Lead/Engineer | Practitioner Champions | Pain-focused, demo offer |
| Mid-fit | ICP score 50-80 | Exploratory Outreach | Lighter touch, content share |
| Trigger-based | Recent hiring/funding signal detected | Signal-Triggered | Event reference, timely hook |
Each campaign in Instantly gets its own sending schedule, follow-up sequence, and A/B test variants. The field mapping stays consistent across campaigns, but the templates leverage different subsets of your custom variables based on what's relevant for that segment.
Lead Management Across Clay and Instantly
Once leads are flowing from Clay into Instantly automatically, you need a system for managing their lifecycle across both tools. Without this, you end up with duplicate sends, prospects receiving conflicting campaigns, and no single source of truth for lead status.
Deduplication
The most common failure mode is sending the same prospect multiple campaigns simultaneously. This happens when leads enter Clay from different sources (different lists, different team members, CRM and non-CRM origins) and each gets pushed to Instantly independently.
Solve this at the Clay layer. Before any lead reaches the Instantly action step, run a deduplication check against:
- Your CRM: Is this contact already an active opportunity or recent customer?
- Other Clay tables: Is this lead already being enriched or sequenced through another workflow?
- Instantly's existing leads: Use the Instantly API to check if this email is already enrolled in an active campaign.
Status Syncing
Instantly tracks engagement status (opened, replied, bounced, unsubscribed) but that data lives in Instantly. For a complete picture, you need engagement data flowing back to Clay or your CRM.
The practical approach: use Instantly's webhook notifications to push engagement events back to Clay or directly to your CRM. When a lead replies, the webhook fires and updates the lead's status in your central system. This enables downstream workflows like:
- Positive reply triggers a task for your AE in the CRM
- Bounce triggers a re-enrichment attempt for a new email address
- Unsubscribe updates the lead's contact preferences across all systems
- No engagement after the full sequence triggers a nurture or alternate channel play
Suppression Lists
Maintain a master suppression list that both Clay and Instantly reference. This should include:
- Current customers
- Active opportunities in your pipeline
- Leads who have unsubscribed or replied negatively
- Competitor domains
- Leads already in an active sequence (across any sending tool, not just Instantly)
Clay can check against this list as part of its enrichment workflow. Instantly has its own global block list. Keep both in sync, and make the Clay check your primary gate since it happens before the lead ever reaches a sending tool.
Performance Tracking and Optimization
The Clay + Instantly stack gives you two distinct layers of analytics. Clay tells you about enrichment quality and lead qualification accuracy. Instantly tells you about campaign performance and engagement rates. Combining these is how you actually optimize.
Metrics That Matter
| Metric | Source | What It Tells You | Action Threshold |
|---|---|---|---|
| Enrichment completion rate | Clay | % of leads with all critical fields populated | Below 70%: review data providers |
| Qualification pass rate | Clay | % of enriched leads that meet ICP criteria | Below 30%: refine list sourcing |
| Bounce rate | Instantly | Email verification quality | Above 3%: add verification step in Clay |
| Open rate | Instantly | Subject line + deliverability | Below 40%: check warm-up and subject lines |
| Reply rate | Instantly | Message relevance and personalization quality | Below 3%: review personalization variables |
| Positive reply rate | Instantly | Offer-market fit for your target segment | Below 1%: revisit messaging or ICP |
Closing the Feedback Loop
The most underused optimization lever in a Clay + Instantly stack is feeding Instantly's engagement data back into Clay's enrichment logic. Here's how it works in practice:
Export or webhook Instantly's campaign results back into a Clay table. Now you have enrichment data and engagement outcomes in the same place. Use Clay's AI columns to analyze patterns:
- Which enrichment signals correlate with replies? Maybe leads with recent hiring signals reply 3x more than leads identified through technographic data alone.
- Which personalization variables drive the highest positive response rates? If your {{company_insight}} variable outperforms {{tech_stack_ref}}, double down on the research-based approach.
- Which ICP segments convert at higher rates? Your qualification model might be scoring mid-market SaaS too low relative to actual reply rates.
This analysis feeds back into three areas: refining your ICP scoring criteria, improving your AI column prompts for personalization, and adjusting your campaign routing logic. Teams that run this feedback loop monthly see compound improvements in reply rates over time.
A/B Testing Through the Stack
Instantly's built-in A/B testing handles subject lines and email body variants. But the more impactful tests often happen at the Clay layer:
- Enrichment depth: Does adding a third enrichment step (e.g., news monitoring) improve reply rates enough to justify the credit cost?
- Personalization approach: Test concept-centric personalization (referencing a business challenge) against proof-point personalization (referencing a specific company event). Route alternating leads to different Instantly campaigns with different templates.
- Qualification thresholds: What happens when you lower your ICP score threshold from 80 to 60? You get more volume but potentially lower reply rates. Run the experiment with a dedicated Instantly campaign for the extended segment.
Common Mistakes and How to Avoid Them
After seeing hundreds of Clay + Instantly implementations, these are the failure modes that show up repeatedly.
Over-Personalizing with Unreliable Data
Teams build five custom variables, map them all to AI-generated columns, and deploy templates that reference all five. The problem: AI columns have a 10-20% failure rate depending on available source data. When two of your five variables produce garbage or render blank, the email reads worse than a simple template would have.
Start with one or two high-reliability custom variables. Add more only after you've validated the enrichment quality across a statistically meaningful sample.
Ignoring Deliverability Fundamentals
Clay enrichment quality means nothing if your emails land in spam. Teams get excited about personalization and skip the basics: warming up sending accounts for 2-3 weeks, rotating across enough accounts to stay under daily sending limits, and monitoring domain reputation.
Instantly handles much of this automatically, but you still need to configure it properly. Don't push 500 leads into a new campaign on day one with freshly created sending accounts.
No Quality Gate Between Clay and Instantly
The easiest mistake to make: connecting Clay's HTTP action directly to Instantly without a quality filter. Every enriched row pushes to Instantly, including rows with unverified emails, missing personalization data, or contacts at companies outside your ICP.
Always add a filter step between enrichment completion and the Instantly push. At minimum, require: verified email, populated first name, and at least one custom personalization variable with a non-empty value.
If your Clay table has 1,000 enriched leads but only 800 pass your quality gate, that's a healthy ratio. You want a meaningful filter. If 990 pass, your gate isn't strict enough. If 500 pass, your enrichment workflow needs attention. Target an 80% pass rate as your benchmark.
Treating It as Set-and-Forget
The initial setup works well for a few weeks. Then enrichment providers change their APIs, Instantly updates their variable syntax, your ICP evolves, or your AI columns start producing stale-sounding insights. The Clay + Instantly stack requires ongoing maintenance, typically 2-4 hours per week for monitoring, prompt tuning, and workflow adjustments.
Scaling Beyond Two Tools
Clay + Instantly is a strong foundation for cold email. But cold email is one channel. As your outbound operation matures, the stack gets more complex. You add LinkedIn touchpoints. You route warm replies to a CRM. You want to trigger different sequences based on product usage signals or intent data. Suddenly your "two tool stack" is actually six or eight tools, and the data flowing between them looks less like a pipeline and more like a tangle.
The fundamental challenge isn't connecting more tools. It's maintaining consistent context across them. When a prospect replies to your Instantly campaign, that signal needs to update their status in your CRM, pause any LinkedIn outreach, inform your AE's pre-call research, and feed back into your Clay enrichment model. With direct tool-to-tool integrations, every new connection multiplies the integration surface. At 5 tools, you're managing 10 potential integrations. At 10 tools, it's 45.
What teams running outbound at scale actually need is a unified context layer: a system that maintains a single, continuously updated view of every account and contact across the entire GTM stack. Instead of building point-to-point webhooks between Clay, Instantly, your CRM, your LinkedIn tool, and your call platform, you feed everything into a central context graph that keeps all systems synchronized.
This is the problem that platforms like Octave are designed to solve. Octave sits between your tools and maintains the shared context that each one needs. When Instantly registers a reply, Octave propagates that signal everywhere it matters. When Clay enriches a lead, Octave ensures the new data is available to every downstream system, not just the one you wired up directly. For teams that have outgrown the two-tool stack and are spending more time maintaining integrations than running campaigns, it's the infrastructure layer that makes scaling practical.
FAQ
Yes, via CSV export and manual import. But this only makes sense for one-off campaigns or initial testing. For ongoing outbound operations, the API-based approach (Clay's HTTP action step) eliminates manual work and enables real-time lead flow. The API method also supports conditional logic, quality gates, and multi-campaign routing that CSV imports can't replicate.
Start with 2-3 custom variables beyond the standard fields. One for a research-based insight (company_insight or pain_point) and one for a contextual reference (tech_stack_ref or relevant_metric). Add more only after you've confirmed the enrichment quality supports them. Over-personalizing with unreliable data produces worse results than a simple, well-written template with minimal variables.
It depends on your workflow configuration. The recommended approach is to set up conditional logic in Clay that routes leads with incomplete enrichment to a "re-enrich" queue or a simpler Instantly campaign that doesn't rely on the missing data. Never push a lead with blank critical variables to a campaign that references those variables in the template.
Instantly has a global block list that applies across campaigns, and you can enable duplicate detection at the account level. But the more reliable approach is deduplication at the Clay layer before leads ever reach Instantly. Check each lead against your CRM, other active Clay tables, and Instantly's existing leads via the API. This catches duplicates before they enter your sending infrastructure.
For most teams, Clay's HTTP action step hitting Instantly's API directly is sufficient and the simplest option. Use a middleware webhook (via Zapier, Make, or n8n) only if you need complex routing logic, multi-tool fan-out, or CRM sync steps between Clay and Instantly. Every middleware layer adds latency and potential failure points.
Minimum 2 weeks, ideally 3-4 weeks for new sending domains. Instantly's automated warm-up handles the mechanics, but don't shortcut the timeline. Start pushing Clay leads to campaigns only after your sending accounts show consistent deliverability metrics. Rushing this step undermines everything your enrichment pipeline builds upstream.
Conclusion
Clay + Instantly is a proven combination for cold email because it cleanly separates the two hardest problems: knowing your prospect and reaching their inbox. Clay handles research and enrichment. Instantly handles delivery and engagement tracking. The integration between them determines whether those capabilities compound or collide.
The practical takeaways: use Clay's HTTP action for direct API-based lead pushing rather than CSV exports. Build a quality gate between enrichment and sending that prevents incomplete data from reaching live campaigns. Start with 2-3 custom personalization variables and expand only after validating enrichment reliability. Route leads to different campaigns based on qualification scores and persona segments. And close the feedback loop by analyzing which enrichment signals actually correlate with replies.
Most importantly, build the system with growth in mind. A Clay + Instantly workflow that works at 100 leads per week will break at 1,000. Quality controls, deduplication logic, and engagement feedback loops are investments that compound as your outbound operation scales. The teams that get the most from this stack are the ones that treat it as infrastructure, not a hack.