Content Marketing

Burning hours on YouTube topic research is a creator tax nobody should pay. This n8n template turns a keyword into a stream of high-performing video ideas, thumbnail notes, and AI-written outlines inside Google Sheets – without opening a single YouTube tab.

In this tutorial you’ll import a ready-made workflow that combines n8n Apify OpenAI GPT-4.1 GPT-4o-mini Vision Google Sheets to automate the exact research loop most YouTubers run by hand every week.

What the workflow does

The template exposes a simple n8n form that accepts a keyword or topic. From there, everything is automatic:

1. Scrape trending videos with Apify’s YouTube search actor – last 60 days, mid-length, newest first, capped at 100 results per run.
2. Filter outliers: keep only videos with more than 1,000 views and more views than the channel has subscribers. This surfaces videos the algorithm is actively amplifying.
3. Deduplicate against your sheet so you never re-process the same video twice.
4. Analyze the thumbnail with GPT-4o-mini Vision – layout, subjects, color palette, mood – in one natural-language paragraph.
5. Fetch the transcript via a second Apify actor.
6. Generate an SEO-tuned title plus a 3-5 word thumbnail overlay with GPT-4.1-mini (JSON mode).
7. Write an original outline with GPT-4.1 that borrows the structure of the winning video but takes a fresh angle – no copy-paste.
8. Update the Google Sheet with the enriched row: new title, thumbnail text, thumbnail description, transcript, and outline.

Why this beats manual YouTube research

A manual research session typically takes 60-90 minutes for ten candidate topics: searching, skimming, noting view counts, checking sub counts, screenshotting thumbnails, drafting titles. This workflow runs the same loop in roughly 3-5 minutes per keyword and stores everything in a sortable sheet you can revisit for months.

The outlier filter is the secret sauce. A video with 200k views on a channel that has 30k subscribers is statistically winning right now. Those are the ideas you want to study – not the evergreen giants sitting on top of the search results.

Prerequisites

• An n8n instance – self-hosted (Docker, VPS, Render) or n8n Cloud. Version 1.70+.
• Apify account with API token. Free tier is enough for testing.
• OpenAI API key with access to gpt-4o-mini, gpt-4.1-mini, and gpt-4.1.
• Google Workspace account and a spreadsheet you control.

You’ll find the exact step-by-step to obtain every credential in the Credentials Guide PDF included with the download, and a full import walkthrough in the Setup Guide PDF. Grab the template here.

Step 1 – Prepare the Google Sheet

Create a new Google Sheet, rename the first tab to Step 1, and paste this header row across the top:

id | title | url | fromYTUrl | thumbnailUrl | channelName | channelUrl | duration | likes | numberOfSubscribers | viewCount | videoTranscript | thumbnailDescription | thumbnailText | newTitle | newOutline

Order doesn’t matter – n8n maps columns by name – but every field above must exist or the workflow will error out on write.

Step 2 – Import the n8n workflow

1. Open n8n and hit + New > Import from File.
2. Select analyze-trending-youtube-videos-apify-openai-sheets-n8n.json from the ZIP.
3. n8n will open the canvas. You’ll see 12 nodes: a form trigger, two Apify HTTP calls, an IF filter, a Google Sheets dedupe + append, three OpenAI nodes, a merge, an update row, and a sticky note with setup instructions.

Step 3 – Paste your Apify token

Click Scrape Trending Videos (Apify), then Fetch Transcript (Apify). Each has an Authorization header set to Bearer YOUR_APIFY_TOKEN. Replace the placeholder with your real token from console.apify.com/account/integrations.

Step 4 – Attach OpenAI credentials

Open Analyze Thumbnail, YouTube Title Generator, and Generate Original Outline. For each, pick or create an OpenAI credential with your API key. The models are pre-selected:

• Analyze Thumbnail: gpt-4o-mini in image mode (~$0.00015 per thumbnail).
• YouTube Title Generator: gpt-4.1-mini in JSON mode.
• Generate Original Outline: gpt-4.1 for deeper structure – swap to gpt-4.1-mini if you want to save 60% on that node.

Budget roughly $0.01-$0.02 per video analyzed at default settings.

Step 5 – Connect Google Sheets

Click each of the three Google Sheets nodes (Find Duplicate Entries, Step 1 Results, Update Rows) and:

1. Attach your Google Sheets OAuth2 credential.
2. Open the Document dropdown and pick the sheet you prepared in Step 1.
3. Open the Sheet dropdown and choose the Step 1 tab.

Step 6 – Activate and run

Toggle the workflow active in the top-right corner. n8n exposes a public form at the URL shown on the On form submission node. Open it, type a keyword like “ai automation” or “home workout for seniors”, and submit.

Within a couple of minutes your sheet fills up with filtered videos, AI-optimized titles, and fresh outlines ready for scripting. Sort by viewCount / numberOfSubscribers in a helper column to see the strongest outliers first.

How the filter works under the hood

The Filter High-Potential Videos node enforces two conditions with an AND combinator:

viewCount > 1000
viewCount > numberOfSubscribers

The first condition removes noise – brand-new uploads with a handful of views. The second is the outlier signal: a video whose views already beat the uploader’s subscriber count is almost certainly being pushed by YouTube’s recommendation engine. That’s the exact moment to study the thumbnail, hook, and structure.

Customization ideas

• Daily cron: replace the form trigger with a Schedule node that runs a rotating list of keywords every morning.
• Slack digest: add a Slack node after Update Rows to post the top five new outliers to #content channel.
• Notion sync: mirror the sheet into a Notion database so writers can claim outlines from their side.
• Shorts mode: swap lengthFilter to "under4" in the scrape node to hunt trending Shorts instead of long-form.
• Voice cloning prep: pipe the generated outline into ElevenLabs for a rough voiceover of the hook.

Troubleshooting

“Unauthorized” from Apify: the Bearer token is missing or has a trailing space. Paste it again without the word Bearer duplicated.

Google Sheets node errors on missing column: double-check the header row spelling. Column names are case-sensitive.

OpenAI returns a non-JSON outline: the Generate Original Outline node is in text mode on purpose (outlines are prose). If you want structured JSON, toggle JSON Output on and update the system prompt.

Transcript is empty: the Apify transcript actor occasionally fails on age-restricted or auto-generated-caption-disabled videos. The workflow continues gracefully – the row simply has a blank videoTranscript and a weaker outline.

Final thoughts

YouTube research used to be a research skill. Now it’s a workflow you run on a coffee break. Hook this into your weekly content planning, let it pre-fill your sheet with validated topics, and spend your actual creative energy on the hook and delivery – the parts AI still can’t do for you.

Chasing trends is exhausting. You’re scrolling Google Trends hoping something resonates, sketching outlines, writing blog posts, designing graphics, scripting videos—all for three different platforms. By the time you publish, the trend’s already fading. What if your entire content machine ran itself? Every 8 hours, a workflow discovers the hottest trending topic, generates a polished 3000-word blog outline, a 5-slide Instagram carousel concept, and a 60-second TikTok script—then sends them to you for a single-click approval. That’s the power of an AI Content Factory built with n8n, OpenAI, and Slack.

Ready to automate your content creation pipeline? Get the complete workflow template to start building.

What You’ll Build

This workflow transforms you from a content creator into a content director. Here’s the five-step experience:

1. Trend discovery runs automatically — Every 8 hours, the system fetches the US Google Trends RSS feed and identifies the single most viral topic using AI analysis.
2. Three AI agents work in parallel — A blog writer generates a 3000-word SEO outline with proper heading hierarchy, an Instagram designer dreams up a 5-slide carousel concept, and a TikTok writer scripts a punchy 60-second video hook.
3. Content is reviewed via Slack — A beautifully formatted message arrives in your Slack channel with preview text and one-click Approve/Reject buttons.
4. You approve or reject instantly — No need to touch n8n. Just click in Slack, and the workflow reacts in real time.
5. Approved content lands in Google Sheets — All three content pieces (blog, Instagram, TikTok) save to a spreadsheet you can export, edit, or feed into your publishing tools.

