Auto-Summarize YouTube Playlist Podcasts: Transcribe → AI Summary → Save to Sheet

Input a YouTube playlist → extract videos and fetch transcripts → generate structured AI summaries with Groq → output each record to Google Sheets

Who

n8n users who want to batch-process podcasts or long videos and auto-archive summaries

You get

Every video in a playlist gets transcribed, summarized with sectioned AI output, and logged to Google Sheets

You need

n8n · google-sheets

Steps

1. Configure credentials and prerequisites

   Create and connect three credentials in n8n: youTubeOAuth2Api (YouTube Data API), googleSheetsOAuth2Api (Google Sheets), and groqApi (Groq LLM). Additionally, enter your x-api-key in the Header of the Supadata HTTP Request node. Create a target Google Sheets document and obtain its URL/ID.

2. Set up YouTube playlist trigger

   Add a Manual Trigger or Schedule Trigger, then connect to the YouTube Playlist node. In the YouTube Playlist node, enter your playlistId, select resource=playlistItem, operation=getAll, returnAll=true. When executed, it should return raw data for all videos in the playlist.

   Setup guidance · Source text。YouTube Playlist node notes or configuration reference

   Copy prompt

   📺 **YouTube Playlist**
   
   Fetches all videos from a specific YouTube playlist.
   
   **How to change:** Change the `playlistId` to use a different playlist. Adjust `part` to fetch different details. Change credentials for another YouTube account.

3. Extract video titles, URLs, and IDs

   Use a Function node (titles/URL) to extract videoId and title from the YouTube snippet, generate the full YouTube URL, and assign row IDs starting from 2. Then use a Code node (video ID) to parse the pure videoId from the URL, preserving id and title. Finally, use a Split Out node to break the array into individual records for looping.

   Execution prompt · Source text。titles/URL Function node's functionCode field

   Copy prompt

   // Extract video URLs, titles, and add an id starting from 2
   return items.map((item, index) => {
     const videoId = item.json.snippet.resourceId.videoId;
     const title = item.json.snippet.title;
     return {
       json: {
         id: index + 2,
         url: `https://www.youtube.com/watch?v=${videoId}`,
         title: title
       }
     };
   });

   Execution prompt · Source text。video ID Code node's jsCode field

   Copy prompt

   return items.map((item, index) => {
     // Get the URL and title from the input
     const url = item.json.url;
     const title = item.json.title || null;
     // Extract the video ID from the URL
     let videoId = null;
     if (url && url.includes('v=')) {
       videoId = url.split('v=')[1].split('&')[0];
     }
     // id starts from 1; change to index+2 if you want to start from 2
     return {
       json: {
         id: index + 2,
         videoId,
         title
       }
     };
   });

4. Loop over items to process one by one

   Add a Loop Over Items (Split In Batches) node to feed individual records downstream sequentially. Each record will go through transcription, merging, summarization, and saving before the next one is picked up.

5. Fetch transcript via Supadata

   Inside the loop, add an HTTP Request node (supadata) with URL `https://api.supadata.ai/v1/transcript?url=https://youtu.be/{{ $json.videoId}}` and Header `x-api-key`. On success, the downstream should receive JSON containing a content array with segmented text.

   Setup guidance · Source text。supadata HTTP Request node notes or configuration reference

   Copy prompt

   📝 **supadata (HTTP Request Node)**
   
   Calls the Supadata API to get the transcript for each video.
   
   **How to change:** Update the API URL or key if the service changes. Modify request headers or parameters for other APIs.

6. Merge transcript segments and extract opening sentences

   First, use a Code node (scirpt) to iterate through the content array and concatenate all segment.text into a single string called script. Then use a Code node (Code1) to split script into sentences and extract the first 5 (the code uses slice(0,5) though the comment says 10; be aware of the actual behavior), outputting firstTenSentences for the AI Agent.

   Execution prompt · Source text。scirpt Code node's jsCode field

   Copy prompt

   // Combine all "text" fields from the content array into one string
   let script = '';
   
   // Loop through all input items
   for (const item of items) {
     if (item.json.content && Array.isArray(item.json.content)) {
       for (const segment of item.json.content) {
         if (segment.text) {
           script += segment.text + ' ';
         }
       }
     }
   }
   
   script = script.trim();
   
   return [
     {
       json: {
         script
       }
     }
   ];

   Execution prompt · Source text。Code1 Code node's jsCode field

   Copy prompt

   // Get the script text
   const script = items[0].json.script || "";
   
   // Split into sentences using a regular expression
   const sentences = script.match(/[^\.!\?]+[\.!\?]+/g) || [];
   
   // Get the first 10 sentences (or fewer if less than 10)
   const firstTen = sentences.slice(0, 5).join(' ').trim();
   
   return [
     {
       json: {
         firstTenSentences: firstTen
       }
     }
   ];

7. Generate structured summary with Groq AI Agent

   Add an AI Agent node with promptType=define, and paste the following prompt into the text field. Also add a Groq Chat Model sub-node, select model llama-3.1-8b-instant, and connect the groqApi credential. The AI Agent receives `{{ $json.firstTenSentences }}` as input and outputs a structured summary to `{{ $json.output }}`.

   Execution prompt · Source text。AI Agent1 node's text field (promptType=define)

   Copy prompt

   =Summarize the following podcast script.
   The summary must be clear, well-organized, and comprehensive.
   
   Include all important information, data, and key points from the script.
   
   Divide the summary into sections according to the main topics, ideas, or parts discussed in the podcast.
   
   For each section, list all main points, facts, examples, and arguments mentioned.
   
   Do not omit any significant information or insight.
   
   The summary should be detailed enough to give a full understanding of the podcast, but avoid unnecessary repetition or filler.
   
   Use headings and bullet points for clarity.
   
   The result should be useful for someone who has not listened to the podcast but wants to understand all its important content and insights. podcast: {{ $json.firstTenSentences }}

   Execution prompt · Source text。Confirm the destination, input variables and output format before use.

   Copy prompt

   📜 **scirpt (Code Node)**
   
   Combines the transcript segments into a single script string.
   
   **How to change:** Change logic to format or preprocess the script differently (e.g., filter out certain lines).

   Execution prompt · Source text。Confirm the destination, input variables and output format before use.

   Copy prompt

   ✂️ **Code1 (Code Node)**
   
   Extracts the first few sentences from the script for summarization.
   
   **How to change:** Adjust the number of sentences extracted. Change the splitting logic for different transcript formats.

8. Write results to Google Sheets

   Add a Google Sheets node, operation=update, select your documentId and sheetName. In columns, define four mappings: video titles = `{{ $('Loop Over Items1').item.json.title }}`, script = `{{ $('scirpt').item.json.script }}`, summery = `{{ $json.output }}`, row_number = `{{ $('Loop Over Items1').item.json.id }}`. Set matchingColumns to row_number to update by row ID.

9. Activate and test the workflow

   Save and execute manually once. Verify that YouTube data retrieval, Supadata transcription, Groq summarization, and Google Sheets writing all complete without errors. Once confirmed, switch the trigger to Schedule for daily automatic runs. [First-test safety] Create a test Google Sheet first and temporarily point documentId there, or add a breakpoint/IF before the Sheets node; connect the real spreadsheet only after the rows look correct.

You are setting up an n8n automation workflow: automatically fetch videos from a YouTube playlist, transcribe and summarize each with AI, then archive to Google Sheets. First confirm you have an n8n instance, YouTube OAuth2, Google Sheets OAuth2, Groq API key, and Supadata API key ready, then import the template and fill in all REDACTED parameters step by step.