How to Build an Automated Email Campaign Generator With Claude Code

March 20, 2026

Most email marketing tools give you templates. Claude Code gives you a system — one that thinks, personalizes, and adapts to your audience the way a seasoned copywriter would, but at a scale no human team could match. If you've ever stared at a blank email editor wondering how to segment your list, write five variations of a subject line, and schedule everything around a product launch — all at once — this guide is for you.

What follows is a complete, hands-on walkthrough for building an automated email campaign generator using Claude Code. By the end, you'll have a working system that ingests audience data, generates personalized email copy, organizes campaigns by segment, and outputs ready-to-deploy content — all driven by AI. No prior machine learning experience required. Just a willingness to follow the steps, understand what you're building, and think like a systems designer rather than a template picker.

Limited Event

Master Claude Code in One Day — Live Workshop by Adventure Media

Go from zero coding experience to building real AI-powered tools. Hands-on projects, expert guidance, no fluff.

Register Now — Spots Filling Fast →

What you'll need before starting: Basic familiarity with the command line, a text editor (VS Code recommended), Node.js installed on your machine, a Claude API key from Anthropic, and a CSV or JSON file of audience data you want to work with. Estimated total build time: 3–5 hours for a fully functional v1.

Step 1: Understanding What You're Actually Building (and Why It Matters)

Before writing a single line of code, you need a clear architectural picture of the system. Skipping this step is the single most common reason developers end up with a brittle, confusing codebase two hours in. Take 20–30 minutes here — it will save you hours later.

The system you're building has four core components working in sequence:

Data Ingestion Layer — reads your audience data (CSV, JSON, or database query results) and structures it into a format the AI can reason about.
Segmentation Engine — applies rules or AI-generated logic to group contacts by relevant attributes (purchase history, engagement score, industry, geographic region, etc.).
Copy Generation Module — sends structured prompts to Claude's API and receives personalized email copy tailored to each segment.
Output Formatter — organizes generated emails into a folder structure or exports them as a JSON payload your email platform (Mailchimp, ActiveCampaign, Klaviyo, etc.) can consume.

Understanding this architecture matters because Claude Code isn't just a chatbot you're querying — it's functioning as the reasoning core of a multi-step pipeline. Each component passes structured data to the next. If your data ingestion layer produces messy output, your segmentation engine will produce bad segments, and your copy will reflect that garbage-in, garbage-out reality.

Key Architectural Decision: Stateless vs. Stateful Generation

For most email campaign generators, a stateless approach works best at the start — meaning each email is generated fresh from a prompt, with no memory of previous calls. This keeps your system simple and debuggable. As you scale, you can introduce conversation history to maintain tone consistency across a campaign series, but don't start there.

Common Mistake to Avoid at This Stage

Don't try to build all four components simultaneously. Build and test each one individually. A working data ingestion layer with a broken segmentation engine is far easier to fix than a tangled mess where you don't know which part is failing.

Pro Tip: Sketch your architecture on paper or in a simple diagram tool before touching your editor. Write down the input and output of each component. This becomes your contract — what you're building toward — and it makes debugging infinitely easier.

Step 2: Setting Up Your Development Environment

A clean development environment prevents half the issues developers encounter when working with API-based AI tools. This step covers setup from scratch — even if you've built with Claude before, walk through this checklist to make sure nothing is missing.

Estimated time: 20–30 minutes

Initialize Your Project

Open your terminal and create a new project directory:

mkdir claude-email-generator
cd claude-email-generator
npm init -y

Install the required dependencies. You'll need the Anthropic SDK, a CSV parsing library, and dotenv for managing your API key securely:

npm install @anthropic-ai/sdk csv-parse dotenv fs-extra

Create a .env file in your project root and add your Claude API key:

ANTHROPIC_API_KEY=your_api_key_here

Immediately add .env to your .gitignore file. This is non-negotiable. Committing API keys to version control — even in a private repo — is a security risk you don't want to learn about the hard way.

Create Your Project Structure

Set up the following folder structure before writing any logic:

claude-email-generator/
├── .env
├── .gitignore
├── package.json
├── src/
│   ├── ingest.js
│   ├── segment.js
│   ├── generate.js
│   └── format.js
├── data/
│   └── audience.csv
├── output/
│   └── (generated emails land here)
└── prompts/
    └── (your prompt templates)

This folder structure maps directly to the four components you identified in Step 1. Every file has one job. This modularity is what makes the system maintainable and testable.

Test Your Claude API Connection

Before building anything, verify your API key works. Create a quick test file:

// test-connection.js
require('dotenv').config();
const Anthropic = require('@anthropic-ai/sdk');

const client = new Anthropic();

async function testConnection() {
  const message = await client.messages.create({
    model: "claude-opus-4-5",
    max_tokens: 100,
    messages: [{ role: "user", content: "Say hello in one sentence." }]
  });
  console.log(message.content[0].text);
}

testConnection();

Run node test-connection.js. If you see a greeting, your environment is configured correctly. If you see an authentication error, double-check your API key in the .env file.

Warning: Always reference the official Anthropic API documentation for the most current model names and API parameters. Model names update frequently, and using a deprecated model name will cause silent failures.

Step 3: Building the Data Ingestion Layer

Your data ingestion layer is the foundation everything else rests on. Its job is simple: take raw audience data in whatever format it exists, and transform it into clean, structured JavaScript objects your system can work with.

Estimated time: 30–45 minutes

Preparing Your Audience Data File

For this walkthrough, we'll use a CSV format since it's the most common export format from CRMs and email platforms. Your audience.csv file should have columns like these (adjust to match your actual data):

email,first_name,last_name,industry,purchase_count,last_purchase_date,engagement_score,location_state

The specific columns matter less than making sure they're consistent, non-null where critical, and named clearly. If your real data has columns like engmnt_scr or lst_purch, rename them now. You'll thank yourself when reading prompts at 11pm trying to figure out why a segment isn't working.

Writing the Ingestion Module

Open src/ingest.js and write the following:

// src/ingest.js
require('dotenv').config();
const { parse } = require('csv-parse/sync');
const fs = require('fs');
const path = require('path');

function loadAudienceData(filePath) {
  const absolutePath = path.resolve(filePath);
  
  if (!fs.existsSync(absolutePath)) {
    throw new Error(`Data file not found: ${absolutePath}`);
  }

  const fileContent = fs.readFileSync(absolutePath, 'utf-8');
  
  const records = parse(fileContent, {
    columns: true,
    skip_empty_lines: true,
    trim: true,
    cast: true  // Auto-converts numbers and booleans
  });

  // Basic validation
  const requiredFields = ['email', 'first_name'];
  for (const record of records) {
    for (const field of requiredFields) {
      if (!record[field]) {
        console.warn(`Warning: Record missing required field '${field}':`, record);
      }
    }
  }

  console.log(`Loaded ${records.length} audience records.`);
  return records;
}

module.exports = { loadAudienceData };

Test this immediately: create a small 5-row CSV file with sample data and run a quick script that calls loadAudienceData('./data/audience.csv') and logs the result. You should see an array of objects, each representing one contact.

Handling Real-World Data Messiness

Real audience data is never clean. Plan for these common issues:

Duplicate emails: Add a deduplication step using new Set() on the email field
Missing engagement scores: Set a default value (e.g., 0) rather than letting nulls propagate
Inconsistent date formats: Parse all dates through a normalizer before they enter your pipeline
Special characters in names: These can break JSON serialization — strip or escape them early

Pro Tip: Add a sanitizeRecord() function that applies all your data cleaning rules in one place. This makes it easy to add new rules later without hunting through your codebase.

Step 4: Building the Segmentation Engine

Segmentation is where your campaign generator starts to earn its value. The difference between a mass blast and a personalized campaign lives entirely in how well you segment your audience before generating copy.

Estimated time: 45–60 minutes

Defining Your Segmentation Strategy

