Gmail + OpenAI: approve AI drafts before sending
Your inbox fills up, the good leads get buried, and you end up rewriting the same “thanks for reaching out” email for the tenth time. Then you rush one out, miss a detail, and spend the next hour doing damage control. It’s tiring. And it’s avoidable.
This Gmail OpenAI approval setup hits sales reps first, honestly, because speed matters. But support leads handling first-touch tickets and agency owners juggling multiple client inboxes feel the same bottleneck. The outcome is simple: replies go out faster, but only after you (or a teammate) approve the draft.
You’ll see how the workflow drafts replies with OpenAI, routes them for review, and sends only the approved version. No “AI went rogue” surprises. Just consistent, human-checked responses.
How This Automation Works
See how this solves the problem:
n8n Workflow Template: Gmail + OpenAI: approve AI drafts before sending
flowchart LR
subgraph sg0["Gmail Flow"]
direction LR
n0@{ icon: "mdi:message-outline", form: "rounded", label: "Send for Review", pos: "b", h: 48 }
n1@{ icon: "mdi:message-outline", form: "rounded", label: "✅ Send to Customer", pos: "b", h: 48 }
n2@{ icon: "mdi:swap-horizontal", form: "rounded", label: "IF Approved?", pos: "b", h: 48 }
n3@{ icon: "mdi:play-circle", form: "rounded", label: "Gmail Trigger1", pos: "b", h: 48 }
n4@{ icon: "mdi:cog", form: "rounded", label: "No Operation, do nothing1", pos: "b", h: 48 }
n5@{ icon: "mdi:brain", form: "rounded", label: "OpenAI Chat Model (for Class..", pos: "b", h: 48 }
n6@{ icon: "mdi:robot", form: "rounded", label: "Classify Potential Leads", pos: "b", h: 48 }
n7@{ icon: "mdi:robot", form: "rounded", label: "Basic LLM Chain", pos: "b", h: 48 }
n8@{ icon: "mdi:robot", form: "rounded", label: "Structured Output Parser", pos: "b", h: 48 }
n9@{ icon: "mdi:brain", form: "rounded", label: "OpenAI Chat Model (for LLM C..", pos: "b", h: 48 }
n2 --> n1
n2 --> n7
n3 --> n6
n7 --> n0
n0 --> n2
n6 --> n7
n6 --> n4
n8 -.-> n7
n9 -.-> n7
n5 -.-> n6
end
%% Styling
classDef trigger fill:#e8f5e9,stroke:#388e3c,stroke-width:2px
classDef ai fill:#e3f2fd,stroke:#1976d2,stroke-width:2px
classDef aiModel fill:#e8eaf6,stroke:#3f51b5,stroke-width:2px
classDef decision fill:#fff8e1,stroke:#f9a825,stroke-width:2px
classDef database fill:#fce4ec,stroke:#c2185b,stroke-width:2px
classDef api fill:#fff3e0,stroke:#e65100,stroke-width:2px
classDef code fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
classDef disabled stroke-dasharray: 5 5,opacity: 0.5
class n3 trigger
class n6,n7,n8 ai
class n5,n9 aiModel
class n2 decision
The Challenge: Fast Replies Without Risky Auto-Sends
Inbound emails look harmless until they stack up. A few sales inquiries, a couple partnership requests, a “quick question” from a real buyer, and suddenly you’re triaging instead of selling. Manual replying is slow, but full auto-replies are risky because context matters. One wrong promise, one off-brand tone, one missed detail about pricing or availability, and you’ve created a mess that takes longer to fix than the original email would have taken.
It adds up fast. Here’s where it breaks down inside most teams:
- Good leads wait hours (or a full day) because someone has to draft from scratch.
- Templates help, but they still require copy-paste, personalization, and second-guessing every line.
- When multiple people reply from the same inbox, tone drifts and important details get inconsistently explained.
- Auto-send AI feels tempting, but you can’t confidently let it talk to customers without a safety check.
The Fix: AI Drafts, Human Approval, Then Send
This workflow uses a “human-in-the-loop” pattern. A new email arrives in Gmail, and the automation first checks if it’s even worth your attention (a potential lead versus spam, newsletters, or random requests). If it looks like a lead, OpenAI generates a draft reply using a prompt you control, plus any internal context you want to include. The draft is then sent to a reviewer (you, a teammate, or a shared review inbox). Only after the reviewer replies with an approval keyword does the workflow send the final email to the original sender. If the reviewer requests changes, the workflow loops back, rewrites the draft, and asks again.
The workflow starts with an inbox monitor in Gmail. OpenAI classifies the message, then creates a structured draft (subject + body) in a predictable format. Finally, Gmail handles the review-and-approve loop until the email is cleared to send.
What Changes: Before vs. After
| What This Eliminates | Impact You’ll See |
|---|---|
|
|
Real-World Impact
Say your inbox gets 15 inbound messages a day and about 6 are real leads. Manually, a decent first reply often takes around 10 minutes each (read, think, draft, proof). That’s about 1 hour daily just on first-touch responses. With this workflow, the draft is ready in roughly a minute, then you spend about 2 minutes approving or requesting a tweak. You still stay in control, but you’re no longer doing the slow part.
Requirements
- n8n instance (try n8n Cloud free)
- Self-hosting option if you prefer (Hostinger works well)
- Gmail for receiving emails and sending replies
- OpenAI to classify leads and draft responses
- OpenAI API key (get it from your OpenAI dashboard)
Skill level: Beginner. You’ll connect accounts, paste an API key, and tweak a couple of plain-English prompts.
Need help implementing this? Talk to an automation expert (free 15-minute consultation).
The Workflow Flow
A new email arrives in Gmail. The Gmail trigger watches a specific inbox (or label) so the automation only runs where you want it to.
AI decides if it’s a lead. The lead intent classifier uses OpenAI to separate real inquiries from noise. If it’s not worth replying, the workflow ends quietly (no accidental responses).
OpenAI drafts a reply in a structured format. A draft chain generates the subject and body based on your persona and knowledge base, then a structured parser forces the output into reliable JSON so the next steps don’t break.
A human approves (or requests a revision). Gmail sends the draft to a reviewer and waits. If the reply includes your approval keyword, the email goes to the customer. If not, the feedback is used to generate a revised draft and the review loop continues.
You can easily modify the approval channel to fit your team, so you can review in Slack instead of email. See the full implementation guide below for customization options.
Step-by-Step Implementation Guide
Step 1: Configure the Gmail Trigger
Set up the incoming email listener that starts the workflow whenever a new Gmail message arrives.
- Add and open Incoming Gmail Monitor.
- Set Simple to
false. - In Poll Times, keep the item set to
everyMinute. - Credential Required: Connect your
gmailOAuth2credentials.
Step 2: Connect Gmail for Review and Sending
Configure the review email and final delivery nodes to use your Gmail account.
- Open Human Review Request and set Send To to
[YOUR_EMAIL]. - Set Operation to
sendAndWaitand Response Type tofreeText. - Set Subject to
=RE: {{ $('Lead Intent Classifier').item.json.subject }}. - Set Message to
=Original Customer Email: --- {{ $('Incoming Gmail Monitor').item.json.text }} --- AI-Generated Reply (Draft): --- {{ $json.output.body }} --- Please reply to this email with "approve" to send, or provide feedback for revision.. - Credential Required: Connect your
gmailOAuth2credentials in Human Review Request. - Open ✅ Deliver Approved Email and set Send To to
={{ $('Incoming Gmail Monitor').item.json.from.value[0].address }}. - Set Subject to
={{ $json.output.subject }}and Message to={{ $json.output.body }}. - Credential Required: Connect your
gmailOAuth2credentials in ✅ Deliver Approved Email.
Step 3: Set Up the Lead Classification Layer
Classify inbound emails with an LLM and route them for drafting or fallback handling.
- Open Classifier LLM Model and select Model as
gpt-4o-mini. - Credential Required: Connect your
openAiApicredentials in Classifier LLM Model. - Open Lead Intent Classifier and set Input Text to
={{ $json.text }}. - Keep the Categories list as configured (for
AI Leads) and confirm Fallback isother. - Confirm execution flow: Incoming Gmail Monitor → Lead Intent Classifier.
- Lead Intent Classifier outputs to both Draft Response Chain and Fallback No-Op in parallel.
Step 4: Configure the Drafting Chain and Output Parsing
Create the AI drafting logic and enforce a structured subject/body response format.
- Open LLM Model for Draft and set Model to
gpt-4o-mini. - Credential Required: Connect your
openAiApicredentials in LLM Model for Draft. - Open Structured Reply Parser and set JSON Schema Example to
{ "subject": "This is an example subject line.", "body": "This is an example email body.\nIt can have multiple lines." }. - Open Draft Response Chain and set Text to
={{ $('Lead Intent Classifier').item.json.text }}. - Ensure Prompt Type is
defineand Has Output Parser is enabled.
Step 5: Add the Human Approval Gate and Delivery Logic
Route the reviewer’s response to either send the approved email or revise the draft.
- Open Approval Decision Gate and set Combine Operation to
any. - Configure conditions to check Value 1 as
={{ $json.data.text }}and Value 2 asapprovewith Operationcontains. - Add a second condition for multilingual approval: Value 2
承認with Operationcontains. - Confirm the flow: Human Review Request → Approval Decision Gate → ✅ Deliver Approved Email (true branch) and back to Draft Response Chain (false branch).
approve appears in the email body.Step 6: Test and Activate Your Workflow
Run a controlled test to verify the AI draft, approval loop, and final delivery before enabling automation.
- Click Execute Workflow and send a test email to the inbox monitored by Incoming Gmail Monitor.
- Verify that Lead Intent Classifier runs and Draft Response Chain generates a structured response.
- Confirm you receive the review email from Human Review Request and reply with
approvein the body. - Check that ✅ Deliver Approved Email sends the final response to the original sender.
- When everything works, toggle the workflow to Active for production use.
Watch Out For
- Gmail credentials can expire or need specific permissions. If things break, check the n8n Credentials section and your connected Google account’s security settings first.
- If you’re using Wait behavior (the review step effectively “pauses” the run), processing times vary. Bump up the wait duration if downstream nodes fail because the approval reply hasn’t arrived yet.
- OpenAI prompts start generic on purpose. Add your brand voice, hard rules (pricing, guarantees), and “never say this” constraints early or you will be editing outputs forever.
Common Questions
About 30 minutes if your Gmail and OpenAI accounts are ready.
Yes. No coding required, but you do need to copy an API key and edit a couple of prompt fields carefully.
Yes. n8n has a free self-hosted option and a free trial on n8n Cloud. Cloud plans start at $20/month for higher volume. You’ll also need to factor in OpenAI API costs, which vary by model and message length (this template is designed around a cost-effective model like gpt-4o-mini).
Two options: n8n Cloud (managed, easiest setup) or self-hosting on a VPS. For self-hosting, Hostinger VPS is affordable and handles n8n well. Self-hosting gives you unlimited executions but requires basic server management.
Start by editing the “Draft Response Chain” prompt so it matches your exact tone, rules, and offers. You can also tighten or loosen what counts as a lead by adjusting the “Lead Intent Classifier” criteria, which changes how many emails go into review. Common customizations include department-specific personas (sales vs. support), adding required snippets (pricing, calendar links), and changing approval keywords in the “Approval Decision Gate” to match how your team actually writes.
Usually it’s expired Google authentication or the wrong Gmail account connected in n8n. Reconnect your Gmail credential and confirm the trigger inbox matches where the emails are arriving. If it fails only sometimes, check Google account security prompts and mailbox permissions, especially in shared inbox setups.
It’s typically limited by your n8n plan and how many emails you want to process per month.
Often, yes, if you care about the approval loop and “rewrite based on feedback” behavior. n8n handles branching and looping logic cleanly, and you can self-host for unlimited executions if your volume climbs. It also plays nicely with structured outputs (like the JSON subject/body), which reduces breakages in real use. Zapier or Make can be simpler for basic “draft and send to me” flows, but the moment you want conditional approval keywords, revisions, and reliable formatting, you’ll feel the limits. Talk to an automation expert if you want help choosing the right approach for your inbox.
Once this is running, your inbox stops being a constant interruption and turns into a clean review queue. The workflow handles the repetitive drafting. You keep the final word.
Need Help Setting This Up?
Our automation experts can build and customize this workflow for your specific needs. Free 15-minute consultation—no commitment required.