---
title: "Video ideas from YouTube comments with web research"
kind: "Kit"
category: "Marketing & SEO"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/af45c701-7022-4e9d-b862-ac3afcf288de"
updated: "2026-11-09"
---

# Video ideas from YouTube comments with web research

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

An n8n workflow that reads up to 100 comments on a YouTube video you paste in n8n’s chat and has OpenAI pick the ones that suggest a video. Each pick is saved in Google Sheets, then an agent searches the web with Tavily and adds a topic for it.

Video ideas from YouTube comments with web research is an n8n workflow in the Marketing \& SEO 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 reads a YouTube video’s comments for ideas you could film next. You paste the video’s link in n8n’s chat. It fetches up to 100 of the newest top-level comments, and OpenAI’s gpt-4.1-mini answers Yes or No for each one. The question is whether a viewer is asking for, or hinting at, a video worth making. Every Yes is written to a Google Sheet, together with the commenter’s name, the comment’s text and its like and reply counts, so you can sort the requests later. A second gpt-4.1-mini step then takes those rows one at a time, searches the web through Tavily and writes a topic into each. YouTube itself is only read.

You paste a YouTube link in n8n’s chat → YouTube returns up to 100 top-level comments → OpenAI keeps the ones that suggest a video → Each one becomes a row in Google Sheets → An agent with Tavily search adds a topic to each row

### Who it suits

Creators whose viewers ask for videos in the comments, and the teams that plan content for them. It reads one video per run and leaves a sheet of requests you can sort. Skip it if you want the research write-up as well. The model writes one for each idea, but only the topic reaches the sheet.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Tutorial channels | Creators who teach tools | Run it on last month’s most watched video and film the most asked-for topic | A creator sees three viewers asking how to link a tool to a CRM and plans that video. |
| Content teams | Planners with a backlog of ideas | Keep one sheet per channel and sort it by likeCount | A team sorts the sheet so the requests with the most likes come first. |
| Agencies | Strategists for client channels | Run a client’s best videos and send the topics on as a plan | An agency turns a client’s comment sections into a month of topics. |
| Competitor research | Marketing teams | Paste a rival’s video and see what its viewers want next | A brand reads which requests under a rival’s tutorial went unanswered. |

### Where to use it

Any n8n that can reach Google, OpenAI and Tavily will run it. The video can be any public one.

- n8n Cloud or your own server: the same file and steps
- n8n’s chat: where you paste each link
- Google Sheets: one row per idea, updated in place when the same comment comes round again

### 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 18 minutes. Make the sheet first: a tab named `Sheet1` with these eight headers in its first row.

```text
id | text | likeCount | replyCount | publishedTime | author | contentIdea | topic
```

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server of your own |
| Google Cloud | The YouTube Data API v3 turned on, for a YouTube OAuth2 credential |
| OpenAI | An API key, for both model calls |
| Tavily | An API key, typed into the search tool’s header |
| Google Sheets | The sheet above, and a Google Sheets OAuth2 credential |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Add a YouTube OAuth2 credential and select it in `Get Video Comments`.
3. Add an OpenAI credential and select it in `Message a model` and `Message a model1`.
4. Open `Tavily` and replace `<YOUR_TAVILY_API_KEY>` in its Authorization header with your key, keeping `Bearer` and the space after it.
5. Add a Google Sheets OAuth2 credential and select it in `Append or update row in sheet` and `Update row in sheet`. In both, replace `YOUR_SHEET_ID` with the ID in your sheet’s address.
6. Save, open the chat, paste a video link and watch the rows fill in.

### How to use it

Paste a full YouTube link, a `youtube.com/watch?v=` address or a short `youtu.be` one. All the comments are judged first, then the saved rows go through research one at a time, so the topics arrive after the rows. A comment already in the sheet is matched on `id` and updated, never added twice.

What to change for a different result