Before writing code, decide on your segments. For a standard e-commerce or B2B email campaign, common segments include:

High-Value Actives: High purchase count + high engagement score + recent purchase
Lapsed Customers: Previous purchases + no activity in 90+ days
New Subscribers: No purchases + account created in last 30 days
Engaged Non-Buyers: High engagement score + zero purchases
Industry-Specific: Grouped by industry vertical for B2B campaigns

These segments directly inform the tone, urgency, offer type, and CTA your generated emails will use. A "Lapsed Customer" email should feel different from a "New Subscriber" welcome — and Claude will write them differently if you tell it which segment it's writing for.

Writing the Segmentation Module

Open src/segment.js:

// src/segment.js

function segmentAudience(records) {
  const segments = {
    high_value_active: [],
    lapsed_customer: [],
    new_subscriber: [],
    engaged_non_buyer: [],
    general: []
  };

  const now = new Date();
  const ninetyDaysAgo = new Date(now - 90 * 24 * 60 * 60 * 1000);
  const thirtyDaysAgo = new Date(now - 30 * 24 * 60 * 60 * 1000);

  for (const record of records) {
    const lastPurchase = record.last_purchase_date 
      ? new Date(record.last_purchase_date) 
      : null;
    const accountCreated = record.created_at 
      ? new Date(record.created_at) 
      : null;

    const isHighEngagement = (record.engagement_score || 0) >= 70;
    const isHighPurchaseCount = (record.purchase_count || 0) >= 3;
    const isRecentPurchase = lastPurchase && lastPurchase > ninetyDaysAgo;
    const isLapsed = lastPurchase && lastPurchase <= ninetyDaysAgo;
    const isNewSubscriber = accountCreated && accountCreated > thirtyDaysAgo;
    const isNonBuyer = (record.purchase_count || 0) === 0;

    if (isHighEngagement && isHighPurchaseCount && isRecentPurchase) {
      segments.high_value_active.push(record);
    } else if (isLapsed && isHighPurchaseCount) {
      segments.lapsed_customer.push(record);
    } else if (isNewSubscriber && isNonBuyer) {
      segments.new_subscriber.push(record);
    } else if (isHighEngagement && isNonBuyer) {
      segments.engaged_non_buyer.push(record);
    } else {
      segments.general.push(record);
    }
  }

  // Log segment counts
  for (const [name, members] of Object.entries(segments)) {
    console.log(`Segment '${name}': ${members.length} contacts`);
  }

  return segments;
}

module.exports = { segmentAudience };

Common Mistake: Contacts that fall into multiple segments. Your logic needs a clear priority order — the if/else if chain above handles this implicitly (high-value actives are checked first), but make sure your priority order matches your business logic, not just what you coded first.

Using Claude to Assist With Segmentation Logic

Here's an advanced option worth knowing: you can ask Claude itself to suggest segmentation rules based on a sample of your data. Send a few sample records and your campaign goals to Claude via the API, and ask it to recommend segment definitions. This is especially powerful when you're working with unfamiliar audience data or entering a new vertical. The AI can surface patterns a human might miss.

Step 5: Engineering Your Email Generation Prompts

This is the creative and technical heart of the system. The quality of your generated emails is almost entirely determined by the quality of your prompts. Bad prompts produce generic copy. Well-engineered prompts produce emails that feel like they were written by someone who actually knows the recipient.

Estimated time: 60–90 minutes — this step deserves the most attention

The Anatomy of an Effective Email Generation Prompt

A high-quality email generation prompt has six components:

Role definition: Tell Claude what kind of copywriter it's being asked to be
Audience context: Describe the specific segment being written for
Contact personalization data: Inject the individual's actual data
Campaign goal: What should the reader do after reading this email?
Tone and voice guidelines: Brand voice, formality level, emotional tone
Output format specification: Exactly what fields you want back, in what structure

Create a prompts directory and write a template for each segment. Here's an example for the lapsed customer segment:

// prompts/lapsed_customer.js

function getLapsedCustomerPrompt(contact, brandName, productCategory) {
  return `You are an expert email copywriter specializing in customer win-back campaigns.

AUDIENCE CONTEXT:
This email is going to a lapsed customer — someone who previously made ${contact.purchase_count} purchases but hasn't engaged in over 90 days. They were once a real fan of the brand. Your job is to re-ignite that relationship, not just push a sale.

CONTACT INFORMATION:
- First name: ${contact.first_name}
- Industry: ${contact.industry || 'Not specified'}
- Last purchase date: ${contact.last_purchase_date}
- Engagement score: ${contact.engagement_score}/100

CAMPAIGN DETAILS:
- Brand: ${brandName}
- Product category: ${productCategory}
- Goal: Drive a re-engagement click (return to site or reply to email)
- Do NOT include a discount unless it feels genuinely earned in the copy

TONE: Warm, slightly surprised to see them gone, genuinely curious — not desperate or pushy. This brand values the relationship, not just the transaction.

OUTPUT FORMAT (respond in valid JSON only):
{
  "subject_line": "string (40-60 characters, no clickbait)",
  "preview_text": "string (80-100 characters)",
  "body_html": "string (full HTML email body, 150-250 words)",
  "cta_text": "string (3-6 words)",
  "personalization_note": "string (brief note explaining personalization choices made)"
}`;
}

module.exports = { getLapsedCustomerPrompt };

Write similar prompt templates for each of your segments. The key variables to inject from each contact record are: name, relevant behavioral data (purchase count, engagement score), and any contextual data that signals what this person cares about.

Why Asking for JSON Output Matters

Requesting structured JSON output from Claude is critical for automation. When Claude returns valid JSON, your system can immediately parse it, extract each field, and route it to the right place — without any manual cleanup. Always validate the JSON response before passing it downstream, because occasionally Claude will include a markdown code fence or extra explanation text that needs to be stripped.

Add a simple JSON extractor utility:

function extractJSON(text) {
  const jsonMatch = text.match(/\{[\s\S]*\}/);
  if (!jsonMatch) throw new Error('No valid JSON found in response');
  return JSON.parse(jsonMatch[0]);
}

Testing Your Prompts Before Scaling

Before running your generator against 10,000 contacts, test each prompt with 5–10 sample contacts manually. Read every email. Ask yourself: does this feel personalized? Does it match the segment strategy? Is the tone right? Would I click this CTA?

This review step catches prompt engineering issues before they multiply across your entire audience.

Step 6: Writing the Core Generation Module

With prompts engineered and tested, it's time to build the module that actually calls Claude's API and generates emails at scale. This module also handles rate limiting, error recovery, and progress logging — the operational concerns that separate a toy script from a production tool.

Estimated time: 45–60 minutes

// src/generate.js
require('dotenv').config();
const Anthropic = require('@anthropic-ai/sdk');
const { getLapsedCustomerPrompt } = require('../prompts/lapsed_customer');
// Import other prompt templates...

const client = new Anthropic();

// Rate limiting: Claude API has request limits
const DELAY_BETWEEN_REQUESTS = 1000; // 1 second between calls
const MAX_RETRIES = 3;

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function generateEmailForContact(contact, segment, brandConfig) {
  let prompt;
  
  switch(segment) {
    case 'lapsed_customer':
      prompt = getLapsedCustomerPrompt(contact, brandConfig.name, brandConfig.productCategory);
      break;
    // Add other segment cases...
    default:
      throw new Error(`Unknown segment: ${segment}`);
  }

  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
    try {
      const response = await client.messages.create({
        model: "claude-opus-4-5",
        max_tokens: 1500,
        messages: [{ role: "user", content: prompt }]
      });
      
      const rawText = response.content[0].text;
      const emailData = extractJSON(rawText);
      
      return {
        contact_email: contact.email,
        segment: segment,
        ...emailData
      };
      
    } catch (error) {
      if (attempt === MAX_RETRIES) {
        console.error(`Failed to generate email for ${contact.email} after ${MAX_RETRIES} attempts`);
        return null;
      }
      await sleep(attempt * 2000); // Exponential backoff
    }
  }
}

