What a Real Cold Outbound Stack Costs in 2026 (Full Line-Item Breakdown)

Every "cost of cold outbound" article you'll find right now is written by a company selling one layer of the stack. A mailbox provider prices mailboxes. A warmup tool prices warmup. Clay's own pricing page tells you what Clay costs and stops there. Add those numbers up and none of the totals agree, because none of them count the line that's usually the biggest one: the labor.

We don't sell a tool. We run this exact stack (Clay, Smartlead, FullEnrich, waterfalls across three or four sources) for paying clients. So we're pricing the whole thing, layer by layer, including the part nobody bills separately. Most people budget the tools and get blindsided by the system.

The four cost layers nobody prices together

Every existing cold outbound cost breakdown treats the tool bill as the whole cost. It isn't. A working stack has four layers. And most articles price one of them carefully while waving at the rest.

Data and enrichment. Finding the right contact and getting a real email or phone number for them. Clay, Apollo, FullEnrich, and the waterfall logic that chains sources together when the first one comes back empty.

Sending infrastructure. The mailboxes, domains, and warmup that let a message actually land in an inbox. A sending tool like Smartlead or Instantly on top, a mailbox and domain provider underneath.

Deliverability and verification. The ongoing monitoring that keeps sending infrastructure from quietly degrading: inbox placement tests, spam checks, list hygiene, DMARC.

Orchestration and labor. The person, or the hours, who designs the waterfall, decides what the logic should do, and rebuilds it when a vendor changes an API. This is GTM engineering, and it's the layer every tool vendor's blog skips. None of them sell it.

Layer 1: data and enrichment

Data and enrichment is the layer everyone else treats as the entire cost of cold outbound, because it's the one with a pricing page and a plan name. It's also the layer where the free tier is a trap. Clay's Free plan gives you 500 actions and 100 data credits a month, capped at 200 rows per table. Enough to test the tool. Nowhere near enough to run a real list.

The tier that actually runs a working waterfall starts at $167 a month, Clay's Launch plan, as of July 2026 per Clay's pricing page, which buys 15,000 actions, 3,000 data credits, and tables up to 50,000 rows. And Growth, at $446 a month, adds the HTTP API step and CRM sync most agencies eventually need.

The number that actually matters isn't the plan price. It's what happens when Clay's primary source comes back empty. But a real waterfall doesn't stop there, it falls through to a second and third source. FullEnrich is a common second stop at $55 a month for 1,000 credits, as of July 2026 per FullEnrich's pricing page, priced per field: a work email costs one credit, a mobile number costs ten. Apollo and Cognism show up in the same role in a lot of stacks we've run, usually as a third or fourth fallback rather than a primary source. But we didn't independently re-verify either vendor's current pricing this pass, so we're not quoting numbers for them here. We've laid out how the tools we run this stack on actually compare, past just what each one costs, in a separate piece.

One cost lever hiding in that pairing: how you connect FullEnrich to Clay changes what a lookup costs. Run it through Clay's native integration and every hit spends Clay credits at Clay's rate. Buy a plan from FullEnrich directly instead, drop your own API key into the table, and lookups bill against FullEnrich's per-credit pricing while your Clay credits stay untouched. At small volume the difference is noise. Past a real lookup volume it stops being noise, and the direct plan becomes the cheaper wiring. That's how we wire it when FullEnrich earns a spot in a waterfall.

This is the layer every existing cost breakdown treats as the whole bill. Clay plus one enrichment fallback runs $167 to roughly $500 a month depending on volume. That's real money. But it's also, as you'll see below, often the smallest of the four layers once you count what it takes to run the thing.

Layer 2: sending infrastructure, mailboxes, domains, warmup

This is the layer most vendor blogs already cover well, because most vendor blogs in this space are written by companies that sell exactly this layer. We won't try to out-explain them. The mechanics of setup, domain structure, mailbox counts, and warmup cadence get their own full teaching here. So what we'll do is price it.

Two separate purchases live under this one layer, and treating them as a single line item is where a lot of budgets go wrong first. A sending tool, Smartlead or Instantly, handles sequencing, tracking, and connects to your mailboxes. And a mailbox and domain provider sells pre-warmed inboxes on fresh domains that don't touch your main company domain's reputation.

