How can I filter YouTube video metadata and extract transcript structure with OpenAI in n8n?

Below is some guidance on both aspects of your workflow:

---

a. Filtering videos by views and length

• YouTube API limitations:
The YouTube API endpoint you’re using returns video metadata (including statistics and contentDetails), but it doesn’t support filtering by views or video duration in the API call itself. To filter videos by views or duration, you need to retrieve the metadata and then filter the results within your workflow.

• Recommended approach:

1. Retrieve Video Details:
   Use the YouTube node if possible, or an HTTP Request node to call the YouTube API (making sure you supply valid video IDs and API key).

2. Filter using a Function Node:
   Once you have the data, add a Function node to process the results. Here you can, for example:

   • Convert the ISO 8601 duration (from the contentDetails.duration field) to seconds (or minutes) to compare length.
   • Check the statistics.viewCount for each video.
   • Filter out videos that don’t meet your criteria.

   Example Function Node code:

   JAVASCRIPTCopied
   // Assuming 'items' holds the output from your HTTP Request node.
   // Each item should have 'json.statistics.viewCount' 
   // and 'json.contentDetails.duration' in ISO 8601.
   
   const parseISO8601Duration = (duration) => {
     // Simple parser example: PT1H2M3S -> seconds
     const match = duration.match(/PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?/);
     const hours = parseInt(match[1] || 0);
     const minutes = parseInt(match[2] || 0);
     const seconds = parseInt(match[3] || 0);
     return hours * 3600 + minutes * 60 + seconds;
   };
   
   // Define your criteria here
   const minViews = 1000;   // Example criterion for views
   const maxDuration = 600; // Maximum duration in seconds (e.g. 10 minutes)
   
   const filteredItems = items.filter(item => {
     const viewCount = parseInt(item.json.statistics.viewCount);
     const durationSeconds = parseISO8601Duration(item.json.contentDetails.duration);
     
     return viewCount >= minViews && durationSeconds <= maxDuration;
   });
   
   return filteredItems.map(item => ({ json: item.json }));

3. Proceed with Filtered Videos:
   The output of the Function node now contains only the videos meeting your criteria. You can then further process these videos (e.g. pass video URLs or IDs to your Apify transcription process).

---

b. Identifying script structure with OpenAI

• Transcription and analysis context:
It sounds like you’re using Apify to get transcripts. Once you have the transcript for each video, you’ll want to send that transcript to OpenAI (via the OpenAI node or HTTP Request node) with a clear prompt asking for the “structure” (e.g. introduction, body, conclusion, etc.).

• Recommended approach:

1. Use a Function Node (optional):
   If needed, pre-process or shorten the transcript (perhaps only sending a relevant excerpt if the transcript is very long) to avoid token limits.

2. Call OpenAI with a descriptive prompt:
   In your OpenAI node, craft a detailed prompt. For example:

   "Here is a transcript of a YouTube video. Analyze and list its script structure components (for example, introduction, main content segments, conclusion, etc.).

   Transcript: [TRANSCRIPT_PLACEHOLDER]"

   Make sure to pass the transcript into the prompt using an expression, for example:

   JSONCopied
   {
     "model": "gpt-4",
     "messages": [
       {
         "role": "user",
         "content": "Analyze this transcription and identify the script structure including sections like introduction, body, and conclusion. Transcript:\n{{$json[\"transcript\"]}}"
       }
     ]
   }

3. Review OpenAI node settings and credentials:
   Ensure your OpenAI credentials (or API key in case you’re using the HTTP Request node) are set up correctly. If no output is returned, double-check that:

   • The transcript text is being passed correctly.
   • The token limits are not exceeded (if the transcript is too long, consider summarizing it first).
   • You’re handling the output correctly (for instance, by mapping the response to subsequent nodes).

• Troubleshooting Tips:

• If you’re getting errors from the OpenAI node, try testing with a smaller transcript sample.
• You can also test the prompt and response outside of n8n using tools like Postman to ensure your request is structured correctly.

---

Final workflow overview

1. Get Video Data:
   • Use YouTube node or HTTP Request node to fetch video details.
2. Filter Videos:
   • Use a Function node to filter based on views and duration.
3. Get Transcripts:
   • Process each valid video with your Apify transcription integration.
4. Analyze Transcript Structure:
   • Pass the transcript text to an OpenAI node with a clear prompt to extract the script structure.

This approach should allow you to overcome the limitations of filtering directly in the YouTube API and to inspect the transcript structure using OpenAI’s capabilities. If you continue to face issues, verifying your node configurations and credentials (per the n8n HTTP Request node common issues) may also help.

Hope this helps in advancing your workflow!