What can you do with this server?

The youtube-context-mcp server gives AI agents rich contextual information about any YouTube video, including transcripts, metadata, viewer engagement data, and visual frames. * Fetch transcripts (get_transcript): Retrieve captions as plain text, optionally grouped into [mm:ss] timestamped blocks and/or translated via ISO language code. * List available transcripts (list_transcripts): Discover which transcript languages are available, whether auto-generated or manual, and supported translation targets. * Build timestamped links (build_video_link): Generate a watch?v=…&t= URL that jumps directly to a specific moment, accepting seconds or mm:ss/h:mm:ss format. * Get video metadata (get_video_metadata): Retrieve title, channel, upload date, duration, view/like counts, chapters, tags, thumbnail, and optionally the full description. * Get most-replayed moments (get_most_replayed): Surface the top viewer-interest heatmap peaks (up to 20), each with a timestamp, clickable URL, chapter context, and relative intensity score — useful for finding highlights. * Capture a video frame (get_video_frame): Extract a still image at a specific moment for multimodal analysis, e.g. reading slides or on-screen UI (requires ffmpeg). * Get a visual preview sheet (get_video_preview): Generate a tiled contact-sheet of frames sampled across the full video or a time window, with a timestamp legend (requires ffmpeg).

Which integrations are available for this server?

Provides tools to fetch YouTube video transcripts (plain or timestamped), metadata (title, channel, upload date, duration, view/like counts, chapters, tags), and most-replayed moments, enabling AI agents to summarize, quote, highlight, or link to specific moments in YouTube videos.

How do I use youtube-context-mcp?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@youtube-context-mcp Get transcript and key moments from https://youtu.be/dQw4w9WgXcQ" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

youtube-context-mcp

by realiti4

Overview Schema Related Servers Score Discussions

Python

Remote

youtube-context-mcp

An MCP server that gives agents rich context about any YouTube video — what's said, what's popular, and what's on screen:

Transcript — plain or [mm:ss]-timestamped text, with optional translation
Deep links — watch?v=…&t=… URLs that jump straight to a moment
Metadata — title, channel, upload date, duration, view/like counts, chapters, tags
Most-replayed moments — the peaks of YouTube's viewer-interest heatmap
Visuals (for multimodal models) — a still frame at any moment, or a tiled preview sheet of the whole video

Agents use it to answer questions about a video, summarize it, pull quotes, surface highlights, read what's on screen, or link you to exactly where something is said.

It builds on youtube-transcript-api (transcripts) and yt-dlp (metadata), which do the actual fetching, and shapes them into a focused set of MCP tools designed for agents.

Transcripts are a video's existing captions/subtitles — it does not transcribe audio (no Whisper/ASR). Videos without captions have no transcript to return.

Install

Run it on demand with uv (no install needed):

uvx youtube-context-mcp@latest

Or install it:

pip install youtube-context-mcp

Related MCP server: YouTube Insights MCP Server

Use it with an agent

Add it to your MCP client config:

{
  "mcpServers": {
    "youtube-context": {
      "command": "uvx",
      "args": ["youtube-context-mcp@latest"]
    }
  }
}

Or, in Claude Code:

claude mcp add youtube-context -- uvx youtube-context-mcp@latest

Running over HTTP

By default the server talks stdio (the client launches it). If your client runs on a different host — for example LM Studio on Windows while this server runs in WSL2 — run it as a long-lived HTTP server instead and point the client at a URL:

youtube-context-mcp --transport http --host 0.0.0.0 --port 8000

Then add it by URL:

{
  "mcpServers": {
    "youtube-context": { "url": "http://localhost:8000/mcp" }
  }
}

(--host 0.0.0.0 makes it reachable from the Windows side; WSL2 forwards localhost.)

Tools

In every tool, video accepts a full YouTube URL (watch, youtu.be, shorts, embed, live) or a bare 11-character video ID.

`get_transcript`

get_transcript(video, languages=["en"], include_timestamps=False, translate_to=None)

Returns the transcript as plain text. Set include_timestamps=True to group it into ~15s [mm:ss] blocks — handy for locating a topic and building a link; translate_to takes an ISO language code.

`build_video_link`

build_video_link(video, start)

Builds a watch?v=…&t=<seconds> URL that opens the video at a moment, so a user can click straight to it. start is seconds or a "mm:ss" / "h:mm:ss" string. Pairs with get_transcript(include_timestamps=True) to turn "where is X mentioned?" into a clickable link.

`list_transcripts`

list_transcripts(video)