How It Works — The Big Picture

Here’s the complete flow, from trend detection to Sheets:

┌─────────────────────────────────────────────────────────────┐
│  Schedule Trigger (Every 8 hours)                           │
└────────────────────┬────────────────────────────────────────┘
                     │
┌────────────────────v────────────────────────────────────────┐
│  Config Node (Google Trends URL, Slack channel)             │
└────────────────────┬────────────────────────────────────────┘
                     │
┌────────────────────v────────────────────────────────────────┐
│  HTTP Request → Google Trends Daily RSS Feed (US)           │
└────────────────────┬────────────────────────────────────────┘
                     │
┌────────────────────v────────────────────────────────────────┐
│  AI Agent: Trend Filter (GPT-4o-mini)                       │
│  → Selects 1 viral topic + reason + target audience         │
│  → Returns JSON with structured output                      │
└────────────┬──────────────────────────────────────┬─────────┘
             │                                      │
    ┌────────v────────┐         ┌─────────────────v────────┐
    │ AI Agent:       │         │ AI Agent:                 │
    │ Blog Writer     │         │ Instagram Designer        │
    │ (GPT-4o-mini)   │         │ (GPT-4o-mini)             │
    │ → 3K word SEO   │         │ → 5-slide carousel        │
    │   outline       │         │   concept                 │
    └────────┬────────┘         └────────────┬──────────────┘
             │                               │
             │      ┌──────────────────┐    │
             │      │ AI Agent:        │    │
             │      │ TikTok Script    │    │
             │      │ (GPT-4o-mini)    │    │
             │      │ → 60-sec script  │    │
             │      └────────┬─────────┘    │
             └──────────┬────────────────────┘
                        │
        ┌───────────────v────────────────┐
        │  Merge (3 inputs)              │
        │  Combine all 3 AI outputs      │
        └───────────────┬────────────────┘
                        │
        ┌───────────────v────────────────┐
        │  Code Node (JavaScript)        │
        │  Sanitize text + structure     │
        │  → blog_content                │
        │  → instagram_content           │
        │  → tiktok_script               │
        └───────────────┬────────────────┘
                        │
        ┌───────────────v────────────────┐
        │  Slack Message (Block Kit)     │
        │  Send Approve/Reject buttons   │
        └───────────────┬────────────────┘
                        │
        ┌───────────────v────────────────┐
        │  Wait for Webhook Callback     │
        │  Pause until user clicks       │
        └───────────────┬────────────────┘
                        │
        ┌───────────────v────────────────┐
        │  IF: query.action === approve? │
        └───┬──────────────────────────┬─┘
    YES │                              │ NO
        │                         (End)│
    ┌───v─────────────────────────────┘
    │
    │  Google Sheets Append
    │  → blog_content, instagram_content,
    │    tiktok_script (3 columns)
    │  ✓ Content saved
  

What You’ll Need

Before you start, gather these pieces:

• n8n instance — Free cloud at n8n.cloud or self-hosted
• OpenAI API key — GPT-4o-mini model access (budget ~$0.20–$0.50 per workflow run)
• Slack workspace — With bot token (scopes: chat:write, incoming-webhook)
• Google Sheets — One sheet with 3 columns: blog_content, instagram_content, tiktok_script
• Google Trends RSS URL — US daily trends: https://trends.google.com/trends/trendingsearches/daily/rss?geo=US
• Time — ~45 minutes to set up (most time spent configuring credentials)

Part 1 — Trend Discovery

1 Schedule Trigger