Neither Smartlead nor Instantly sells you the mailboxes themselves. Instantly's Growth plan bundles unlimited mailboxes and warmup, which can substitute for a separate infra provider at low volume. Smartlead's plans include unlimited connected mailboxes too. But you still need somewhere to buy the inboxes and domains. InboxKit is what we run for client inboxes: it provisions slots on real Google Workspace and Microsoft 365 tenants ($31 a month for 10 mailboxes on Professional, as of July 2026 per InboxKit's pricing page), which matters because mail from an ESP-native tenant sits inside Google's or Microsoft's own trust graph rather than third-party SMTP. The alternatives price differently: Maildoso sells pre-warmed mailboxes per seat ($75 buys 30 at the entry tier, with the rate dropping at higher tiers), and Inframail's $129 is flat no matter how many inboxes you connect. Which model is cheapest depends entirely on your mailbox count, so price all three at your real volume instead of assuming the entry tier holds as you scale.

So add a sending tool and a mailbox provider together and the entry price for real sending infrastructure sits somewhere between $70 (Smartlead Base plus InboxKit Professional) and $176 (Instantly Growth plus Inframail) a month, before you've sent a single email.

Layer 3: deliverability and verification

Deliverability is the layer competitors gloss over fastest, usually one line about warmup add-ons and then straight on to the next section. The bigger point is that this cost never stops. Warmup runs continuously, not once. Domain reputation degrades if nobody's watching it. And a waterfall that verified emails correctly in March can start bouncing in June because a provider changed its API without telling anyone.

EmailGuard's Free plan covers 3 email accounts and 50 verification credits, a testing tier, not a running one. Its Pro plan, $49 a month as of July 2026 per EmailGuard's pricing page, covers 25 domains, 100 email accounts, 3,000 verification credits, and 300 inbox placement tests, recurring for as long as you're sending. That recurrence is the part every "hidden costs" section in this space seems to miss. But it isn't a setup fee you pay once. It's a subscription you keep paying as long as the stack is live, and it climbs, not falls, as sending volume grows.

Layer 4: orchestration and labor, the cost no tool vendor will show you

Every tool-vendor breakdown stops here, at three layers, because none of them sell the fourth. Somebody has to design the waterfall logic (which source goes first, what triggers the fallback, what counts as a bad match), build it, and rebuild it every time a vendor changes an API or a plan tier. That's labor. It's usually the largest line in the budget, not the smallest.

The going rate for that labor, per The 2026 State of GTM Engineering (a self-selected survey of GTM engineers whose authors call it "meaningful but not statistically representative"): a US in-house GTM engineer's median base salary lands around $135,000, versus closer to $75,000 for non-US peers. Whether that person can code matters too. Low-code operators sit around $90,000 median; code-capable operators run closer to $135,000, roughly a $40K to $45K premium for the skill that builds a real HTTP API step instead of clicking through a template.

A separate analysis of job postings, run by Bloomberry (Henley Wing Chiu), puts the median advertised salary for the role at $127,500, landing in the same range from a different angle. And Clay specifically shows up everywhere in this labor market: 84% of GTM engineers in the OneGTM survey report using it, climbing to 96% among agencies. Pay for the labor layer and you're very likely paying for someone who already knows this tool.

Three real stack configurations at different scales

Put all four layers together and the honest answer to "what does a cold outbound stack cost" depends entirely on who's running it. Three configurations, three very different totals.

The solo column is the one every "cheap cold outbound stack" article quotes, and it's real. $286 a month gets you a working system if you're also the one running it. What that column hides is the time. Someone still has to design the waterfall, watch deliverability, and rebuild the sequence when a reply pattern changes. At solo scale that's you, and your time isn't in the total because you're not paying yourself a salary for it. It's still a cost.

The in-house column is where the labor line stops being invisible. A $135,000 salary dwarfs the roughly $1,050-a-month tool spend it sits next to, by more than ten times over. But compare "the cost of the stack" between the solo and in-house rows while only counting tools, and you're comparing two completely different budgets that happen to share a Clay subscription.

The agency column looks the strangest until you separate what's inside it.

So that's next.

What agencies actually charge, and what the retainer buys

The only disclosed, methodology-stated number we found for agency retainers is OneGTM's: monthly agency retainers range from as little as $1K to as high as $33K per month, from the same State of GTM Engineering survey. That range is wide enough to be nearly useless on its own. And we're not going to pretend otherwise. It's also, as far as we found, the only number in this category with any real sourcing behind it.

There's a smaller survey out there too, GTME Pulse's, run on a set of agency operators rather than individual GTM engineers. We're not blending its figures with OneGTM's here. Different sample, different question, and we didn't independently re-verify its numbers against a primary source this pass. But that kind of quiet blending is exactly what makes a lot of published stats in this category untrustworthy in the first place.

Here's what we'll say plainly, since it's our own margin we're describing: a retainer isn't hard tool cost with a percentage stapled on. It's paying someone to own the waterfall so it doesn't break silently, watch deliverability so a domain doesn't quietly die, and rebuild the logic when a vendor changes an API, on a schedule you don't have to track. That's the same Layer 4 labor cost from the in-house row above, just packaged as a service instead of a headcount line. Whether that's worth it depends on whether you'd rather hire the $135,000 role yourself or rent a fraction of one across several accounts. Neither answer is wrong. But we know which one we sell, and we're not going to hide that this section describes our own business. We're also building our own dataset on agency pricing across the category, but it isn't finished, so we're not citing it yet.

Build vs. buy: when each number makes sense

None of the three columns above is "right" in the abstract. Each fits a specific point.

Solo DIY makes sense while you're validating whether outbound works for your ICP at all, and $286 a month is cheap tuition for that answer. It stops making sense the moment you already know outbound works and you're the bottleneck on running it.

So in-house makes sense once volume and specificity justify a full salary: your waterfall logic is actually differentiated, needs constant tuning, and you'd rather own that skill than rent it. It's also an expensive bet on one person staying, worth naming out loud before you make it.

Agency makes sense when you want the Layer 4 skill without the headcount risk, or you're running outbound across more than one brand and the composability pays for itself across accounts.

We go deeper on this exact decision, with the tradeoffs at each stage, in our build-vs-buy breakdown. This piece is about what each path costs. That one is about which path fits.

The stack above is already changing: the agentic version

Everything priced so far assumes one shape: a credit-billing platform at the center, a person clicking through it. That shape is shifting. Ours included. More and more of our research and enrichment runs in Claude Code directly now, not as an assistant bolted onto a Clay table but as the layer doing the work: reading the ICP definition, researching an account, calling enrichment sources, drafting the personalization, handing a finished row to the sequencer.

Two things happen to the bill when the stack goes agentic.

Credits turn into usage. A platform credit is, mechanically, a markup on an API call. When an agent calls a source directly, you pay the source's own rate plus compute instead of the platform's credit price. Our waterfalls now include BlitzAPI exactly this way, an HTTP API the agent hits next to Clay rather than a block inside it. The subscription lines shrink. A usage line appears in their place. For the agent itself, Claude's Max plan includes Claude Code and starts at $100 a month as of July 2026 per Anthropic's pricing page; heavier setups run on API rates and bill by what they actually consume.

The labor line changes shape before it changes size. Someone still designs the waterfall, still decides what counts as a bad match, still owns deliverability. What disappears is the clicking. That pushes the role further toward the code-capable end of the Layer 4 salary split, not away from it. But the judgment stays human. So does the salary.

Be careful with the obvious conclusion, though. An agentic stack is not automatically cheaper. Usage billing is spikier than a flat subscription, harder to budget, and it assumes an operator who can actually run agents. What it buys first is speed: forking a waterfall stops being an afternoon in a UI and becomes a prompt. The cost win comes later, with volume, when the per-credit markups you no longer pay start compounding.

You can watch this shift happening in our tools directory. Flip on the Agent-ready filter and the 66 tools split into two groups: the ones an agent can drive headlessly through an API, CLI, or MCP server, and the ones that only work with a human sitting in the UI. Which side of that line a tool sits on is quietly becoming the most important fact on its pricing page.

A real line-item budget template (copy this)

Here's the template we actually use internally, stripped of client specifics. Copy it into a spreadsheet and fill in your own numbers.

Two things worth doing before you trust this. First, swap in your actual send volume. The tiers above are entry-level, and a list of any real size pushes you into the next tier up on at least two rows. Second, be honest about the labor row even when the number is $0. If it's your own unpaid time, write down the hours anyway. A stack that costs $330 a month and eats, say, fifteen hours of your own week isn't actually a $330 stack.

But these prices move. We pulled every number on this page directly from the vendor's own pricing page in July 2026. Check current rates before you build a budget around them, because cold email tools reprice more often than most software categories.