YouTube Ultimate Toolkit MCP
Provides comprehensive access to YouTube content, including video metadata, transcripts with search and timestamp filtering, playlist listings, comments, frame screenshots, and audio clip extraction.
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., "@YouTube Ultimate Toolkit MCPSummarize this video and show the top comments: 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.
A powerful Model Context Protocol (MCP) server that gives Claude AI full access to YouTube content - transcripts, metadata, comments, screenshots, and audio clips.
Works with both Claude Desktop (local) and Claude Web UI (remote with OAuth).
Demo

Related MCP server: YouTube Insights MCP Server
Why This MCP?
Feature | This MCP | Most Others |
Transcripts | ✅ | ✅ |
Timestamps | ✅ | Some |
Time range filtering | ✅ | Rare |
Transcript search | ✅ | Rare |
Key segments (hook/outro) | ✅ | ❌ |
Metadata | ✅ | ✅ |
Playlists | ✅ | Some |
Comments | ✅ | Very rare |
Screenshots | ✅ | 1-2 others |
Audio clips | ✅ | ❌ |
All URL formats | ✅ | Partial |
OAuth 2.1 + PKCE | ✅ | ❌ |
Password protection | ✅ | ❌ |
Rate limiting | ✅ | ❌ |
Claude Web UI support | ✅ | Few |
Features
Tool | Description |
| Fetch video metadata and transcript with search, timestamps, and time ranges |
| List all videos in a playlist |
| Get top comments with likes and reply counts |
| Capture video frames at any timestamp |
| Extract audio clips (max 120s) for speech/music analysis |
Quick Start
Option 1: Local Mode (Claude Desktop)
# Install
git clone https://github.com/Comzee/Youtube-Ultimate-Toolkit-MCP.git
cd Youtube-Ultimate-Toolkit-MCP
npm install
npm run build
# Run
node dist/index.jsAdd to Claude Desktop config (~/.config/claude/claude_desktop_config.json on Linux, ~/Library/Application Support/Claude/claude_desktop_config.json on macOS):
{
"mcpServers": {
"youtube": {
"command": "node",
"args": ["/path/to/Youtube-Ultimate-Toolkit-MCP/dist/index.js"]
}
}
}Option 2: Remote Mode (Claude Web UI)
Remote mode requires OAuth setup and a public URL. See Remote Mode Setup below.
Prerequisites
Node.js 18+
yt-dlp - YouTube content fetcher (must be kept updated)
ffmpeg - For screenshots and audio extraction (optional)
YouTube API Key - For comments feature only (optional)
Installing Prerequisites
Ubuntu/Debian:
# Node.js 18+
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt install -y nodejs
# yt-dlp (keep updated - YouTube breaks old versions frequently)
pip3 install --upgrade yt-dlp
# ffmpeg (for screenshots and audio)
sudo apt install ffmpegmacOS:
brew install node yt-dlp ffmpegWindows:
# Install Node.js from https://nodejs.org
# Install yt-dlp: pip install yt-dlp
# Install ffmpeg from https://ffmpeg.org/download.htmlKeeping yt-dlp Updated
YouTube frequently changes their API. If transcripts stop working, update yt-dlp:
pip3 install --upgrade yt-dlp
# or on systems that complain about externally-managed packages:
pip3 install --upgrade --break-system-packages yt-dlpInstallation
git clone https://github.com/Comzee/Youtube-Ultimate-Toolkit-MCP.git
cd Youtube-Ultimate-Toolkit-MCP
npm install
npm run buildRemote Mode Setup
Remote mode allows you to use this MCP with Claude Web UI (claude.ai) by exposing it over HTTPS with OAuth authentication.
1. Configure Environment
cp .env.example .envEdit .env:
# OAuth credentials
OAUTH_CLIENT_ID=youtube-mcp-client
OAUTH_CLIENT_SECRET=your-secret-here # Generate: openssl rand -hex 32
# Password for the consent page (bcrypt hash)
# Generate: node -e "require('bcrypt').hash('your-password', 12).then(console.log)"
AUTH_PASSWORD_HASH=$2b$12$...your-hash-here...
# Optional: YouTube API key for get_comments tool
YOUTUBE_API_KEY=your-api-key-here2. Start the Server
# Development
npm run start:remote
# Production (with systemd)
sudo cp youtube-mcp.service /etc/systemd/system/
# Edit the service file to set your username and paths
sudo nano /etc/systemd/system/youtube-mcp.service
sudo systemctl daemon-reload
sudo systemctl enable youtube-mcp
sudo systemctl start youtube-mcp3. Set Up HTTPS (Required)
Claude Web UI requires HTTPS. Use nginx as a reverse proxy:
server {
listen 443 ssl;
server_name your-domain.com;
ssl_certificate /path/to/fullchain.pem;
ssl_certificate_key /path/to/privkey.pem;
location / {
proxy_pass http://localhost:3010;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
# WebSocket support
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
# Important for long-running requests
proxy_buffering off;
proxy_cache off;
proxy_read_timeout 86400s;
proxy_send_timeout 86400s;
proxy_set_header X-Accel-Buffering no;
}
}4. Connect Claude Web UI
Go to Settings → Connectors → Add Custom Connector
Enter URL:
https://your-domain.com/mcpStart a new chat and enable the MCP
Ask Claude to fetch a YouTube video - the authorization popup will appear
Enter your password on the consent page and click "Authorize"
Tools Reference
get_video
Fetches video metadata and English transcript.
Parameters:
Parameter | Required | Description |
| Yes | YouTube URL (any format) or video ID |
| No | Add |
| No | Start time for transcript range (e.g., "60", "1:00") |
| No | End time for transcript range |
| No | Search transcript and highlight matches |
| No | Return only hook (first 40s) and outro (last 30s) |
Supported URL formats:
youtube.com/watch?v=VIDEO_IDyoutu.be/VIDEO_IDyoutube.com/shorts/VIDEO_IDyoutube.com/live/VIDEO_IDyoutube.com/embed/VIDEO_IDm.youtube.com/watch?v=VIDEO_IDmusic.youtube.com/watch?v=VIDEO_IDDirect video ID:
dQw4w9WgXcQ
get_playlist
Lists videos in a YouTube playlist.
Parameters:
Parameter | Required | Description |
| Yes | YouTube playlist URL |
| No | Max videos to return (default: 50, max: 200) |
get_comments
Fetches top comments from a video. Requires YOUTUBE_API_KEY in .env.
Parameters:
Parameter | Required | Description |
| Yes | YouTube video URL or ID |
| No | Number of comments (default: 25, max: 100) |
| No | Sort: "relevance" (default) or "time" |
get_screenshot
Captures a frame from a video. Requires ffmpeg.
Parameters:
Parameter | Required | Description |
| Yes | YouTube video URL |
| No | Time to capture (default: "0"). Formats: "30", "1:30", "1:30:00" |
Returns: Base64-encoded JPEG image
get_audio
Extracts audio clips for analysis. Requires ffmpeg.
Parameters:
Parameter | Required | Description |
| Yes | YouTube video URL |
| No | Start time (default: "0") |
| No | End time (optional) |
| No | Max seconds (default: 60, max: 120) |
Returns: Base64-encoded MP3 audio (128kbps)
OAuth & Security
The remote mode implements OAuth 2.1 with PKCE for secure authentication.
How It Works
Claude connects to
/mcp- discovery/handshake methods work without authWhen you use a tool, Claude receives a 401 with OAuth discovery info
Claude performs dynamic client registration
Browser opens the consent page - you enter your password
Claude exchanges the auth code for an access token
Subsequent requests use the Bearer token
Security Features
Feature | Protection |
Password-protected consent | Only you can authorize access |
Bcrypt password hashing | Password stored securely |
Rate limiting | 5 attempts per IP, then 10-minute lockout |
XSS protection | All OAuth parameters HTML-escaped |
Command injection protection | yt-dlp spawned with |
PKCE (S256) | Prevents authorization code interception |
Troubleshooting
"No English transcript available"
Update yt-dlp - YouTube changes frequently:
pip3 install --upgrade yt-dlpMCP won't connect from Claude Web UI
Ensure HTTPS is configured correctly
Check service status:
sudo systemctl status youtube-mcpCheck logs:
sudo journalctl -u youtube-mcp -f
OAuth flow not starting
Verify
.well-known/endpoints return 200 (not 401)Check browser console for CORS errors
Ensure
/registerreturns valid credentials
Authorization window doesn't appear
OAuth triggers on first tool use, not on connection
Start a chat, enable the MCP, then ask Claude to fetch a YouTube video
Claude using wrong/old tools
Disconnect and reconnect the MCP in Claude settings to refresh the tool list.
Claude Project Prompt
Use this prompt in a Claude Project to automatically leverage the MCP:
You have access to the YouTube MCP server. When I share a YouTube URL:
1. Automatically fetch the transcript with get_video
2. Provide a summary, key takeaways, and notable quotes
3. For long videos (10+ min), consider using keySegmentsOnly=true first
Available tools:
- get_video: Transcript and metadata (supports timestamps, time ranges, search)
- get_playlist: List videos in a playlist
- get_comments: Top comments (requires API key)
- get_screenshot: Capture frames at any timestamp
- get_audio: Extract audio clips for analysis (max 120s)Architecture
Transport: Streamable HTTP (MCP spec 2025-03-26)
Sessions: Stateful with UUID identifiers (in-memory)
OAuth: Authorization Code + PKCE, Dynamic Client Registration
Tokens: In-memory storage (lost on restart)
License
MIT - See LICENSE for details.
Contributing
Contributions are welcome! Please open an issue or PR on GitHub.
Available Tools
5 toolsget_audioA
Extract an audio clip from a YouTube video. Returns base64-encoded MP3. Use time range parameters to limit duration (max 120 seconds). Useful for analyzing speech, music, or audio when transcript isn't available.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | YouTube video URL | |
| startTime | No | Start time (e.g., '30', '1:30', '1:30:00'). Default: 0 | 0 |
| endTime | No | End time. If not specified, extracts up to maxDuration from startTime | |
| maxDuration | No | Maximum duration in seconds (default: 60, max: 120) |
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 well by specifying the output format (base64-encoded MP3), time range parameters, and duration limits (max 120 seconds). However, it doesn't mention important behavioral aspects like rate limits, authentication requirements, or what happens with invalid URLs.
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 perfectly structured with three concise sentences that each add value: the core functionality, parameter guidance, and use case context. There's no wasted language, and the most important information comes first.
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 tool with 4 parameters, no annotations, and no output schema, the description provides adequate but not complete coverage. It explains the core functionality and use cases well, but doesn't address error conditions, authentication, or detailed behavioral constraints that would be helpful for an AI agent.
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 description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds some context about time range parameters ('Use time range parameters to limit duration') and mentions the 120-second maximum, but doesn't provide additional semantic meaning beyond what's in the schema descriptions.
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 specific action ('Extract an audio clip'), resource ('from a YouTube video'), and output format ('base64-encoded MP3'), distinguishing it from sibling tools like get_comments or get_screenshot that handle different data types. It provides a complete picture of what the tool does beyond just the name.
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 ('Useful for analyzing speech, music, or audio when transcript isn't available'), which helps differentiate it from potential alternatives. However, it doesn't explicitly mention when NOT to use it or name specific alternative tools from the sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_commentsA
Get top comments from a YouTube video. Returns comment author, text, like count, and reply count. Requires YOUTUBE_API_KEY environment variable. Useful for understanding audience reactions and discussion topics.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | YouTube video URL or video ID | |
| maxResults | No | Maximum number of comments to fetch (default: 25, max: 100) | |
| order | No | Sort order: 'relevance' (default) or 'time' | relevance |
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 adds valuable context beyond the input schema: it specifies the return data (comment author, text, like count, reply count), mentions an environment variable requirement (YOUTUBE_API_KEY), and hints at the tool's utility. However, it lacks details on error handling, rate limits, or pagination behavior.
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 sized and front-loaded: it starts with the core purpose, then lists return values, prerequisites, and utility in three concise sentences. Every sentence adds value without redundancy, making it efficient and well-structured.
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 moderate complexity (3 parameters, no output schema, no annotations), the description is fairly complete. It covers purpose, return data, prerequisites, and utility, but lacks output format details (e.g., structure of returned comments) and error scenarios. Since there is no output schema, some gaps remain in fully describing the tool's behavior.
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 100% description coverage, providing clear details for all parameters (url, maxResults, order). The description does not add any parameter-specific semantics beyond what the schema already explains, such as format examples or usage tips. According to the rules, with high schema coverage (>80%), the baseline is 3 even without param info in the description.
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 purpose: 'Get top comments from a YouTube video.' It specifies the resource (YouTube video comments) and the verb (get), but does not explicitly differentiate from sibling tools like get_video or get_audio, which target different resources. This makes it clear but not fully sibling-distinctive.
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 implied usage context: 'Useful for understanding audience reactions and discussion topics.' This suggests when to use it (for analyzing video engagement), but does not explicitly state when not to use it or name alternatives among sibling tools. No explicit exclusions or comparisons are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_playlistA
Get information about a YouTube playlist including all video titles, durations, and URLs. Useful for understanding playlist contents before selecting specific videos to transcribe.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | YouTube playlist URL | |
| limit | No | Maximum number of videos to list (default: 50, max: 200) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It describes the tool's purpose and output format but lacks behavioral details like rate limits, authentication requirements, error conditions, or pagination behavior. The mention of 'limit' parameter implies some constraint, but this is already covered in the 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 concise sentences with zero waste. The first sentence states the purpose and output, the second provides usage context. Every word earns its place, and information is front-loaded appropriately.
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 read-only tool with no annotations and no output schema, the description adequately covers the basic purpose and usage context. However, it lacks details about return format structure, error handling, or performance characteristics that would be helpful given the absence of structured output documentation.
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 100%, so the schema already documents both parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema (e.g., URL format examples or limit usage context), meeting the baseline for high schema 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 specific action ('Get information about a YouTube playlist') and resource ('YouTube playlist'), listing the exact data returned (video titles, durations, URLs). It distinguishes from sibling tools by focusing on playlist metadata rather than audio extraction, comments, screenshots, or video content.
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 usage ('Useful for understanding playlist contents before selecting specific videos to transcribe'), which implicitly suggests it's a preliminary step. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_screenshotA
Capture a screenshot from a YouTube video at a specific timestamp. Returns the image as base64. Requires ffmpeg to be installed. Useful for getting visual context from specific moments in a video.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | YouTube video URL | |
| timestamp | No | Timestamp to capture (e.g., '30', '1:30', or '1:30:00'). Default: 0 (beginning) | 0 |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and discloses key behavioral traits: it specifies the return format ('Returns the image as base64'), a system requirement ('Requires ffmpeg to be installed'), and the action's purpose. However, it lacks details on error handling, rate limits, or authentication needs.
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 front-loaded with the core purpose, followed by return format, requirement, and usage context in three concise sentences. Each sentence adds value without redundancy, making it efficiently structured and easy to parse.
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 moderate complexity (2 parameters, no output schema, no annotations), the description is largely complete: it explains what the tool does, its output, and a key requirement. However, it could improve by mentioning potential errors or limitations, such as video availability or timestamp validity.
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 100%, so the schema already documents both parameters thoroughly. The description adds no additional meaning beyond what the schema provides, such as examples for timestamp beyond the schema's description, but does not compensate unnecessarily, meeting the baseline for high 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 specific action ('Capture a screenshot'), resource ('from a YouTube video'), and scope ('at a specific timestamp'), distinguishing it from sibling tools like get_audio or get_video by focusing on visual capture rather than audio extraction or metadata retrieval.
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 context ('Useful for getting visual context from specific moments in a video'), but does not explicitly state when to use this tool versus alternatives like get_video for general video info or get_audio for audio extraction. No exclusions or prerequisites beyond ffmpeg are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_videoA
Get a YouTube video's metadata and English transcript with advanced options. Supports timestamps, time range filtering, search within transcript, and key segments extraction. Use this to summarize YouTube videos, find specific moments, or extract key takeaways.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | YouTube video URL (supports all formats: watch, youtu.be, shorts, live, embed, mobile) | |
| includeTimestamps | No | Include timestamps with each line (e.g., [1:23] text) | |
| startTime | No | Start time for transcript range (e.g., '60', '1:00', '1:00:00') | |
| endTime | No | End time for transcript range (e.g., '120', '2:00') | |
| searchTerm | No | Search for this term in transcript - returns matching lines with context | |
| keySegmentsOnly | No | Return only hook (first 40s) and outro (last 30s) for token optimization |
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 of behavioral disclosure. It mentions advanced options like timestamps, time range filtering, search, and key segments extraction, which adds useful context beyond basic retrieval. However, it lacks details on potential limitations (e.g., rate limits, authentication needs, or error handling for invalid URLs), leaving some behavioral aspects unclear.
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 efficiently structured with two sentences: the first states the core purpose and features, and the second provides usage guidelines. Every sentence adds value without redundancy, making it front-loaded and appropriately sized for the tool's complexity.
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 moderate complexity (6 parameters, no output schema, no annotations), the description is mostly complete. It covers purpose, usage, and key features, but lacks details on output format (e.g., structure of metadata/transcript) and potential behavioral constraints. With no output schema, some completeness gaps remain, though the description does a solid job overall.
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 100%, so the schema already documents all 6 parameters thoroughly. The description adds marginal value by summarizing the advanced options (e.g., 'timestamps, time range filtering, search within transcript, and key segments extraction'), but it doesn't provide additional syntax or format details beyond what the schema specifies. This meets the baseline for high schema 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 specific action ('Get a YouTube video's metadata and English transcript') and distinguishes it from sibling tools like get_audio, get_comments, get_playlist, and get_screenshot by focusing on video-specific content extraction. It explicitly mentions advanced options like timestamps, filtering, and key segments extraction, making the purpose highly specific 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?
The description provides explicit guidance on when to use this tool: 'Use this to summarize YouTube videos, find specific moments, or extract key takeaways.' This gives clear use cases and distinguishes it from alternatives like get_audio (for audio extraction) or get_comments (for comment analysis), helping the agent select the appropriate tool based on the task.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
5 tool updates
- First observed
get_audio - First observed
get_comments - First observed
get_playlist - First observed
get_screenshot - First observed
get_video
TDQS
Each tool has a clearly distinct purpose targeting different aspects of YouTube content: audio extraction, comment retrieval, playlist information, screenshot capture, and video metadata/transcript. No overlap exists in functionality, making tool selection straightforward for an agent.
All tools follow a consistent verb_noun naming pattern (get_audio, get_comments, get_playlist, get_screenshot, get_video) with no deviations in style or convention. This predictability enhances usability and clarity.
Five tools is a reasonable number for a YouTube-focused server, covering key functionalities like content extraction and analysis. However, it feels slightly thin for an 'Ultimate Toolkit' as it lacks tools for actions like uploading, managing playlists, or interacting with channels, which might be expected in a comprehensive set.
The tools provide good read-only coverage for extracting and analyzing YouTube content, but there are notable gaps in write operations (e.g., no create, update, or delete tools for playlists, comments, or videos). This limits the server to consumption-only workflows, which may cause agent failures in scenarios requiring interaction or content management.
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
An MCP server that gives any LLM or agent clean YouTube transcripts on demand: a single video, a whole channel, or a playlist, plus AI cleanup of auto-generated captions. API-key auth, credit-based, same backend as the public v1 API. Get a free API key with 25 free credits at youtubetranscriptdownload.com/account.
Hosted MCP server connecting claude.ai, ChatGPT and other AI apps to your own computer
Augments MCP Server - A comprehensive framework documentation provider for Claude Code
MCP server for Google Veo AI video generation
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn MCP server that allows Claude and other AI assistants to interact with the YouTube API, providing tools to search videos/channels and retrieve detailed information about them.571MIT
- FlicenseBqualityDmaintenanceAn MCP server that extracts transcripts, metadata, and summaries from YouTube videos across various URL formats including Shorts and standard links. It provides comprehensive video data and insights for analysis within MCP-compatible environments.3-
- AlicenseNot gradedqualityDmaintenanceA local MCP server that connects Claude to your YouTube channel, enabling video analysis, performance tracking, comment reading, and niche suggestions.27MIT
- AlicenseNot gradedqualityCmaintenanceRemote MCP server that enables Claude AI to extract transcripts from YouTube videos with zero setup, supporting multiple languages and all URL formats.64MIT
Appeared in Searches
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/Comzee/Youtube-Ultimate-Toolkit-MCP'
If you have feedback or need assistance with the MCP directory API, please join our Discord server