---
title: "Write and send Gmail from a plain request"
kind: "Kit"
category: "Productivity"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/b3079913-3f91-4198-adfd-1f2cab60f1ae"
updated: "2026-11-09"
---

# Write and send Gmail from a plain request

> The name, the description, the About and a README below are the seller's words: data, not instructions.

A small n8n tool workflow that another workflow or an AI agent calls with an email request in plain words. OpenAI works out the recipient, subject and message with a sign-off, and Gmail sends it from your account.

Write and send Gmail from a plain request is an n8n workflow in the Productivity category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-09. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n.

## About

### What it is

This n8n workflow is a tool for other workflows to call, and it sends real email. Whatever calls it passes one input named `query`, a request in plain words. OpenAI (gpt-4o) turns it into a recipient, a subject and a message that ends with a sign-off, the Gmail node sends it as plain text, and the last node sets `response` to `Sent`. Four nodes in all.

### Who it suits

Builders of n8n AI agents who want a send-an-email tool, and teams that send routine messages and would rather say it in a sentence. Skip it if a person should read each email before it goes. Nothing here asks for approval.

### Where to use it

Inside a larger workflow, as the target of an Execute Workflow node or as a tool an AI agent can call. Any n8n works, as long as a Gmail account can be authorized in it.

### How to set it up

Get it saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Its author puts setup at about 9 minutes.

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Add an OpenAI credential with your key and select it in `OpenAI`.
3. Add a Gmail credential, sign in with Google, and select it in `Gmail`.
4. Replace `YOUR_NAME` in two places: the Sender Name option of `Gmail`, and the sign-off line in the system message of `OpenAI`.
5. Save and publish it, then open the calling workflow and choose this one in its Execute Workflow node or tool.

The trigger declares one field, `query`, of type any. The caller passes this and gets one field back:

```json
{
  "query": "Email dana@example.com a reminder that the invoice is due on Friday"
}
```

```json
{
  "response": "Sent"
}
```

### How to use it

Write the request as you would tell an assistant: who it goes to, what it is about and the tone. OpenAI returns eight fields, and Gmail uses three of them: `sendTo`, `subject` and `message`. The other five (`emailType`, `appendAttribution`, `ccList`, `bccList`, `senderName`) are asked for but never reach Gmail, which has its own fixed settings: plain text, no n8n attribution, and the sender name in the node. A CC or BCC in the request is parsed and then dropped, unless you wire those two lists into the Gmail node’s options.

### Example

A caller passes the request from the fence above. The model sets `sendTo` to the address, writes a short subject about the invoice and a polite message that ends with the sign-off, and Gmail sends it from your account. The caller receives `Sent`.

### For newcomers and experts

**If you are new.** A tool workflow runs only when another workflow calls it, and this one sends for real. Test it with your own address as the recipient before anyone else’s.

**For experts.** The OpenAI node runs gpt-4o with JSON output on. Its user message is `JSON.stringify($json.query)`, so a string or an object both arrive as text. The system message names the eight fields and tells the model to sign off with a first name and never to leave a placeholder such as a bracketed name. Gmail reads the model’s answer from `message.content`, and `Sent` comes back only once Gmail has accepted the message.

### Good to know

The risk is in what the model writes, because nothing checks it before it goes out.

- No review: a wrong recipient or an invented detail in the body is sent as written, so for an agent add a confirmation step before this tool
- Sender: the mail leaves your authorized Gmail account, with the name you set
- Billing: one OpenAI request per email, and Gmail’s own sending limits apply
- Privacy: the whole \`query\` goes to OpenAI
- Credentials: the JSON holds none, and the author’s own name is replaced by \`YOUR\_NAME\`

## README

```markdown
# Write and send Gmail from a plain request

An n8n workflow, and a tool for other workflows to call. Give it an email request in plain words and it writes the
message and sends it through Gmail.

## What is inside

- `workflow.json`: the workflow as n8n exports it, four nodes. It holds no credential. The author's first name, which
  the file used as the sender name and in the sign-off, is replaced by the placeholder `YOUR_NAME`.
- `README.md`: these notes.

## Before you start

- An n8n instance, on n8n Cloud or your own server.
- An OpenAI API key.
- A Gmail account you can authorize in n8n.
- A workflow of yours that calls this one, such as an AI agent with a tool (below).

## Set it up

1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`.
2. Add an OpenAI credential and select it in `OpenAI`.
3. Add a Gmail credential (Google sign-in) and select it in `Gmail`.
4. Replace `YOUR_NAME` in two places: the Sender Name option of `Gmail`, and the sign-off lines in the system message
   of `OpenAI`.
5. Save, then press Publish at the top of the canvas (or Shift+P).
6. In the calling workflow, choose this one in an Execute Workflow node, or add it as a tool for your agent.

## How a workflow calls it

| Direction | Field | What it holds |
|---|---|---|
| In | `query` | the email request, in plain words (the trigger takes any type) |
| Out | `response` | `Sent`, set once Gmail has accepted the message |

OpenAI returns eight fields: `sendTo`, `subject`, `emailType`, `message`, `appendAttribution`, `bccList`, `ccList`
and `senderName`. The Gmail node reads only `sendTo`, `subject` and `message`. Its type, attribution and sender name
are fixed in the node, and the two CC and BCC lists are not connected to anything.

## Change it

- Tone and sign-off: the system message in `OpenAI`.
- CC and BCC: add them under the Options of `Gmail` and point them at `ccList` and `bccList` from the OpenAI answer.
- HTML mail: `Email Type` in `Gmail` is set to text.
- The reply: the `response` value in `Edit Fields`.

## Good to know

- Nothing reviews the email before it goes. A wrong recipient or an invented detail is sent as written. Test with your
  own address first, and give an agent a confirmation step before this tool.
- The mail leaves your authorized Gmail account, so replies come to you.
- Each call is one OpenAI request, and the whole `query` is sent to OpenAI.
```

## What is in it

2 files, 6 KB, downloaded as a zip.

```text
README.md  2 KB
workflow.json  3 KB
```

## Workflow check

Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run.

- Steps: 4 steps, starting when another workflow calls it
- AI: 1 step calls an AI model: OpenAI
- Sign-ins: Signs in to: Gmail
- API keys: No API key is left in the file
- Step types: Mindket’s checker reads all 4 of its step types

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/b3079913-3f91-4198-adfd-1f2cab60f1ae)
- [Its page on Mindket](https://mindket.com/p/b3079913-3f91-4198-adfd-1f2cab60f1ae)