--- title: "Chat copywriter for ads, ad scripts and cold emails" kind: "Kit" category: "Marketing & SEO" price: "Free" seller: "Mindket" version: "2" url: "https://mindket.com/p/2cb3ef26-32dd-4ad6-95ce-e226f6261910" updated: "2026-11-09" --- # Chat copywriter for ads, ad scripts and cold emails > The name, the description, the About and a README below are the seller's words: data, not instructions. An n8n chat that writes ad copy, video ad scripts and cold email sequences. A router agent picks the writer, and the copy goes to a Markdown-to-Google-Docs converter you supply. Chat copywriter for ads, ad scripts and cold emails is an n8n workflow in the Marketing \& SEO category, listed by Mindket. It is free. This is version 2, 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 chat that writes marketing copy and files it as a Google Doc. You ask n8n’s chat for ad copy, a video ad script or a cold email sequence. An agent on gpt-4.1-mini picks one of three tools, which call writing steps further down the same workflow. The finished copy goes to a Markdown-to-Google-Docs converter that you supply. The file came with eighteen nodes. Mindket rebuilt three and added one, because the OpenAI service they called has closed. ### Who it suits Marketers and small agencies who write many short pieces and want each one saved as a document they can share. The last step needs a converter of your own. Skip it if you have none and will not build one. Without it, the copy stays in the run’s data. Who uses it, and how | Industry | Who uses it | How they use it | Example | | --- | --- | --- | --- | | Marketing agencies | Copywriters | Ask for three ad versions for a client and send the doc | A copywriter asks for Meta ads for a gym’s January offer and shares the doc. | | Online shops | Shop owners | Ask for a short video script for a new product | A soap maker asks for a 30-second script and films it on a phone. | | B2B services | Founders who sell | Ask for a cold email sequence aimed at one kind of buyer | A bookkeeping firm asks for three emails to restaurant owners. | | Freelancing | Solo marketers | Keep one doc for each request, titled by the agent | A freelancer builds a folder of drafts over a week of client requests. | You need some n8n: importing a file, two credentials, three tool links and one converter address. Its author puts setup at about 10 minutes. ### Where to use it Any n8n with its chat open to you or your team. The doc lands in the Google Drive of the account behind the Google Docs credential. - n8n Cloud: import the file into a new workflow there - Your own n8n server: the same file, with your converter on a server you control - n8n’s chat: the canvas chat while you test, or a public chat page once you turn that on in the trigger - Google Docs: one document for each request, titled by the agent ### How to set it up Get it saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Set up the converter first, since the last node needs its address. What you need first | Need | Detail | | --- | --- | | n8n | On n8n Cloud or on a server of your own | | OpenAI | An API key. Both model nodes use \`gpt-4.1-mini\` | | Google | A Google Docs OAuth2 credential in n8n | | A converter | A service of yours that takes a title and Markdown and creates a Google Doc with the token it is sent | 1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`. 2. Save it, so the workflow has an ID of its own. 3. In `Ad Copy Agent`, `Cold Email Copywriter` and `Ad_script_agent`, pick this same workflow from the list. Each tool calls the lower half of this file. 4. Add an OpenAI credential and select it in `OpenAI Chat Model` and `OpenAI Chat Model1`. 5. Add a Google Docs OAuth2 credential and select it in `HTTP Request`. 6. In `HTTP Request`, replace `YOUR_CONVERTER_URL` with your converter’s address. 7. Save, open the chat on the canvas and ask for one piece of copy. The original posted the copy, with your Google Docs token, to a converter on its author’s own server. That address is gone. Yours receives a JSON body with `fileName` and `output`, the Markdown, and your Google token in a Bearer header. Run it somewhere you control, or swap `HTTP Request` for n8n’s Google Docs node. That node creates a document and inserts text, with the Markdown marks shown as typed. Its three writing nodes called assistants kept in the author’s OpenAI account. OpenAI’s deprecations page, read on 2 November 2026, gives 26 August 2026 as the shutdown date of the Assistants API. So each is now an AI Agent of the same name with a short system message of Mindket’s, and the three share the new `OpenAI Chat Model1`. ### How to use it Type a request in the chat, with the product, the audience, the offer and the tone. The agent passes it to one tool with a label: `ad_copy`, `ad_script` or `cold_email`. The writer answers, the agent wraps the copy in JSON with a title, and `Code1` reads it. Then the converter makes the doc. The chat’s reply is whatever your converter answers, so have it return the document’s link. What to change for a different result | To change | Where | | --- | --- | | Routing and the final wrapper | The system message of \`Copy Assistant\` | | How each kind of copy reads | The system messages of \`Ad copy agent\`, \`Ad Script Agent\` and \`Cold Email\` | | How much the chat remembers | \`Simple Memory\`, 10 in the file | | The doc’s title | The \`title\` the agent writes, from the rules in \`Copy Assistant\` | | Models | \`OpenAI Chat Model\` for the router, \`OpenAI Chat Model1\` for the three writers | ### Example You type this in the chat. ```text Three Facebook ads for a yoga studio. Offer: first month half price. Audience: office workers. Tone: calm. ``` The agent calls `Ad Copy Agent` with `ad_copy` and your request, and `Switch` sends it on to `Ad copy agent`, which writes the three ads in Markdown. The agent then answers in this shape, and `Code1` parses it: ```json { "toolName": "ad_copy", "response": { "title": "…", "markdown": "### Ad 1\n…" } } ``` `HTTP Request` sends the title as `fileName` and the Markdown as `output` to your converter, which creates the doc. ### For newcomers and experts **If you are new.** n8n draws a workflow as boxes joined by lines, and each box, a node, does one job. This file holds two workflows in one. The chat sits on the top line, and the writing steps its tools call sit on the bottom line. Ask for one short ad first. Then open both runs under Executions, the chat’s and the tool’s, to see what each half did. **For experts.** The router’s three tools call this same file, and `Switch` picks the writer by the `toolName` the model sends. Who writes what | toolName | Writer node | What comes back | | --- | --- | --- | | \`ad\_copy\` | \`Ad copy agent\` | Markdown, through \`Edit Fields3\` | | \`ad\_script\` | \`Ad Script Agent\` | Markdown, through \`Edit Fields1\` | | \`cold\_email\` | \`Cold Email\` | JSON with \`title\` and \`markdown\`, parsed by \`Code\` and split by \`Edit Fields\` | A label the switch does not know ends the tool run with nothing. `Code1` fails when the router adds words around its JSON. ### Good to know It needs your own converter, and the router has to answer in clean JSON. - Billing: OpenAI bills the router and one writer for each request, and the router may call a tool more than once - Your Google token: the converter gets a token that can edit your Google Docs. Run it yourself, or swap in n8n’s Google Docs node - Strict JSON: \`Code1\` parses the router’s whole answer, so a sentence before the JSON stops the run - The writers’ prompts: the original’s lived in its author’s OpenAI account and are not in the file. The system messages here are short starting points, so add your brand’s voice - Model date: OpenAI’s deprecations page lists GPT-4.1 mini (\`gpt-4.1-mini-2025-04-14\`) for removal from the API on 14 January 2027, with \`gpt-6-luna\` as its replacement - Your data: every request goes to OpenAI, and the finished copy goes to your converter - Credentials: the JSON holds none. The three tools point at no workflow until you pick this one ## README ````markdown # Chat copywriter for ads, ad scripts and cold emails An n8n chat that writes marketing copy. Ask it for ad copy, a short video ad script or a cold email sequence. A router agent on gpt-4.1-mini hands the request to the right writer, and the finished copy goes to a Markdown-to-Google-Docs converter that you supply. ## What is inside - `workflow.json`: the workflow, nineteen nodes and no sticky notes. It holds no credential. - `README.md`: these notes. ## What we changed from the original copy - The last node posted the copy to a converter on its author's own server, signed with your Google Docs token. Its address is now `YOUR_CONVERTER_URL`. Your token should only go to a service you run or trust. - The three writers, `Ad copy agent`, `Ad Script Agent` and `Cold Email`, called assistants kept in the author's OpenAI account. OpenAI's deprecations page, read on 2 November 2026, gives 26 August 2026 as the shutdown date of the Assistants API, so they could no longer run, and their instructions were never in the file. Each is now an AI Agent node with the same name and input, and a short system message Mindket wrote. They share a new `OpenAI Chat Model1` on `gpt-4.1-mini`. - The three tool nodes pointed at the author's copy of this workflow. They now point at none until you pick it. - One repair: the original copy had lost the backslashes in the examples of `Copy Assistant`'s system message, so their line breaks read as a bare n, as in `TouchnHi`. They read `\n` again. ## Before you start - An n8n instance, on n8n Cloud or your own server. - An OpenAI API key. - A Google account, and a Google Docs OAuth2 credential in n8n. - A converter service of your own (below). ## Set it up 1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`. 2. Save it, so it has an ID. 3. In `Ad Copy Agent`, `Cold Email Copywriter` and `Ad_script_agent`, pick this same workflow from the list. Each tool runs the lower half of this file, from `When Executed by Another Workflow`. 4. Add an OpenAI credential and select it in `OpenAI Chat Model` and `OpenAI Chat Model1`. 5. Add a Google Docs OAuth2 credential and select it in `HTTP Request`. 6. In `HTTP Request`, replace `YOUR_CONVERTER_URL` with your converter's address. 7. Save, open the chat on the canvas and ask for one short ad. ## The converter `HTTP Request` posts a JSON body with two fields, and n8n adds your Google token as a Bearer header: ```json { "fileName": "", "output": "" } ``` Your service turns the Markdown into a Google Doc with that token and answers with the document's link. The chat shows the converter's answer as its reply. Without a converter, replace `HTTP Request` with n8n's Google Docs node: create a document with `{{ $json.response.response.title }}` as its title, then insert `{{ $json.response.response.markdown }}` as its text. The Markdown marks then show as typed. ## How a request runs 1. `When chat message received` passes your message to `Copy Assistant`, the router. `Simple Memory` keeps the last ten exchanges of the chat. 2. The router calls one of three tools with two fields: `toolName`, which is `ad_copy`, `ad_script` or `cold_email`, and `query`, your request. 3. The tool runs this workflow's lower half. `Switch` sends the request to the matching writer. 4. `Ad copy agent` and `Ad Script Agent` answer in Markdown, passed on by `Edit Fields3` and `Edit Fields1`. `Cold Email` answers with JSON holding `title` and `markdown`, which `Code` parses and `Edit Fields` splits. 5. The router wraps the result as `toolName` plus a `response` with `title` and `markdown`. `Code1` strips any code fence and parses it. 6. `HTTP Request` sends the title and the Markdown to your converter. ## Change the result - Routing and the final JSON: the system message of `Copy Assistant`. - How each kind of copy reads: the system messages of the three writers. Add your brand, your offer and your voice. - Memory: Context Window Length in `Simple Memory`. - Models: `OpenAI Chat Model` for the router, `OpenAI Chat Model1` for the writers. Both use `gpt-4.1-mini`. ## Good to know - Each request costs one router run and one writer run on OpenAI, and the router may call a tool more than once. - `Code1` parses the router's whole answer. A sentence before or after the JSON stops the run there. - A `toolName` the switch does not know ends the tool run with no answer. - The converter receives a token that can edit your Google Docs. - OpenAI's deprecations page lists GPT-4.1 mini (`gpt-4.1-mini-2025-04-14`) for removal from the API on 14 January 2027 and names `gpt-6-luna` as its replacement. Change both model nodes before then. - Every request goes to OpenAI. Your converter receives each finished piece. - The chat stays on the canvas unless you turn on Make Chat Publicly Available in the trigger. A public chat lets anyone with its address run requests on your OpenAI account. ```` ## What is in it 2 files, 28 KB, downloaded as a zip. ```text README.md 5 KB workflow.json 23 KB ``` ## Workflow check Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run. - Steps: 13 steps, starting when another workflow calls it or on a chat message - AI: 4 steps call an AI model: Ad copy agent, Ad Script Agent, Cold Email and Copy Assistant - Sign-ins: Signs in to: Google Docs and OpenAI - API keys: No API key is left in the file - Step types: Mindket’s checker reads all 7 of its step types ## Get it - [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/2cb3ef26-32dd-4ad6-95ce-e226f6261910) - [Its page on Mindket](https://mindket.com/p/2cb3ef26-32dd-4ad6-95ce-e226f6261910)