async function generateCampaign(segments, brandConfig) {
  const results = {};
  
  for (const [segmentName, contacts] of Object.entries(segments)) {
    console.log(`\nGenerating emails for segment: ${segmentName} (${contacts.length} contacts)`);
    results[segmentName] = [];
    
    for (let i = 0; i < contacts.length; i++) {
      const contact = contacts[i];
      console.log(`  [${i + 1}/${contacts.length}] ${contact.email}`);
      
      const email = await generateEmailForContact(contact, segmentName, brandConfig);
      if (email) results[segmentName].push(email);
      
      // Rate limiting delay
      if (i < contacts.length - 1) {
        await sleep(DELAY_BETWEEN_REQUESTS);
      }
    }
    
    console.log(`  ✓ Generated ${results[segmentName].length} emails for ${segmentName}`);
  }
  
  return results;
}

function extractJSON(text) {
  const jsonMatch = text.match(/\{[\s\S]*\}/);
  if (!jsonMatch) throw new Error('No valid JSON found in response');
  return JSON.parse(jsonMatch[0]);
}

module.exports = { generateCampaign };

Understanding Rate Limits and Cost Management

Each API call to Claude costs tokens — both the prompt tokens you send and the completion tokens you receive back. For a campaign generating emails for 1,000 contacts, you're making 1,000 API calls. Before running at scale, use Anthropic's token counting to estimate your costs. A well-engineered prompt with a 200-word output typically runs around 500–800 tokens total per call — but measure your actual prompts, not estimates.

For large campaigns, consider batching by segment and running overnight, or implementing a progress checkpoint system that saves results to disk after every 100 emails so a failure doesn't lose your work.

Step 7: Building the Output Formatter and Export Layer

Your generated emails are only useful if they get into the hands of your email platform. The output formatter takes the raw generation results and transforms them into whatever format your platform needs — whether that's a structured JSON file, a CSV for bulk import, or a direct API call to Mailchimp or Klaviyo.

Estimated time: 30–45 minutes

// src/format.js
const fs = require('fs-extra');
const path = require('path');

async function saveResults(campaignResults, outputDir = './output') {
  await fs.ensureDir(outputDir);
  
  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
  const campaignDir = path.join(outputDir, `campaign-${timestamp}`);
  await fs.ensureDir(campaignDir);

  // Save full JSON
  const jsonPath = path.join(campaignDir, 'full-campaign.json');
  await fs.writeJSON(jsonPath, campaignResults, { spaces: 2 });
  
  // Save per-segment CSV files for easy platform import
  for (const [segmentName, emails] of Object.entries(campaignResults)) {
    if (emails.length === 0) continue;
    
    const csvRows = ['email,subject_line,preview_text,cta_text'];
    for (const email of emails) {
      const row = [
        email.contact_email,
        `"${(email.subject_line || '').replace(/"/g, '""')}"`,
        `"${(email.preview_text || '').replace(/"/g, '""')}"`,
        `"${(email.cta_text || '').replace(/"/g, '""')}"`
      ].join(',');
      csvRows.push(row);
    }
    
    const csvPath = path.join(campaignDir, `${segmentName}.csv`);
    await fs.writeFile(csvPath, csvRows.join('\n'));
  }

  // Save HTML bodies as individual files for visual review
  const htmlDir = path.join(campaignDir, 'html-previews');
  await fs.ensureDir(htmlDir);
  
  for (const [segmentName, emails] of Object.entries(campaignResults)) {
    for (const email of emails) {
      if (email.body_html) {
        const filename = `${segmentName}-${email.contact_email.replace('@', '_at_')}.html`;
        await fs.writeFile(path.join(htmlDir, filename), email.body_html);
      }
    }
  }

  console.log(`\n✅ Campaign saved to: ${campaignDir}`);
  return campaignDir;
}

module.exports = { saveResults };

Integrating With Email Platforms

If you want to push emails directly into Mailchimp, Klaviyo, or ActiveCampaign via their APIs, the output formatter is where that integration lives. Rather than exporting files, you'd replace the file-writing logic with API calls to create campaigns, add tags, or schedule sends. The generated JSON structure maps cleanly to most platform APIs — the field names just need to be remapped to match the platform's expected schema.

Step 8: Wiring It All Together With a Main Runner

Now bring all four components together into a single orchestrator script. This is your campaign generator's entry point — the script you'll actually run when you want to generate a campaign.

Estimated time: 20–30 minutes

// run-campaign.js
require('dotenv').config();
const { loadAudienceData } = require('./src/ingest');
const { segmentAudience } = require('./src/segment');
const { generateCampaign } = require('./src/generate');
const { saveResults } = require('./src/format');

const BRAND_CONFIG = {
  name: "Your Brand Name",
  productCategory: "SaaS productivity tools",
  voice: "Professional but approachable",
  primaryCTA: "https://yourdomain.com/return"
};

async function main() {
  console.log('🚀 Starting email campaign generation...\n');
  
  // Step 1: Load data
  const audienceData = loadAudienceData('./data/audience.csv');
  
  // Step 2: Segment
  const segments = segmentAudience(audienceData);
  
  // Step 3: Generate
  const campaignResults = await generateCampaign(segments, BRAND_CONFIG);
  
  // Step 4: Export
  const outputPath = await saveResults(campaignResults);
  
  console.log('\n🎉 Campaign generation complete!');
  console.log(`Review your emails at: ${outputPath}`);
}

main().catch(console.error);

Run the full system with node run-campaign.js. Watch the console as it loads your data, segments your audience, and generates emails one by one. When it finishes, open your output folder and read through a sample of emails from each segment.

What Good Output Looks Like

A well-tuned system will produce emails where you can genuinely see the segmentation working. A lapsed customer email should feel warmer and more nostalgic than a new subscriber welcome, which should be more energetic and orientation-focused. If all your emails feel similar regardless of segment, your prompts need more differentiation — go back and add more segment-specific context and tone guidance.

If you're the kind of learner who wants to go from zero to building real systems like this with hands-on guidance, Adventure Media is running a full-day Claude Code workshop called "Master Claude Code in One Day" — designed specifically for people who want to build actual AI-powered tools, not just experiment with prompts. It's a practical session where you walk away with working projects.

Step 9: Quality Control, Testing, and Iteration

Building the system is only half the job. The second half is making sure it produces emails you'd actually be proud to send. This step covers the quality control layer every production-grade generator needs.

Estimated time: 45–60 minutes (ongoing)

Automated Quality Checks

Add a validation layer that runs after generation and flags emails that fail basic quality criteria:

Subject line length: Flag anything under 20 or over 70 characters
Personalization presence: Verify the contact's first name appears in the email body
CTA presence: Ensure every email has a clear call-to-action
Spam trigger words: Run subject lines through a basic blocklist check (words like "FREE!!!" or "Act NOW" are red flags)
HTML validity: Use a lightweight HTML parser to check for unclosed tags in body_html

Human Review Protocol

Even with automated checks, build a human review step into your workflow. Generate a random sample — 5% of each segment, minimum 10 emails per segment — and have a human read them before any campaign goes live. Specifically look for:

Tone mismatches (an email that sounds wrong for the brand)
Factual errors (Claude occasionally confabulates details if your prompts are vague)
Personalization that feels off (e.g., using data points awkwardly)
CTAs that don't match the campaign goal

A/B Testing Your Generated Copy

One underused advantage of AI-generated email campaigns is how easy it is to generate multiple variants. Ask Claude to produce three subject line variations for each email and split-test them. Over time, you'll learn which prompt patterns produce subject lines that drive opens for your specific audience — and you can encode those learnings back into your prompts.

Advanced Enhancements Worth Building Next

Once your v1 system is working reliably, these are the enhancements that turn a functional tool into a genuinely powerful marketing asset.

