yt-subtitles-mcp
Provides tools for retrieving metadata, chapters, and timestamped captions/transcripts from public YouTube videos, including language selection and paginated transcript access, so AI assistants can summarize, analyze, and answer questions with source references.
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., "@yt-subtitles-mcpsummarize this talk and give timestamps: 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.
yt-subtitles-mcp
Give your AI assistant the source material to summarize and discuss YouTube videos.
A Python MCP server built with FastMCP. One call retrieves video metadata, chapters and a timestamped transcript page. Your assistant uses that evidence to produce summaries, key takeaways, study notes, comparisons or answers with source references.
The server does not run a separate LLM, need an AI API key, or claim to watch video frames. It works with public YouTube videos that expose supported captions.
Quick start
docker compose up --build -dConnect a local MCP client to http://127.0.0.1:8000/mcp (Streamable HTTP):
{
"mcpServers": {
"yt-subtitles-mcp": {
"url": "http://127.0.0.1:8000/mcp"
}
}
}Configuration placement varies by client. A cloud-hosted client cannot connect to
your computer's localhost. Health endpoint: http://127.0.0.1:8000/health.
docker compose ps
docker compose logs -f
docker compose downRelated MCP server: YouTube Video Summarizer MCP Server
What to ask your assistant
“Summarize this video and list its main arguments with timestamps.”
“Turn this lecture into study notes. Separate facts from the speaker's opinions.”
“What does the speaker say about this topic? Give me the supporting passage.”
“Compare the arguments in these two videos and link to their sources.”
For multiple videos, the assistant calls the tools for each URL. There is no search, playlist crawling, visual analysis, speech recognition or automatic translation service. The assistant can translate or summarize the returned text itself.
MCP tools
Tool | Purpose |
| Start here: metadata, chapters and transcript evidence in one request |
| Continue reading a long transcript or request a specific language |
| Retrieve only video metadata when the transcript is unnecessary |
| List exact available language codes and caption types |
All tools accept url. Context/transcript tools accept an optional language and
limit (default 12,000, maximum 20,000 characters). The transcript tool also accepts
offset (default 0). Language selection prefers the original audio language when
available, otherwise authored captions before automatic captions. For a selected
language, authored captions take precedence. Explicit languages never silently fall
back to another language.
get_video_context returns transcript_status:
complete: the response contains the full available transcript.partial: read more usingget_video_transcriptwith the returnedlanguageandnext_offset; do not describe a first-page summary as covering the entire video.unavailable: metadata is still available, buttranscript_errorexplains why transcript evidence is missing. The assistant should report this limitation.
Timestamps such as [00:01:23] are preserved in the transcript when supplied by
YouTube. Offsets count characters in this timestamped text. Each page refetches the
source, so captions edited during pagination can change the result. Chapters are
limited to 100 entries with an explicit chapters_truncated flag.
Local installation
Requires Python 3.12–3.14, uv and Deno for full YouTube support. Docker includes the JavaScript runtime and bundled yt-dlp challenge solver. Linux and macOS are supported; Windows users can use Docker or WSL.
uv sync --frozen
uv run --frozen yt-subtitles-mcp # stdio, started by the MCP client
uv run --frozen yt-subtitles-mcp --transport http # local HTTP
uv run --frozen python -m yt_subtitles_mcp --helpFor stdio clients, replace the path with your checkout:
{
"mcpServers": {
"yt-subtitles-mcp": {
"command": "uv",
"args": ["--directory", "/absolute/path/yt-subtitles-mcp", "run", "--frozen", "yt-subtitles-mcp"]
}
}
}Docker stdio after building: docker compose run --rm -T --no-deps yt-subtitles-mcp --transport stdio.
The old root-level scripts and old subtitle tool names have been removed; update
existing client commands and tool references to the names above.
Project layout
src/yt_subtitles_mcp/
server.py # FastMCP instance, tool contracts and safe error mapping
youtube.py # YouTube extraction, caption parsing and context assembly
models.py # Typed responses and explicit evidence/coverage boundaries
cli.py # Transport arguments and process entrypoint
__main__.py # python -m yt_subtitles_mcpThe distribution, CLI and GitHub project use yt-subtitles-mcp; the Python package
uses yt_subtitles_mcp. pyproject.toml defines dependencies and tooling, and
uv.lock is the single dependency lockfile. Docker installs the same package used
in development. There are no repository/service interfaces, plugin frameworks,
database, job queue or persistent cache.
Safety and limitations
Source text is explicitly marked as untrusted. The server supplies evidence rather than generating user-role prompts from external text. The consuming agent must not follow instructions inside titles, chapter names or captions, or treat them as permission to access files, secrets or other tools. This is a trust boundary, not a promise that an LLM can never be prompt-injected.
Only canonical HTTPS YouTube video URLs are accepted. Playlist-only URLs, custom ports, user credentials and arbitrary sites are rejected. Extraction uses no shell, no user configuration/plugins, no browser cookies and no inherited server secrets. Caption downloads accept only YouTube's HTTPS timedtext endpoint and no redirects. Network operations still trust YouTube, HTTPS/DNS and the pinned extractor.
Extraction is limited to 60 seconds and 8 MiB stdout/64 KiB stderr. Caption fetching is limited to 25 seconds and 4 MiB. Up to two source operations run concurrently; excess work is rejected. Timeout/cancellation terminates the process group. Docker adds a non-root user, read-only filesystem, bounded tmpfs, dropped capabilities and CPU/memory/PID limits. Dependencies and base images are pinned; nothing self-updates.
HTTP is unauthenticated and bound to localhost through Compose. Host/Origin checks protect the MCP endpoint against browser-origin and DNS rebinding requests; they are not authentication for local applications. Add authentication and TLS before any public deployment.
YouTube may rate-limit, require sign-in or block the server IP. Health checks confirm server responsiveness, not YouTube availability. Private/restricted videos are not bypassed. Captions can be inaccurate and omit visual information.
Development
uv sync --frozen
uv run --frozen ruff check .
uv run --frozen ruff format --check .
uv run --frozen pytest -q
uv build
docker compose config --quiet
docker compose buildTests use local fixtures and mocked YouTube responses, plus real subprocess and MCP stdio/HTTP integration checks. GitHub Actions checks formatting, tests, packaging and Docker build. No YouTube credentials or external video access are needed for CI.
To change dependencies, edit pyproject.toml, run uv lock, then repeat the checks.
Update image tags/digests deliberately when security releases arrive. Do not commit
cookies, credentials, transcripts or .env files. Report sensitive vulnerabilities
privately through GitHub's vulnerability reporting feature if enabled; use issues
for non-sensitive reproducible bugs.
Provenance
This project started from setkyar/youtube-subtitles-mcp and has been reorganized
around agent-driven video understanding. No upstream license file was present in
the imported checkout. This repository is intentionally published without a project license for now.
Available Tools
4 toolsget_video_contextGet Video ContextARead-onlyIdempotent
Start here for video summaries, key takeaways, comparisons or Q&A.
Return metadata, chapters and a timestamped transcript page in one request. With language omitted, select the original audio language when available, otherwise authored captions before automatic captions. Partial coverage and unavailable transcripts are explicit. This tool supplies evidence; the client agent writes the summary. It cannot analyze visual-only content.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | HTTPS URL of one YouTube video. | |
| limit | No | ||
| language | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| video | Yes | |
| chapters | Yes | |
| guidance | No | |
| transcript | Yes | |
| analysis_scope | No | |
| transcript_error | No | |
| transcript_status | Yes | |
| untrusted_content | No | |
| chapters_truncated | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Goes well beyond the annotations (readOnly/idempotent/non-destructive/openWorld) by disclosing the language fallback order (original audio, then authored captions, then automatic captions), that partial coverage and unavailable transcripts are surfaced explicitly, and the hard limitation that visual-only content cannot be analyzed. These are non-obvious behavioral traits an agent 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?
Front-loads the use case in the first clause, then layers scope, defaulting behavior, edge-case handling, and the responsibility boundary in tight sentences with no 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?
With an output schema present the description need not explain return shape, and it covers the caveats an agent must anticipate (partial coverage, unavailable transcripts, visual-only limitation). The only meaningful gap is any guidance on the limit parameter.
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 documents url and language but leaves limit undocumented (33% coverage per signals). The description compensates for the language parameter by explaining the default selection cascade when it is omitted, which is genuine semantic value the schema does not provide; the limit parameter remains unexplained in both places.
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+resource (returns metadata, chapters, timestamped transcript for one video) and frames itself as the entry point for summary/comparison/Q&A tasks. It does not explicitly contrast itself with siblings like get_video_info or get_video_transcript, so the sibling differentiation is only implied.
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?
"Start here for video summaries, key takeaways, comparisons or Q&A" gives a clear usage context, and the line "This tool supplies evidence; the client agent writes the summary" clarifies the division of labor. It stops short of naming when to prefer a sibling tool instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_video_infoGet Video InfoARead-onlyIdempotent
Get a video's title, channel, duration, upload date and views as untrusted data.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | HTTPS URL of one YouTube video. |
Output Schema
| Name | Required | Description |
|---|---|---|
| url | Yes | |
| title | Yes | |
| channel | Yes | |
| video_id | Yes | |
| view_count | Yes | |
| upload_date | Yes | |
| content_notice | No | |
| duration_seconds | Yes | |
| untrusted_content | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, open-world, non-destructive, so the safety profile is covered. The description adds a genuinely useful behavioral note — that retrieved content is untrusted data — which flags prompt-injection risk, a trait not present in the 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?
One front-loaded sentence with no filler; the return fields lead and the untrusted-data caveat closes it. Every clause earns its place.
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?
An output schema exists, so return values need not be re-explained, and annotations cover the safety profile for this simple read tool. The only gap is the lack of sibling routing, which the purpose and usage scores already capture.
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% and the single url parameter is fully documented in the schema (HTTPS YouTube video URL, length bounds). The description adds no format or constraint detail beyond that, so the baseline 3 applies.
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?
Clear specific verb + resource and an explicit enumeration of what is returned (title, channel, duration, upload date, views). It does not, however, differentiate itself from the sibling get_video_context, which an agent could easily confuse with 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?
There is no when-to-use guidance and no exclusion of the siblings; the agent must infer that this is the metadata-fetch tool and get_video_context/transcript tools serve other needs. Nothing states prerequisites or the single-video scope beyond the schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_video_transcriptGet Video TranscriptARead-onlyIdempotent
Continue reading timestamped source text for summarization or questions about a video.
Use the language returned by get_video_context when continuing its transcript. With no language specified, prefer the original audio language, then authored captions.
Offset and limit count characters. Repeat with next_offset until it is null. No translation or visual analysis is performed. Use list_transcript_languages for exact codes.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | HTTPS URL of one YouTube video. | |
| limit | No | ||
| offset | No | ||
| language | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| url | Yes | |
| text | Yes | |
| offset | Yes | |
| language | Yes | |
| video_id | Yes | |
| automatic | Yes | |
| next_offset | Yes | |
| content_notice | No | |
| total_characters | Yes | |
| untrusted_content | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover readOnly, idempotent, and non-destructive semantics, so the bar is lower. The description adds genuinely useful behavior beyond them: no translation or visual analysis is performed, offset/limit are character counts (not tokens or lines), and the language fallback order is original audio then authored captions.
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?
Terse and front-loaded: purpose first, then language selection, then pagination mechanics, then scope limits. Every line carries information, though the opening 'Continue reading' framing is a touch indirect for an agent that may be calling this cold.
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?
An output schema exists so return values need no explanation, and the description covers the non-obvious parts an agent needs: pagination via next_offset, character-based offsets, and language resolution. Only minor gaps remain, such as any rate-limit or caption-availability failure 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?
Schema coverage is only 25%, so limit and offset are undocumented in the schema. The description compensates by stating that offset and limit count characters and by naming next_offset as the cursor to loop on, plus explaining the language preference order when language is omitted.
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 (read/continue reading) and resource (timestamped source text for a video), and the tool name confirms it is the transcript reader. It distinguishes itself from get_video_context by positioning itself as the continuation mechanism, though the phrase 'timestamped source text' is slightly indirect compared to simply saying '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?
Explicitly routes to siblings and conditions: use the language from get_video_context when continuing its transcript, use list_transcript_languages for exact codes, and repeat with next_offset until null. Both the 'when to use' and the pagination loop condition are spelled out.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_transcript_languagesList Transcript LanguagesBRead-onlyIdempotent
List exact available subtitle codes, distinguishing authored and automatic captions.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | HTTPS URL of one YouTube video. |
Output Schema
| Name | Required | Description |
|---|---|---|
| url | Yes | |
| video_id | Yes | |
| languages | Yes | |
| content_notice | No | |
| untrusted_content | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds one genuinely useful behavioral trait beyond that – the distinction between authored and automatic caption tracks – but says nothing about ordering of results or code format.
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?
A single tight sentence that front-loads the core action and appends the one qualifying detail that matters. No waste.
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?
With an output schema present, the description needn't explain return values, and it correctly does not. It is nearly complete for a one-parameter lister, with the only gap being the lack of any relationship statement to the transcript-fetching sibling.
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% for the single 'url' parameter, so the schema already documents the input fully. The description contributes nothing further about the parameter, so the baseline 3 applies.
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 (List) and resource (subtitle codes) with useful qualifying detail that the result distinguishes authored from automatic captions. It does not, however, differentiate itself from the sibling get_video_transcript, which an agent might confuse it with.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no when-to-use guidance, no prerequisites, and never names the sibling alternative get_video_transcript or the sequencing relationship (e.g. call this first to pick a subtitle code). Usage is only weakly implied.
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.3.0- First observed
get_video_context - First observed
get_video_info - First observed
get_video_transcript - First observed
list_transcript_languages
TDQS
Scored across 4 tools
Each tool has a reasonably distinct primary role: context bootstraps, info gives lightweight metadata, list_transcript_languages enumerates codes, and get_video_transcript paginates. However, get_video_info's metadata overlaps with get_video_context's returned metadata, and context also returns transcript, creating mild ambiguity about when to use info vs. the composite tool.
All names are snake_case with a verb-first pattern (get_/list_), which is predictable. There is a minor resource-naming inconsistency: three tools scope to 'video' while list_transcript_languages scopes to 'transcript', so the resource vocabulary isn't fully uniform.
Four tools is on the thin side but appropriate for a focused transcript/metadata server where each tool has a clear jobs-to-be-done. The only questionable inclusion is get_video_info, which largely duplicates a subset of get_video_context.
The surface covers metadata, chapters, language enumeration, transcript retrieval with pagination, and explicit handling of partial/unavailable coverage, which is solid lifecycle coverage for this domain. Gaps like in-transcript search or translation are either out of scope or explicitly excluded by the descriptions.
Maintenance
Related MCP Connectors
YouTube transcripts, search, channel/playlist listings and upload tracking for AI agents. No signup.
YouTube transcripts, search, channel browsing, and playlists for AI agents via MCP.
Search YouTube, read video metadata, and fetch transcripts with language preferences
YouTube transcripts, search, channels, playlists and bulk transcript jobs for AI agents. 14 tools.
Related MCP Servers
- AlicenseAqualityCmaintenanceEnables AI models to interact with YouTube content including video details, transcripts, channel information, playlists, and search functionality through the YouTube Data API.71110MIT
- AlicenseBqualityFmaintenanceEnables AI assistants to analyze and summarize YouTube videos by extracting captions, subtitles, and comprehensive metadata including title, description, and duration in multiple languages.16661MIT
- AlicenseAqualityDmaintenanceEnables AI assistants to fetch YouTube video transcripts with precise timestamps, multi-language support, and time-range filtering.31MIT
- AlicenseAqualityDmaintenanceEnables AI tools to access YouTube content, including transcript extraction, video/channel info, and search.414MIT