YouTube Research MCP
Enables AI agents to research YouTube with multi-language search, transcript highlights, transcript slices by time range/chapter/query, real video frames, video details and chapters, top comments, and channel outlier scores, without requiring a YouTube API key.
Click on "Deploy 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 Research MCPFind this year's top AI productivity videos and quote their opening hooks with timestamps."
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 Research MCP
A keyless YouTube MCP server and research skill for AI agents. Multi-language YouTube search with transcript highlights, transcripts by time range, chapter or query, real video frames, comments and channel outlier scores, in Claude Code, Codex and any MCP client.
Website · Install · Tools · The skill · FAQ
What it does
Ask your agent things like:
"List 20 hooks from this year's top AI productivity videos, with hook type, what's on screen, and a link to the second."
"Which of @channel's videos broke out this year, and what do they have in common?"
"What do creators say is the biggest mistake with AI note-taking? Quote them."
…and get back a table with verbatim quotes, ?t= timestamp links and a coverage line (what was searched, reviewed and skipped). No YouTube Data API key, no OAuth, no cookies.
Most YouTube MCP servers expose one call per video and dump whole transcripts into context. That falls apart when an agent has to look at 50 videos. This one follows the pattern that works for web-search agents: few tools, results that are already useful, and the research method in a skill.
Related MCP server: mcp-youtube-intelligence
Features
🔎 Multi-query, multi-language search in one call. Up to 12 queries, each with its own interface language and region (
hl/gl), merged and de-duplicated. Videos found by several queries rank higher.✨ Transcript highlights. The top results come with the passages that match your topic, with timestamped links, so the agent often never opens a transcript.
✂️ Read only what you need. Transcripts by time range (
start: 0, end: 30for hooks), by chapter, or only the passages matching a query. Up to 25 videos per call.🎞️ Real video frames. Decoded frames (up to 1280 px) evenly spaced over a range or at exact seconds. On-screen text, b-roll and screen demos become visible. ffmpeg reads only the bytes around each frame, never the whole video.
📈 Outlier scores. A channel's videos scored against its median views, to find the breakouts. Views/day on every search result.
💬 Details, chapters, comments. Exact publish date, likes, tags, description, chapters (or description timestamps), top comments with pinned/creator flags, thumbnails.
🧾 Nothing disappears silently. Every response ends with a coverage footer (raw → unique → after filters, what was dropped and why), and per-video failures carry a reason code.
🛡️ Careful with YouTube's limits. API calls and caption downloads have separate queues. A caption rate limit triggers a cooldown instead of retries, and the tools say exactly how long to wait while everything else keeps working. Optional
YT_PROXYfor big sweeps.🧠 A research skill. It plans queries in every relevant language, fans out to parallel subagents, then merges, spot-checks quotes and reports coverage.
Install
The easy way: ask your agent
Paste this into Claude Code, Codex, Cursor or any agent that can run commands:
Install YouTube Research MCP for me from https://github.com/jindratilk/youtube-research-mcp. Follow the "Install instructions for AI agents" in its README for the client you are running in: the plugin (MCP server + research skill) in Claude Code or Codex, otherwise the MCP server config. Then run youtube_doctor and tell me whether everything works, and if I need to restart anything.Claude Code (plugin: MCP server + skill)
claude plugin marketplace add jindratilk/youtube-research-mcpclaude plugin install youtube-research@youtube-researchCodex (plugin: MCP server + skill)
codex plugin marketplace add jindratilk/youtube-research-mcpcodex plugin add youtube-research@youtube-researchClaude Desktop, Cursor, Windsurf, VS Code, Zed, any MCP client
{
"mcpServers": {
"youtube": {
"command": "npx",
"args": ["-y", "github:jindratilk/youtube-research-mcp"]
}
}
}The skill is optional outside the plugins: copy skills/youtube-research into your agent's skills folder.
From source
git clone https://github.com/jindratilk/youtube-research-mcp && cd youtube-research-mcp && npm install && npm run buildclaude mcp add youtube -- node "$PWD/dist/index.js"Requirements: Node.js 20+. dist/index.js is one bundled file with no runtime dependencies. For video frames also install yt-dlp and ffmpeg (brew install yt-dlp ffmpeg); yt-dlp also serves as a transcript fallback.
Install instructions for AI agents
If a user asked you to install YouTube Research MCP, follow these steps exactly.
Check Node.js:
node --versionmust be 20 or newer. If it is older or missing, stop and tell the user.Install for the client you are running in:
Claude Code (the
claudeCLI exists): runclaude plugin marketplace add jindratilk/youtube-research-mcp, thenclaude plugin install youtube-research@youtube-research. This installs theyoutubeMCP server and theyoutube-researchskill.Codex (the
codexCLI exists): runcodex plugin marketplace add jindratilk/youtube-research-mcp, thencodex plugin add youtube-research@youtube-research.Any other MCP client: add this server to the client's MCP config, keeping existing entries:
"youtube": { "command": "npx", "args": ["-y", "github:jindratilk/youtube-research-mcp"] }. Common config files: Claude Desktop~/Library/Application Support/Claude/claude_desktop_config.json(macOS) or%APPDATA%\Claude\claude_desktop_config.json(Windows); Cursor~/.cursor/mcp.json; Windsurf~/.codeium/windsurf/mcp_config.json; VS Code.vscode/mcp.json(uses aserverskey instead ofmcpServers). If the client supports skills, copyskills/youtube-researchinto its skills folder.
Verify now, without a restart: run
npx -y github:jindratilk/youtube-research-mcp --doctor. Every line should start with ✓.yt-dlpandffmpegare optional (needed only for video frames); if they are missing, offer to install them (brew install yt-dlp ffmpegon macOS) but do not install without asking. A[rate_limited]transcript line means YouTube is throttling this IP for a while; everything else still works.Tell the user what you installed, the doctor result, and that they need to start a new session (or restart the app) for the new tools to appear.
Tools
Tool | What it does |
Multi-query search with filters and transcript highlights | |
Batch read: transcript slices, real frames, details, chapters, comments, thumbnail | |
A channel's videos with ×median outlier scores | |
Checks every YouTube path from your machine, with timings |
youtube_search
{
"queries": [
"AI productivity workflow",
"how I use AI to save 10 hours a week",
{ "query": "productividad con IA", "hl": "es", "gl": "ES" }
],
"uploaded": "year",
"minViews": 10000,
"highlights": 5
}Parameter | Meaning |
| 1–12 strings or |
| Results per query before merging (default 10, max 50) |
|
|
|
|
|
|
| Post-filters |
|
|
| Only videos with subtitles/CC |
|
|
| How many top results get transcript passages (default 5) and how many each (default 3) |
| Highlight something other than the search topic, e.g. |
| Preferred caption languages; default is the video's original language |
youtube_fetch
{
"videos": ["https://youtu.be/TL8V41Ea6oM", "htZRCE2GgIs"],
"parts": ["details", "transcript", "frames"],
"start": 0,
"end": 30,
"frames": 4
}Parameter | Meaning |
| 1–25 URLs or IDs (a |
|
|
| Range for transcript and frames, in seconds or |
| Limit to the chapter whose title contains this text |
| Return only matching transcript passages instead of the full text |
|
|
| Transcript budget per video (default 12000); truncation says where to resume |
| N evenly spaced frames, or exact seconds; width up to 1280 px |
| Top comments per video (default 20) |
youtube_channel
{ "channel": "@aliabdaal", "limit": 60, "minOutlier": 2 }Videos, Shorts or streams; latest · popular · oldest; up to 300 videos; subscriber and video counts; publishedAfter; minOutlier to keep only breakouts.
youtube_doctor
No parameters. Checks search, video details, transcripts, watch page, channels, yt-dlp and ffmpeg, and shows an active rate-limit pause.
The research skill
skills/youtube-research turns a request into a supervised sweep:
Define the result first: the row schema and what qualifies (language, recency, views, long-form vs Shorts).
Plan queries by angle and language: how-to, story, tools, mistakes; the user's language plus English, written natively.
Spend transcripts carefully: pick by metadata first; transcripts are the rate-limited resource.
Fan out: up to 3 parallel Haiku subagents, each with exact video IDs, the schema, and the closing lines
videos_reviewed: N/skipped: ….Merge and verify: de-duplicate by video, spot-check quotes against the transcript, report coverage.
References: searching · hooks (10-type taxonomy) · quotes & claims · creators & outliers · synthesis.
How it works
No API key: talks to YouTube's internal Innertube API (the one the website and apps use) with plain HTTPS. Search, watch page, channels and comments use the web client; the player request uses the Android/iOS clients, whose caption URLs work without a PO token.
Highlights: lexical passage scoring in memory per request. It folds accents, stems by prefix (so
productivitymatchesproductive), weights rare terms higher and rewards passages that hit several concepts.Frames: yt-dlp resolves a ≤720p stream URL; ffmpeg seeks with HTTP range requests and decodes one frame per timestamp.
Stateless: no database or index. A 15-minute in-memory cache means search → fetch never downloads the same transcript twice.
Configuration
Env var | Default | Meaning |
| all | Comma-separated tools to expose |
| 4 / 120 | API request queue |
| 2 / 350 | Caption download queue |
| 60000 | First pause after a caption 429 (doubles per repeat, max 15 min) |
| none | HTTP(S) proxy for all YouTube requests, yt-dlp and ffmpeg |
| 15000 | Per-request timeout |
| 900000 | In-memory cache lifetime |
| 720 / 3 | Stream quality for frames; parallel ffmpeg processes |
| on / | Disable or locate the helpers |
| off | Log every YouTube request (status, queue wait, latency) to stderr |
| built in | Override Innertube client versions if YouTube starts rejecting them |
Honest limits
Transcripts are rate-limited per IP. In testing, a burst of roughly 80–100 transcripts within a few minutes triggered HTTP 429 on captions (yt-dlp too, since it uses the same endpoint), while search and metadata kept working. Innertube's
get_transcriptendpoint is closed to anonymous clients, so there is no second keyless source. The server pauses and tells the agent when to retry; for sweeps of hundreds of videos useYT_PROXY.Search dates are approximate ("3 weeks ago" → ±1 unit).
youtube_fetchreturns the exact publish date.No server-side date sort: YouTube dropped it;
sort: "date"re-sorts fetched results, so pair it withuploaded.Top comments only: the "newest first" sort is not offered to anonymous clients.
No captions, no transcript: there is no speech-to-text in the server. Frames still work.
Frames take ~10–20 s for the first frames of a video (stream lookup), then ~2 s each; max 20 per video and 40 per call.
FAQ
Does it need a YouTube API key? No. No API key, OAuth or cookies.
Which clients does it work with? Any MCP client over stdio: Claude Code, Codex, Claude Desktop, Cursor, Windsurf, VS Code, Zed and more. Claude Code and Codex get the plugin with the skill.
Does it download videos? No. Transcripts come from caption files; frames are decoded from small byte ranges of the stream.
Does it work for non-English content? Yes: per-query language and region, original-language transcripts by default, and accent-aware highlights.
Researching Instagram Reels too? See the sibling project Reels Research MCP.
Is it affiliated with YouTube or Google? No. It is an independent open-source project. Use it in line with YouTube's terms and respect creators' rights.
Development
npm test # offline unit tests: parsing, highlights, filters, frame spacing
npm run smoke # end-to-end against live YouTube through a real MCP client
npm run dev # run from source
npm run build # typecheck + bundle to dist/index.jsLayout: src/innertube.ts (HTTP, queues, errors) · src/youtube.ts (search, player, transcripts, watch page, comments, channels) · src/highlights.ts · src/frames.ts · src/tools/* (MCP tools) · skills/ · docs/ (website).
License
MIT. Not affiliated with YouTube or Google. YouTube is a trademark of Google LLC.
Keywords: YouTube MCP server, YouTube transcript MCP, YouTube search for AI agents, Model Context Protocol, Claude Code plugin, Codex plugin, YouTube without API key, YouTube hooks research, video frames for LLMs, agent skill.
Available Tools
4 toolsyoutube_channelList channel videosARead-onlyIdempotent
List a channel's videos with an outlier score: how many times more views a video got than the channel's median.
Best for: finding a creator's breakout videos (the ones whose hooks/titles/topics worked), reviewing recent uploads, building a list of videos to fetch. Returns: channel stats (subscribers, video count) and videos with views, outlier ×median, date, duration. The median is computed over the videos listed, so list enough (30+) for a fair baseline.
| Name | Required | Description | Default |
|---|---|---|---|
| tab | No | Default videos. | |
| sort | No | Default latest. | |
| limit | No | Videos to list (default 30, max 300). | |
| channel | Yes | @handle, channel URL or UC… channel ID. | |
| minOutlier | No | Only show videos with at least this ×median score, e.g. 2. The median still uses all listed videos. | |
| publishedAfter | No | YYYY-MM-DD or YYYY-MM, approximate (from '3 weeks ago'-style dates). Works best with sort=latest. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, non-destructive and open-world, so safety is covered. The description adds genuinely non-obvious behavior: the median is computed only over the videos returned, so the limit matters for score fairness, and dates may be approximate. It does not discuss pagination or rate limits, but for a read-only listing that is a minor 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?
Three short blocks — what it does, when to use it, what it returns — with the outlier definition front-loaded. Every sentence carries information; nothing is restated from the schema verbatim.
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?
There is no output schema, and the description compensates by summarizing the return payload (channel stats plus per-video views, outlier multiple, date, duration). Combined with the six documented parameters and the median caveat, an agent has everything needed to call it and interpret results.
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 coverage is 100%, so the baseline is 3, but the description adds meaning beyond the schema: the 30+ recommendation for a stable median ties the `limit` parameter to result quality, and the minOutlier caveat is restated in context. This helps an agent choose values rather than just syntax.
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?
States a specific verb and resource ('List a channel's videos') and immediately adds the differentiating feature — the outlier score defined inline as views relative to the channel median. This clearly separates it from youtube_search (query-based) and youtube_fetch (single-video retrieval) without opening a schema.
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 'Best for:' line enumerates three concrete jobs (finding breakout videos, reviewing recent uploads, building a list to fetch), the last of which implicitly routes to youtube_fetch. It stops short of an explicit exclusion rule naming the alternative tool and its trigger condition, so it is clear context rather than full routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
youtube_doctorCheck YouTube accessARead-onlyIdempotent
Check that every YouTube path this server uses works from this machine right now (search, video details, transcripts, watch page, channels, yt-dlp and ffmpeg for frames), with timings. Run it when other youtube_* tools fail.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, openWorld, and non-destructive, so safety is covered. The description adds genuinely new behavioral context: it probes live network paths from this machine and reports timings, which tells the agent this is a real-time environment check rather than a cached lookup.
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 sentences, zero filler. The scope enumeration is front-loaded and the usage trigger is the closing sentence, which is exactly the right ordering for a diagnostic tool.
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 no-param diagnostic with no output schema, the description covers what is checked and when to invoke it. It only lightly gestures at the return shape ("with timings") without saying what a partial or total failure report looks like, a small gap given there is no output schema to fill it.
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 tool takes zero parameters, so the baseline is 4. The description correctly adds nothing about parameters, and no parameter meaning is left ambiguous.
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?
Specific verb ("Check") plus an enumerated scope: search, video details, transcripts, watch page, channels, yt-dlp, ffmpeg. It is unmistakably a diagnostic tool, cleanly distinguishable from youtube_search, youtube_fetch, and youtube_channel.
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?
Gives an explicit trigger condition: "Run it when other youtube_* tools fail," which names the sibling tools it complements. It stops short of stating when not to run it (e.g. before any failure, or as a routine preflight), so it is clear context without full exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
youtube_fetchRead YouTube videosARead-onlyIdempotent
Read YouTube videos: transcript (whole, a time range, a chapter, or only passages matching a query), real video frames, details, chapters, comments and thumbnail. Batch many videos in one call.
Best for: reading what was said after youtube_search, pulling the same slice from many videos (e.g. the first 30 s of each video to study hooks), quoting with exact timestamps. Returns: per video a header (title, channel, exact publish date, views, likes, duration) and the requested parts. Transcript lines carry [m:ss] stamps; links with ?t= jump to the moment. Per-video failures are reported inline, never dropped.
Tips:
Hooks / intros: start=0, end=30 (plus parts ["details","transcript","thumbnail","frames"] if the visual hook matters).
Frames are real decoded video frames (up to 1280 px): evenly spaced over start–end / the chapter / the whole video (frames=N), or at exact moments (frameAt). The first frames of a video take ~10–20 s (stream lookup); keep frame-heavy calls to a few videos.
Finding a topic inside long videos: pass query instead of reading whole transcripts.
Long transcript cut off? Call again with start = the second where it stopped.
| Name | Required | Description | Default |
|---|---|---|---|
| end | No | Range end for transcript and frames: seconds or 'm:ss'. | |
| parts | No | Any of details, transcript, chapters, comments, thumbnail, frames. Default ["details","transcript"]. | |
| query | No | Return only transcript passages matching these phrases (any language/synonyms), not the full text. | |
| start | No | Range start for transcript and frames: seconds or 'm:ss'. | |
| frames | No | With part frames: how many frames, evenly spaced over the range (default 6, max 20 per video, 40 per call). | |
| videos | Yes | 1–25 video URLs or IDs. A ?t= in a URL is used as start when start is not given. | |
| chapter | No | Limit transcript and frames to the chapter whose title contains this text. | |
| frameAt | No | With part frames: exact moments instead of even spacing, e.g. [0, 3, '0:12']. | |
| matches | No | Max passages per video in query mode (default 6, max 20). | |
| frameWidth | No | Frame width in px (default 640, max 1280). Wider = readable small text, more tokens. | |
| timestamps | No | paragraph (default): ~30 s blocks with [m:ss]; segment: every caption line; none: plain text. | |
| commentsLimit | No | Top comments per video (default 20, max 200). | |
| maxCharacters | No | Transcript characters per video (default 12000, max 60000). | |
| transcriptLangs | No | Preferred transcript languages in order, e.g. ['es','en']. Default: the video's original language. | |
| descriptionChars | No | Description characters in details (default 1500). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only/idempotent/non-destructive, and the description goes further with latency (~10–20 s for the first frames, stream lookup) and partial-failure semantics ('per-video failures are reported inline, never dropped'). It also flags cost tradeoffs (frame width = more tokens, frame-heavy calls across a few videos) and truncation behavior, which the agent cannot infer from 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?
Well front-loaded and organized under Best for / Returns / Tips, with each tip carrying actionable content. Slightly verbose for the payoff, with a little redundancy (batching stated in the opening line and again in the multi-video tip), which keeps it short of a 5.
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 15-parameter tool with no output schema, the description supplies the return shape (per-video header with title, channel, publish date, views, likes, duration, plus [m:ss]-stamped transcript lines) and the failure/truncation model. An agent has everything needed to compose a correct call and interpret the 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?
Schema description coverage is 100%, so the baseline is 3; the description still adds interpretive value by explaining how start/end apply to both transcript and frames, the frames-vs-frameAt distinction, and the ?t= start fallback. It does not add meaning for the more peripheral knobs (commentsLimit, transcriptLangs, descriptionChars, matches) beyond what the schema already says.
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?
Specific verb+resource (read YouTube videos) with the full list of retrievable parts (transcript, frames, details, chapters, comments, thumbnail) and batching scope. The phrase 'after youtube_search' explicitly distinguishes it from the search sibling, so the agent can route without opening schemas.
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?
Gives concrete when-to-use scenarios (post-search reading, same slice across many videos, quoting with timestamps) and decision rules for alternatives: use query instead of full transcripts for topic finding, and re-call with start=<stop second> when a transcript is cut off. This is close to a decision tree, not just a context hint.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
youtube_searchSearch YouTubeARead-onlyIdempotent
Search YouTube videos and get back ready-to-use results with transcript highlights: the passages where each video actually talks about your topic, with timestamped links.
Best for: finding videos on a topic, finding what creators say about something, collecting examples (hooks, claims, tutorials) across many videos. Returns: one merged, de-duplicated list across all queries. Each video has metadata (channel, views, date, duration, views/day), YouTube's matched snippet and key moments, plus transcript highlights for the top results.
Query tips:
Send several queries in ONE call to cover the topic: synonyms, angles and languages, e.g. ["AI productivity workflow", "how I use AI to save time at work", {"query": "productividad con IA", "hl": "es", "gl": "ES"}].
Write queries the way a creator would title the video, not as keyword soup.
Use filters (uploaded, publishedAfter, minViews, duration, shorts) instead of asking for more results.
If highlights are not enough, call youtube_fetch on the best videos (it can return only a time range, e.g. the first 30 s for a hook, or only passages matching a query).
| Name | Required | Description | Default |
|---|---|---|---|
| sort | No | relevance (default), views (server-side), or date: newest first among the fetched results; YouTube dropped server-side date sort, so pair it with uploaded. | |
| limit | No | Results per query before merging (default 10, max 50). | |
| shorts | No | Default exclude. | |
| queries | Yes | 1–12 queries, run in one call and merged. Strings, or {query, hl, gl} for a language/region-specific query. | |
| duration | No | Server-side: short <4 min, medium 4–20 min, long >20 min. | |
| minViews | No | ||
| uploaded | No | Server-side upload-date window. Prefer this over publishedAfter when it fits. | |
| highlights | No | How many top results get transcript highlights (default 5, 0 = off, max 25). Each downloads one transcript; YouTube rate-limits transcripts per IP, so spend them where they matter. | |
| captionsOnly | No | Only videos with subtitles/CC (server-side filter). | |
| highlightQuery | No | What to highlight in transcripts, if different from the search queries (e.g. search 'AI productivity', highlight 'biggest mistake'). | |
| maxDurationSec | No | ||
| minDurationSec | No | ||
| publishedAfter | No | YYYY-MM-DD or YYYY-MM. Applied after search on YouTube's relative dates ('3 weeks ago'), so it is approximate (±1 unit). | |
| publishedBefore | No | YYYY-MM-DD or YYYY-MM, approximate like publishedAfter. | |
| transcriptLangs | No | Preferred transcript languages in order, e.g. ['es','en']. Default: the video's original language. | |
| highlightsPerVideo | No | Passages per video (default 3, max 8). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, openWorld, idempotent, non-destructive. The description adds crucial behavioral context beyond that: merged de-duplicated results across queries, transcript highlights only for top results (rate-limit aware, default 5), approximate date filtering, and the note that highlights cost a transcript download per video due to YouTube rate limits. This is rich operational detail.
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?
Front-loaded with purpose and return value, then structured as 'Best for', 'Returns', and 'Query tips'. Every section is useful, though the query tips section is slightly long. Overall efficient and scannable.
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 16-parameter search tool with no output schema, the description provides enough context to call it correctly: it explains result merging, highlight mechanics, rate-limit implications, and when to use youtube_fetch instead. The only gap is that the return shape (fields like views/day, key moments) is described in prose rather than schema, but that's adequate. An agent has what it needs.
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 coverage is 81%, so the schema carries most parameter documentation. The description adds value by explaining the query array can mix strings and objects with hl/gl for localization, and by suggesting highlightQuery can differ from search queries. It doesn't explain every parameter (e.g., no details on sort or transcriptLangs), but the schema handles those adequately at 81% 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?
States a specific verb (search) and resource (YouTube videos), and uniquely distinguishes itself from siblings by emphasizing transcript highlights and timestamped links. An agent can immediately tell this is the broad discovery tool vs. youtube_fetch for deep 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?
Explicitly lists what it's best for (topic finding, creator claims, example collection), provides concrete query construction tips, and names the alternative (youtube_fetch) with the exact condition to switch. Covers when to use filters instead of more results.
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.
4 tool updates
v0.1.0- First observed
youtube_channel - First observed
youtube_doctor - First observed
youtube_fetch - First observed
youtube_search
TDQS
Scored across 4 tools
Each tool has a clearly distinct role: search discovers videos, fetch reads specific videos, channel lists a single channel's videos with outlier scoring, and doctor diagnoses connectivity. The only mild overlap is that search and channel both return video lists, but their query-based vs. per-channel framing is spelled out clearly.
All tools share the youtube_ prefix and snake_case, giving a strong predictable pattern. There is a minor deviation in that search/fetch are verbs while channel/doctor are nouns, but the convention is still readable and consistent.
Four tools is well-scoped for a focused research server, and each earns its place: discovery, deep reading, channel analysis, and diagnostics. No tool feels redundant or tacked on.
The surface covers the core research lifecycle: find videos, read transcripts/frames/comments, analyze channels, and self-diagnose failures. Minor gaps remain, such as no dedicated playlist handling or channel/creator search, but agents can work around these.
Maintenance
Related MCP Connectors
YouTube transcripts, search, channel browsing, and playlists for AI agents via MCP.
Your agent needs to find video — which channels own a topic, which videos rank for a phrase, what exists in a given country and language. **What you can ask for** • "Which videos rank for 'rag pipeline tutorial' in the US this month?" • "Find channels publishing about MCP, sorted by relevance." • "What playlists cover this subject in Japanese?" • "Search videos uploaded this week only." **How to use it** Point any MCP client at https://mcp.aisa.one/youtube-search/mcp and sign in with OAuth — there is no key to create or paste. One search tool covering videos, channels and playlists, narrowed by country, language, upload date, duration and sort order. **It is also a door to the rest** The same login reaches 26 sources and 580+ operations. Find the video here, then ask the same agent what the channel's site traffic is or what the same phrase does in Google — without adding a second server. **What it costs** Finding and inspecting an operation is free. Running one is billed per call at API prices, with no seat and no monthly minimum, and every call takes max_price_usd so an agent cannot overspend by accident. **Where else it reaches** https://mcp.aisa.one/social/mcp for X plus Instagram, Reddit, Pinterest and YouTube; https://mcp.aisa.one/gtm/mcp for those plus Similarweb and Apollo.
YouTube transcripts, search, channel/playlist listings and upload tracking for AI agents.
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.
Related MCP Servers
- AlicenseNot gradedqualityNot gradedmaintenanceAn MCP server that provides YouTube data access without API keys or quotas. It enables agents to search videos, retrieve transcripts and metadata, and perform full-text search across cached content for AI context retrieval.3 npm-
- AlicenseAqualityAmaintenanceMCP server for extracting structured intelligence from YouTube channels and videos — transcripts, topics, and competitive signals for AI-powered research workflows.145 npmMIT
- AlicenseAqualityAmaintenanceMCP server that provides YouTube video data to AI agents, supporting search, metadata, comments, and transcripts without an API key.610 npmISC
- AlicenseAqualityCmaintenanceA production-ready MCP server for YouTube integration with intelligent caching. Enables searching videos, retrieving transcripts, analyzing channels, and monitoring live streams via natural language.311MIT