---
title: "Webhook that summarizes a YouTube video with Gemini"
kind: "Kit"
category: "Research"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/0be36527-02d6-4ea7-896c-3e48144584b2"
updated: "2026-11-12"
---

# Webhook that summarizes a YouTube video with Gemini

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

An n8n webhook for YouTube links. It looks the video up, has Gemini watch it and write a structured summary, returns the summary to the caller and sends the title and link to Telegram.

Webhook that summarizes a YouTube video with Gemini is an n8n workflow in the Research category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. 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 turns a YouTube link into a structured summary. You post the link to a webhook. The workflow pulls the video’s id out of it and looks the video up on YouTube for its title and description. It then sends the video’s address to Google’s Gemini API, which watches the video and writes a summary under markdown headers. The summary goes back to the caller, and Telegram gets the title and the link. The file holds nine nodes, one of them a sticky note that Mindket added.

### Who it suits

Researchers, students and content teams who want the gist of a long video before they sit through it. Skip it if you need the speaker’s exact words. The summary is the model’s reading of the video, and no transcript is kept.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Research | Analysts | Skim a recorded talk before they decide to cite it | An analyst posts a conference talk and reads the headers before the full video. |
| Education | Students | Get a structured outline of a lecture | A student posts a recorded lecture and gets topics under headers with the key terms in bold. |
| Media | Content teams | Log what each source video covers | A newsroom assistant posts an interview and gets a summary and the title in a Telegram chat. |
| Software | Developers | Add video summaries to their own tools | A developer calls the webhook from a bookmark app that saves YouTube links. |

You need some n8n and three accounts: import a file, make three credentials and post a link to a webhook.

### Where to use it

Any n8n that can reach YouTube, Google’s Gemini API and Telegram will run it.

- n8n Cloud: import the file and publish it, so the webhook has an address that stays
- Your own n8n server: the same file, with the webhook open to the callers you choose
- Any caller: a script, a no-code tool or a form that can send a POST with a link

### How to set it up

Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. The original copy needed a community node for transcripts. It is no longer on npm, so Mindket swapped it for a Gemini call.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server of your own |
| Gemini | An API key from Google AI Studio, kept in a Header Auth credential |
| Google Cloud | The YouTube Data API on, and an OAuth2 credential for the video lookup |
| Telegram | A bot, and the id of the chat it writes to |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Add a Header Auth credential with the name `x-goog-api-key` and your Gemini key as the value. Select it in `Summarize and Analyze Video`.
3. Add a YouTube OAuth2 credential and select it in `Get YouTube Video`.
4. Add a Telegram credential, select it in `Telegram` and replace `<YOUR_TELEGRAM_CHAT_ID>` with your chat’s id. Delete the node if you do not want the message.
5. Save, then post a link to the webhook’s test address. Publish the workflow to use the production address.

### How to use it

Post a JSON body with one field, `youtubeUrl`. The call returns when the summary is ready, which can take a while for a long video. Gemini reads public videos only.

What to change for a different result

| To change | Where |
| --- | --- |
| The shape of the summary | The prompt inside the body of \`Summarize and Analyze Video\` |
| The model | The \`model\` line in the same body |
| What the caller gets back | The fields of \`Response Object\` |
| The Telegram message | The text of \`Telegram\` |

### Example

You post this to the webhook.

```text
{"youtubeUrl": "https://www.youtube.com/watch?v=<VIDEO_ID>"}
```

The call answers with a JSON object. `summary` holds the markdown summary, and `title`, `description`, `id` and `youtubeUrl` describe the video. Telegram receives the title and the link.

### 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 runs in a straight line from the webhook to the answer, with Telegram on a side branch at the end. A webhook is an address that starts the run when something posts to it. Test with a short video first.

**For experts.** One HTTP Request node calls Gemini’s Interactions API, and the answer’s `steps` hold the text.

Where to look closer

| Node | What it does | What to know |
| --- | --- | --- |
| \`YouTube Video ID\` | Code node that matches the id in a link | It reads watch, youtu.be and embed links, and a Shorts link gives no id |
| \`Get YouTube Video\` | YouTube node, get one video | It needs a YouTube OAuth2 credential |
| \`Summarize and Analyze Video\` | POST to \`/v1beta/interactions\`, \`gemini-3.8-flash\`, \`store\` false | The key goes in the \`x-goog-api-key\` header |
| \`Response Object\` | Set node that picks the model’s text from \`steps\` | It fails when the answer has no \`steps\` |

### Good to know

The webhook has no authentication, and Gemini’s YouTube link feature is a preview.

- Gemini: public videos only, not private or unlisted ones. Google’s video understanding page, read on 12 November 2026, calls the feature a preview whose pricing and limits are likely to change. It caps the free tier at 8 hours of YouTube video a day
- Open webhook: anyone who learns the address can start a run that spends Gemini quota and sends a Telegram message. Turn on authentication in \`Webhook\` before you publish
- Storage: \`store\` is false, so Google keeps no copy of the exchange for later turns
- Telegram: its HTML mode refuses a title that holds a stray \`\<\` or \`\&\`
- Topics: \`topics\` is always an empty list
- Your data: the video link goes to Google, and the title and link go to Telegram
- Credentials: the JSON holds none

## README

````markdown
# Webhook that summarizes a YouTube video with Gemini

An n8n webhook for YouTube links. You post a link, the workflow looks the video up on YouTube, and Gemini watches it and
writes a structured summary. The summary goes back to the caller, and the title and link go to Telegram.

## What is inside

- `workflow.json`: the workflow as n8n exports it, nine nodes. One is a sticky note that Mindket added. It holds no
  credential.
- `README.md`: these notes.

## What we changed from the original copy

- The original copy read the video through a community node, `n8n-nodes-youtube-transcription`, which turned the video
  into a transcript for an OpenAI model. A community node installs by its package name in n8n's community nodes
  settings. This package is no longer on npm: it was withdrawn, and the repository it named is gone (npm registry, read
  on 12 November 2026). There is nothing to install. YouTube's own caption address also returned nothing to a plain
  request on the same day.
- Mindket swapped the transcript node, the three nodes after it and the OpenAI model for one HTTP Request node,
  `Summarize and Analyze Video`. It sends the video's address to Google's Gemini API, which reads the video itself, so
  the workflow still ends in a structured summary. The summary now comes from the model's reading of the video, picture
  and sound, and not from a transcript.
- In the original copy `Get YouTube Video` and the transcript node were not joined to anything after them, so a run
  stopped at the video lookup. `Get YouTube Video` now joins the new node.
- `Telegram` had no chat set. It holds the placeholder `<YOUR_TELEGRAM_CHAT_ID>`.
- The prompt asks Gemini to watch the video, where it used to ask for a summary of given text.
- A sticky note says where the new node came from.

## Before you start

- An n8n instance, on n8n Cloud or your own server.
- A Gemini API key, from Google AI Studio.
- A Google Cloud project with the YouTube Data API on, for the OAuth2 credential that `Get YouTube Video` needs.
- A Telegram bot and the id of the chat it writes to. Delete `Telegram` if you do not want the message.

## Set it up

1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`.
2. Add a Header Auth credential whose name is `x-goog-api-key` and whose value is your Gemini key. Select it in
   `Summarize and Analyze Video`.
