How to Build an AI Email Assistant That Responds to Leads Automatically

Speed-to-lead is one of the most critical factors in conversion. Research from Harvard Business Review found that companies that respond to leads within an hour are 7x more likely to have a meaningful conversation than those that wait even 2 hours. For most businesses, responding within an hour is impossible during off-hours, weekends, or when the team is busy, which is where an AI email assistant changes everything.

In this guide, we'll build an AI email assistant using n8n that monitors an inbox for incoming leads, reads and understands each email, generates a personalized response, and sends it, all within minutes of the email arriving. This is one of the most impactful automations you can deliver to a client.

If you're new to n8n or want to understand the fundamentals first, read our beginner's guide to building AI agents in n8n before this tutorial.

Why AI Email Assistants Are a High-Value Agency Offering

Before diving into the build, let's understand why this specific automation commands premium pricing and high client satisfaction. The AI email assistant solves a problem that every business owner feels viscerally: leads coming in when nobody is available to respond.

The drop-off between a 5-minute response and a next-day response is dramatic. For a service business getting 50 leads per month, the revenue difference between fast and slow response can easily be $5,000-$10,000 per month. This is what makes the ROI conversation with clients so straightforward, the automation practically sells itself when you frame it around recovered revenue.

System Overview

The AI email assistant operates in two phases:

1. Monitoring and Classification: Polls or receives new emails, classifies them as lead inquiries vs. other emails, and routes appropriately
2. Response Generation and Sending: Reads the email content, generates a personalized response using business context, and sends via the client's email account

The system includes intelligent escalation, for complex requests, high-value leads, or uncertain situations, it drafts a response for human review rather than sending automatically. This safety layer is critical for client confidence and is what separates a professional build from a basic auto-responder.

Email Access Options

There are three ways to connect n8n to a client's email inbox:

Option 1: Gmail Trigger (Easiest)

If the client uses Gmail or Google Workspace, use n8n's native Gmail Trigger node:

• Trigger On: Message Received
• Filters: Label ID (to watch a specific label or inbox), unread only
• Polls every minute by default on n8n Cloud; can configure more frequent polling on self-hosted

Option 2: IMAP (Universal)

For any email provider (Outlook, Yahoo, custom business email), use the IMAP Email node:

• Credentials: IMAP server address, port (993 for SSL), username, password or app password
• Mailbox: INBOX or a specific folder
• Action: Get Many Emails (Unseen)
• Trigger this node on a schedule (Cron Trigger → every 5 minutes)
• For Office 365/Microsoft Exchange, use OAuth credentials rather than basic auth (required since Microsoft deprecated basic auth)

Option 3: Dedicated Lead Email Address

For the cleanest setup, configure a dedicated email address for leads (like leads@clientdomain.com) that all contact forms, ad platforms, and inquiry sources funnel into. This eliminates the need to classify emails, everything in this inbox is a lead.

This is the recommended approach for most client deployments because it eliminates false positives (non-lead emails triggering responses) and simplifies the workflow significantly. If the client is using a contact form on their website, configure the form to send notifications to this dedicated address.

Step 1: Email Monitoring Workflow

Set up the monitoring workflow:

1. Trigger: Gmail Trigger (new message) OR Cron Trigger (every 5 min) → IMAP Email node
2. Function node, Deduplicate: Check if this email has been processed before using a Redis key based on the message-id header. Skip if already processed.
3. OpenAI node, Classification: Classify whether this is a lead inquiry, existing customer, spam, or other. Model: gpt-4o-mini, temperature: 0.
4. IF node, Route Lead Emails: Only continue if classification = "lead_inquiry"
5. Set node, Mark as Processing: Store the message-id in Redis with a TTL to prevent duplicate responses

Step 2: Email Content Extraction

Raw email content needs cleaning before passing to GPT-4. Add a Function node:

// Clean and extract key info from email
const email = items[0].json;

// Strip HTML tags if present
const textBody = email.text || email.html?.replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim() || '';

// Extract key fields
const senderName = email.from?.name || email.from?.address?.split('@')[0] || 'there';
const senderEmail = email.from?.address || '';
const subject = email.subject || '';
const receivedDate = email.date || new Date().toISOString();