1. Campaign Series Generation

Extend your generator to produce multi-email drip sequences rather than single sends. Pass the previous email's content into the next prompt so Claude can write sequels that reference what was said before. This creates campaign narrative continuity that single-send generators can't match.

2. Dynamic Offer Injection

Build a product catalog module that injects relevant product recommendations into each email based on the contact's purchase history or industry. Claude can weave these recommendations into the copy naturally rather than just appending a product list.

3. Send-Time Optimization

Add a scheduling layer that recommends optimal send times based on each contact's historical open data. If your audience data includes past engagement timestamps, you can calculate each contact's most active hour and output a personalized send-time recommendation alongside each generated email.

4. Performance Feedback Loop

After campaigns send, import your open rates, click rates, and conversion data back into the system. Use this data to refine your segmentation thresholds and prompt templates. Over multiple campaigns, your system gets measurably better — this is the compounding advantage of building your own generator versus using a static tool.

5. Multi-Brand Support

Extend your BRAND_CONFIG object into a full brand profile system. Store voice guidelines, product catalogs, and campaign history per brand. This makes the tool useful for agencies running campaigns for multiple clients without any cross-contamination of tone or data.

Frequently Asked Questions

How much does it cost to run this generator for a list of 10,000 contacts?

The cost depends on your prompt length and output length, but for a typical setup generating 200-word emails with a 300-word prompt, you can estimate roughly 500-800 tokens per contact. At 10,000 contacts, that's 5–8 million tokens. Use Anthropic's current pricing page to calculate the exact cost for the model you're using, as pricing varies by model tier and changes periodically. Running a test batch of 100 contacts first will give you a reliable per-contact cost estimate for your specific setup.

Can this system write emails in languages other than English?

Yes — Claude is highly capable in multiple languages. Simply add a language field to your contact records and inject it into your prompts with an instruction like "Write this email in [language], maintaining the same tone and structure." Test each language output manually before sending, as nuance and cultural appropriateness require human review.

What happens if Claude returns invalid JSON?

This happens occasionally, especially with longer or more complex outputs. The extractJSON() utility in the generation module handles the most common case (text before or after the JSON block). For more robust handling, add a retry that explicitly asks Claude to return only valid JSON if the first attempt fails. Logging failed extractions separately lets you review and manually fix them without losing the rest of your batch.

How do I handle contacts who opt out or unsubscribe?

Unsubscribe management should happen at the data ingestion layer, before any API calls are made. Filter out unsubscribed contacts from your audience CSV before loading it into the system. Never generate emails for contacts who have opted out — beyond being a legal requirement under CAN-SPAM and GDPR, it's a waste of API spend. Maintain a suppression list and apply it during ingestion.

Is this approach compliant with CAN-SPAM regulations?

The generator itself doesn't affect CAN-SPAM compliance — your email sending practices do. Make sure every generated email includes a physical mailing address, a clear unsubscribe mechanism, and an honest "From" name. The generator can be configured to include these elements in the HTML template wrapper that surrounds the generated body content. Review the FTC's CAN-SPAM compliance guide if you have questions about specific requirements.

Can I use this with other AI models besides Claude?

Yes, the architecture is model-agnostic. The generate.js module is the only file that talks to the Anthropic API. You could swap it out for OpenAI's API, Google's Gemini, or any other provider by changing the client initialization and API call syntax. The prompt templates would need minor adjustments for model-specific formatting preferences.

How do I prevent Claude from generating emails that feel too "AI-written"?

The single most effective fix is adding specific, concrete brand voice examples to your prompts. Instead of saying "write in a warm tone," include two or three example sentences that exemplify your brand's voice. Also, explicitly instruct Claude to avoid certain AI writing clichés: phrases like "in today's fast-paced world," "look no further," or "game-changer" are telltale signs. The more specific your voice guidance, the more human the output.

What's the best way to handle email personalization beyond first name?

The richest personalization comes from behavioral data, not demographic data. Injecting the contact's last purchase category, their most-viewed product type, or their engagement pattern (e.g., "opens emails on Tuesday mornings") gives Claude genuinely useful context to personalize around. First-name personalization alone is table stakes in 2026 — behavioral personalization is what drives measurable lift in click rates.

How should I structure prompts for a B2B audience versus B2C?

B2B prompts should emphasize business outcomes, ROI language, and professional context, while B2C prompts should lead with emotional resonance and personal benefit. For B2B, include the contact's industry, company size (if available), and job function in the prompt — Claude will naturally adjust its framing. B2C emails can be warmer and more conversational. Maintaining separate prompt templates for B2B and B2C segments is cleaner than trying to handle both in one prompt.

Can this system generate entire email sequences, not just individual emails?

Yes — this is one of the most powerful extensions of the base system. To generate a 5-email drip sequence, run the generator in a loop where each iteration receives the previous email's content as context. You can either store previous emails in memory during the session or save them to disk and reload them. The result is a sequence where each email builds naturally on the last, rather than five disconnected messages that happen to share a subject.

How do I know if the generated emails are actually performing better than my previous templates?

Set up a proper A/B test: send AI-generated emails to half your segment and your previous template to the other half. Track open rate, click-through rate, and conversion rate (not just opens). Run the test for at least two weeks across multiple sends before drawing conclusions. Most teams find the first AI-generated campaign underperforms their templates, the second is competitive, and by the third iteration — with prompt refinements based on real data — the AI-generated campaigns outperform. The system improves with feedback.

What if I want to generate emails for a segment I haven't built a prompt template for yet?

You can ask Claude to help you design the prompt template itself. Describe your new segment to Claude — who they are, what their relationship with your brand is, what you want them to do — and ask it to write a prompt template for that segment. This is one of the most useful meta-applications of the system: using AI to improve the AI's own instructions. Review and refine the generated template before using it in production.

Conclusion: You've Built Something That Scales With You

What you've built over these eight steps is more than an email generator — it's a systematic approach to personalized communication at scale. The architecture you've created separates concerns cleanly, handles real-world messiness in your data, and produces output your team can actually review and trust before sending.

The most important thing to remember as you move into production: this system gets better with iteration. Your first campaign will reveal gaps in your segmentation logic. Your second will expose prompt patterns that consistently underperform. Your third will benefit from both rounds of refinement. Build in the feedback loop from day one — even if it's just a simple spreadsheet where you note what worked and what didn't after each campaign.

Claude Code changes what's possible for teams without large engineering resources. A marketing manager with basic JavaScript knowledge can now build and maintain a personalization system that would have required a dedicated data science team two years ago. That's not hype — it's what the technology actually enables when you approach it systematically rather than treating it as a magic prompt box.

If you're ready to go deeper into building with Claude Code — beyond email generators into full AI-powered workflows — Adventure Media's "Master Claude Code in One Day" workshop is designed exactly for this. It's a hands-on session where you build real tools, not toy examples, with instructors who use Claude Code in production daily. For teams serious about building their own AI-powered marketing infrastructure, it's a faster path than trial and error alone.

Now run your generator, read the output, and send your first AI-personalized campaign. The feedback loop starts the moment your first email lands in an inbox.

Ready to Master Claude Code?

Stop reading tutorials and start building. Adventure Media's "Master Claude Code in One Day" workshop takes you from zero to building real, functional AI tools — in a single day. Hands-on projects. Expert guidance. No coding experience required.

Reserve Your Spot — Seats Are Limited

Most email marketing tools give you templates. Claude Code gives you a system — one that thinks, personalizes, and adapts to your audience the way a seasoned copywriter would, but at a scale no human team could match. If you've ever stared at a blank email editor wondering how to segment your list, write five variations of a subject line, and schedule everything around a product launch — all at once — this guide is for you.