| To change | Where |
| --- | --- |
| Which comments count as ideas | The system message of \`Message a model\`, with its examples |
| How a topic is researched | The system message of \`Message a model1\` |
| How much is searched | \`max\_results\` (1 in the file) and \`search\_depth\` in the body of \`Tavily\` |
| How many comments | \`maxResults\` in \`Get Video Comments\`, 100 in the file, the most one page holds |
| Keeping the research | A new column, mapped from \`research\_overview\` in \`Update row in sheet\` |

### Example

Under a video about running a small online shop, a viewer writes: “Could you show how to send the day’s orders to a spreadsheet every night?” The first model answers Yes. A row lands with the viewer’s name, the text and `contentIdea` set to Yes. The research step searches the web and answers in this shape, and only the topic lands in the row:

```json
{
  "topic": "<a video topic built from the request>",
  "research_overview": "<300 to 500 words from the search, not saved>"
}
```

### 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 one has 12. Tavily is a search service made for AI models, and here the model decides what to search for. Loop Over Items sends the saved rows through research one at a time, so a long list takes a while. Start with a video that has a few dozen comments.

**For experts.** Both model calls use gpt-4.1-mini through the OpenAI node’s message operation, with JSON output on and simplify off. That is why later nodes read `choices[0].message.content`.

The two model calls

| Node | Reads | Returns | Tool |
| --- | --- | --- | --- |
| \`Message a model\` | One comment’s text | A JSON answer whose \`output\` is Yes or No | None |
| \`Message a model1\` | One saved row’s \`text\` | \`topic\` and \`research\_overview\` | \`Tavily\`, an HTTP tool whose \`searchTerm\` the model fills, at advanced depth with one result |

`Filter` keeps an exact `Yes` in `output`. The judge’s prompt asks for a bare word, so if a run saves nothing, open `Message a model` and check which key it answered with. `Append or update row in sheet` matches on `id`, and `Update row in sheet` matches the same column and writes `topic` alone.

### Good to know

Commenters’ names land in your sheet, and only the topic of each research run is kept.

- Personal data: the sheet stores each commenter’s display name beside the comment, so keep it private
- Research dropped: \`research\_overview\` is written and then thrown away, since no column takes it
- One page: the comments call reads a single page of up to 100, newest first
- Billing: one OpenAI call for every comment read, and another, with Tavily searches, for every idea saved
- The Tavily key: it sits in the node’s header, not in a credential, so anyone who can open the workflow can read it
- The original copy: its \`Get Video ID\` code had lost its backslashes, so its fallback pattern could not compile and the node failed on every run. This one has them back
- Credentials: the JSON holds none, and nothing from its author’s accounts

## README

```markdown
# Video ideas from YouTube comments with web research

An n8n workflow. Paste a YouTube link in n8n's chat, and it reads up to 100 comments on the video. OpenAI picks the ones
that suggest a video, each is saved in Google Sheets, and an agent with Tavily search adds a topic to each row.

## What is inside

- `workflow.json`: the workflow as n8n exports it, 12 nodes. It holds no credential.
- Changes to the original copy. Its `Get Video ID` code had lost its backslashes, so its fallback pattern for links it
  cannot parse could not compile and the node failed on every run. This copy has them back. Its spreadsheet ID is now
  `YOUR_SHEET_ID`, its tab is picked by the name `Sheet1`, and the Tavily header reads `Bearer <YOUR_TAVILY_API_KEY>`.
- `README.md`: these notes.

## Before you start

- An n8n instance, on n8n Cloud or your own server.
- A Google Cloud project with the YouTube Data API v3 turned on, and an OAuth client for n8n's YouTube credential.
- An OpenAI API key.
- A Tavily API key.
- A Google Sheet with a tab named `Sheet1` and these headers in its first row: `id`, `text`, `likeCount`,
  `replyCount`, `publishedTime`, `author`, `contentIdea`, `topic`.

## Set it up

1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`.
2. Add a YouTube OAuth2 credential and select it in `Get Video Comments`.
3. Add an OpenAI credential and select it in `Message a model` and `Message a model1`.
4. Open `Tavily`, find the Authorization header and replace `<YOUR_TAVILY_API_KEY>` with your key. Keep `Bearer` and
   the space after it.
5. Add a Google Sheets OAuth2 credential and select it in `Append or update row in sheet` and `Update row in sheet`.
   In both, replace `YOUR_SHEET_ID` with the ID from your sheet's address, the part between `/d/` and the next slash.
6. Save. Open the chat from the canvas, paste the link of a video with a few dozen comments, and watch the rows arrive.

## What lands in the sheet

| Column | From |
|---|---|
| `id` | the comment thread's ID, used to match rows |
| `text`, `author`, `likeCount`, `replyCount`, `publishedTime` | the comment |
| `contentIdea` | the first model's answer, Yes for every saved row |
| `topic` | the research step's topic, written once the row has been researched |

The research step also writes a `research_overview` of 300 to 500 words. No column takes it, so it is lost unless you
add one and map it in `Update row in sheet`.

## Change the look

- Which comments count: the system message of `Message a model` and its examples.
- How topics are researched: the system message of `Message a model1`.
- Search size: `max_results` (1) and `search_depth` (advanced) in the body of `Tavily`.
- Number of comments: `maxResults` in `Get Video Comments` (100, the most one page holds).

## Good to know

- `Filter` keeps an exact `Yes` in the field `output`. The judge's prompt asks for a bare word, so if a run saves
  nothing, check which key `Message a model` answered with.
- The sheet keeps each commenter's display name. Treat it as personal data.
- Only one page of comments is read, newest first.
- The Tavily key sits in the node, not in a credential, so anyone who can open the workflow can read it.
- Each comment costs one OpenAI call, and each saved idea one more plus its Tavily searches.
```

## What is in it

2 files, 25 KB, downloaded as a zip.

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

## Workflow check

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

- Steps: 11 steps, starting on a chat message
- AI: 2 steps call an AI model: Message a model and Message a model1
- Sign-ins: Signs in to: YouTube and Google Sheets
- API keys: No API key is left in the file
- Step types: Mindket’s checker reads all 9 of its step types

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/af45c701-7022-4e9d-b862-ac3afcf288de)
- [Its page on Mindket](https://mindket.com/p/af45c701-7022-4e9d-b862-ac3afcf288de)