Lists available transcripts (language, code, manual vs auto-generated, translatable) plus the translation targets. Use it when get_transcript can't find your language.

`get_video_metadata`

get_video_metadata(video, include_description=False)

Returns the video's title, channel, upload date, duration, view/like counts, chapters and tags — answers "what's this video / who made it?" without fetching the transcript. Set include_description=True to also include the (often long) description.

`get_most_replayed`

get_most_replayed(video, top_n=8)

Returns the video's most-replayed moments (YouTube's viewer-interest heatmap) as up to top_n distinct high-interest content regions — each with a peak_label/region_label (mm:ss), a clickable jump url, the chapter it falls in, and a relative_intensity (0–1 within the video, 1.0 = its single most-rewatched moment — not a view count). Use it for "what are the best parts?" or to weight a summary by what viewers actually rewatch.

A peak flagged is_opening: true sits at the start (t≈0) — usually a playback-start artifact, not a real rewatch; it's returned in addition to top_n so it can't crowd out the content peaks. has_data is false when YouTube has no heatmap (common for newer/low-traffic videos and some Shorts).

`get_video_frame`

get_video_frame(video, at, max_width=640)

Captures a single still frame (screenshot) at a moment and returns it as an image, so a multimodal model can answer "what's on screen here?" — read a slide, a burned-in caption, or a UI being demoed. at is seconds or a "mm:ss" / "h:mm:ss" string; the frame is the nearest keyframe at/just before it and is downscaled to max_width (clamped 64–1280) to stay cheap on the image budget. Pairs with get_most_replayed / get_transcript(include_timestamps=True) to pick the moment first. Requires ffmpeg.

`get_video_preview`

get_video_preview(video, tiles=12, tile_width=320, start=None, end=None)

Returns a contact sheet: tiles frames sampled evenly across the whole video, composited into one tiled grid image, plus a text legend mapping each tile to its mm:ss timestamp — a cheap visual overview of the entire video (a 4×3 sheet costs about 3× one frame). Pass start / end (seconds or "mm:ss" / "h:mm:ss") to preview just a window of the video — e.g. zoom into the part an overview sheet or get_most_replayed flagged as interesting. Tiles are small by design: spot scene changes and pick a moment here, then zoom in further with get_video_frame at a tile's timestamp. Requires ffmpeg.

Media tools (ffmpeg)

get_video_frame and get_video_preview are the only tools that need an ffmpeg binary (everything else is metadata/transcript only). yt-dlp resolves the video stream and ffmpeg grabs downscaled JPEGs; images come back as MCP image content, so the client/model must be able to display images (e.g. a multimodal model such as Gemma in LM Studio).

The system ffmpeg is used when it's on PATH. The optional media extra installs imageio-ffmpeg, whose wheel bundles a static ffmpeg, making the install self-contained:

pip install "youtube-context-mcp[media]"   # or: uvx youtube-context-mcp[media]@latest
# or bring your own: apt install ffmpeg | brew install ffmpeg | see ffmpeg.org

If neither is available, only the two media tools are affected and they return a clear error.

Proxies (optional)

YouTube blocks most datacenter/cloud IPs, so on a server you may hit RequestBlocked / IpBlocked (transcripts) or a "Sign in to confirm you're not a bot" block (metadata). Locally this is rarely needed. The same env vars route both transcript and metadata requests through a proxy:

Env var	Purpose
`WEBSHARE_PROXY_USERNAME`, `WEBSHARE_PROXY_PASSWORD`	Use Webshare rotating residential proxies.
`WEBSHARE_PROXY_LOCATIONS`	Optional CSV of country codes, e.g. `us,de`.
`YT_TRANSCRIPT_HTTP_PROXY`, `YT_TRANSCRIPT_HTTPS_PROXY`	Use a generic HTTP/HTTPS proxy instead.
`YT_TRANSCRIPT_TIMEOUT`	Per-request timeout in seconds (default `20`).

With no env set, requests go out directly.

Troubleshooting

RequestBlocked / IpBlocked — YouTube blocked the IP. Set the proxy env vars above.
No transcript found — call list_transcripts to see which languages exist for that video.
Transcripts disabled — the uploader turned captions off; nothing can be fetched.
"ffmpeg is not installed" — the media tools need it; install it or use the [media] extra (Media tools).
Frame/preview returns but no image shows — the MCP client/model must support image content; text-only setups drop it silently.

Development