What follows is a complete, hands-on walkthrough for building an automated email campaign generator using Claude Code. By the end, you'll have a working system that ingests audience data, generates personalized email copy, organizes campaigns by segment, and outputs ready-to-deploy content — all driven by AI. No prior machine learning experience required. Just a willingness to follow the steps, understand what you're building, and think like a systems designer rather than a template picker.

Limited Event

Master Claude Code in One Day — Live Workshop by Adventure Media

Go from zero coding experience to building real AI-powered tools. Hands-on projects, expert guidance, no fluff.

Register Now — Spots Filling Fast →

What you'll need before starting: Basic familiarity with the command line, a text editor (VS Code recommended), Node.js installed on your machine, a Claude API key from Anthropic, and a CSV or JSON file of audience data you want to work with. Estimated total build time: 3–5 hours for a fully functional v1.

Step 1: Understanding What You're Actually Building (and Why It Matters)

Before writing a single line of code, you need a clear architectural picture of the system. Skipping this step is the single most common reason developers end up with a brittle, confusing codebase two hours in. Take 20–30 minutes here — it will save you hours later.

The system you're building has four core components working in sequence:

Data Ingestion Layer — reads your audience data (CSV, JSON, or database query results) and structures it into a format the AI can reason about.
Segmentation Engine — applies rules or AI-generated logic to group contacts by relevant attributes (purchase history, engagement score, industry, geographic region, etc.).
Copy Generation Module — sends structured prompts to Claude's API and receives personalized email copy tailored to each segment.
Output Formatter — organizes generated emails into a folder structure or exports them as a JSON payload your email platform (Mailchimp, ActiveCampaign, Klaviyo, etc.) can consume.

Understanding this architecture matters because Claude Code isn't just a chatbot you're querying — it's functioning as the reasoning core of a multi-step pipeline. Each component passes structured data to the next. If your data ingestion layer produces messy output, your segmentation engine will produce bad segments, and your copy will reflect that garbage-in, garbage-out reality.

Key Architectural Decision: Stateless vs. Stateful Generation

For most email campaign generators, a stateless approach works best at the start — meaning each email is generated fresh from a prompt, with no memory of previous calls. This keeps your system simple and debuggable. As you scale, you can introduce conversation history to maintain tone consistency across a campaign series, but don't start there.

Common Mistake to Avoid at This Stage

Don't try to build all four components simultaneously. Build and test each one individually. A working data ingestion layer with a broken segmentation engine is far easier to fix than a tangled mess where you don't know which part is failing.

Pro Tip: Sketch your architecture on paper or in a simple diagram tool before touching your editor. Write down the input and output of each component. This becomes your contract — what you're building toward — and it makes debugging infinitely easier.

Step 2: Setting Up Your Development Environment

A clean development environment prevents half the issues developers encounter when working with API-based AI tools. This step covers setup from scratch — even if you've built with Claude before, walk through this checklist to make sure nothing is missing.

Estimated time: 20–30 minutes

Initialize Your Project

Open your terminal and create a new project directory:

mkdir claude-email-generator
cd claude-email-generator
npm init -y

Install the required dependencies. You'll need the Anthropic SDK, a CSV parsing library, and dotenv for managing your API key securely:

npm install @anthropic-ai/sdk csv-parse dotenv fs-extra

Create a .env file in your project root and add your Claude API key:

ANTHROPIC_API_KEY=your_api_key_here

Immediately add .env to your .gitignore file. This is non-negotiable. Committing API keys to version control — even in a private repo — is a security risk you don't want to learn about the hard way.

Create Your Project Structure

Set up the following folder structure before writing any logic:

claude-email-generator/
├── .env
├── .gitignore
├── package.json
├── src/
│   ├── ingest.js
│   ├── segment.js
│   ├── generate.js
│   └── format.js
├── data/
│   └── audience.csv
├── output/
│   └── (generated emails land here)
└── prompts/
    └── (your prompt templates)

This folder structure maps directly to the four components you identified in Step 1. Every file has one job. This modularity is what makes the system maintainable and testable.

Test Your Claude API Connection

Before building anything, verify your API key works. Create a quick test file:

// test-connection.js
require('dotenv').config();
const Anthropic = require('@anthropic-ai/sdk');

const client = new Anthropic();

async function testConnection() {
  const message = await client.messages.create({
    model: "claude-opus-4-5",
    max_tokens: 100,
    messages: [{ role: "user", content: "Say hello in one sentence." }]
  });
  console.log(message.content[0].text);
}

testConnection();

Run node test-connection.js. If you see a greeting, your environment is configured correctly. If you see an authentication error, double-check your API key in the .env file.

Warning: Always reference the official Anthropic API documentation for the most current model names and API parameters. Model names update frequently, and using a deprecated model name will cause silent failures.

Step 3: Building the Data Ingestion Layer

Your data ingestion layer is the foundation everything else rests on. Its job is simple: take raw audience data in whatever format it exists, and transform it into clean, structured JavaScript objects your system can work with.

Estimated time: 30–45 minutes

Preparing Your Audience Data File

For this walkthrough, we'll use a CSV format since it's the most common export format from CRMs and email platforms. Your audience.csv file should have columns like these (adjust to match your actual data):

email,first_name,last_name,industry,purchase_count,last_purchase_date,engagement_score,location_state

The specific columns matter less than making sure they're consistent, non-null where critical, and named clearly. If your real data has columns like engmnt_scr or lst_purch, rename them now. You'll thank yourself when reading prompts at 11pm trying to figure out why a segment isn't working.

Writing the Ingestion Module

Open src/ingest.js and write the following:

// src/ingest.js
require('dotenv').config();
const { parse } = require('csv-parse/sync');
const fs = require('fs');
const path = require('path');

function loadAudienceData(filePath) {
  const absolutePath = path.resolve(filePath);
  
  if (!fs.existsSync(absolutePath)) {
    throw new Error(`Data file not found: ${absolutePath}`);
  }

  const fileContent = fs.readFileSync(absolutePath, 'utf-8');
  
  const records = parse(fileContent, {
    columns: true,
    skip_empty_lines: true,
    trim: true,
    cast: true  // Auto-converts numbers and booleans
  });

  // Basic validation
  const requiredFields = ['email', 'first_name'];
  for (const record of records) {
    for (const field of requiredFields) {
      if (!record[field]) {
        console.warn(`Warning: Record missing required field '${field}':`, record);
      }
    }
  }

  console.log(`Loaded ${records.length} audience records.`);
  return records;
}

module.exports = { loadAudienceData };

Test this immediately: create a small 5-row CSV file with sample data and run a quick script that calls loadAudienceData('./data/audience.csv') and logs the result. You should see an array of objects, each representing one contact.

Handling Real-World Data Messiness

Real audience data is never clean. Plan for these common issues:

Duplicate emails: Add a deduplication step using new Set() on the email field
Missing engagement scores: Set a default value (e.g., 0) rather than letting nulls propagate
Inconsistent date formats: Parse all dates through a normalizer before they enter your pipeline
Special characters in names: These can break JSON serialization — strip or escape them early

Pro Tip: Add a sanitizeRecord() function that applies all your data cleaning rules in one place. This makes it easy to add new rules later without hunting through your codebase.

Step 4: Building the Segmentation Engine

Segmentation is where your campaign generator starts to earn its value. The difference between a mass blast and a personalized campaign lives entirely in how well you segment your audience before generating copy.

Estimated time: 45–60 minutes

Defining Your Segmentation Strategy

Before writing code, decide on your segments. For a standard e-commerce or B2B email campaign, common segments include:

High-Value Actives: High purchase count + high engagement score + recent purchase
Lapsed Customers: Previous purchases + no activity in 90+ days
New Subscribers: No purchases + account created in last 30 days
Engaged Non-Buyers: High engagement score + zero purchases
Industry-Specific: Grouped by industry vertical for B2B campaigns

These segments directly inform the tone, urgency, offer type, and CTA your generated emails will use. A "Lapsed Customer" email should feel different from a "New Subscriber" welcome — and Claude will write them differently if you tell it which segment it's writing for.

