Fetches video transcripts and captions from YouTube, supporting multiple languages and optional timestamps, with fallback to AI-based transcription when captions are unavailable.
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 Transcript MCP Transcript of 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.
Search YouTube, then get transcripts, without paying for ones you could have had free.
Most YouTube videos already have captions. This gets those first, checks they're any good, and only pays a model to transcribe the video when they're missing or broken. A typical call costs nothing.
You need nothing to start. A key is only for the fallback.
{
"mcpServers": {
"yt-transcript": {
"command": "npx",
"args": ["-y", "yt-transcript-gemini-mcp"],
"env": { "AI_GATEWAY_API_KEY": "paste-your-key-here" }
}
}
}**Me at the zoo** by jawed, 19s.
Source: human-written captions (en). Free, no model call.
All right, so here we are in front of the elephants...The source line is the point. A human-written caption track and a machine transcription are different kinds of evidence, and a transcript that doesn't say which it is can't be judged.
Related MCP server: MCP-YouTube-Transcribe
Search and filter in one call, free, no API key. The filters combine, which is the point:
a video about
rust asyncwith over 50,000 views, from a channel with over 80,000 subscribers, longer than a minute
**3** result(s) for **rust async**.
Read 19 result(s), 3 channel lookup(s). Free, no API key.
- **Async Rust explained in 20 minutes**
`wXtngLBkK4Q` · 62,742 views · 2 months ago · 19:15
Let's Get Rusty (172,000 subscribers)Filter | Cost | Notes |
| free | Comes back with the search results |
| free | Coarse; see below |
| free |
|
| one request per channel | Runs last, after the free filters have cut the set. Each channel is looked up once however many of its videos survive |
The date filter is approximate, and the tool says so every time you use it. YouTube reports "3 weeks ago", not a date. Anything posted inside the current month reads as weeks at best, so "the past month" is honest and "since the 14th" is not.
The result tells you how many raw results were read and how many channel lookups it cost, so a filter that had to work hard is visible rather than silent. If it returns fewer than you asked for, raise maxPages.
youtube_transcripts takes up to 20 URLs or ids and runs them in parallel. One failure doesn't stop the rest.
The paid fallback is OFF by default here, which is the opposite of the single-video tool. Twenty videos is twenty bills, and an agent handed a search result will pass the whole list. allowPaid: true when you mean it.
1. The video's own captions. Free. Fetched through YouTube's InnerTube endpoint, parsed, and checked before you get them.
2. Gemini reads the URL. Billed. The watch URL goes straight to the model; there's no download and no upload step. Needs a key.
3. yt-dlp. Free, if you have it installed. Last because it's the only step with a binary to install and keep current.
That order is deliberate and it isn't what the research recommended. Every write-up on this puts yt-dlp second, because it's the traditional answer. But Gemini needs no binary, no PATH, and no maintenance against a target that actively changes to break you, so it earns the middle slot.
YouTube refuses most datacentre addresses outright. The caption path works from a home connection and fails from a cloud host, which quietly pushes every request onto the paid fallback and turns a free tool into a billed one.
npx in your own MCP config is exactly right. A hosted deployment is the case to think twice about.
All local string work, so the checks cost nothing. That's the design: the expensive decision is whether to pay, and deciding shouldn't itself cost money.
Check | Rejects |
Coverage | A track that stops a third of the way in. The text that IS there reads fine, which is what makes this the failure people miss |
Language | A German track when you asked for English. Returning the wrong language silently is worse than returning nothing |
Repetition | A stuck recogniser looping one phrase. Only applied to auto-generated tracks: a human track that repeats is a chorus |
Punctuation | Auto-captions with no full stops or capitals. Sent for repair rather than rejected |
Note: the repetition check ignoring human tracks is not a nicety. Measured on a pop video, 56% of the phrasing repeated and the captions were perfect. Applying that check to a manual track rejects every chorus ever written.
When a video has auto-captions and nothing better, the words are usually right. What's missing is punctuation, casing and paragraphs. Sending that text back as text costs a fraction of sending the video, because video is billed by sampled frames and audio seconds while text is billed by the word.
Measured on the same 19-second video:
cost | |
Transcribe the video | $0.0028 |
Repair the captions | $0.0006 |
On by default. YT_TRANSCRIPT_REPAIR=false turns it off and you get the raw unpunctuated track instead.
Both found by measuring, and both the opposite of what they look like.
Thinking is off, and that's most of the saving. Transcription has nothing to reason about, but the model reasons anyway: 438 of 503 output tokens on one call, 1,097 of 1,146 on another. Output is billed at five times input, so that was 96% of the bill spent deliberating over where to put full stops. Setting the thinking budget to zero gives identical text for a twentieth of the tokens.
Flex tier is a false economy here, so it's off. Flex halves both rates, which sounds like free money. It also ignores the thinking budget. Measured twice on the same prompt: standard with thinking off returned 33 output tokens; flex with identical options returned 604 and 650, nearly all reasoning. Half the rate on nineteen times the tokens is about nine times the bill. YT_TRANSCRIPT_FLEX=true if a future gateway release honours the setting.
Only needed for the fallback. Captions work without one.
Vercel AI Gateway (vercel.com/docs/ai-gateway) is the one to get. gemini-3.6-flash resolves there.
Google AI Studio (aistudio.google.com/apikey) also works, with a caveat worth knowing: on the key tested here, gemini-3.6-flash returned 404 while every other model resolved. If yours does the same, set YT_TRANSCRIPT_MODEL=gemini-3.5-flash, which works and transcribes fine.
Treat either like a password.
Captions are free and most videos have them. The bill only starts when they don't.
Set a budget anyway. Vercel and Google Cloud both let you set a spending limit and an alert. Two minutes each, and it's the difference between a surprise and a number you chose.
This server caps transcription at 30 per hour and 180 minutes per video, both on by default, because an agent looping over a playlist is the shape that runs up a bill nobody agreed to. Captions are never capped.
No liability for spend. Free software, as-is, MIT. You are responsible for your own API usage and any charges Google or Vercel bill you, including charges caused by bugs, misconfiguration, runaway agents, or anything else. Neither Luke Rhodes nor Fledgeling is liable for your spending. Set a budget.
All optional. The server runs with none of them, captions only.
Setting | Default | What it does |
| Vercel AI Gateway. Preferred, because | |
| AI Studio key. | |
|
| Which model transcribes. The gateway prefix is added for you |
|
| Repair auto-captions with a text call instead of re-transcribing |
|
| Vercel's flex tier. Off because it ignores the thinking budget; see above |
|
| Transcriptions per rolling hour. |
|
| Longest video the paid path will accept |
|
| How long to wait on a model call |
|
| Where yt-dlp lives, if it isn't on PATH |
youtube_search searches and filters. Free, no key.
youtube_transcript takes a URL or a bare video id, plus optional languages, timestamps, and allowPaid. Set allowPaid: false to get captions or nothing, which is right when cost matters more than coverage.
youtube_transcripts does up to 20 at once, in parallel, with the paid fallback off unless you ask for it.
youtube_transcript_doctor says what actually works right now: whether captions are reachable from this address, whether a key is configured, whether yt-dlp is installed. Free.
Timestamps only survive the caption path. A model transcription has no timings, so timestamps: true is quietly ignored there.
It doesn't work on private or unlisted videos, through any of the three paths.
It doesn't evade blocks. No proxy rotation, no token harvesting. On a refusal it says so and moves to the next source. Working around a bot check is against YouTube's terms and a treadmill nobody wins.
Written down because they contradict what's widely published, and they'll drift again.
Watch-page caption URLs are dead. They return HTTP 200 with zero bytes, in every format, with every client parameter. That looks exactly like a video with no captions unless you check the length.
Search and captions need different InnerTube clients. IOS serves captions; its search response carries only videoId, with no view counts, dates or channel. WEB serves a full search result but its caption URLs return nothing. So the two paths use different clients, and neither is a typo.
The subscriber count on a channel page is not subscriberCountText. A channel response carries several of those and none of them is the channel's own: they're the recommended-channel sidebar. Measured on a channel with 4.24M subscribers, the two values present were 466 thousand and 49 thousand. The real figure is in the page header's metadata rows. An early version of this server reported the sidebar number, which is wrong and entirely plausible.
IOS is the InnerTube client that works for captions. yt-dlp's PO Token Guide lists tv, android_vr and web_embedded as the ones needing no token. Measured on 2 August 2026, those return LOGIN_REQUIRED, LOGIN_REQUIRED and ERROR. IOS answers with a usable caption list. The guide may describe a different request context, or it may have drifted.
The client list is ordered rather than fixed, because this is an undocumented surface and a second client is a cheaper recovery than a release.
TypeScript, ESM, Node 20.11 or newer. FastMCP over stdio, Vercel AI SDK v7, Zod at every boundary, exactOptionalPropertyTypes on, no any.
npm install
npm run gate # typecheck, lint, test, buildI'm Luke Rhodes, a founder and engineer building Fledgeling. I spent years shipping developer tools and got tired of proprietary formats and slow editors, so Fledgeling is the opposite of that: fast software built from scratch, your work in plain text you own, and AI as a collaborator you can always overrule. The human is always the editor of record.
I'm also co-founder of Diolog with Amy Benson, building investor-relations software for listed companies and the retail investors following them.
GitHub: github.com/lprhodes
LinkedIn: linkedin.com/in/lukerhodes
Email: hello@fledgeling.app
Media Gen Pro generates images and video. Eight image models and four video ones behind one call, with the server reading your prompt to pick which. Returns file paths, not megabytes of base64.
npx -y media-gen-pro-mcpGoogle Search MCP does the looking: Google search through the Gemini API, returning the answer, the real source URLs, and the queries the model actually ran.
Dossier runs proper deep research: several backends on the same question at once, then checks the citations resolve and flags where the backends disagree. The architecture of this server came out of a Dossier panel, and two of its recommendations turned out to be wrong when measured, which is exactly why the merge tells you which claims only one backend made.
MIT. Use it, fork it, ship it.
Search YouTube and filter the results on view count, how recently they were posted, video length, and the channel's subscriber count. Filters combine: a video about X with over 50,000 views, posted in the last month, from a channel with over 80,000 subscribers. Free, no API key. Returns video ids you can pass to youtube_transcript.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | How many results to return after filtering. Defaults to 10. | |
| query | Yes | What to search for, in plain language. | |
| maxPages | No | How many result pages to read before giving up. Defaults to 4. Raise it when a narrow filter returns too few. | |
| maxViews | No | Drop videos with more views than this. Useful for finding smaller creators. | |
| minViews | No | Drop videos with fewer views than this. | |
| minSubscribers | No | Drop videos from channels with fewer subscribers than this. Costs one extra request per distinct channel, so it runs last, after the free filters have cut the set. | |
| maxDurationSeconds | No | Drop videos longer than this. | |
| minDurationSeconds | No | Drop videos shorter than this. 60 excludes most Shorts. | |
| publishedWithinDays | No | Drop videos older than this many days. COARSE: YouTube gives a relative string ("3 weeks ago"), not a date, so anything inside the current month reads as weeks. Good for "the past month", not for "since the 14th". |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows it's safe. The description adds valuable context beyond annotations: 'Free, no API key' (no auth/access issues), 'Filters combine' (explanatory logic), and 'Returns video ids' (output format). It does not contradict 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?
Three sentences, each earning its place: first states purpose and filters, second gives a concrete example, third covers key non-obvious facts (free, no API key) and output destination. No fluff, well front-loaded.
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?
Despite 9 parameters and no output schema, the description is complete: it covers the core functionality, example usage, cost/auth requirements, and return value. The schema thoroughly documents all parameters, and sibling tools provide context for downstream usage.
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 parameters are already well-documented. The description adds value by providing a concrete example of how filters combine ('a video about X with over 50,000 views, posted in the last month, from a channel with over 80,000 subscribers'), which illustrates parameter interaction beyond individual 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 tool's function with a specific verb ('Search YouTube') and resource, then enumerates the filter dimensions (view count, recency, video length, subscriber count). It distinguishes itself from sibling transcript tools by noting it returns video IDs for use with youtube_transcript.
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: it's a search/filter tool for finding videos, and explicitly mentions passing results to youtube_transcript, providing a clear workflow. It does not explicitly say 'use this when X, use alternative when Y,' but the sibling tool names and the stated output make the distinction obvious.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a YouTube video's transcript. Tries the video's own captions first (free, and most videos have them), then Gemini reading the URL (billed), then yt-dlp if installed. Returns the transcript plus which source produced it, so you can tell a human-written caption track from a machine transcription. Accepts any YouTube URL shape or a bare video id.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | A YouTube URL (watch, youtu.be, shorts, embed) or a bare 11-character video id. | |
| allowPaid | No | Allow the billed Gemini fallback when captions are missing or unusable. Defaults to true. Set false to get captions or nothing, which is the right choice when cost matters more than coverage. | |
| languages | No | Preferred caption languages as BCP-47 codes, most wanted first, e.g. ["en","fr"]. Defaults to English. | |
| timestamps | No | Prefix each line with [mm:ss]. Only possible from a caption track; a model transcription has no timings. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the tool's behavioral traits beyond annotations: it tries multiple sources in order, may incur billing via Gemini, uses yt-dlp conditionally, and returns the source for transparency. This adds significant context that annotations alone do not provide, though it does not contradict any annotation.
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 three sentences, front-loads the main purpose, and packs in essential behavioral details without fluff. Every sentence provides value, from the fallback chain to the output source indication.
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 four parameters and no output schema, but the description covers the key runtime behavior, billing, fallback logic, and return value. It does not describe the exact transcript format, but given the tool's simplicity and strong schema coverage, this is a minor 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?
Schema description coverage is 100%, so parameters are already well documented. The description adds minor nuance about URL shapes and timestamps being only available from caption tracks, but this does not materially improve on the schema's own descriptions. Baseline 3 is appropriate.
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 'Get a YouTube video's transcript', a specific verb+resource action that clearly states the tool's primary function. It differentiates itself from sibling tools by detailing the fallback chain and source attribution, making its unique role evident.
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 through the fallback chain (captions, Gemini, yt-dlp) and mentions billing implications, but it does not explicitly state when to use this tool over alternatives like youtube_transcripts or youtube_transcript_doctor. There is no clear when-to-use vs when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check what this server can actually do right now: which caption clients answer, whether a transcription key is configured, and whether yt-dlp is installed. Free, and makes one unauthenticated request to YouTube.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=true and destructiveHint=false, so the safety profile is already covered. The description adds meaningful behavioral context: it is free, makes one unauthenticated request to YouTube, and checks specific configuration items (caption clients, transcription key, yt-dlp). This is valuable beyond annotations, though it does not describe return format or error 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?
Two sentences, front-loaded with the core purpose, followed by a brief note on cost and request behavior. Every word earns its place with 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?
For a zero-parameter diagnostic tool with good annotations and no output schema, the description covers the essential points: what it checks, that it is free, and that it makes one unauthenticated request. It lacks explicit mention of return value shape, but the simple nature of the tool makes this a minor 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 tool has zero parameters, which sets the baseline at 4. The description adds no parameter information (there is none to add), and the schema already fully documents that no parameters are accepted. No gap exists.
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 as a diagnostic/healthcheck: it checks which caption clients answer, whether a transcription key is configured, and whether yt-dlp is installed. This distinguishes it from siblings like youtube_transcript (which likely fetches transcripts) and youtube_search (which searches videos). The verb 'check' is specific and the resource scope is clear.
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 when to use this tool: as a pre-flight check to verify server capabilities before using transcript-related tools. It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to infer that this is a capability probe, not a data-fetching tool. Sibling names reinforce the distinction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get transcripts for several videos in one call. Each one goes through the same chain as youtube_transcript: captions first, then Gemini, then yt-dlp. Videos are fetched in parallel and a failure on one does not stop the rest. Set allowPaid false to keep the whole batch free.
| Name | Required | Description | Default |
|---|---|---|---|
| urls | Yes | YouTube URLs or bare video ids. Capped at 20 per call, because each one can be a billed transcription. | |
| allowPaid | No | Allow the billed Gemini fallback per video. Defaults to FALSE for a batch, which is the opposite of the single-video tool: twenty videos is twenty bills. | |
| languages | No | Preferred caption languages, most wanted first. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses several important behaviors beyond annotations: the fallback chain (captions → Gemini → yt-dlp), parallel fetching, partial failure tolerance, and cost implications (billing per video). This is valuable context not provided by the sparse 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 front-loaded with the purpose. Each sentence adds new information: batch capability, fallback chain, parallel behavior, and cost control. No redundant or wasted words.
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 complexity of batch processing, the description covers key aspects: fallback order, concurrency, failure handling, and cost. Minor gap: it does not describe the return format, but no output schema exists and the tool name implies the result. Overall, the description is quite complete.
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 already provides detailed descriptions for all three parameters (URLs cap, allowPaid default, languages). The description's mention of 'Set allowPaid false to keep the whole batch free' adds little beyond the schema. Baseline 3 applies due to full 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 tool's function: 'Get transcripts for several videos in one call.' It uses a specific verb (get) and resource (transcripts), and explicitly contrasts with the single-video tool 'youtube_transcript', making it easy to distinguish.
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: for multiple videos in one call. It names the alternative single-video tool and explains the behavior difference (default allowPaid false vs. true), helping the agent choose the right tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.2.0youtube_searchyoutube_transcriptyoutube_transcript_doctoryoutube_transcriptsyoutube_transcript and youtube_transcripts are potentially confusing due to their similar names, but their descriptions clearly distinguish single from batch operations. youtube_search and youtube_transcript_doctor are unambiguous.
All tool names use snake_case and share the youtube_ prefix, creating a consistent and predictable pattern. The use of singular vs plural is a clear convention for single vs batch operations.
With only 4 tools, the server is well-scoped and each tool serves a distinct purpose: single transcript, batch transcript, search, and diagnostics. The count feels appropriate for a focused transcript service.
The tool set covers the core workflow completely: search for videos, retrieve a single transcript, retrieve multiple transcripts, and check server capabilities. No obvious gaps exist for a transcript-focused server.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Fetch the full transcript of any YouTube video as clean text. No API key, no signup.
Free YouTube transcript fetcher: clean text, timestamped, SRT, VTT, Markdown, or JSON. No API key.
Fetch transcripts, subtitles, chapters, metadata and frames from YouTube and 10+ video platforms
Clean YouTube transcripts for agents: single videos, channels, playlists, plus AI caption cleanup.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/fledgeling-co/yt-transcript-gemini-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