uv sync
uv run ruff check . && uv run ruff format --check .
uv run pytest
uv run mcp dev src/youtube_context_mcp/server.py --with-editable .   # interactive inspector

License

MIT

Credits

Transcript fetching is done by youtube-transcript-api by Jonas Depoix, and metadata by yt-dlp. This project is the MCP adapter that wires them together for agents.

Available Tools

7 tools

build_video_linkA

Build a YouTube link that opens a video at a specific moment.

Returns a watch URL like https://www.youtube.com/watch?v=&t= so a user can click straight to the moment something is discussed. Pair it with get_transcript(include_timestamps= True) -- read off the [mm:ss] of the relevant block and pass it as start -- to turn "where is X mentioned?" into a clickable link.

Args: video: A YouTube URL (watch, youtu.be, shorts, embed, live) or an 11-character video ID. start: The moment to jump to -- seconds (e.g. 90) or a "mm:ss" / "h:mm:ss" string.

Returns: The watch URL as a string.

ParametersJSON Schema

Name	Required	Description	Default
`video`	Yes
`start`	Yes

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description fully explains input formats and return value. Lacks mention of error handling or validation, but overall transparent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Well-structured with Args/Returns sections. Could be slightly more concise, but the example paragraph adds clarity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Complete for a simple tool: covers all inputs, return format, and use case. No output schema, but the return is clearly described.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Despite 0% schema description coverage, the description thoroughly explains both parameters: video accepts various URL forms or ID; start can be seconds or time strings. Provides examples.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states the action (build a link) and the specific resource (YouTube video at a moment). Differentiates from sibling tools like get_transcript or get_video_metadata.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit use case pairing with get_transcript to turn time stamps into clickable links. Does not explicitly mention when not to use, but the context is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_most_replayedA

Get a YouTube video's "most replayed" moments -- the peaks of its viewer-interest heatmap (the curve shown above the timeline marking where people rewatch most).

Use this for "what are the best / most-rewatched parts?", "jump me to the good part", or to weight a summary toward what viewers actually care about. Each peak is a high-interest region (region_start_seconds..region_end_seconds) with the hottest instant at peak_start_seconds, a ready-to-share url that opens the video at the start of the stretch, and the chapter it falls in. relative_intensity is 0..1 within this video (1.0 = its single most-rewatched moment) -- it is NOT a view count and is not comparable across videos.

A peak with is_opening=True sits at the very start (t~=0): that spot is almost always inflated by playback starting there, not a genuine rewatch, so discount it as a "best part". It is returned in addition to (not counted against) top_n, so the opening can't crowd out content.

To say what is actually happening at a peak, read its peak_label (mm:ss) and look it up with get_transcript(include_timestamps=True); profile is a coarse 0..1 curve for the overall shape (front-loaded vs steady vs spikes near the end).

has_data may be False -- then peaks is empty and note explains why (many newer, low-traffic, or Shorts videos have no heatmap).

Args: video: A YouTube URL (watch, youtu.be, shorts, embed, live) or an 11-character video ID. top_n: Max number of content peak regions (clamped to 1..20; default 8). The flagged opening (t~=0) peak, when present, is returned in addition to these.

ParametersJSON Schema

Name	Required	Description	Default
`video`	Yes
`top_n`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`video_id`	Yes
`has_data`	Yes
`duration_seconds`	Yes
`peaks`	Yes
`profile`	Yes
`note`	Yes

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description fully discloses key behaviors: relative_intensity is relative within video, not comparable; is_opening flag indicates inflated interest; has_data may be False; profile curve shape description. This provides comprehensive transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is detailed but well-structured, with main purpose upfront. Every sentence adds value, though some redundancy could be trimmed. Overall, it is appropriately sized for the complexity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers all important aspects: output fields, edge cases (no heatmap, inflated opening), and usage guidance. Given the presence of an output schema, it does not need to detail return format, making the description complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Although schema coverage is 0%, the description fully explains both parameters: video accepts various YouTube URL formats or video ID; top_n is clamped 1-20 with default 8 and the opening peak is additional. This compensates for the lack of schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves 'most replayed' moments from a YouTube video, specifying the resource and the specific data. It distinguishes from siblings like get_transcript and get_video_metadata by focusing on viewer-interest heatmap peaks.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear use cases (e.g., finding best parts, jumping to good parts) and warns about the inflated opening peak and the possibility of missing data. It does not explicitly exclude alternative tools, but the use cases are distinct enough from siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_transcriptA

Fetch a YouTube video's existing captions as text so you can answer questions about it.

