Generate a Digital Product Multichannel Launch Copy Pack with n8n + OpenAI

Input product name, tagline, price, audience, and brand tone → n8n LLM chain calls GPT-4o-mini to generate blog, LinkedIn, X, Instagram, and email copy → optionally append to Google Sheets

Who

Digital product creators, indie sellers, or content operators who need consistent multichannel launch copy quickly

You get

One run produces 5 pieces of launch copy (blog intro, LinkedIn post, X post, Instagram caption, launch email) as plain-text JSON, reusable or archivable

You need

n8n · google-sheets

Steps

1. Prepare product input

   Execute the workflow manually in n8n. Review and replace the sample fields in the Set Product Data node: productName, tagline, price, productURL, targetAudience, and brandTone. You can edit the JSON directly or later replace this node with a real data source.

2. Generate launch copy

   The Create Launch Content node (Basic LLM Chain) concatenates product data into a text prompt and sends it to the OpenAI GPT-4 Model. The model uses responseFormat=json_object and temperature=0.7. The system prompt instructs the model to return strict JSON with exactly five keys—blog_intro, linkedin_post, x_post, instagram_caption, launch_email—each containing publish-ready copy that includes the product URL, matches the brand tone, and leads with benefits.

   Execution prompt · Source text。SystemMessagePromptTemplate message field of the Create Launch Content node

   Copy prompt

   You are an expert launch copywriter for digital products sold on Gumroad and Etsy.
   
   Return ONLY valid JSON, no markdown, no code fences, no prose, no explanation. The JSON object must contain exactly these keys: blog_intro, linkedin_post, x_post, instagram_caption, launch_email. Return exactly this json structure:
   
   {"blog_intro": "<200-word benefit-led blog intro that hooks the reader, focuses on outcomes not features, and ends with a clear CTA linking to the product URL>", "linkedin_post": "<150-200 word professional LinkedIn post; insight-led opening, 2-3 short paragraphs, closes with CTA including the product URL>", "x_post": "<punchy X/Twitter post under 240 characters total including the product URL; hook-first>", "instagram_caption": "<100-150 word Instagram caption; warm and vivid tone, 3-5 relevant hashtags at the end, CTA with product URL>", "launch_email": "<launch email where the first line is exactly 'Subject: [your subject line here]', then a blank line, then 200-250 word benefit-led body, clear CTA with product URL, warm sign-off>"}
   
   Rules:
   - Every single asset MUST include the exact product URL from the input.
   - Lead with benefits and transformation, never with feature lists.
   - Match the stated brand tone exactly.
   - Write real, publish-ready copy — no placeholders, no filler.
   - Output the JSON object only — nothing before or after it.

   Execution prompt · Source text。text field of the Create Launch Content node (n8n expression, rendered at runtime as the user message)

   Copy prompt

   ={{ "Product Name: " + $json.productName + "\nTagline: " + $json.tagline + "\nPrice: " + $json.price + "\nProduct URL: " + $json.productURL + "\nTarget Audience: " + $json.targetAudience + "\nBrand Tone: " + $json.brandTone }}

3. Format output

   The Format Launch Content node (Code node, JavaScript) receives the LLM response and handles two possible shapes: if OpenAI auto-parsed the JSON, the five keys are already at the top level of item.json; if the chain returned raw text, the code falls back to the text/output/response field, strips markdown fences, and JSON.parse it. It validates that all five required keys exist (throws if missing), coerces every value to a string, and returns clean JSON for downstream nodes.

   Execution prompt · Source text。jsCode field of the Format Launch Content node

   Copy prompt

   // Shape-agnostic reader for the Basic LLM Chain ('Generate Launch Content').
   // The Basic LLM Chain can hand us the data in EITHER of two shapes, depending
   // on the model's Response Format:
   //   PATH A (already-parsed): because OpenAI Chat Model has Response Format =
   //     JSON, the chain auto-parses the model's JSON and exposes the 5 content
   //     keys DIRECTLY at the top level of item.json. There is no `text` field.
   //   PATH B (text-to-parse): the chain returns the raw string under `text`
   //     (or `output` / `response`), which we must JSON.parse ourselves.
   // This code handles both without assuming which one occurred.
   const item = $input.first();
   const data = item.json || {};
   const required = ['blog_intro', 'linkedin_post', 'x_post', 'instagram_caption', 'launch_email'];
   
   // Coerce any value to a string so downstream nodes always get clean text,
   // even if the model returned a number, null, or an object for a field.
   function asString(v) { return (v === undefined || v === null) ? '' : String(v); }
   
   let parsed;
   let pathTaken;
   
   // PATH A — the 5 keys are already present at the top level: use them directly.
   if (required.some(function (key) { return key in data; })) {
     parsed = data;
     pathTaken = 'already-parsed';
   } else {
     // PATH B — fall back to a raw text field and parse it ourselves.
     const raw = data.text ?? data.output ?? data.response;
     if (raw === undefined || raw === null || raw === '') {
       throw new Error(
         'Could not find content. No top-level content keys and no text/output/response field. ' +
         'Received keys: ' + JSON.stringify(Object.keys(data))
       );
     }
     // The model may wrap JSON in markdown code fences (```json ... ```). Strip them.
     let cleaned = String(raw).trim()
       .replace(/^```(?:json)?\s*/i, '')  // opening fence
       .replace(/\s*```$/i, '')           // closing fence
       .trim();
     try {
       parsed = JSON.parse(cleaned);
     } catch (e) {
       throw new Error(
         'LLM did not return valid JSON. Parse error: ' + e.message +
         '\n--- Raw text received ---\n' + String(raw)
       );
     }
     pathTaken = 'text-to-parse';
   }
   
   // Only fail if a key is genuinely ABSENT. A present-but-empty value is fine.
   const missing = required.filter(function (key) { return !(key in parsed); });
   if (missing.length > 0) {
     throw new Error(
       'Content is missing required key(s): ' + missing.join(', ') +
       ' (path: ' + pathTaken + '). Received keys: ' + JSON.stringify(Object.keys(parsed))
     );
   }
   
   return [{
     json: {
       blog_intro: asString(parsed.blog_intro),
       linkedin_post: asString(parsed.linkedin_post),
       x_post: asString(parsed.x_post),
       instagram_caption: asString(parsed.instagram_caption),
       launch_email: asString(parsed.launch_email)
     }
   }];

4. Optional: append to Google Sheets

   To archive results, enable the Append Launch Content to Sheets node (disabled by default). Configure a Google Sheets OAuth2 credential, enter the target spreadsheet ID and sheet name (default Sheet1). The node uses autoMapInputData to map the five fields from the previous step as a new row. Note: first-time setup requires completing the Google OAuth2 authorization flow.

You are an n8n workflow setup assistant. The user wants to recreate the "Digital Product Multichannel Launch Copy Pack" template. Assist in this order:
1. Confirm the user has an n8n instance (cloud or self-hosted) and an OpenAI API key.
2. Guide importing the workflow JSON or installing template ID 16670 from the library.
3. Check the sample product data in the Set Product Data node and help replace it with real data.
4. Explain how to create and bind an OpenAI credential to the OpenAI GPT-4 Model node.
5. Explain the purpose of the Format Launch Content node (tolerant parsing for two possible LLM response shapes).
6. If Google Sheets archiving is needed, explain enabling the node, configuring OAuth2, and entering the spreadsheet ID.
7. Suggest running manually with sample data first to verify all 5 copy pieces look correct before enabling Sheets.