Start with a Schedule Trigger node set to repeat every 8 hours. This ensures your content factory runs throughout the day—morning, afternoon, evening. Choose a time that fits your workflow; 9 AM, 5 PM, and 1 AM is a solid split.

2 Config Node

Next, create a Set node called “Config” to store your constants. This keeps your workflow clean and reusable:

• google_trends_url = https://trends.google.com/trends/trendingsearches/daily/rss?geo=US
• slack_channel = #content-approvals
• slack_bot_token = (your Slack bot token)

Store these as {{ $node["Config"].json.google_trends_url }} when you reference them later. This pattern keeps credentials safe if you share the workflow.

3 HTTP Request — Fetch Google Trends

Add an HTTP Request node with these settings:

• Method: GET
• URL: {{ $node["Config"].json.google_trends_url }}
• Response Format: JSON

Google Trends serves an RSS feed. n8n automatically parses it into JSON. You’ll get back a list of trending topics with titles, descriptions, and images. The structure looks like this:

{
  "rss": {
    "channel": {
      "item": [
        {
          "title": "Climate Crisis 2026",
          "description": "Up 2,100% in the last 24 hours",
          "link": "https://..."
        },
        {
          "title": "AI Robotics Breakthrough",
          "description": "Up 1,850% in the last 24 hours"
        }
        // ... more items
      ]
    }
  }
}

The HTTP Request node extracts these automatically. You’ll reference {{ $node["HTTP Request"].json.rss.channel.item }} in the next step.

4 AI Agent — Trend Filter

Now the AI enters. Create an AI Agent node (OpenAI) that analyzes all trends and picks the single most viral topic. Configure it like this:

• Model: GPT-4o-mini
• Prompt:

You are a trend analyst. I've given you a list of today's Google Trends.
Analyze each trend's growth metrics and cultural relevance.
Pick THE SINGLE most viral topic that will appeal to a broad creator audience.
Return a JSON object with exactly these fields:
{
  "selected_topic": "exact trend title",
  "reason": "2-sentence explanation of why this trend is viral",
  "target_audience": "who should care about this (e.g., Gen Z, fitness enthusiasts)"
}

Set Structured Output Parser to JSON mode. Pass in {{ $node["HTTP Request"].json.rss.channel.item }} as the input data. The AI Agent will return structured JSON like:

{
  "selected_topic": "AI-Powered Fitness Wearables",
  "reason": "Up 2,340% in last 24h. Combines AI hype + health trend + consumer gadgets.",
  "target_audience": "Tech enthusiasts, fitness influencers, early adopters"
}

Part 2 — Parallel Content Generation

Now that you have the viral topic, three AI agents run simultaneously to create content for different platforms. This is where n8n’s parallel execution shines.

5 AI Agent — Blog Writer

Add an AI Agent node called “Blog Writer” with this prompt:

You are an expert SEO content strategist. I need a 3000-word blog post outline
on this topic: "{{ $node["Trend Filter"].json.selected_topic }}"

Create a comprehensive outline with:
- H1: Catchy main title
- H2 sections (5–7 main sections)
- H3 subsections under each H2
- 2–3 bullet points under each H3
- Include an intro section, an FAQ section, and a CTA section

Target audience: {{ $node["Trend Filter"].json.target_audience }}

Output as plain text outline (not HTML).

Model: GPT-4o-mini. This generates a roadmap for writers or AI-to-content pipelines. The output is ready to feed to a blog post writer or expanded into full prose.

6 AI Agent — Instagram Designer

Add another AI Agent called “Instagram Designer” with this prompt:

You are a social media content strategist specializing in Instagram.
Create a 5-slide carousel concept for this trending topic: "{{ $node["Trend Filter"].json.selected_topic }}"

Slide breakdown:
- Slide 1 (Cover): Eye-catching headline + hook
- Slides 2-4 (Info): Key insights, stats, or benefits (one concept per slide)
- Slide 5 (CTA): Call-to-action (link bio, DM for more, etc.)