Returns existing captions/subtitles only; it does not transcribe audio. Videos without captions have nothing to return.

Args: video: A YouTube URL (watch, youtu.be, shorts, embed, live) or an 11-character video ID. languages: Preferred language codes in priority order. Defaults to ["en"]. include_timestamps: If true, group the transcript into ~15s blocks, each prefixed with [mm:ss] (or [h:mm:ss] past an hour). Use this to find where a topic is discussed and pass that [mm:ss] to build_video_link. translate_to: Optional ISO language code to translate the transcript into.

Returns: The transcript as plain text.

ParametersJSON Schema

Name	Required	Description	Default
`video`	Yes
`languages`	No
`include_timestamps`	No
`translate_to`	No

TDQS

A4.4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It discloses key behaviors: does not transcribe audio, only returns existing captions, default language is ["en"], include_timestamps groups into ~15s blocks with [mm:ss] prefix, and translate_to performs translation. It does not mention error handling (e.g., missing video) or side effects, but for a read-only tool, the covered traits are sufficient.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with a concise opening sentence, a clarifying limitation, then parameter details in a list-like format, and finally return type. It is front-loaded. While every sentence is valuable, the length could be slightly reduced without losing clarity, but overall it is efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 4 parameters, no output schema, and no annotations, the description is fairly complete. It explains the return (plain text), all parameters, and key behavior. It could add more on error scenarios (e.g., no captions found returns empty string or error), but for typical use it is adequate.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must fully explain each parameter. It does so: video (YouTube URL/ID format), languages (priority order, default ["en"]), include_timestamps (purpose and format), translate_to (optional ISO code). The description adds critical meaning beyond the schema's minimal title/type fields.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it fetches existing YouTube captions as text, explicitly distinguishes itself from audio transcription ("it does not transcribe audio"), and the verb "Fetch" plus resource "YouTube video's existing captions" is specific. This differentiates it from sibling tools like list_transcripts (which lists available captions) and get_video_metadata (metadata).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context: use this tool to get existing captions to answer questions about a video. It also clarifies a limitation (only works if captions exist). However, it does not explicitly state when not to use it or suggest alternative sibling tools (e.g., use list_transcripts to check availability first, or get_video_metadata for non-caption info).

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_video_frameA

Capture a single still frame (screenshot) from a YouTube video at a moment and return it as an image, so a multimodal model can answer "what's on screen here?".

Use this to see the video at a specific time -- e.g. read a slide, a caption burned into the video, or a UI being demoed. Pair it with get_most_replayed or get_transcript(include_timestamps =True) to pick an interesting moment, then grab the frame there.

Requires ffmpeg on the server. The captured frame is the nearest keyframe at or just before the requested moment (it can be off by a second or two) and is downscaled to max_width to keep the response small.

Args: video: A YouTube URL (watch, youtu.be, shorts, embed, live) or an 11-character video ID. at: The moment to capture -- seconds (e.g. 90) or a "mm:ss" / "h:mm:ss" string. max_width: Max width in pixels of the returned image (clamped 64..1280; default 640). Smaller is cheaper on a vision model's image-token budget.

ParametersJSON Schema

Name	Required	Description	Default
`video`	Yes
`at`	Yes
`max_width`	No

TDQS

A4.8/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden and discloses key behaviors: requires ffmpeg on server, captured frame is nearest keyframe (may be off by seconds), downscaled to max_width (clamped 64-1280, default 640), and mentions response size implications. This is thorough for a frame capture tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Description is front-loaded with purpose, then usage, then technical details and parameters. It is thorough but slightly lengthy; every sentence adds value, so it earns a high score.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema, the description does not specify the returned image format (e.g., base64, URL) or error handling. However, it covers parameters well and provides usage context. For a simple tool, it is fairly complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, but description fully compensates: 'video' explained as YouTube URL or ID; 'at' as seconds or mm:ss format; 'max_width' with range, default, and cost implication for vision models. Each parameter is clearly described beyond schema type.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states 'Capture a single still frame (screenshot) from a YouTube video at a moment and return it as an image'. It specifies the resource (YouTube video) and action, and indirectly distinguishes from sibling tools by mentioning pairing with get_most_replayed or get_transcript.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly says 'Use this to see the video at a specific time' and provides examples (read a slide, caption, UI). Suggests pairing with get_most_replayed or get_transcript to pick moments, giving clear context for when to use this tool versus siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_video_metadataA

Get a YouTube video's metadata: title, channel, upload date, duration, view/like counts, chapters and tags.