Writing the Segmentation Module

Open src/segment.js:

// src/segment.js

function segmentAudience(records) {
  const segments = {
    high_value_active: [],
    lapsed_customer: [],
    new_subscriber: [],
    engaged_non_buyer: [],
    general: []
  };

  const now = new Date();
  const ninetyDaysAgo = new Date(now - 90 * 24 * 60 * 60 * 1000);
  const thirtyDaysAgo = new Date(now - 30 * 24 * 60 * 60 * 1000);

  for (const record of records) {
    const lastPurchase = record.last_purchase_date 
      ? new Date(record.last_purchase_date) 
      : null;
    const accountCreated = record.created_at 
      ? new Date(record.created_at) 
      : null;

    const isHighEngagement = (record.engagement_score || 0) >= 70;
    const isHighPurchaseCount = (record.purchase_count || 0) >= 3;
    const isRecentPurchase = lastPurchase && lastPurchase > ninetyDaysAgo;
    const isLapsed = lastPurchase && lastPurchase <= ninetyDaysAgo;
    const isNewSubscriber = accountCreated && accountCreated > thirtyDaysAgo;
    const isNonBuyer = (record.purchase_count || 0) === 0;

    if (isHighEngagement && isHighPurchaseCount && isRecentPurchase) {
      segments.high_value_active.push(record);
    } else if (isLapsed && isHighPurchaseCount) {
      segments.lapsed_customer.push(record);
    } else if (isNewSubscriber && isNonBuyer) {
      segments.new_subscriber.push(record);
    } else if (isHighEngagement && isNonBuyer) {
      segments.engaged_non_buyer.push(record);
    } else {
      segments.general.push(record);
    }
  }

  // Log segment counts
  for (const [name, members] of Object.entries(segments)) {
    console.log(`Segment '${name}': ${members.length} contacts`);
  }

  return segments;
}

module.exports = { segmentAudience };

Common Mistake: Contacts that fall into multiple segments. Your logic needs a clear priority order — the if/else if chain above handles this implicitly (high-value actives are checked first), but make sure your priority order matches your business logic, not just what you coded first.

Using Claude to Assist With Segmentation Logic

Here's an advanced option worth knowing: you can ask Claude itself to suggest segmentation rules based on a sample of your data. Send a few sample records and your campaign goals to Claude via the API, and ask it to recommend segment definitions. This is especially powerful when you're working with unfamiliar audience data or entering a new vertical. The AI can surface patterns a human might miss.

Step 5: Engineering Your Email Generation Prompts

This is the creative and technical heart of the system. The quality of your generated emails is almost entirely determined by the quality of your prompts. Bad prompts produce generic copy. Well-engineered prompts produce emails that feel like they were written by someone who actually knows the recipient.

Estimated time: 60–90 minutes — this step deserves the most attention

The Anatomy of an Effective Email Generation Prompt

A high-quality email generation prompt has six components:

Role definition: Tell Claude what kind of copywriter it's being asked to be
Audience context: Describe the specific segment being written for
Contact personalization data: Inject the individual's actual data
Campaign goal: What should the reader do after reading this email?
Tone and voice guidelines: Brand voice, formality level, emotional tone
Output format specification: Exactly what fields you want back, in what structure

Create a prompts directory and write a template for each segment. Here's an example for the lapsed customer segment:

// prompts/lapsed_customer.js

function getLapsedCustomerPrompt(contact, brandName, productCategory) {
  return `You are an expert email copywriter specializing in customer win-back campaigns.

AUDIENCE CONTEXT:
This email is going to a lapsed customer — someone who previously made ${contact.purchase_count} purchases but hasn't engaged in over 90 days. They were once a real fan of the brand. Your job is to re-ignite that relationship, not just push a sale.

CONTACT INFORMATION:
- First name: ${contact.first_name}
- Industry: ${contact.industry || 'Not specified'}
- Last purchase date: ${contact.last_purchase_date}
- Engagement score: ${contact.engagement_score}/100

CAMPAIGN DETAILS:
- Brand: ${brandName}
- Product category: ${productCategory}
- Goal: Drive a re-engagement click (return to site or reply to email)
- Do NOT include a discount unless it feels genuinely earned in the copy

TONE: Warm, slightly surprised to see them gone, genuinely curious — not desperate or pushy. This brand values the relationship, not just the transaction.

OUTPUT FORMAT (respond in valid JSON only):
{
  "subject_line": "string (40-60 characters, no clickbait)",
  "preview_text": "string (80-100 characters)",
  "body_html": "string (full HTML email body, 150-250 words)",
  "cta_text": "string (3-6 words)",
  "personalization_note": "string (brief note explaining personalization choices made)"
}`;
}

module.exports = { getLapsedCustomerPrompt };

Write similar prompt templates for each of your segments. The key variables to inject from each contact record are: name, relevant behavioral data (purchase count, engagement score), and any contextual data that signals what this person cares about.

Why Asking for JSON Output Matters

Requesting structured JSON output from Claude is critical for automation. When Claude returns valid JSON, your system can immediately parse it, extract each field, and route it to the right place — without any manual cleanup. Always validate the JSON response before passing it downstream, because occasionally Claude will include a markdown code fence or extra explanation text that needs to be stripped.

Add a simple JSON extractor utility:

function extractJSON(text) {
  const jsonMatch = text.match(/\{[\s\S]*\}/);
  if (!jsonMatch) throw new Error('No valid JSON found in response');
  return JSON.parse(jsonMatch[0]);
}

Testing Your Prompts Before Scaling

Before running your generator against 10,000 contacts, test each prompt with 5–10 sample contacts manually. Read every email. Ask yourself: does this feel personalized? Does it match the segment strategy? Is the tone right? Would I click this CTA?

This review step catches prompt engineering issues before they multiply across your entire audience.

Step 6: Writing the Core Generation Module

With prompts engineered and tested, it's time to build the module that actually calls Claude's API and generates emails at scale. This module also handles rate limiting, error recovery, and progress logging — the operational concerns that separate a toy script from a production tool.

Estimated time: 45–60 minutes

// src/generate.js
require('dotenv').config();
const Anthropic = require('@anthropic-ai/sdk');
const { getLapsedCustomerPrompt } = require('../prompts/lapsed_customer');
// Import other prompt templates...

const client = new Anthropic();

// Rate limiting: Claude API has request limits
const DELAY_BETWEEN_REQUESTS = 1000; // 1 second between calls
const MAX_RETRIES = 3;

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function generateEmailForContact(contact, segment, brandConfig) {
  let prompt;
  
  switch(segment) {
    case 'lapsed_customer':
      prompt = getLapsedCustomerPrompt(contact, brandConfig.name, brandConfig.productCategory);
      break;
    // Add other segment cases...
    default:
      throw new Error(`Unknown segment: ${segment}`);
  }

  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
    try {
      const response = await client.messages.create({
        model: "claude-opus-4-5",
        max_tokens: 1500,
        messages: [{ role: "user", content: prompt }]
      });
      
      const rawText = response.content[0].text;
      const emailData = extractJSON(rawText);
      
      return {
        contact_email: contact.email,
        segment: segment,
        ...emailData
      };
      
    } catch (error) {
      if (attempt === MAX_RETRIES) {
        console.error(`Failed to generate email for ${contact.email} after ${MAX_RETRIES} attempts`);
        return null;
      }
      await sleep(attempt * 2000); // Exponential backoff
    }
  }
}

async function generateCampaign(segments, brandConfig) {
  const results = {};
  
  for (const [segmentName, contacts] of Object.entries(segments)) {
    console.log(`\nGenerating emails for segment: ${segmentName} (${contacts.length} contacts)`);
    results[segmentName] = [];
    
    for (let i = 0; i < contacts.length; i++) {
      const contact = contacts[i];
      console.log(`  [${i + 1}/${contacts.length}] ${contact.email}`);
      
      const email = await generateEmailForContact(contact, segmentName, brandConfig);
      if (email) results[segmentName].push(email);
      
      // Rate limiting delay
      if (i < contacts.length - 1) {
        await sleep(DELAY_BETWEEN_REQUESTS);
      }
    }
    
    console.log(`  ✓ Generated ${results[segmentName].length} emails for ${segmentName}`);
  }
  
  return results;
}