// Truncate body to 2000 chars to control token usage
const cleanedBody = textBody.substring(0, 2000);

return [{
  json: {
    sender_name: senderName,
    sender_email: senderEmail,
    subject: subject,
    body: cleanedBody,
    received_date: receivedDate,
    message_id: email.messageId
  }
}];

The truncation to 2000 characters is important for cost control. Most lead inquiry emails are well under this limit, but some email threads can be very long. Truncating ensures you do not burn through API credits on lengthy email chains while still capturing all the relevant information from the initial inquiry.

Step 3: Lead Analysis with GPT-4

Use an OpenAI node to deeply analyze the lead email:

• Model: gpt-4o
• Temperature: 0.2

System prompt:

You are an AI assistant analyzing lead inquiries for [Business Name], a [type of business].

Analyze the email and return JSON with:
{
  "lead_type": "new_inquiry" | "quote_request" | "information_request" | "complaint" | "existing_customer",
  "urgency": "high" | "medium" | "low",
  "qualification_score": number (1-10),
  "key_needs": ["need 1", "need 2"],
  "mentioned_services": ["service mentioned in email"],
  "budget_indicators": "string or null",
  "recommended_response_tone": "professional" | "warm" | "urgent" | "informative",
  "should_auto_respond": boolean,
  "escalation_reason": "string or null (reason why human should handle this)"
}

Set should_auto_respond to false if:
- The inquiry is complex and requires detailed customization
- Budget mentioned is above $10,000
- The sender seems frustrated or has a complaint
- You're unsure about the appropriate answer to their specific question

This analysis step is what transforms a simple auto-responder into an intelligent system. The qualification score helps the business prioritize follow-up. The escalation logic prevents embarrassing automated responses to sensitive situations. The tone recommendation ensures the AI's response matches the context of the inquiry.

Step 4: Routing, Auto-Respond or Draft for Review

Add an IF node based on the should_auto_respond field:

• True (auto-respond): Generate and send the response automatically
• False (human review): Draft the response and send to the team for review before sending

For the human review path, use Gmail's draft feature (via the Gmail node with operation "Create Draft") so the team can review and edit in their normal inbox before sending.

The dual-path architecture is essential for client trust. When you pitch this system, emphasize that it does not send responses blindly, it intelligently determines which emails it can handle and which need human attention. This dramatically reduces client anxiety about automated email responses going out under their business name.

Step 5: AI Response Generation

For the auto-respond path, use a second OpenAI node specifically for writing the response:

• Model: gpt-4o
• Temperature: 0.7 (higher for more natural writing)
• Max Tokens: 500

System prompt (include comprehensive business context here):

You are [Contact Name], [Title] at [Business Name].

BUSINESS CONTEXT:
[Company name, what you do, key services, typical pricing range, process, team details]

RESPONSE GUIDELINES:
- Write in first person as if you are [Contact Name]
- Be warm, professional, and helpful
- Keep responses concise (150-250 words) unless the inquiry requires detail
- Always include a clear next step CTA (schedule a call, visit, etc.)
- Include your direct phone number and calendar link when appropriate
- Never fabricate specific details (pricing, timelines) that aren't in your context
- If asked about something you're uncertain about, offer to clarify on a call

EMAIL TO RESPOND TO:
From: {{sender_name}}
Subject: {{subject}}
Message: {{email_body}}

Lead analysis: {{JSON.stringify(lead_analysis)}}

Write the email response body only. No subject line.

The business context section is where you invest the most time during client onboarding. A thorough context document, including services offered, typical pricing ranges, common questions and their answers, the team's availability, and the client's preferred communication style, is what makes AI responses sound authentic rather than generic. Spend 1-2 hours building this context with the client during setup.

Step 6: Sending the Response

Use the Gmail node (or SMTP node for non-Gmail):

• Resource: Message
• Operation: Reply (to maintain the same thread)
• Message ID: {{$json.message_id}}, this keeps the response in the same email thread
• To: {{$json.sender_email}}
• Subject: Re: {{$json.subject}}
• Message: AI-generated response from Step 5
• Reply to Message ID: The original message ID for proper threading

For SMTP sending (non-Gmail), use the Send Email node:

• Configure with client's SMTP credentials (server, port 587 or 465, username, password/app password)
• Set In-Reply-To and References headers for thread continuity

Add a Wait node (2-5 minutes) before the send step. This delay makes the response feel human rather than instant, and it helps with email deliverability. An email that arrives 3 minutes after the inquiry looks like a fast human response. An email that arrives 2 seconds after looks like a bot.

Step 7: CRM Integration and Lead Logging

After responding, log the lead to the client's CRM:

1. HubSpot node: Upsert contact by email, add the email inquiry as an activity
2. Set deal stage: Create a deal if qualification score > 6
3. Airtable: Log to a leads tracker with all metadata for reporting
4. Slack notification: Alert the team for high-score leads (> 7) with full lead context

The CRM integration is what turns this from a response tool into a complete lead management system. Every lead is captured, scored, and tracked, which gives the business owner visibility they have never had before. This visibility is a major selling point for the ongoing retainer, because it provides concrete data on lead volume, response rates, and conversion metrics.

Step 8: Follow-Up Enrollment

After the initial response, automatically enroll the lead in a follow-up sequence if they don't reply within 3 days. Connect this to the automated follow-up sequence or use n8n's Wait nodes for a simpler in-workflow approach.

A basic in-workflow follow-up sequence using Wait nodes:

• Day 2: Check if the lead has replied (query inbox for thread). If no reply, send a brief follow-up: "Hi [Name], just wanted to make sure my previous message got through. Happy to answer any questions about [service they inquired about]."
• Day 5: If still no reply, send a value-add follow-up with a relevant resource or case study.
• Day 8: Final follow-up with a direct CTA: "Would a quick 10-minute call be helpful? Here is my calendar: [link]."

Advanced: Conversation Threading

When leads reply to the AI's first response, handle the thread intelligently:

1. Gmail Trigger fires on new email in thread
2. Retrieve previous conversation history from Redis or database (keyed by thread ID)
3. Pass full conversation history to OpenAI to maintain context
4. Generate contextually appropriate reply
5. After 2-3 exchanges, escalate to human and send a notification with full thread context

Store conversation history using the Gmail threadId as the Redis key: email_thread:{{threadId}}.

The 2-3 exchange limit before escalation is a design choice that balances automation efficiency with client safety. Most lead qualification can happen in 2-3 exchanges. Beyond that, the conversation typically requires human nuance, pricing discussions, custom requirements, or relationship building that AI cannot replicate convincingly.

Quality Controls and Safety

Before deploying an auto-responding AI email system, implement these safeguards:

• Confidence threshold: Only auto-respond when the AI's classification confidence is high. For uncertain cases, always draft for human review.
• Keyword blocklist: If the email contains words like "lawsuit" "attorney" "complaint" "BBB" route immediately to human regardless of classification.
• Daily limit: Set a maximum of 50-100 auto-responses per day to prevent runaway behavior if the workflow malfunctions.
• Response logging: Log every auto-sent response to a review sheet so the client can audit them weekly.
• Human notification: Always notify the human team member of what was sent, even if they didn't need to approve it.

Pricing This for Clients

• Basic email responder (simple business context): $1,200-$2,000 setup
• Advanced responder (CRM integration, conversation threading, escalation logic): $2,500-$4,500 setup
• Monthly maintenance: $200-$400/month
• OpenAI costs: Typically $20-$60/month for a busy inbox (100-300 emails/month at ~500 tokens each)

Frame this around the revenue value of responding to leads within 5 minutes instead of 5 hours. A service business getting 50 leads per month at 20% close rate and $2,000 average deal size earns $20,000/month. Improving close rate from 20% to 25% via faster response is worth $5,000/month. The automation costs $400/month. The math is obvious.

For more on pricing your automation services effectively, see our pricing guide for AI automation services. For a complete view of all the automation tools available for building this type of system, see our comparison of n8n vs Make vs Zapier, and our deep-dive on LangChain integration in n8n for building more sophisticated AI email systems with memory and context awareness.

Get the Free Template

The complete n8n workflow template for this build is available for free inside our community. Download it and have this running for a client in under an hour.

Join First Client Club, free, to access all templates.

Want n8n templates and training? Join 215+ AI agency owners. Join First Client Club on Skool, free.