Use this to answer questions about a video (its name, who made it, how long it is, when it came out) without fetching its transcript.

Args: video: A YouTube URL (watch, youtu.be, shorts, embed, live) or an 11-character video ID. include_description: If true, also return the (often long) description; otherwise it's omitted to keep the response small.

ParametersJSON Schema

Name	Required	Description	Default
`video`	Yes
`include_description`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`video_id`	Yes
`title`	Yes
`channel`	Yes
`channel_url`	Yes
`upload_date`	Yes
`duration_seconds`	Yes
`view_count`	Yes
`like_count`	Yes
`description`	Yes
`tags`	Yes
`chapters`	Yes
`thumbnail`	Yes
`webpage_url`	Yes

TDQS

A4.6/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure. It explains that include_description is omitted by default to keep responses small, and it specifies valid input formats for the video parameter. It doesn't discuss rate limits, authentication, or error handling, but for a read-only metadata fetch, the transparency is adequate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and well-structured, starting with the overall purpose, then providing usage guidance, and finally detailing arguments in a labeled format. Every sentence adds value without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (2 parameters, output schema exists), the description is complete. It covers what metadata is returned, the input format, and an optional flag. The presence of an output schema means return values need not be described further.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has no parameter descriptions (0% coverage), so the description must compensate entirely. It does so excellently: it explains the video parameter accepts various YouTube URL formats or a video ID, and the include_description parameter details its effect and rationale for omission.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves a YouTube video's metadata (title, channel, etc.) and distinguishes itself from retrieving the transcript, as indicated by 'without fetching its transcript.' The verb 'get' and resource 'video metadata' are specific and differentiate from sibling tools like get_transcript.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description advises using this tool for metadata questions without fetching the transcript, providing clear context for when to use it. However, it does not explicitly state when not to use it or mention alternatives like get_most_replayed or build_video_link, which are siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_video_previewA

Get a visual overview of a YouTube video as ONE tiled contact-sheet image: tiles frames sampled evenly across the video (or across a start..end window of it), plus a text legend mapping each tile to its mm:ss timestamp.

Use this to see what's going on across a video (talking head vs slides vs demo footage, scene changes, "is there a chart anywhere?") and to pick moments worth a closer look. To inspect one part in more detail, call it again with start/end around that part -- but pick the window from the transcript, chapters, or get_most_replayed first and zoom once; don't binary-search the video with repeated sheets, since every returned image stays in context. Read each tile's timestamp from the legend -- do not count grid cells yourself. Tiles are small and not readable: to read a slide, caption, or UI, follow up with get_video_frame(video, at=<that tile's timestamp>). Windows under ~1 minute may return near-duplicate tiles (frames land on keyframes, a few seconds apart).

Requires ffmpeg on the server (the system binary, or the one bundled by the [media] extra).

Args: video: A YouTube URL (watch, youtu.be, shorts, embed, live) or an 11-character video ID. tiles: How many frames to sample (clamped 4..24; default 12). tile_width: Width in pixels of each tile (clamped 160..480; default 320). The whole sheet stays around 1000-1300 px wide at the defaults -- cheap on a vision model's image budget while keeping tiles recognizable. start: Optional window start -- seconds (e.g. 90) or a "mm:ss" / "h:mm:ss" string. Defaults to the beginning of the video. end: Optional window end, same forms. Defaults to (and is clamped to) the video's end.

ParametersJSON Schema

Name	Required	Description	Default
`video`	Yes
`tiles`	No
`tile_width`	No
`start`	No
`end`	No

TDQS

A4.6/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description discloses behavioral traits: returns one image, tiles are non-readable, image dimensions, server dependency (ffmpeg), clamping of parameters, and potential duplicate tiles. Lacks explicit read-only statement but implied; no mention of auth or rate limits, but acceptable for this tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-organized with clear sections (what, when, requirements, parameters). Every sentence adds value, but it is slightly lengthy. The embedded Args block is justified given the schema lacks descriptions.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 5 parameters, no output schema, and no annotations, the description covers purpose, usage, parameter details, constraints, and common pitfalls (near-duplicate tiles). It could be more explicit about the output format (e.g., image dimensions), but overall it is sufficiently complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema has 0% description coverage, but the description's Args section adds extensive meaning: explains video accepts URL or ID, tiles and tile_width with clamping and defaults, start/end accept seconds or time strings with defaults. This compensates fully for the schema gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states the tool returns a single tiled contact-sheet image with timestamp legend, distinguishing it from sibling tools like get_video_frame (single frame) and get_transcript (text). The verb 'get' and resource 'visual overview' are specific.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly advises when to use (to get an overview), when not to (avoid binary-searching), and how to zoom in using start/end parameters with guidance to first use transcript or get_most_replayed. Also warns about near-duplicate tiles for short windows.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_transcriptsA