function extractJSON(text) {
  const jsonMatch = text.match(/\{[\s\S]*\}/);
  if (!jsonMatch) throw new Error('No valid JSON found in response');
  return JSON.parse(jsonMatch[0]);
}

module.exports = { generateCampaign };

Understanding Rate Limits and Cost Management

Each API call to Claude costs tokens — both the prompt tokens you send and the completion tokens you receive back. For a campaign generating emails for 1,000 contacts, you're making 1,000 API calls. Before running at scale, use Anthropic's token counting to estimate your costs. A well-engineered prompt with a 200-word output typically runs around 500–800 tokens total per call — but measure your actual prompts, not estimates.

For large campaigns, consider batching by segment and running overnight, or implementing a progress checkpoint system that saves results to disk after every 100 emails so a failure doesn't lose your work.

Step 7: Building the Output Formatter and Export Layer

Your generated emails are only useful if they get into the hands of your email platform. The output formatter takes the raw generation results and transforms them into whatever format your platform needs — whether that's a structured JSON file, a CSV for bulk import, or a direct API call to Mailchimp or Klaviyo.

Estimated time: 30–45 minutes

// src/format.js
const fs = require('fs-extra');
const path = require('path');

async function saveResults(campaignResults, outputDir = './output') {
  await fs.ensureDir(outputDir);
  
  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
  const campaignDir = path.join(outputDir, `campaign-${timestamp}`);
  await fs.ensureDir(campaignDir);

  // Save full JSON
  const jsonPath = path.join(campaignDir, 'full-campaign.json');
  await fs.writeJSON(jsonPath, campaignResults, { spaces: 2 });
  
  // Save per-segment CSV files for easy platform import
  for (const [segmentName, emails] of Object.entries(campaignResults)) {
    if (emails.length === 0) continue;
    
    const csvRows = ['email,subject_line,preview_text,cta_text'];
    for (const email of emails) {
      const row = [
        email.contact_email,
        `"${(email.subject_line || '').replace(/"/g, '""')}"`,
        `"${(email.preview_text || '').replace(/"/g, '""')}"`,
        `"${(email.cta_text || '').replace(/"/g, '""')}"`
      ].join(',');
      csvRows.push(row);
    }
    
    const csvPath = path.join(campaignDir, `${segmentName}.csv`);
    await fs.writeFile(csvPath, csvRows.join('\n'));
  }

  // Save HTML bodies as individual files for visual review
  const htmlDir = path.join(campaignDir, 'html-previews');
  await fs.ensureDir(htmlDir);
  
  for (const [segmentName, emails] of Object.entries(campaignResults)) {
    for (const email of emails) {
      if (email.body_html) {
        const filename = `${segmentName}-${email.contact_email.replace('@', '_at_')}.html`;
        await fs.writeFile(path.join(htmlDir, filename), email.body_html);
      }
    }
  }

  console.log(`\n✅ Campaign saved to: ${campaignDir}`);
  return campaignDir;
}

module.exports = { saveResults };

Integrating With Email Platforms

If you want to push emails directly into Mailchimp, Klaviyo, or ActiveCampaign via their APIs, the output formatter is where that integration lives. Rather than exporting files, you'd replace the file-writing logic with API calls to create campaigns, add tags, or schedule sends. The generated JSON structure maps cleanly to most platform APIs — the field names just need to be remapped to match the platform's expected schema.

Step 8: Wiring It All Together With a Main Runner

Now bring all four components together into a single orchestrator script. This is your campaign generator's entry point — the script you'll actually run when you want to generate a campaign.

Estimated time: 20–30 minutes

// run-campaign.js
require('dotenv').config();
const { loadAudienceData } = require('./src/ingest');
const { segmentAudience } = require('./src/segment');
const { generateCampaign } = require('./src/generate');
const { saveResults } = require('./src/format');

const BRAND_CONFIG = {
  name: "Your Brand Name",
  productCategory: "SaaS productivity tools",
  voice: "Professional but approachable",
  primaryCTA: "https://yourdomain.com/return"
};

async function main() {
  console.log('🚀 Starting email campaign generation...\n');
  
  // Step 1: Load data
  const audienceData = loadAudienceData('./data/audience.csv');
  
  // Step 2: Segment
  const segments = segmentAudience(audienceData);
  
  // Step 3: Generate
  const campaignResults = await generateCampaign(segments, BRAND_CONFIG);
  
  // Step 4: Export
  const outputPath = await saveResults(campaignResults);
  
  console.log('\n🎉 Campaign generation complete!');
  console.log(`Review your emails at: ${outputPath}`);
}

main().catch(console.error);

Run the full system with node run-campaign.js. Watch the console as it loads your data, segments your audience, and generates emails one by one. When it finishes, open your output folder and read through a sample of emails from each segment.

What Good Output Looks Like

A well-tuned system will produce emails where you can genuinely see the segmentation working. A lapsed customer email should feel warmer and more nostalgic than a new subscriber welcome, which should be more energetic and orientation-focused. If all your emails feel similar regardless of segment, your prompts need more differentiation — go back and add more segment-specific context and tone guidance.

If you're the kind of learner who wants to go from zero to building real systems like this with hands-on guidance, Adventure Media is running a full-day Claude Code workshop called "Master Claude Code in One Day" — designed specifically for people who want to build actual AI-powered tools, not just experiment with prompts. It's a practical session where you walk away with working projects.

Step 9: Quality Control, Testing, and Iteration

Building the system is only half the job. The second half is making sure it produces emails you'd actually be proud to send. This step covers the quality control layer every production-grade generator needs.

Estimated time: 45–60 minutes (ongoing)

Automated Quality Checks

Add a validation layer that runs after generation and flags emails that fail basic quality criteria:

Subject line length: Flag anything under 20 or over 70 characters
Personalization presence: Verify the contact's first name appears in the email body
CTA presence: Ensure every email has a clear call-to-action
Spam trigger words: Run subject lines through a basic blocklist check (words like "FREE!!!" or "Act NOW" are red flags)
HTML validity: Use a lightweight HTML parser to check for unclosed tags in body_html

Human Review Protocol

Even with automated checks, build a human review step into your workflow. Generate a random sample — 5% of each segment, minimum 10 emails per segment — and have a human read them before any campaign goes live. Specifically look for:

Tone mismatches (an email that sounds wrong for the brand)
Factual errors (Claude occasionally confabulates details if your prompts are vague)
Personalization that feels off (e.g., using data points awkwardly)
CTAs that don't match the campaign goal

A/B Testing Your Generated Copy

One underused advantage of AI-generated email campaigns is how easy it is to generate multiple variants. Ask Claude to produce three subject line variations for each email and split-test them. Over time, you'll learn which prompt patterns produce subject lines that drive opens for your specific audience — and you can encode those learnings back into your prompts.

Advanced Enhancements Worth Building Next

Once your v1 system is working reliably, these are the enhancements that turn a functional tool into a genuinely powerful marketing asset.

1. Campaign Series Generation

Extend your generator to produce multi-email drip sequences rather than single sends. Pass the previous email's content into the next prompt so Claude can write sequels that reference what was said before. This creates campaign narrative continuity that single-send generators can't match.

2. Dynamic Offer Injection

Build a product catalog module that injects relevant product recommendations into each email based on the contact's purchase history or industry. Claude can weave these recommendations into the copy naturally rather than just appending a product list.

3. Send-Time Optimization