For each slide, write:
1. Text copy (max 150 chars per slide)
2. Visual concept (describe the design, colors, layout)
3. Recommended hashtags

Target audience: {{ $node["Trend Filter"].json.target_audience }}

Output as plain text instructions for a designer or content creator.

The AI creates a blueprint that you or a designer can use to create the actual carousel graphics.

7 AI Agent — TikTok Script Writer

Create a third AI Agent called “TikTok Script Writer”:

You are a TikTok content strategist. Write a 60-second TikTok script on this topic:
"{{ $node["Trend Filter"].json.selected_topic }}"

Script structure:
- Hook (0–3 seconds): Stop-the-scroll opener
- Body (3–50 seconds): Main content, insights, or entertainment
- CTA (50–60 seconds): What viewers should do next

Include:
- [Action] or [Visual] cues in brackets
- Pacing notes (fast cuts, slow reveals, etc.)
- Suggested audio vibe (upbeat, educational, etc.)

Target audience: {{ $node["Trend Filter"].json.target_audience }}

Output as plain text script with brackets for visual cues.

Position all three AI agents in parallel—they don’t depend on each other, so n8n runs them simultaneously. This saves ~45 seconds per workflow run.

Part 3 — Review & Approval

8 Merge Node

After the three AI agents finish, add a Merge node to combine their outputs. Set it to merge “3 into 1 row” to bundle the data:

• Input 1: Blog Writer AI output
• Input 2: Instagram Designer AI output
• Input 3: TikTok Script Writer AI output

The Merge node creates a single data object with all three content pieces.

9 Code Node — Sanitize & Structure

Add a Code node (JavaScript) to clean up the text and create a final data structure:

// Sanitize helper: remove extra whitespace, HTML entities
const sanitize = (str) => {
  return str.trim().replace(/"/g, '"').replace(/&/g, '&').slice(0, 5000);
};

// Extract content from merged inputs
const blogContent = sanitize($('Blog Writer').json.text || '');
const instagramContent = sanitize($('Instagram Designer').json.text || '');
const tiktokScript = sanitize($('TikTok Script Writer').json.text || '');

return {
  blog_content: blogContent,
  instagram_content: instagramContent,
  tiktok_script: tiktokScript,
  topic: $('Trend Filter').json.selected_topic,
  timestamp: new Date().toISOString()
};

This node outputs a clean, validated JSON object ready for Slack and Google Sheets.

10 Slack — Send Approval Message

Add a Slack node to post a beautifully formatted message with Approve/Reject buttons. Use Block Kit format:

{
  "channel": "#content-approvals",
  "blocks": [
    {
      "type": "header",
      "text": {
        "type": "plain_text",
        "text": "New Trending Content Ready for Review"
      }
    },
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*Topic:* {{ $node["Code"].json.topic }}\n*Generated:* {{ $node["Code"].json.timestamp }}"
      }
    },
    {
      "type": "divider"
    },
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*Blog Outline Preview:*\n```{{ $node["Code"].json.blog_content.slice(0, 300) }}...```"
      }
    },
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*Instagram Carousel:*\n```{{ $node["Code"].json.instagram_content.slice(0, 300) }}...```"
      }
    },
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*TikTok Script:*\n```{{ $node["Code"].json.tiktok_script.slice(0, 300) }}...```"
      }
    },
    {
      "type": "actions",
      "elements": [
        {
          "type": "button",
          "text": {
            "type": "plain_text",
            "text": "Approve"
          },
          "style": "primary",
          "action_id": "approve_btn"
        },
        {
          "type": "button",
          "text": {
            "type": "plain_text",
            "text": "Reject"
          },
          "style": "danger",
          "action_id": "reject_btn"
        }
      ]
    }
  ]
}

11 Wait for Webhook