List the transcripts available for a YouTube video.

Use this when get_transcript can't find your requested language. It reports each available transcript (language, code, whether it's auto-generated, whether it's translatable) plus the set of languages you can pass to get_transcript's translate_to.

Args: video: A YouTube URL or an 11-character video ID.

ParametersJSON Schema

Name	Required	Description	Default
`video`	Yes

Output Schema

ParametersJSON Schema

Name	Required	Description
`transcripts`	Yes
`translation_languages`	Yes

TDQS

A4.8/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Although no annotations are provided, the description details what the tool reports (language, code, auto-generated, translatable) and notes that it also returns languages for translation. This goes beyond basic functionality, though it does not explicitly state read-only or side-effect-free behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short paragraphs with clear front-loading of purpose and usage. Every sentence adds value; no redundancy or fluff.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given a single parameter and output schema existence, the description covers all necessary aspects: what it does, when to use, parameter format, and output content. Complete for the tool's complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description fully explains the single parameter 'video' with format guidance ('A YouTube URL or an 11-character video ID'). Since schema coverage is 0%, the description compensates completely, adding essential meaning.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool lists available transcripts for a YouTube video, with a specific verb 'List' and resource 'transcripts'. It also distinguishes itself from sibling tool get_transcript by indicating when to use this tool.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly provides usage context: 'Use this when get_transcript can't find your requested language.' This tells the agent when to choose this tool over alternatives, meeting the highest standard.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.6/5.0

Disambiguation5/5

Each tool targets a distinct aspect of YouTube video interaction: building links, retrieving heatmap peaks, fetching transcripts, getting metadata, and listing available transcripts. There is no functional overlap.

Naming Consistency5/5

All tool names follow a consistent verb_noun snake_case pattern (build_, get_, list_), making the set predictable and easy to navigate.

Tool Count5/5

Five tools is well-scoped for a YouTube context server—enough to cover core operations without being overwhelming or incomplete.

Completeness4/5

The server covers key operations: metadata retrieval, transcript access, heatmap analysis, and link generation. Minor gaps like advanced search or comment retrieval are outside the stated purpose.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

YouTube Transcript Downloader A
com.youtubetranscriptdownload
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.
Entertainment & Media Research & Data Web Scraping
42
RiverScript A
com.riverscript
MCP server for RiverScript, an AI transcription platform - fetches transcripts shared via a link.
Audio Processing AI & Machine Learning
11
💯 YouTube Transcript + YouTube Search MCP for AI Agents
com.transcriptapi
💯 The fastest YouTube transcript + YouTube search MCP for AI agents. Try for free.
Search Entertainment & Media
29
framefetch A
io.github.MarvinRey7879
Any social-video URL → transcript, metadata, frames, OCR, summary, search, Q&A. MCP server + x402.
Social Media Multimedia Processing
42

Related MCP Servers

ytt-mcp
Entertainment & Media Text Summarization Web Scraping
cottongeeks
A
license
B
quality
D
maintenance
An MCP server designed to fetch transcripts for YouTube videos. It enables AI tools to access video text content for tasks like summarization, analysis, and key takeaway extraction.
Updated a year ago (2025-10-15 20:02 UTC)
1
73
MIT
YouTube Insights MCP Server
Multimedia Processing Search Web Scraping
tejas-borate-wai
F
license
B
quality
D
maintenance
An MCP server that extracts transcripts, metadata, and summaries from YouTube videos across various URL formats including Shorts and standard links. It provides comprehensive video data and insights for analysis within MCP-compatible environments.
Updated 9 months ago (2025-11-28 04:45 UTC)
3
yt
Search Entertainment & Media RAG Systems
progrmoiz
A
license
Not graded
quality
Not graded
maintenance
An 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.
Updated 5 months ago (2026-04-18 00:47 UTC)
3
tldw-mcp
Entertainment & Media Text Summarization
limace11
A
license
Not graded
quality
D
maintenance
MCP server that extracts YouTube video transcripts (including metadata) as Markdown, enabling AI to summarize and discuss video content without watching it.
Updated 3 months ago (2026-06-07 21:46 UTC)
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/realiti4/youtube-context-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server