Add a scheduling layer that recommends optimal send times based on each contact's historical open data. If your audience data includes past engagement timestamps, you can calculate each contact's most active hour and output a personalized send-time recommendation alongside each generated email.

4. Performance Feedback Loop

After campaigns send, import your open rates, click rates, and conversion data back into the system. Use this data to refine your segmentation thresholds and prompt templates. Over multiple campaigns, your system gets measurably better — this is the compounding advantage of building your own generator versus using a static tool.

5. Multi-Brand Support

Extend your BRAND_CONFIG object into a full brand profile system. Store voice guidelines, product catalogs, and campaign history per brand. This makes the tool useful for agencies running campaigns for multiple clients without any cross-contamination of tone or data.

Frequently Asked Questions

How much does it cost to run this generator for a list of 10,000 contacts?

The cost depends on your prompt length and output length, but for a typical setup generating 200-word emails with a 300-word prompt, you can estimate roughly 500-800 tokens per contact. At 10,000 contacts, that's 5–8 million tokens. Use Anthropic's current pricing page to calculate the exact cost for the model you're using, as pricing varies by model tier and changes periodically. Running a test batch of 100 contacts first will give you a reliable per-contact cost estimate for your specific setup.

Can this system write emails in languages other than English?

Yes — Claude is highly capable in multiple languages. Simply add a language field to your contact records and inject it into your prompts with an instruction like "Write this email in [language], maintaining the same tone and structure." Test each language output manually before sending, as nuance and cultural appropriateness require human review.

What happens if Claude returns invalid JSON?

This happens occasionally, especially with longer or more complex outputs. The extractJSON() utility in the generation module handles the most common case (text before or after the JSON block). For more robust handling, add a retry that explicitly asks Claude to return only valid JSON if the first attempt fails. Logging failed extractions separately lets you review and manually fix them without losing the rest of your batch.

How do I handle contacts who opt out or unsubscribe?

Unsubscribe management should happen at the data ingestion layer, before any API calls are made. Filter out unsubscribed contacts from your audience CSV before loading it into the system. Never generate emails for contacts who have opted out — beyond being a legal requirement under CAN-SPAM and GDPR, it's a waste of API spend. Maintain a suppression list and apply it during ingestion.

Is this approach compliant with CAN-SPAM regulations?

The generator itself doesn't affect CAN-SPAM compliance — your email sending practices do. Make sure every generated email includes a physical mailing address, a clear unsubscribe mechanism, and an honest "From" name. The generator can be configured to include these elements in the HTML template wrapper that surrounds the generated body content. Review the FTC's CAN-SPAM compliance guide if you have questions about specific requirements.

Can I use this with other AI models besides Claude?

Yes, the architecture is model-agnostic. The generate.js module is the only file that talks to the Anthropic API. You could swap it out for OpenAI's API, Google's Gemini, or any other provider by changing the client initialization and API call syntax. The prompt templates would need minor adjustments for model-specific formatting preferences.

How do I prevent Claude from generating emails that feel too "AI-written"?

The single most effective fix is adding specific, concrete brand voice examples to your prompts. Instead of saying "write in a warm tone," include two or three example sentences that exemplify your brand's voice. Also, explicitly instruct Claude to avoid certain AI writing clichés: phrases like "in today's fast-paced world," "look no further," or "game-changer" are telltale signs. The more specific your voice guidance, the more human the output.

What's the best way to handle email personalization beyond first name?

The richest personalization comes from behavioral data, not demographic data. Injecting the contact's last purchase category, their most-viewed product type, or their engagement pattern (e.g., "opens emails on Tuesday mornings") gives Claude genuinely useful context to personalize around. First-name personalization alone is table stakes in 2026 — behavioral personalization is what drives measurable lift in click rates.

How should I structure prompts for a B2B audience versus B2C?

B2B prompts should emphasize business outcomes, ROI language, and professional context, while B2C prompts should lead with emotional resonance and personal benefit. For B2B, include the contact's industry, company size (if available), and job function in the prompt — Claude will naturally adjust its framing. B2C emails can be warmer and more conversational. Maintaining separate prompt templates for B2B and B2C segments is cleaner than trying to handle both in one prompt.

Can this system generate entire email sequences, not just individual emails?

Yes — this is one of the most powerful extensions of the base system. To generate a 5-email drip sequence, run the generator in a loop where each iteration receives the previous email's content as context. You can either store previous emails in memory during the session or save them to disk and reload them. The result is a sequence where each email builds naturally on the last, rather than five disconnected messages that happen to share a subject.

How do I know if the generated emails are actually performing better than my previous templates?

Set up a proper A/B test: send AI-generated emails to half your segment and your previous template to the other half. Track open rate, click-through rate, and conversion rate (not just opens). Run the test for at least two weeks across multiple sends before drawing conclusions. Most teams find the first AI-generated campaign underperforms their templates, the second is competitive, and by the third iteration — with prompt refinements based on real data — the AI-generated campaigns outperform. The system improves with feedback.

What if I want to generate emails for a segment I haven't built a prompt template for yet?

You can ask Claude to help you design the prompt template itself. Describe your new segment to Claude — who they are, what their relationship with your brand is, what you want them to do — and ask it to write a prompt template for that segment. This is one of the most useful meta-applications of the system: using AI to improve the AI's own instructions. Review and refine the generated template before using it in production.

Conclusion: You've Built Something That Scales With You

What you've built over these eight steps is more than an email generator — it's a systematic approach to personalized communication at scale. The architecture you've created separates concerns cleanly, handles real-world messiness in your data, and produces output your team can actually review and trust before sending.

The most important thing to remember as you move into production: this system gets better with iteration. Your first campaign will reveal gaps in your segmentation logic. Your second will expose prompt patterns that consistently underperform. Your third will benefit from both rounds of refinement. Build in the feedback loop from day one — even if it's just a simple spreadsheet where you note what worked and what didn't after each campaign.

Claude Code changes what's possible for teams without large engineering resources. A marketing manager with basic JavaScript knowledge can now build and maintain a personalization system that would have required a dedicated data science team two years ago. That's not hype — it's what the technology actually enables when you approach it systematically rather than treating it as a magic prompt box.

If you're ready to go deeper into building with Claude Code — beyond email generators into full AI-powered workflows — Adventure Media's "Master Claude Code in One Day" workshop is designed exactly for this. It's a hands-on session where you build real tools, not toy examples, with instructors who use Claude Code in production daily. For teams serious about building their own AI-powered marketing infrastructure, it's a faster path than trial and error alone.

Now run your generator, read the output, and send your first AI-personalized campaign. The feedback loop starts the moment your first email lands in an inbox.

Ready to Master Claude Code?

Stop reading tutorials and start building. Adventure Media's "Master Claude Code in One Day" workshop takes you from zero to building real, functional AI tools — in a single day. Hands-on projects. Expert guidance. No coding experience required.

Reserve Your Spot — Seats Are Limited

Request A Marketing Proposal

We'll get back to you within a day to schedule a quick strategy call. We can also communicate over email if that's easier for you.

Visit Us

New York
1074 Broadway
Woodmere, NY

Philadelphia
1429 Walnut Street
Philadelphia, PA

Florida
433 Plaza Real
Boca Raton, FL

General Inquiries

info@adventureppc.com
(516) 218-3722

AdVenture Education

Over 300,000 marketers from around the world have leveled up their skillset with AdVenture premium and free resources. Whether you're a CMO or a new student of digital marketing, there's something here for you.

OUR BOOK

We wrote the #1 bestselling book on performance advertising

Named one of the most important advertising books of all time.

buy on amazon

OUR EVENT

DOLAH '24.
Stream Now.

Over ten hours of lectures and workshops from our DOLAH Conference, themed: "Marketing Solutions for the AI Revolution"

check out dolah

The AdVenture Academy

Resources, guides, and courses for digital marketers, CMOs, and students. Brought to you by the agency chosen by Google to train Google's top Premier Partner Agencies.