mcp-youtube-transcript
Provides tools for extracting and analyzing YouTube video transcripts, including transcript extraction, quality analysis, metadata retrieval, and search capabilities.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@mcp-youtube-transcriptGet transcript from https://youtu.be/dQw4w9WgXcQ"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
🎥 YouTube Video Intelligence Suite
Professional-grade YouTube transcript extraction and AI-powered video analysis for Claude Desktop
A comprehensive Model Context Protocol (MCP) server that transforms YouTube videos into intelligent, searchable content through advanced transcript extraction and AI analysis. No API keys required - works seamlessly with Claude Desktop's built-in intelligence.
� Current Version: v0.5.0
Latest Enhancement: VTT→SRV1 Migration with Enhanced Quality Analysis
Smart Format Fallback: SRV1 → JSON3 → TTML → VTT priority chain for superior quality
Advanced Quality Analysis: Comprehensive safety validation with quality scoring
Enhanced Deduplication: Intelligent duplicate detection with effectiveness tracking
Professional-Grade Output: Industry-standard transcript quality with safety validation
Related MCP server: YouTube Transcript MCP Server
🚀 Quick Start
Prerequisites
Python 3.10+
uv package manager
Claude Desktop app
No API keys required! ✨
Installation & Testing
# Clone and setup
git clone <repository-url>
cd mcp-youtube-transcript
uv sync
# Quick test (optional but recommended)
python quick_test.py
# Or use automated setup
./setup.shClaude Desktop Configuration
Edit ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"youtube-transcript": {
"command": "uv",
"args": [
"run",
"--directory",
"/FULL/PATH/TO/mcp-youtube-transcript",
"python",
"main.py"
]
}
}
}⚠️ Replace /FULL/PATH/TO/mcp-youtube-transcript with your actual project path!
Test in Claude Desktop
Get the transcript from: https://www.youtube.com/watch?v=jNQXAC9IVRw📖 For complete setup instructions, see DEPLOYMENT_GUIDE.md
🛠️ Standalone Extraction Tools
NEW: Professional CLI Tool (Decoupled from MCP)
A complete standalone extraction system with transcript + comment support:
# Extract transcript only
uv run python scripts/youtube_extract.py <video-url>
# Extract transcript + comments
uv run python scripts/youtube_extract.py <video-url> --comments --max-comments 100
# With custom options
uv run python scripts/youtube_extract.py <video-url> \
--comments \
--max-comments 50 \
--comment-replies \
--format both \
--output ./data
# Minimal format optimized for Claude
uv run python scripts/youtube_extract.py <video-url> --minimalFeatures:
✅ Transcript extraction (multi-format fallback)
✅ Comment extraction with threading
✅ Quality analysis and metrics
✅ Multiple output formats (Markdown, JSON)
✅ Completely standalone (no MCP dependency)
✅ Production-ready error handling
📖 Full documentation: docs/STANDALONE_CLI.md
Legacy Tool (MCP-focused)
# Basic extraction for MCP resources
uv run scripts/youtube_to_mcp.py <video-url>
# Output saved to resources/transcripts/ as markdown files🌟 Features
🏗️ Complete MCP Architecture
8 Core Tools - Professional transcript extraction + advanced analysis
6 Smart Resources - Zero-token access to cached data and analytics
3 Essential Prompts - Guided conversation starters for common workflows
Enhanced Quality Pipeline - Advanced deduplication and safety validation
Rich Metadata - Comprehensive video information with engagement metrics
Modular Design - Shared extraction module for consistency across interfaces
🚀 Enhanced Extraction Pipeline (v0.5.0)
Smart Format Fallback - SRV1 → JSON3 → TTML → VTT priority chain for best quality
Advanced Quality Analysis - Comprehensive safety validation with quality metrics
Intelligent Deduplication - Advanced algorithms with effectiveness tracking
HTML Entity Support - Proper decoding across all subtitle formats
Context-Aware Validation - Video metadata integration for enhanced assessment
Professional-Grade Output - Industry-standard transcript quality
Core Transcript Extraction
Multi-format YouTube URL support (youtube.com, youtu.be, embed URLs)
Multi-language transcript extraction with automatic fallbacks
Robust error handling with detailed quality analysis
yt-dlp based extraction for universal reliability (no cloud server blocking)
Enhanced text processing with proper HTML entity decoding
🔧 8 Core Tools
Transcript Extraction
get_youtube_transcript - Primary extraction with quality analysis
get_youtube_transcript_ytdlp - Alternative extraction method
get_plain_text_transcript - Clean text output with deduplication
get_transcript_quality_analysis - Comprehensive quality metrics
Video Analysis
get_enhanced_video_metadata - Rich video information and engagement metrics
create_mcp_resource_from_transcript_v2 - Save transcripts as MCP resources
System Tools
search_transcript - Find content within transcripts
get_system_status - Server health and configuration info
📊 6 Smart Resources
Access cached data and enhanced content through MCP resources:
transcripts://available - Browse all available transcripts
transcripts://content/{video_id} - Access specific transcript content
transcripts://cached - View all cached transcripts with metadata
transcripts://quality_report - System-wide quality analytics and trends
analytics://history - View previous analysis results and usage patterns
system://status - Server status and configuration information
🎯 3 Essential Prompts
Guided workflows for comprehensive analysis:
transcript_analysis_workshop - Deep-dive video content analysis
study_notes_generator - Create structured study materials from videos
video_insight_explorer - Comprehensive video exploration and insights
🎨 What You Can Do
Basic Operations
"Get the transcript from: [YouTube URL]"
"Extract transcript from this video: [URL]"
"Show me the quality analysis for: [URL]"Advanced Analysis
"Analyze this video for key points: [URL]"
"Create study notes from: [Educational video URL]"
"Generate a comprehensive analysis of: [URL]"
"Compare the arguments in these videos: [URL1] [URL2]"Resource Access
"Show me all cached transcripts"
"What's the quality report for the system?"
"Access the transcript content for video ID: abc123"🏗️ Architecture
Modular Design
src/youtube_core/ - Standalone extraction library (NEW!)
extractor.py- Core extraction classtranscript.py- Transcript extraction logiccomments.py- Comment retrieval systemquality.py- Quality analysis engineformatters.py- Output formattingconfig.py- Configuration management
streamlined_server.py - Complete MCP server implementation
main.py - Entry point for Claude Desktop integration
scripts/youtube_extract.py - Professional standalone CLI tool
scripts/youtube_to_mcp.py - Legacy MCP-focused tool
Quality-First Approach
Smart Format Selection - Automatic fallback ensures best available quality
Advanced Deduplication - Sophisticated algorithms remove caption overlaps
Safety Validation - Multi-layer content quality checks
Professional Output - Industry-standard transcript formatting
Standalone Core Library
The new youtube_core module provides:
Zero MCP dependency - Use independently anywhere
Programmatic API - Import and use in your Python projects
Complete functionality - Transcript + comments + metadata + quality analysis
Production-ready - Error handling, timeouts, retries
from youtube_core import YouTubeExtractor
extractor = YouTubeExtractor()
result = extractor.extract(url, include_comments=True)Zero Dependencies Bloat
yt-dlp - Reliable transcript extraction (no cloud server blocking)
mcp - Model Context Protocol integration (optional for standalone use)
Pure Python - No heavy AI libraries or API dependencies
📈 Version History
v0.5.0 (Current) - VTT→SRV1 Migration
Smart format fallback system (SRV1 → JSON3 → TTML → VTT)
Enhanced quality analysis with safety validation
Advanced deduplication with effectiveness tracking
Professional-grade transcript quality
v0.4.0 - Complete yt-dlp Migration
Removed youtube-transcript-api dependency
Universal reliability with yt-dlp-only approach
Enhanced VTT processing and deduplication
Eliminated cloud server blocking issues
v0.3.0 - Enhanced Quality & Rich Resources
Major quality improvements (5,700% richer content)
Advanced deduplication algorithms
Comprehensive resource architecture
Enhanced metadata integration
🔧 Troubleshooting
Common Issues
"Command not found: uv"
curl -LsSf https://astral.sh/uv/install.sh | sh source ~/.zshrcClaude Desktop not recognizing server
Verify full path in claude_desktop_config.json
Restart Claude Desktop completely
Run
python quick_test.pyto validate setup
Transcript extraction fails
Check internet connection
Verify video has available transcripts
Try alternative extraction method
Validation
# Test everything works
python quick_test.py
# Test manual extraction
uv run scripts/youtube_to_mcp.py https://www.youtube.com/watch?v=jNQXAC9IVRw📚 Documentation
DEPLOYMENT_GUIDE.md - Complete setup instructions
docs/ - Comprehensive documentation
CHANGELOG.md - Version history and changes
SHARING_SUMMARY.md - Repository sharing guide
🎯 Success Criteria
You should be able to:
Extract transcripts from any YouTube video
Perform AI analysis without API keys
Access cached content through MCP resources
Use guided prompts for complex analysis
Run standalone extraction scripts
Get professional-grade transcript quality
🎉 Transform YouTube videos into intelligent, searchable content with professional-grade quality! 🎥✨
Available Tools
8 toolscreate_mcp_resource_from_transcript_v2A
Create a persistent MCP resource from a YouTube video transcript.
This creates a markdown file in resources/transcripts/ that can be accessed with zero token consumption via MCP resources.
Args: video_url: YouTube video URL resource_name: Optional custom name for the resource (auto-generated if empty)
| Name | Required | Description | Default |
|---|---|---|---|
| video_url | Yes | ||
| resource_name | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the side effect of creating a markdown file at a specific path and the benefit of zero token consumption. However, it does not mention whether an existing resource with the same name is overwritten, what permissions are required, or what the tool returns after creation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief and well-structured: a purpose statement, a benefit/location sentence, and an Args list. Every sentence contributes value, and the information is front-loaded. No fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is a mutation with no annotations and no output schema, so the description must cover side effects and results. It states the file creation path and persistence, but it does not explain the return value (e.g., resource URI or path) or error scenarios. For a simple create tool, this is a noticeable gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema properties have no descriptions (0% coverage), but the description includes an Args section that explains both parameters: video_url is a YouTube video URL, and resource_name is optional with auto-generation if empty. This provides meaning beyond the bare schema, though it could add constraints like URL format or naming rules.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Create a persistent MCP resource from a YouTube video transcript.' It specifies the exact output (a markdown file in resources/transcripts/) and distinguishes it from siblings like get_youtube_transcript by focusing on persistence and zero-token access.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool: when you want a persistent, zero-token-accessible resource from a transcript. It does not explicitly name alternatives or exclusions (e.g., 'if you don't need persistence, use get_youtube_transcript'), but the value proposition is evident.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_enhanced_video_metadataC
Get comprehensive video metadata using enhanced extraction pipeline.
Args: video_url: YouTube video URL
| Name | Required | Description | Default |
|---|---|---|---|
| video_url | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the full burden of behavioral disclosure. The only behavioral claim is 'enhanced extraction pipeline,' which hints at a more involved process but does not explain potential side effects, rate limits, failure modes, or whether it requires authentication. As a 'get' operation, it is presumably safe, but the description lacks any explicit transparency about what happens under the hood.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, consisting of a single line and an 'Args' section, with no redundant filler. It is front-loaded with the core purpose. The 'Args' section adds useful parameter context, though it is slightly under-specified for a tool with no schema descriptions. Overall, it earns a high score for brevity, though not a 5 due to the lack of behavioral or usage detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema, so the description should explain what metadata is returned. Saying 'comprehensive video metadata' is too vague to guide an agent on expected return values. It also lacks any context about when this tool is relevant or how it differs from simpler metadata retrieval. Given the simple 1-parameter schema, the description is incomplete and leaves significant ambiguity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. The description adds the crucial context that video_url is a 'YouTube video URL,' which the schema does not provide. However, it does not elaborate on URL format, optional parameters, or any constraints, so it only minimally meets the compensation requirement.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Get comprehensive video metadata using enhanced extraction pipeline.' It specifies a clear verb (Get) and resource (video metadata) and is distinguishable from sibling tools which all relate to transcripts. However, the term 'comprehensive' is vague and does not specify exactly what metadata fields are included, preventing a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The sibling tools are all transcript-related, so the implicit context is that this tool is for metadata, but no explicit use cases, prerequisites, or alternatives are mentioned. The description does not explain when this tool is preferred over a simpler metadata tool or any other scenario.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_plain_text_transcriptA
Extract clean plain text transcript without timestamps, optimized for AI analysis.
Args: video_url: YouTube video URL aggressive_dedup: Use aggressive deduplication for cleaner text
| Name | Required | Description | Default |
|---|---|---|---|
| video_url | Yes | ||
| aggressive_dedup | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses that the output is plain text without timestamps and explains the aggressive_dedup parameter's effect. However, it does not mention error handling, authentication, rate limits, or the exact return type, which would be helpful for a tool with no annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: a one-sentence summary followed by an Args section. Every line adds value, with no redundancy or extraneous detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the core functionality and parameter semantics, but lacks details about output format (e.g., whether it returns a string), error cases, or how it relates to the sibling transcript tools. Given the absence of an output schema and annotations, it leaves some gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description compensates by defining both parameters: video_url as the YouTube video URL and aggressive_dedup as a flag for cleaner text. The explanations are clear and add meaning beyond the schema's bare titles and default value, though 'aggressive' could be more explicit.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: extracting a clean plain text transcript without timestamps, optimized for AI analysis. The verb+resource (Extract + plain text transcript) is specific, and the 'without timestamps' detail differentiates it from likely sibling transcript tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for AI analysis when a clean transcript without timestamps is needed. However, it does not explicitly mention when to use this tool over sibling tools like get_youtube_transcript or get_youtube_transcript_ytdlp, nor does it state any exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_transcript_quality_analysisC
Get comprehensive quality analysis for a YouTube video transcript.
Args: video_url: YouTube video URL
| Name | Required | Description | Default |
|---|---|---|---|
| video_url | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure, yet it only says 'comprehensive quality analysis' without detailing what the analysis includes, whether it is read-only, or what output format to expect. The absence of any such context is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately short, with a clear 'Args' structure that front-loads the key parameter. The 'Args' block slightly duplicates the input schema but does not harm readability, and every sentence earns its place in stating the core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that there is no output schema and no annotations, the description should explain what 'quality analysis' entails and what the response includes, but it does not. This is especially inadequate for a tool that presumably returns a complex analysis of a transcript, and the description offers no hints about return structure or side effects.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds 'YouTube video URL' as clarification for the single parameter, which is marginally more specific than the schema's 'Video Url' title. However, with 0% schema description coverage, this minimal addition is insufficient to fully clarify parameter semantics, especially since no validation or format expectations are provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('Get comprehensive quality analysis') and a resource ('YouTube video transcript'), which differentiates it from sibling tools focused on retrieval or metadata extraction. However, 'quality analysis' is somewhat broad and could be more specific about what aspects are analyzed.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance on when to use this tool versus its siblings (e.g., get_youtube_transcript or get_enhanced_video_metadata). There is no mention of prerequisites, use cases, or exclusions, leaving the agent to infer the tool's purpose from its name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_youtube_transcriptB
Get the transcript of a YouTube video using the primary extraction method.
Args: video_url: YouTube video URL language: Language code (e.g., 'en', 'es'). Defaults to 'en'
| Name | Required | Description | Default |
|---|---|---|---|
| language | No | en | |
| video_url | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention output format, error handling, rate limits, or what happens if extraction fails. The only behavioral hint is 'primary extraction method,' which is not elaborated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, with a single purpose sentence and a simple Args list. Every word is functional, and the structure is easy to parse. No filler or redundant content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of sibling tools and no output schema or annotations, the description is incomplete. It does not specify the return format, when to use alternative extraction methods, or any constraints. An agent would struggle to decide between this and the ytdlp variant or understand what to expect as a result.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds some semantics beyond the schema by labeling video_url as 'YouTube video URL' and providing examples for language codes ('en', 'es'). However, it does not explain accepted formats, fallback behaviors, or edge cases, so it only partially compensates for the 0% schema description coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action (Get the transcript), the resource (YouTube video), and the specific method (primary extraction method), which distinguishes it from the sibling tool get_youtube_transcript_ytdlp. The verb and resource are explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus its alternatives. The phrase 'primary extraction method' implies it is the default but does not explain when to choose ytdlp, plain text, or other variants. No exclusions or conditional advice are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_youtube_transcript_ytdlpA
Get the transcript of a YouTube video using yt-dlp (most reliable method).
Args: video_url: YouTube video URL language: Language code (e.g., 'en', 'es'). Defaults to 'en'
| Name | Required | Description | Default |
|---|---|---|---|
| language | No | en | |
| video_url | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden for behavioral disclosure, yet it only states the method (yt-dlp) and parameter syntax. It does not mention potential failures (e.g., no transcript available), return format, rate limits, or authentication requirements, leaving the agent without critical operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, leading with the purpose and then directly listing arguments. No wasted words; every sentence earns its place, and the structure makes the tool easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of an output schema and the presence of multiple transcript-related siblings, the description lacks essential context about return format and when to choose this tool over others. The simplicity of the tool does not justify the missing guidance on expected output and selection criteria.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions are absent (0% coverage), so the description must compensate. It does list both parameters, clarifies that video_url is a YouTube URL, and adds examples and a default for language, providing meaningful semantic value beyond the raw schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action (get transcript), resource (YouTube video), and method (yt-dlp). The phrase 'most reliable method' distinguishes it from sibling tools like get_youtube_transcript, making the purpose unambiguous and differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Most reliable method' provides clear context for preferring this tool, but there is no explicit when-not or alternative naming. The absence of exclusionary guidance prevents a 5, but the comparative statement offers useful direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_transcript_resourcesA
List all available transcript resources in the system.
This tool provides access to stored transcript files that can be loaded without tokens.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, and the description notes that resources are stored transcript files loadable without tokens, which is a useful extra behavior. However, it does not disclose the return format, pagination, read-only nature, or authorization requirements, leaving gaps for a tool with no output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two focused sentences front-load the primary purpose and add one supporting detail about token-free loading. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple zero-param list operation, the description is workable, but it omits what the returned resource entries look like or how they relate to load_transcript_resource. Given no output schema and no sibling differentiation, a little more detail on the result format or next-step use would be needed for higher completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero properties, so there are no parameters or defaults for the description to clarify. Baseline for zero-parameter tools is 4, and the description's mention of 'all available' reinforces the query scope, although it adds no parameter-specific detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'List all available transcript resources in the system.' This clearly distinguishes the listing tool from sibling tools focused on getting or loading transcripts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides some implied context—'stored transcript files that can be loaded without tokens'—but never explicitly contrasts this with sibling tools like get_youtube_transcript or load_transcript_resource. It gives no when/when-not guidance, so an agent must infer that listing is intended for discovery before loading.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
load_transcript_resourceC
Load a specific transcript resource by video ID.
Args: video_id: YouTube video ID to load transcript for
| Name | Required | Description | Default |
|---|---|---|---|
| video_id | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must convey behavioral traits, but it only says 'load' without disclosing whether this is a safe read, whether it requires authentication, what happens on missing video_id, or any side effects. The absence of such details leaves the agent guessing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, with one clear sentence followed by a simple arg list. Every word earns its place, and there is no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no output schema), the description is still incomplete. It does not mention what the loaded resource looks like, potential errors, or how it relates to sibling tools. The term 'resource' is undefined, leaving important gaps for an agent to invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, and the description does add meaning by stating 'video_id: YouTube video ID to load transcript for,' clarifying the parameter's role. However, it is minimal and does not explain any constraints or formats beyond the identifier.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'load' and identifies a clear resource ('transcript resource') and key identifier ('video ID'), making the primary function understandable. However, it does not explicitly distinguish itself from sibling tools like get_youtube_transcript, so it's not a perfect 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus the alternatives (e.g., get_youtube_transcript, list_transcript_resources). The description merely states what it does without context on prerequisites or typical use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Multiple tools (get_youtube_transcript, get_youtube_transcript_ytdlp, get_plain_text_transcript) perform nearly identical functions, differing only in extraction method or output format. This creates significant ambiguity for an agent trying to select the right tool.
Most tools follow a get_* prefix, but the presence of list_, load_, create_, and the _v2 suffix breaks the pattern. The names are readable and descriptive, but not uniformly consistent.
8 tools is within the typical well-scoped range for a domain-specific server. However, the three transcript retrieval tools are somewhat redundant and could be consolidated without losing functionality.
The server covers the full transcript workflow: retrieval, plain text extraction, metadata, quality analysis, and resource management. Minor gaps like timestamp filtering or playlist support exist but do not break core usage.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Clean YouTube transcripts for agents: single videos, channels, playlists, plus AI caption cleanup.
Transcribe YouTube via Whisper. Summaries, chapters, semantic-search across your corpus.
Extract YouTube transcripts, search what was said, and read on-screen frames with cited timestamps.
YouTube transcripts, search, channel/playlist listings and upload tracking for AI agents. No signup.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables AI models like Claude to easily access and utilize subtitle data from YouTube videos by extracting transcripts from video URLs with support for multiple languages.1MIT
- AlicenseNot gradedqualityCmaintenanceEnables Claude AI to extract transcripts from YouTube videos with zero setup required. Works on all platforms including mobile, supports multiple languages, and handles all YouTube URL formats through a cloud-hosted service.64MIT
- AlicenseNot gradedqualityDmaintenanceExtracts captions, metadata, and descriptions from YouTube videos to enable AI assistants to summarize their content.11MIT
- AlicenseAqualityDmaintenanceUnifies YouTube transcripts, YouTube search, and Google NotebookLM into a research pipeline for Claude Desktop and MCP clients.15MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/of3y/mcp-youtube-transcript'
If you have feedback or need assistance with the MCP directory API, please join our Discord server