
Youtube Research
- 149 installs
- 80 repo stars
- Updated May 18, 2026
- manojbajaj95/claude-gtm-plugin
Search YouTube for competitor videos, trends, and audience questions so Claude can inform positioning, content strategy, and launch messaging.
About
Research skill for Claude to investigate YouTube for niche trends, competitor explainers, viewer comments, and content gaps that shape GTM messaging, tutorial plans, and launch creative direction.
- Competitor video scans
- Trend scouting
- Comment mining
- Content gap analysis
- Audience question extraction
Youtube Research by the numbers
- 149 all-time installs (skills.sh)
- +1 installs in the week ending Aug 2, 2026 (Skillselion tracking)
- Ranked #1,050 of 1,879 Marketing & SEO skills by installs in the Skillselion catalog
- Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/manojbajaj95/claude-gtm-plugin --skill youtube-researchAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 149 |
|---|---|
| repo stars | ★ 80 |
| Last updated | May 18, 2026 |
| Repository | manojbajaj95/claude-gtm-plugin ↗ |
What it does
Search YouTube for competitor videos, trends, and audience questions so Claude can inform positioning, content strategy, and launch messaging.
Files
YouTube Research
Workspace Context
Read bootstrap context before asking questions: strategy/brand.md for brand, audience, offer, channels, tools, constraints, and metrics; about/me.md for personal voice; content/ideas.md and content/calendar.md for content planning. Use legacy product-marketing context files only as fallback. Save generated drafts to content/<platform>/drafts/YYYY-MM-DD_short-topic-slug.md, and route durable learnings back to strategy/brand.md, about/me.md, or content/ideas.md.
Operating Contract
This skill is self-contained for its frontmatter scope: use its local instructions, references, scripts, and assets as the playbook; ask only for missing task-specific inputs; hand off to adjacent skills instead of expanding scope; and return an actionable artifact, decision, plan, draft, or diagnostic.
Three modes in one skill:
1. Topic Research — competitive landscape, content gaps, strategic insights before planning a video 2. Video Analysis — forensic deconstruction of transcripts to extract viral formulas and retention mechanics 3. API Queries — direct YouTube Data API v3 access for search, stats, comments, and channel info
---
When to Use
- Researching a video topic before planning production
- Analyzing a competitor video to extract what makes it work
- Fetching channel stats, video metrics, or comments via the API
- Identifying content gaps and opportunities in a niche
---
YouTube Data API Setup
1. Get an API Key
1. Go to Google Cloud Console → APIs & Services → Library 2. Enable YouTube Data API v3 3. Create Credentials → API Key
export YOUTUBE_API_KEY="your-api-key-here"Important: When piping curl output, wrap the command in bash -c '...' to preserve env vars:```bash
bash -c 'curl -s "https://..." -H "..." | jq .'
```
2. Key API Commands
Search Videos:
bash -c 'curl -s "https://www.googleapis.com/youtube/v3/search?part=snippet&q=YOUR_QUERY&type=video&maxResults=10&order=viewCount&key=${YOUTUBE_API_KEY}"' | jq '.items[] | {videoId: .id.videoId, title: .snippet.title, channel: .snippet.channelTitle}'Get Video Details (stats, duration):
bash -c 'curl -s "https://www.googleapis.com/youtube/v3/videos?part=snippet,statistics,contentDetails&id=VIDEO_ID&key=${YOUTUBE_API_KEY}"' | jq '.items[0] | {title: .snippet.title, views: .statistics.viewCount, likes: .statistics.likeCount, duration: .contentDetails.duration}'Get Channel by Handle:
bash -c 'curl -s "https://www.googleapis.com/youtube/v3/channels?part=snippet,statistics&forHandle=@HANDLE&key=${YOUTUBE_API_KEY}"' | jq '.items[0] | {id: .id, title: .snippet.title, subscribers: .statistics.subscriberCount, videos: .statistics.videoCount}'Get Video Comments:
bash -c 'curl -s "https://www.googleapis.com/youtube/v3/commentThreads?part=snippet&videoId=VIDEO_ID&maxResults=20&order=relevance&key=${YOUTUBE_API_KEY}"' | jq '.items[] | {author: .snippet.topLevelComment.snippet.authorDisplayName, text: .snippet.topLevelComment.snippet.textDisplay, likes: .snippet.topLevelComment.snippet.likeCount}'Get Trending Videos:
bash -c 'curl -s "https://www.googleapis.com/youtube/v3/videos?part=snippet,statistics&chart=mostPopular®ionCode=US&maxResults=10&key=${YOUTUBE_API_KEY}"' | jq '.items[] | {title: .snippet.title, channel: .snippet.channelTitle, views: .statistics.viewCount}'Quota: 10,000 units/day. Search = 100 units. Most others = 1 unit.
See YouTube Data API docs for full reference.
---
Mode 1: Topic Research
Conduct research before planning a new video. Focus on insights and big levers — not data dumping.
Workflow
Step 0: Create research file
Save all research to: ./youtube/episode/[episode_number]_[topic_short_name]/research.md
If it already exists, read it and continue from where it left off.
Step 1: Understand the topic
- What problem does this video solve?
- Why would someone click on it?
- What makes it relevant now?
Step 2: Research your own channel
Use the API to find related videos you've already published. Document:
- Related videos (title, video ID, URL, key metrics)
- What's already been covered and how to differentiate
Step 3: Competitor research
Search for 5–8 top videos on the topic. For each:
- Get video details (views, likes, duration)
- Note the title, angle, and what makes it successful
- Synthesize common patterns and approaches
Step 4: Content gap analysis
Document:
- What's saturated — 3–5 over-covered angles
- Gaps (Opportunities) — rated ⭐⭐⭐ high / ⭐⭐ medium / ⭐ low
- Recommended focus — specific angle + unique value proposition
Rating criteria:
- ⭐⭐⭐ High: Significant gap, strong demand, clear differentiation
- ⭐⭐ Medium: Moderate gap, some competition, good potential
- ⭐ Low: Minor gap, heavily competed
Research File Template
# [Episode]: [Topic] - Research
## Episode Overview
**Topic**: [Brief description]
**Target Audience**: [Who this is for]
**Goal**: [What viewers will learn/gain]
## YouTube Research
### Your Previous Videos
[Related videos with metrics]
### Top Competing Videos
[5-8 videos: title, channel, views, angle, what works]
### Key Insights
[Patterns and findings synthesized]
## Content Gap Analysis
### What's Already Well-Covered
[List]
### Content Gaps (Opportunities)
[Rated list with ⭐ ratings]
### Recommended Focus
[Specific angle and unique value proposition]
## Production Notes
**Status**: Research Complete
**Created**: [Date]Parallel Research
If the host environment supports parallel research, split focused tasks such as competitor search, own-channel review, and comment mining. Otherwise, do them sequentially and synthesize findings after each section.
Pitfalls
- Data dumping — Limit to 5–8 competitors, synthesize patterns instead of listing every video
- Vague gaps — "Not much content on this" → identify the specific missing angle
- Long reports — Focus on insights and big levers
Next step: Use youtube-content skill to plan the video based on this research.
---
Mode 2: Video Analysis
Forensic deconstruction of video transcripts to extract viral formulas, hooks, and retention mechanics.
Getting the Transcript
Auto-fetch:
python skills/youtube-research/scripts/fetch_transcript.py "YOUTUBE_URL_OR_VIDEO_ID"Manual paste: YouTube's built-in transcript (click "..." → "Show transcript") or ytscribe.ai.
Analysis Framework
Approach the transcript like a crime scene — extract everything systematically. See reference/analysis-framework.md for the full checklist and templates.
Analyze these 11 dimensions:
1. Hook Architecture — Primary hook (first 3–8s), hook type, secondary hooks, fill-in-blank templates 2. Structural Blueprint — Content framework (PAS, Story-Lesson-CTA, List-Depth-Summary), beat map, pacing 3. Retention Mechanics — Open loops, pattern interrupts, curiosity gaps, payoff points 4. Emotional Engineering — Emotional arc, trigger words, identity hooks, Us vs. Them dynamics 5. Storytelling Elements — Narrative framework, character positioning, conflict/stakes, specificity 6. Linguistic Patterns — Power phrases, sentence rhythm, repetition, conversational triggers 7. Algorithm Signals — Watch time optimizers, engagement bait, share/save triggers 8. CTA Architecture — Primary CTA, soft CTAs, timing, value exchange 9. Viral Coefficient — Shareability score (1–10), comment bait density, crossover potential 10. Reusable Templates — Fill-in-blank opening hooks (3 variations), section templates, transition library 11. Implementation Playbook — Top 10 steal-this elements, niche adaptation, A/B test suggestions
Before Analysis, Collect Context
- Your niche/topic
- Your content style (casual, educational, hype, etc.)
- Target platform and video length goal
Output Format
Structure output with all 11 sections. End with a Quick Reference Cheatsheet — one-page summary of all extracted patterns for rapid implementation.
---
Tools
- YouTube API:
bash -c 'curl ...'with$YOUTUBE_API_KEY - MCP (if available):
mcp__plugin_yt-content-strategist_youtube-analytics__search_videos,get_video_details,get_channel_details - Web:
WebSearchandWebFetchfor industry trends and context
Viral Video Analysis Framework
Quick reference for the 11-section viral content deconstruction.
---
Analysis Checklist
1. Hook Architecture
- [ ] Primary hook extracted (first 3-8 seconds)
- [ ] Hook type identified (curiosity gap, pattern interrupt, bold claim, controversy, story loop, identity trigger)
- [ ] Secondary hooks cataloged with timestamps
- [ ] Fill-in-blank templates created
2. Structural Blueprint
- [ ] Content framework identified (PAS, Story-Lesson-CTA, List-Depth-Summary, etc.)
- [ ] Beat map complete (all transition points)
- [ ] Pacing pattern analyzed
- [ ] Section breakdown with time percentages
3. Retention Mechanics
- [ ] Open loops cataloged
- [ ] Pattern interrupts listed
- [ ] Curiosity gaps identified
- [ ] Payoff points mapped
4. Emotional Engineering
- [ ] Emotional arc graphed
- [ ] Trigger words extracted
- [ ] Identity hooks found
- [ ] Us vs. Them dynamics noted
5. Storytelling Elements
- [ ] Narrative framework identified
- [ ] Character positioning analyzed
- [ ] Conflict/stakes mapped
- [ ] Specificity anchors listed
6. Linguistic Patterns
- [ ] Power phrases extracted
- [ ] Sentence rhythm analyzed
- [ ] Repetition techniques noted
- [ ] Conversational triggers mapped
7. Algorithm Signals
- [ ] Watch time optimizers found
- [ ] Engagement bait identified
- [ ] Share/save triggers noted
- [ ] Subscribe hooks analyzed
8. CTA Architecture
- [ ] Primary CTA mapped
- [ ] Soft CTAs throughout noted
- [ ] Timing analyzed
- [ ] Value exchange defined
9. Viral Coefficient
- [ ] Shareability scored (1-10)
- [ ] Comment bait density measured
- [ ] Controversy calibration assessed
- [ ] Crossover potential evaluated
10. Reusable Templates
- [ ] Opening hook templates (3 variations)
- [ ] Section templates with blanks
- [ ] Transition phrase library
- [ ] CTA templates
11. Implementation Playbook
- [ ] Top 10 steal-this elements
- [ ] Niche adaptation guide
- [ ] Common mistakes listed
- [ ] A/B test suggestions
---
Hook Types Reference
| Type | Description | Example Pattern |
|---|---|---|
| Curiosity Gap | Creates information deficit | "The one thing nobody tells you about..." |
| Pattern Interrupt | Breaks expectations | "Forget everything you know about..." |
| Bold Claim | Makes audacious statement | "This changed my entire business in 30 days" |
| Controversy | Challenges consensus | "Why [popular thing] is actually wrong" |
| Story Loop | Opens narrative | "Last week, something happened that..." |
| Identity Trigger | Speaks to who viewer is | "If you're a [type of person], this is for you" |
---
Content Framework Templates
Problem-Agitate-Solve (PAS)
[PROBLEM]: State the pain point
[AGITATE]: Make it worse, show consequences
[SOLVE]: Present your solutionStory-Lesson-CTA
[STORY]: Personal narrative or case study
[LESSON]: Key takeaway or insight
[CTA]: What viewer should do nextList-Depth-Summary
[LIST]: Introduce N items/tips/strategies
[DEPTH]: Deep dive on each
[SUMMARY]: Recap + action stepBefore-After-Bridge
[BEFORE]: Current painful state
[AFTER]: Desired future state
[BRIDGE]: How to get there---
Emotional Arc Patterns
The Rollercoaster
Hope → Tension → Relief → Excitement → ActionThe Build-Up
Curiosity → Anticipation → Revelation → SatisfactionThe Transformation
Pain → Struggle → Breakthrough → Triumph---
Power Phrase Templates
Opening Hooks
- "Here's what [experts/nobody] won't tell you about [TOPIC]..."
- "I spent [TIME] figuring out [TOPIC] so you don't have to..."
- "Stop [COMMON MISTAKE] - do this instead..."
- "The [NUMBER] [TOPIC] mistakes that cost me [CONSEQUENCE]..."
Retention Phrases
- "But here's where it gets interesting..."
- "And this is the part most people miss..."
- "Wait, it gets better..."
- "Now pay attention to this next part..."
Transition Phrases
- "Now that you understand [X], let's talk about [Y]..."
- "This brings us to the most important point..."
- "Here's where everything changes..."
CTA Phrases
- "If this helped, you'll love [NEXT ACTION]..."
- "Drop a [COMMENT] if you want me to cover [TOPIC]..."
- "The link is in the description..."
---
Viral Scorecard
Rate each element 1-10:
| Element | Score | Notes |
|---|---|---|
| Hook Strength | /10 | |
| Retention Mechanics | /10 | |
| Emotional Intensity | /10 | |
| Shareability | /10 | |
| Comment Bait | /10 | |
| Practical Value | /10 | |
| Production Quality | /10 | |
| TOTAL | /70 |
Score Interpretation:
- 60-70: Viral potential
- 45-59: Strong performer
- 30-44: Average
- <30: Needs work
---
Quick Implementation Guide
To Clone a Viral Formula
1. Extract the skeleton - Get the structural framework 2. Keep the timing - Match percentage breakdowns 3. Steal the hooks - Adapt exact patterns 4. Match the energy - Follow pacing rhythm 5. Use the loops - Apply same retention techniques 6. Mirror the arc - Follow emotional journey
Common Mistakes to Avoid
- Copying words instead of patterns
- Ignoring pacing/timing
- Skipping the hook stack
- Weak open loops
- No payoff points
- Generic CTAs
#!/usr/bin/env python3
"""
YouTube Transcript Fetcher
Extracts transcripts from YouTube videos using the youtube-transcript-api library.
No API key required.
Usage:
python fetch_transcript.py "https://youtube.com/watch?v=VIDEO_ID"
python fetch_transcript.py "VIDEO_ID"
python fetch_transcript.py "https://youtu.be/VIDEO_ID"
Install dependency:
pip install youtube-transcript-api
"""
import argparse
import re
import sys
try:
from youtube_transcript_api import YouTubeTranscriptApi
from youtube_transcript_api._errors import (
NoTranscriptFound,
TranscriptsDisabled,
VideoUnavailable,
)
except ImportError:
print("Error: youtube-transcript-api not installed.")
print("Install with: pip install youtube-transcript-api")
sys.exit(1)
def extract_video_id(url_or_id: str) -> str:
"""Extract video ID from various YouTube URL formats or return as-is if already an ID."""
# Already a video ID (11 characters, alphanumeric with - and _)
if re.match(r"^[a-zA-Z0-9_-]{11}$", url_or_id):
return url_or_id
# Standard YouTube URL: youtube.com/watch?v=VIDEO_ID
match = re.search(r"[?&]v=([a-zA-Z0-9_-]{11})", url_or_id)
if match:
return match.group(1)
# Short YouTube URL: youtu.be/VIDEO_ID
match = re.search(r"youtu\.be/([a-zA-Z0-9_-]{11})", url_or_id)
if match:
return match.group(1)
# YouTube Shorts: youtube.com/shorts/VIDEO_ID
match = re.search(r"shorts/([a-zA-Z0-9_-]{11})", url_or_id)
if match:
return match.group(1)
# Embedded URL: youtube.com/embed/VIDEO_ID
match = re.search(r"embed/([a-zA-Z0-9_-]{11})", url_or_id)
if match:
return match.group(1)
# If nothing matched, return as-is and let the API handle the error
return url_or_id
def format_timestamp(seconds: float) -> str:
"""Convert seconds to MM:SS or HH:MM:SS format."""
hours = int(seconds // 3600)
minutes = int((seconds % 3600) // 60)
secs = int(seconds % 60)
if hours > 0:
return f"{hours:02d}:{minutes:02d}:{secs:02d}"
return f"{minutes:02d}:{secs:02d}"
def fetch_transcript(video_id: str, include_timestamps: bool = False, language: str = "en") -> str:
"""
Fetch transcript for a YouTube video.
Args:
video_id: YouTube video ID
include_timestamps: Whether to include timestamps in output
language: Preferred language code (default: "en")
Returns:
Formatted transcript text
"""
try:
# Try to get transcript in preferred language first
transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
try:
# Try manual transcript first (usually higher quality)
transcript = transcript_list.find_manually_created_transcript([language])
except NoTranscriptFound:
try:
# Fall back to auto-generated
transcript = transcript_list.find_generated_transcript([language])
except NoTranscriptFound:
# Fall back to any available transcript
transcript = transcript_list.find_transcript([language])
# Fetch the actual transcript data
transcript_data = transcript.fetch()
# Format output
lines = []
for entry in transcript_data:
text = entry["text"].strip()
if not text:
continue
if include_timestamps:
timestamp = format_timestamp(entry["start"])
lines.append(f"[{timestamp}] {text}")
else:
lines.append(text)
return "\n".join(lines)
except TranscriptsDisabled:
return "Error: Transcripts are disabled for this video."
except VideoUnavailable:
return "Error: Video is unavailable (private, deleted, or invalid ID)."
except NoTranscriptFound:
return f"Error: No transcript found for this video in language '{language}'."
except Exception as e:
return f"Error: {str(e)}"
def main():
parser = argparse.ArgumentParser(
description="Fetch YouTube video transcripts for analysis.",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
Examples:
python fetch_transcript.py "https://youtube.com/watch?v=dQw4w9WgXcQ"
python fetch_transcript.py "dQw4w9WgXcQ" --timestamps
python fetch_transcript.py "https://youtu.be/dQw4w9WgXcQ" --lang es
"""
)
parser.add_argument(
"video",
help="YouTube video URL or video ID"
)
parser.add_argument(
"--timestamps", "-t",
action="store_true",
help="Include timestamps in output"
)
parser.add_argument(
"--lang", "-l",
default="en",
help="Preferred transcript language (default: en)"
)
parser.add_argument(
"--output", "-o",
help="Output file path (default: print to stdout)"
)
args = parser.parse_args()
# Extract video ID
video_id = extract_video_id(args.video)
# Fetch transcript
transcript = fetch_transcript(
video_id,
include_timestamps=args.timestamps,
language=args.lang
)
# Output
if args.output:
with open(args.output, "w", encoding="utf-8") as f:
f.write(transcript)
print(f"Transcript saved to: {args.output}")
else:
print(transcript)
if __name__ == "__main__":
main()