Add a Wait node and set it to “Receive Webhook Data.” This pauses the workflow until someone clicks a button in Slack. Configure the webhook to listen for responses with a unique identifier so n8n knows which workflow instance to resume.

12 IF Node — Check Approval

Add an IF node to evaluate the button click:

• Condition: {{ $json.action_id }} === "approve_btn"
• True path: Proceed to Google Sheets (next step)
• False path: End workflow (Reject path)

13 Google Sheets — Append Content

On the True path, add a Google Sheets node to append a row with your three content pieces:

• Operation: Append Row
• Range: Sheet1!A:C (columns A, B, C)
• Values:

[
  "{{ $node['Code'].json.blog_content }}",
  "{{ $node['Code'].json.instagram_content }}",
  "{{ $node['Code'].json.tiktok_script }}"
]

Each approval adds a new row to your sheet. Your Sheets file becomes a living archive of all generated content.

The Data Structure

Here’s what your Google Sheets looks like after a few approvals:

Full System Flow Diagram

Here’s the complete end-to-end picture:

START
  │
  ├─→ [Schedule: Every 8h]
  │
  ├─→ [Config: Trends URL, Slack channel]
  │
  ├─→ [HTTP: Fetch Google Trends RSS]
  │
  ├─→ [AI: Trend Filter (Pick 1 topic)]
  │    └─→ { selected_topic, reason, audience }
  │
  ├─→ [PARALLEL BRANCH]
  │   ├─→ [AI: Blog Writer]
  │   │   └─→ 3000-word SEO outline
  │   │
  │   ├─→ [AI: Instagram Designer]
  │   │   └─→ 5-slide carousel concept
  │   │
  │   ├─→ [AI: TikTok Script Writer]
  │   │   └─→ 60-second script
  │
  ├─→ [Merge: Combine 3 outputs]
  │
  ├─→ [Code: Sanitize & structure]
  │
  ├─→ [Slack: Send Approve/Reject message]
  │
  ├─→ [Wait: Listen for webhook callback]
  │
  ├─→ [IF: query.action === "approve"?]
  │   ├─ YES: Google Sheets Append → DONE
  │   └─ NO: END (Rejected)
  │
END
  

Testing Your Workflow

Test Plan

1. Test each node individually. Use the “Test” button in n8n to run HTTP Request in isolation. Verify you get valid RSS data.
2. Test the Trend Filter AI Agent. Mock some sample trend data and confirm it picks one topic and returns valid JSON.
3. Test the parallel AI agents. Run Blog Writer, Instagram Designer, and TikTok Script Writer on a sample topic. Check the quality of outputs.
4. Test the Code node. Verify it sanitizes text and structures the final JSON correctly.
5. Test Slack integration. Send a test Block Kit message to your #content-approvals channel. Verify the layout and buttons.
6. Test the full workflow. Trigger manually, approve in Slack, and confirm the row appears in Google Sheets within 30 seconds.

Troubleshooting

Frequently Asked Questions

What’s Next?

You’ve built a lean, mean content machine. Here are four directions to expand:

1. Add LinkedIn content generation. Duplicate the Blog Writer AI Agent, adjust the prompt to LinkedIn voice (professional, conversational), and add LinkedIn as a fourth platform in the Merge node. Your workflow now outputs blog, Instagram, TikTok, and LinkedIn posts simultaneously.
2. Store full blog posts, not outlines. Replace the Blog Writer AI Agent with a more powerful model (GPT-4o) and ask it to generate the full 3000-word blog post with HTML tags. Append the HTML directly to a “Published Content” sheet or send to your WordPress site via REST API.
3. Add image generation. After the Instagram Designer AI Agent, pipe the carousel concept to DALL-E 3 to auto-generate actual carousel images. The Slack message can preview real images instead of text concepts.
4. Build a content calendar dashboard. Connect your Google Sheets to a tool like Airtable or a custom web dashboard. View all pending, approved, and published content in one place. Add filters by topic, platform, and date.