Skip to main content
abm.dev
← Notes from the data layer

B2B enrichment

b2b enrichment for Claude Code

Stuart McLeod5 min

A great rep once knew every account. Now your agents do.

Here is the setup that matters. One API call from inside a Claude Code session — company domain in, verified firmographics out, confidence score attached:

curl -X POST https://api.abm.dev/v1/enrich/company \
  -H "Authorization: Bearer $ABM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"domain": "stripe.com"}'

Cited sources. Eighty-nine canonical fields. No fabricated facts. No silent fallbacks.

That is the whole pitch. Everything below is the why and the how.

Why does enrichment break inside Claude Code?

Most GTM teams reach for the same stack: Apollo for contact data, Clearbit for firmographics, Hunter for email, ZoomInfo for the enterprise layer, Clay to stitch it together, and a spreadsheet to hold the seams. SyncGTM's 2026 waterfall coverage analysis puts it plainly: lead enrichment is still a five-tool juggling act. Export a CSV from LinkedIn Sales Navigator, paste it somewhere, wait, reconcile conflicts, repeat.

That workflow was designed for humans moving at human speed. Claude Code moves faster. When an autonomous agent hits a missing field, it does not pause and file a Jira ticket. It infers. It guesses. It acts on bad data at machine speed — and the mistake compounds before anyone notices.

Explorium's step-by-step guide for adding B2B enrichment to a Claude Code agent frames the core problem well: fragmented multi-vendor enrichment forces the agent to pre-configure endpoint mappings for every data type. Change one vendor, break the map. The agent has no way to know which source is authoritative when two providers disagree.

The result is data with no provenance. Your agent personalizes an outbound sequence for the wrong company size, the wrong tech stack, the wrong budget cycle. At scale, that is not an edge case. It is the default.

What does agent-ready enrichment actually look like?

The phrase gets used loosely. Here is what it means in practice.

Cited sources. Every field carries a reference to the provider that returned it — LinkedIn, Hunter, Perplexity, and others. The agent can inspect provenance before acting. If the confidence score on a phone number is low, the agent routes to email instead. No human required.

Confidence scores. Not a binary verified/unverified flag. A numeric score the agent can threshold. Set your own rules: skip accounts where headquarters confidence falls below a set floor, escalate to human review above a set ceiling.

Waterfall logic, resolved. One call hits ten providers behind the scenes — aggregated, deduped, reconciled. No per-source bills. No per-source rate limits to manage. The agent asks once and gets the best available answer.

Call it over MCP, don’t rebuild it. Anthropic’s Claude Code MCP documentation describes the Model Context Protocol as an open standard for connecting an agent to external tools and data — so Claude Code can call a verified enrichment API directly, without custom integration code. Agent-ready enrichment also means write-back safety: field-level merge rules, so lower-confidence data never overwrites a trusted CRM record.

How do you wire it into Claude Code?

Two paths. Pick the one that matches your setup.

Path one: direct API calls

The fastest start. Add your API key to Claude Code's environment, then prompt the agent to enrich before it writes any outbound copy.

# .env or Claude Code secrets
ABM_API_KEY=your_key_here

import httpx
import os

def enrich_company(domain: str) -> dict:
    resp = httpx.post(
        "https://api.abm.dev/v1/enrich/company",
        headers={"Authorization": f"Bearer {os.environ['ABM_API_KEY']}"},
        json={"domain": domain},
        timeout=15,
    )
    resp.raise_for_status()
    return resp.json()  # includes fields, confidence scores, source citations

# Claude Code calls this before drafting any personalized outreach
data = enrich_company("acme.com")
headcount = data["fields"]["employee_count"]["value"]
confidence = data["fields"]["employee_count"]["confidence"]

if confidence >= 0.75:
    print(f"Headcount: {headcount} — high confidence, use it")
else:
    print("Headcount uncertain — route to human review")

No dashboard. No browser tab. The agent enriches, checks confidence, and decides — all inside the terminal session.

Path two: MCP server

If you want Claude Code to discover enrichment capabilities dynamically — without pre-configured endpoint mappings — the MCP route is cleaner for autonomous loops. Explorium's data layer architecture guide makes the case directly: a purpose-built enrichment layer separates GTM agents that run from ones that work. Claude Code can orchestrate and call APIs, but it cannot maintain a B2B data universe on its own.

One JSON config block in your Claude Code settings.json:

{
  "mcpServers": {
    "abm": {
      "command": "npx",
      "args": ["-y", "@abm.dev/mcp"],
      "env": {
        "ABM_API_KEY": "your_key_here"
      }
    }
  }
}

The agent now has named tools it can call by name without knowing which providers sit behind them. Swap providers, update waterfall logic, change confidence thresholds: the agent's interface does not change.

What does the agent do with the data?

This is where the pattern pays off.

GTME Pulse's end-to-end Claude Code lead enrichment workflow documents the loop that replaces the Monday-morning CSV paste: trigger, waterfall, validate, write back. Built once, runs unattended. The spreadsheet-to-Clay pattern creates maintenance work and breaks repeatedly. The agent loop does not.

Applied to personalized outbound, the loop looks like this:

  1. Trigger — ICP account enters the pipeline (new funding round, hiring signal, tech stack change).
  2. Enrich — agent calls the enrichment API. Gets firmographics, tech stack, budget signals, decision-maker contacts — all with citations.
  3. Validate — agent checks confidence scores against your thresholds. Low confidence on the direct dial? Route to email. Low confidence on the mailing address? Skip direct mail for this account.
  4. Act — agent drafts personalized copy, selects the right channel, triggers the send. No human in the loop unless confidence falls below the floor.

Personalization, at scale.

What breaks without provenance?

The failure mode is worth naming plainly.

An agent acting on unverified data does not fail loudly. It sends the wrong message to the right person, or the right message to the wrong company size, or a direct mail piece to an address that moved. The damage is invisible until the pipeline numbers come in.

Provenance — knowing which source returned which field at what confidence — is not a nice-to-have for autonomous agents. It is the control layer. Without it, you are not running an AI-powered GTM motion. You are running a faster version of the broken five-tool stack.

The short version

Six enrichment tools stitched together with Zapier is a human workflow. Claude Code is not a human. It needs data that arrives with sources attached, confidence scores it can threshold, and a single endpoint it can call without knowing which providers sit behind it.

That is what abm.dev is built for. Eighty-nine canonical fields. Ten providers behind a single call. No per-source bills. No fabricated facts. No silent fallbacks.

Once upon a time, a great rep knew every account — the right detail, the right moment, the real blocker nobody else caught. The data is rich enough to do that again. At scale this time.

Try abm.dev — the account-based marketing API for AI agents. The playground is free. Launch credits with the code LAUNCHCODES.

Stuart McLeod · Co-founder, abm.dev