3. Add a YouTube OAuth2 credential and select it in `Get YouTube Video`.
4. Add a Telegram credential, select it in `Telegram` and replace `<YOUR_TELEGRAM_CHAT_ID>` with the chat's id.
5. Save, open `Webhook` and use its test address. Post a link to it:

```bash
curl -X POST "<YOUR_N8N_HOST>/webhook-test/ytube" -H "Content-Type: application/json" -d '{"youtubeUrl": "https://www.youtube.com/watch?v=<VIDEO_ID>"}'
```

6. To use it for real, publish the workflow and post to `<YOUR_N8N_HOST>/webhook/ytube`.

## How a run goes

1. `Webhook` takes a POST at the path `ytube` and keeps the caller waiting until `Respond to Webhook`.
2. `Get YouTube URL` copies `body.youtubeUrl` into a field named `youtubeUrl`.
3. `YouTube Video ID` pulls the 11-character id out of the link with a regular expression. It reads watch, `youtu.be`
   and embed links. A Shorts or live link gives it no id.
4. `Get YouTube Video` looks the video up, which gives the title, the description and the id.
5. `Summarize and Analyze Video` posts to Gemini's `interactions` endpoint with the model `gemini-3.8-flash`. The body
   holds the prompt and the video's watch address, built from the id. `store` is false, so Google keeps no copy of the
   exchange for later turns.
6. `Response Object` takes the model's text from the `steps` of the answer and sets `summary`, an empty `topics`,
   `title`, `description`, `id` and `youtubeUrl`.
7. `Respond to Webhook` returns those fields to the caller as JSON, and `Telegram` sends the title and the link.

## Change the result

- The summary's shape: the prompt inside the body of `Summarize and Analyze Video`.
- The model: the `model` line in the same body.
- What the caller gets back: the fields of `Response Object`.
- The Telegram message: the text of `Telegram`.

## Good to know

- Gemini reads public videos only, not private or unlisted ones. Google's video understanding page, read on 12 November
  2026, calls the YouTube link feature a preview and says its pricing and limits are likely to change. On the free tier
  it takes at most 8 hours of YouTube video a day.
- The Interactions API keeps a request for a day on the free tier and 55 days on a paid one unless `store` is false.
  This file sets it to false.
- The webhook has no authentication, as in the original copy. Anyone who learns its address can start a run that spends
  Gemini quota and sends a Telegram message. Turn on Basic Auth or Header Auth in `Webhook` before you publish.
- Telegram's HTML mode refuses a title that holds a stray `<` or `&`.
- `topics` is always an empty list. Nothing fills it.
- When Gemini answers with an error, the answer has no `steps` and `Response Object` fails.
- The video link goes to Google. The title and the link go to Telegram.
````

## What is in it

3 files, 14 KB, downloaded as a zip.

```text
NOTICE.md  640 B
README.md  5 KB
workflow.json  8 KB
```

## Workflow check

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

- Steps: 8 steps, starting when its webhook is called
- AI: No step calls an AI model
- Sign-ins: Signs in to: YouTube, Google Gemini and Telegram
- 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/0be36527-02d6-4ea7-896c-3e48144584b2)
- [Its page on Mindket](https://mindket.com/p/0be36527-02d6-4ea7-896c-3e48144584b2)
