Skip to content
B2BenrichA ContactLevel company

Personalize AI outbound with enrichment data

Which enriched fields make AI-written outreach relevant, how to pass them to your model, and how to keep the messages from sounding generated.

Dag Holmen · Updated · 5 min read

View as Markdown

AI cold email personalization works when the model has real facts about the person. Give a model a name and a company and it fills the gaps with guesses: vague praise, an initiative nobody announced, a stat about their industry that may not be true. Give it a short, structured record of who the person is and what their company looks like, and it can write the one relevant line a good rep would have written.

Enrichment gives you that record. This guide covers which fields are worth passing, how to build a context object for each contact, a prompt that keeps the model to the facts, and how to test before you send at volume.

Fields that make a message relevant

FieldWhere it comes fromWhat the model can do with it
job_titlePerson recordSpeak to what the person owns
company_sizePerson recordFrame the problem for a 50-person team or a 5,000-person one
industryPerson recordPick examples and words from their world
Tech stackThe technologies filter you searched withName a tool they use and how you fit with it
Intent topicIntent data (coming to B2Benrich)Lead with the problem they're looking into now

Leave the rest out. Photos, home cities and anything personal don't make a business email better. They make it feel like surveillance.

The tech stack comes with the list. If you pull contacts with company_filters: { technologies: 'HubSpot' }, every record's company matched that filter, so you can pass uses: ['HubSpot'] without another call. The technographic data guide covers building lists by tool.

Intent tells the model what to lead with. B2Benrich is adding intent data: which companies are researching which topics right now. That topic is the best hint you can give a model about which problem to open with. Use it to pick the angle, never as a line in the email. Signal-based outbound shows how to trigger sends on it.

Build a context object per contact

Pull the contacts with the prospector, then turn each record into a small JSON object. If you start from LinkedIn URLs instead, the people enrichment API returns the same kind of person record.

const BASE = 'https://api.b2benrich.com';
const headers = { 'Content-Type': 'application/json', 'X-Api-Key': process.env.B2BENRICH_KEY };

const query = {
  contact_filters: { job_level: 'VP', job_function: 'Marketing' },
  company_filters: { technologies: 'HubSpot', employee_count_range: '201-500' },
  page: 1,
  page_size: 25
};

const res = await fetch(`${BASE}/v1/search/prospector`, { method: 'POST', headers, body: JSON.stringify(query) });
const { records } = await res.json();

function buildContext(p) {
  const context = {
    first_name: p.first_name,
    job_title: p.job_title,
    company_name: p.company_name,
    industry: p.industry,
    company_size: p.company_size && `${p.company_size} employees`,
    uses: [query.company_filters.technologies],
    intent_topic: null // TODO: fill from the B2Benrich intent endpoint once it's live
  };
  // Drop empty fields so the model can't write around a blank
  return Object.fromEntries(Object.entries(context).filter(([, v]) => v != null && v !== ''));
}

For Maya Chen at Acme, that gives:

{
  "first_name": "Maya",
  "job_title": "VP Marketing",
  "company_name": "Acme",
  "industry": "Software Development",
  "company_size": "201-500 employees",
  "uses": ["HubSpot"]
}

Keep facts about you apart: what you sell, one proof point and the ask go in their own block, written by a person and the same for every contact. Enrichment cost doesn't grow with the context you pull: B2Benrich is one plan, unlimited API usage for $500 a month. The model calls are the part that scales with volume.

A prompt that sticks to the facts

function buildPrompt(context, offer) {
  return `You write the first two sentences of a cold email from a B2B company.

Facts about the recipient (JSON). These are the only facts you may use about them:
${JSON.stringify(context, null, 2)}

What we sell and why it matters (written by us, all true):
${offer}

Rules:
- Use at most one recipient fact, and only if it connects to what we sell.
- Never state anything about the recipient or their company that is not in the JSON.
- Never say how we know a fact. No "I saw", "I noticed", tracking, visits or research.
- No compliments, no "hope you're well", no exclamation marks.
- Under 50 words. Plain and specific, like one person writing to another.
- If no fact connects to the offer, write a plain opener and set personalized to false.

Reply with JSON only: {"opener": "...", "fact_used": "...", "personalized": true}`;
}

Asking for fact_used gives your code something to check.

Guardrails

  • No invented facts. Check that fact_used matches a value in the context. Flag any opener with a number that isn't in the context, since numbers are easy for a model to make up.
  • No tracking talk. Intent and enrichment decide who you write to and what you lead with. "I noticed your team is researching X" feels like being watched. Block those phrases in code.
  • Short. Long openers read as generated. Cap the length and reject anything over it.
  • A human reads before it sends. Review every message in the first batches, then a sample of each batch. Log why you reject each one, and fix the prompt, not the email.

A first-pass check before anything reaches review:

function check(out, context) {
  const values = Object.values(context).flat().map(String);
  const numbers = out.opener.match(/\d[\d,.%]*/g) || [];
  if (out.fact_used && !values.some(v => out.fact_used.includes(v))) return 'fact not in context';
  if (numbers.some(n => !values.some(v => v.includes(n)))) return 'number not in context';
  if (/\b(i saw|i noticed|researching|visited|tracking)\b/i.test(out.opener)) return 'mentions tracking';
  if (out.opener.split(/\s+/).length > 50) return 'too long';
  return 'ok';
}

Test before you scale

  1. Start small. Generate openers for 30 to 50 contacts across two or three personas, and read every one.
  2. Fix by persona. If openers for one persona are weak, change the offer block or the rules for that persona, not individual emails.
  3. Run a control. Send half the test group the same email with a plain opener. Compare replies, not opens.
  4. Scale in steps. Raise volume only while the reject rate in review stays low, and keep sampling after that.
  5. Check addresses. A personal opener doesn't help a message that never arrives. Verify emails shortly before the send with an email verification API.

Any script, AI agent or workflow tool that can make an HTTP request can run this loop. If your lists live in Clay, the Clay HTTP API guide shows how to pull these fields into a table and pass them to an AI step.

Frequently asked questions

What data should I give an AI model to personalize cold emails?
A short, structured record per contact: job title, company name, industry, company size and the tools the company uses, plus the topic they’re researching when you have intent data. Leave out personal details. Keep facts about your own offer in a separate block written by a person.
How do I stop AI-written emails from making things up?
Tell the model it may only use facts from the context you pass, ask it to return the fact it used, and check that fact against the context in code. Flag any number that isn’t in the context, and have a person review a sample of every batch.
Should a cold email mention that the company is researching a topic?
No. Use intent data to choose who to write to and which problem to lead with. Saying you know what someone is researching, or that they visited your site, makes the email feel like surveillance and rarely helps.
Can I personalize cold email at scale without it sounding generated?
Yes, if you keep it to one relevant fact and a short opener. Generated emails give themselves away with flattery, long intros and claims that don’t quite fit. Tight rules in the prompt, automatic checks and human review keep the output plain.
Do I need an AI SDR tool to do this?
No. A script or agent that calls an enrichment API and a language model can run the whole loop. AI SDR tools package the same steps. Whichever you use, the quality of the context object decides the quality of the message.

Get your API key.

Sign up, make your first call and start building your lists.

We’ll email you a link to log in. · Read the docs