how to use the n8n ai agent email node (step-by-step)

Most n8n tutorials show you how to send a notification email or forward a form submission. That's fine for static workflows. But the moment you wire an AI Agent node into the mix, the rules change. Your workflow stops being a fixed pipeline and starts making decisions: which emails to reply to, what to say, who to escalate to, and when to stay quiet.

The n8n AI Agent node is what makes this possible. And the Send Email node is how the agent actually acts on those decisions. Getting them to work together isn't hard, but there are a few places where things break if you don't know what to expect.

This guide walks through the full setup, from trigger to send, with the specific field mappings and error handling that the official docs gloss over.

What the n8n AI Agent node actually does#

A regular n8n Function node runs JavaScript you write. It's predictable. You define the logic, and the node executes it the same way every time.

The AI Agent node is different. It takes an input (like an email body), sends it to a language model (OpenAI, Anthropic, DeepSeek, or others), and returns a response that depends on context. You give it a system prompt describing its role, connect it to tools it can call, and let it reason about what to do next.

For email workflows, this means the agent can read an incoming message, decide whether it's a support request or a sales inquiry, draft a reply in the right tone, and pass that reply to the Send Email node. The logic isn't hardcoded. It adapts.

The tradeoff is that you need to handle variability. The agent might format its output differently between runs, skip a field, or hallucinate a recipient address. Good n8n email workflows account for this with validation nodes between the agent and the send step.

How to connect the email node to an AI agent in n8n#

Here's the core wiring, broken into steps you can follow on your own canvas:

1. Add a trigger node (Gmail Trigger, IMAP Email, or a Webhook node) to start the workflow when a new email arrives.
2. Add the AI Agent node and connect it to the trigger. Set your model provider (OpenAI, Anthropic, etc.) and write a system prompt that describes the agent's job.
3. Feed the email fields into the agent's input. Map subject, from, and text (or html) from the trigger output into the agent's prompt using n8n expressions like {{ $json.subject }}.
4. Add a Send Email node (SMTP) or Gmail node after the agent. Map the agent's output fields to To, Subject, and Body using expressions.
5. Configure your SMTP credentials on the Send Email node (host, port, username, password) or authenticate with OAuth for Gmail.
6. Add a Set node between the agent and Send Email to validate that required fields (to, subject, body) exist and aren't empty.
7. Test with a single known recipient before enabling production triggers.

That sixth step is the one most tutorials skip. Without it, you'll hit the infamous No recipients defined error the first time your agent returns an output that doesn't perfectly match the expected field names.

Reading and classifying inbound email with AI#

One of the most practical uses for the n8n AI Agent email node is sorting incoming mail by category before your team ever sees it. Instead of building regex filters or keyword rules, you hand the email to the agent and let it classify.

A typical system prompt for this looks something like:

You are an email classifier. Read the email below and respond with exactly
one of these categories: support, sales, billing, spam, other.

Do not explain your reasoning. Just output the category name.

The key detail: tell the model to output only the category. If you let it explain itself, you'll get three paragraphs of reasoning that you then have to parse. Constraining the output format makes the downstream nodes much simpler.

After classification, use an n8n Switch node to route emails to different branches. Support tickets go to your ticketing system. Sales inquiries get a drafted response. Spam gets logged and discarded.

You can also layer in Retrieval-Augmented Generation (RAG) by connecting a vector store tool to the agent. This lets the agent pull context from your knowledge base, past tickets, or product docs before composing a reply. The quality improvement is significant: instead of generic responses, the agent writes replies grounded in your actual documentation.

Sending AI-generated replies without getting flagged#

Here's where things get practical. Your agent drafted a response. Now you need to actually send it without landing in spam or accidentally emailing the wrong person.

Validate before sending. Add a Function node between the agent and the Send Email node that checks:

const output = $input.first().json;

if (!output.to || !output.to.includes('@')) {
  throw new Error('Invalid or missing recipient address');
}

if (!output.body || output.body.length < 10) {
  throw new Error('Email body is empty or too short');
}

return [{ json: output }];
**Use SMTP over Gmail when possible.** The Gmail node is convenient, but Google enforces strict sending limits (500 emails per day for workspace accounts, less for free accounts). If your agent handles volume, dedicated SMTP infrastructure will save you from hitting walls at the worst time. You can configure the Send Email node with any SMTP provider.

**Add human-in-the-loop for high-stakes sends.** n8n has a built-in Wait node. Place it before the Send Email step, send the draft to Slack or a review dashboard, and pause the workflow until a human approves. This is especially worth doing during the first week of any new agent workflow, while you're still tuning the system prompt.

Passing dynamic data between nodes#

One question that comes up constantly: how do I get values from the AI agent's output into the Send Email node's fields?

In n8n, you reference upstream node output with expressions. If your AI Agent node is named "AI Agent" and its output JSON has a to field, you'd set the Send Email node's recipient to:

{{ $('AI Agent').first().json.to }}

The same pattern works for subject, body, and any other field. The trick is knowing exactly what your agent outputs. Add a Debug node right after the AI Agent during development. It'll show you the raw JSON structure so you can write accurate expressions instead of guessing.

If your agent returns the entire reply as a single text block (common with simpler prompts), you can still use it. Just map the full output to the email body and hardcode the subject line and recipient from the original trigger data.

Scaling past Gmail limits#

Gmail caps sending at 500 messages per day on Google Workspace and even less on free accounts. For personal projects, that's fine. For an AI agent handling customer inquiries or processing inbound leads across multiple campaigns, you'll burn through that quota by lunch.

Your options: use dedicated SMTP infrastructure, rotate across multiple sending accounts, or move to an email service with higher limits. The Send Email node in n8n works with any SMTP server, so switching providers doesn't require rebuilding your workflow. You just update the credentials.

If you're building agents that need their own isolated email identities (separate addresses, separate sending reputations), that's where purpose-built agent email infrastructure like LobsterMail comes in. Each agent gets its own inbox and sending identity without sharing quotas or credentials with your personal accounts.

Tracking and closing the loop#

One gap in most n8n email agent setups: there's no feedback loop. The agent sends an email and has no idea whether it was opened, replied to, or bounced.

For basic tracking, you can poll the inbox for replies using a scheduled trigger and match them against sent messages by thread ID or subject line. For bounce handling, configure your SMTP provider to forward bounce notifications to an inbox your workflow monitors.

The more sophisticated version connects your agent's send history to a simple database (Postgres, Airtable, or even a Google Sheet) and updates the record when a reply arrives. This gives the agent context for follow-up decisions: did the customer respond? Should we send a reminder? Has this thread gone cold?

Building this loop takes an extra hour of setup. It makes the difference between an agent that sends emails into the void and one that actually holds a conversation.