n8n Email Automation: Setup, Example Flow & AI Replies

Somewhere on your team, someone is sending the same follow-up email for the fortieth time this week, and forgetting the forty-first. That is exactly the job n8n takes off their plate. (Curious what n8n costs at your volume? See the n8n pricing guide or the free cost calculator.)

I build these flows for clients constantly, and email is the single most common thing people ask me to automate. This guide covers the nodes that matter, a concrete example flow you can rebuild today, the deliverability traps that quietly kill these systems, and the point where an AI layer earns its keep.

The email nodes you'll use in n8n

n8n ships a handful of email-related nodes. You don't need all of them. Here's what each one is for.

A few practical notes from doing this in the wild:

• Gmail is the right choice when the inbox lives in Google Workspace and you want two-way control: read a thread, generate a reply, and save it as a draft for review. Authentication is OAuth2, so no app passwords.
• SMTP is the workhorse for sending. It doesn't care who your provider is. If you can get SMTP credentials, n8n can send through it.
• Email Trigger (IMAP) is how you catch incoming mail. One gotcha that bites people: long-lived IMAP connections die silently. In the node options, set Force Reconnect Every Minutes to around 10 to 15 so n8n resets the connection before it goes stale. Without it, the workflow looks healthy and just stops receiving mail.
• HTTP Request is your escape hatch. The cold-outreach tools (Instantly, Smartlead, Apollo) are usually driven through their APIs, and the HTTP node handles that fine.

Five email jobs worth automating

Before the example, here's the map. These are the patterns I see pay off most often.

1. Outreach sequences: a multi-step send with delays between touches, pulling contacts from a sheet, CRM, or scraper.
2. Lead follow-ups: someone fills a form or books a call, and they get the right message at the right interval automatically.
3. Internal alerts and notifications: a deal closes, a payment fails, a high-value form comes in, and the team gets pinged by email (or Slack) instantly.
4. Parsing inbound email: incoming messages get read, classified, and turned into structured data: a CRM record, a ticket, a row in a database.
5. AI-drafted replies: the model reads an inbound message and writes a context-aware response, either auto-sent or queued as a draft.

The first three are pure plumbing and you should build them with no AI at all. The last two are where a language model changes what's possible.

A simple example flow: lead form to follow-up sequence

Here's a flow you can rebuild in under an hour. The job: a new lead submits a form, gets an immediate confirmation, and then a follow-up two days later if they haven't replied.

Step 1: Trigger. Start with a Webhook node (or a Form Trigger if you're using n8n's built-in forms). Point your website form at the webhook URL. Every submission now fires the workflow with the lead's name, email, and message.

Step 2: Store the lead. Add a node to write the record somewhere durable: Google Sheets, Airtable, Supabase, or your CRM. This matters for the dedup and follow-up logic later, and it gives you a source of truth outside n8n.

Step 3: Send the confirmation. Use the Gmail or Send Email (SMTP) node. Pull the lead's name into the subject and body with an expression like {{ $json.name }}. Keep this one plain and personal. It's the first thing they see.

Step 4: Wait. Drop in a Wait node set to 2 days. n8n pauses the execution and resumes it on schedule without holding resources open.

Step 5: Check for a reply. This is the step people skip, and it's the one that keeps you from looking like a robot. Use a Gmail node (Get Many, filtered by the thread or sender) or an IMAP search to see whether the lead has responded. Feed that into an IF node.

Step 6: Branch. If they replied, stop, or route to a human. If they didn't, send follow-up number two. Done.

That's six nodes for a follow-up system most teams pay a SaaS subscription for. If you want to go deeper on building reliable workflows like this, my n8n consultant page covers how I approach it for clients.

Deliverability: the part that quietly breaks everything

You can build a flawless workflow and still land in spam. Automation makes sending easy, which makes it easy to send badly. A few non-negotiables for 2026:

• Set up SPF, DKIM, and DMARC. All three are mandatory now, not optional. Google and Yahoo's bulk-sender rules expect proper authentication, and missing records are the fastest way to the spam folder. Configure them on the sending domain before you send a single automated email.
• Respect send limits. For cold outreach, the safe ceiling is roughly 50 to 100 emails per mailbox per day, and that cap includes any warmup traffic. Going higher without a warmed domain trips rate limiting and spam classification. To scale, rotate across multiple mailboxes (3 to 5 inboxes per domain) rather than hammering one.
• Warm new domains slowly. A fresh sending domain needs about three weeks of ramp-up, starting around 5 emails a day and building toward 35 to 50 by week four. Don't point a cold-start automation at a brand-new domain and open the floodgates.
• Watch your complaint rate. Google wants bulk senders to stay under a 0.3% spam complaint rate, which is just 3 complaints per 1,000 emails. Cross it and you risk the whole domain getting blocked from Gmail. Make unsubscribing easy and stop emailing people who don't engage.
• Separate your domains. Never run cold outreach from the domain you use for real business email. If outreach torches your reputation, you don't want your invoices and client replies going down with it. Use a separate sending domain.

None of this is exotic. It's the difference between a system that works for years and one that gets your main domain blacklisted in a month.

When to add an AI layer (and when not to)

AI is the part everyone wants to start with. It's usually the part you should add last.

For the plumbing jobs (sending, scheduling, alerting, branching on whether someone replied), a language model adds cost, latency, and a new failure mode for zero benefit. Rules are predictable. Use them.

Add an AI step when the work depends on understanding the content of a message. Two cases earn it:

Parsing and routing inbound mail. When messages arrive in plain language and need to be sorted, an AI classifier reads the subject and body and tags each one (support, sales, billing, spam) so the right branch fires. n8n's Text Classifier and AI Agent nodes wrap this cleanly. For pure classification you don't need a frontier model; a fast, cheap one handles it well and keeps costs near nothing at volume.

Drafting replies. This is the high-value case. The model reads an inbound email, pulls in context (the customer's history, a knowledge base, the order details), and writes a tailored response. The pattern I recommend almost every time: draft, don't auto-send. Have n8n create a Gmail draft and notify a human to approve it. This is the human-in-the-loop setup, and it gives you the speed of automation with a safety net against the model saying something wrong to a real customer. Once you trust the outputs on a narrow category, you can let those auto-send.

To set up the OpenAI step itself, my ChatGPT automation guide for n8n walks through it, with a lead-qualifier example.

If you're weighing whether to build this on n8n versus a no-code tool, the trade-offs are real and I broke them down in n8n vs Zapier for business. For anything involving an AI layer over your email, the AI automation consultant page is the better starting point.

A sensible build order

If you're starting from scratch, build in this sequence. It keeps each stage testable and stops you from debugging five things at once.

1. Get one email sending through Gmail or SMTP from a manual trigger. Confirm it arrives and isn't in spam.
2. Wire the real trigger (webhook, form, or schedule) and pass live data into the email.
3. Add storage and dedup so you never email the same person twice by accident.
4. Add the wait-and-check branch for follow-ups.
5. Lock down deliverability: SPF, DKIM, DMARC, sane limits.
6. Only then, add AI for parsing or drafting, and keep a human in the loop until you trust it.

Most of the value lands in steps one through five. The AI is the cherry, not the cake.

The bottom line

n8n is a strong fit for email automation because it handles the boring, reliable parts (sending, scheduling, branching, deduping) and the smart parts (classifying and drafting with AI) on the same canvas, and you can self-host it to skip per-task pricing entirely. Start with the plumbing, get deliverability right, and add a language model only where understanding the message matters.

If you'd rather have this built and running than spend a weekend wiring nodes, book a 30-minute call and we'll map the flow that fits how your team already works.