@unclick/youtube-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,15 @@
+Apache License 2.0
+
+Copyright (c) 2026 UnClick / malamutemayhem
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,38 @@
+# YouTube MCP by UnClick
+
+Search YouTube and get video, channel, playlist, and caption details.
+
+> By UnClick. 180+ tools plus persistent agent memory in one install: https://unclick.world
+
+## Install
+
+Installs straight from GitHub, no npm account needed.
+
+```json
+{
+  "mcpServers": {
+    "youtube": {
+      "command": "npx",
+      "args": ["-y", "https://github.com/malamutemayhem/unclick/releases/download/standalone-mcps-latest/youtube.tgz"]
+    }
+  }
+}
+```
+
+## Tools
+
+- `youtube_search`
+- `youtube_get_video`
+- `youtube_get_channel`
+- `youtube_list_playlists`
+- `youtube_list_playlist_items`
+- `youtube_get_captions`
+
+## Want the rest?
+
+This is one connector. [UnClick](https://unclick.world) bundles 180+ tools plus
+persistent cross-session agent memory in a single install.
+
+## License
+
+Apache-2.0

package/dist/index.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+// YouTube MCP. Standalone MCP server by UnClick.
+// By UnClick. 180+ tools plus persistent agent memory in one install: https://unclick.world
+//
+// Generated from the UnClick connector by scripts/generate-standalone-mcp.mjs.
+// Edit the connector in the UnClick monorepo, not here.
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { youtubeSearch, youtubeGetVideo, youtubeGetChannel, youtubeListPlaylists, youtubeListPlaylistItems, youtubeGetCaptions, } from "./youtube-tool.js";
+const TOOLS = [
+    {
+        name: "youtube_search",
+        description: "Search YouTube for videos, channels, or playlists.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                api_key: { type: "string" },
+                query: { type: "string" },
+                type: { type: "string", enum: ["video", "channel", "playlist"], description: "video, channel, or playlist (default: video)" },
+                max_results: { type: "number" },
+                order: { type: "string", description: "relevance, date, rating, viewCount, title" },
+                channel_id: { type: "string" },
+                published_after: { type: "string", description: "RFC 3339 datetime, e.g. 2024-01-01T00:00:00Z" },
+                region_code: { type: "string" },
+                page_token: { type: "string" },
+            },
+            required: ["api_key", "query"],
+        },
+    },
+    {
+        name: "youtube_get_video",
+        description: "Get metadata, statistics, and content details for a YouTube video.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                api_key: { type: "string" },
+                video_id: { type: "string" },
+            },
+            required: ["api_key", "video_id"],
+        },
+    },
+    {
+        name: "youtube_get_channel",
+        description: "Get metadata and statistics for a YouTube channel.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                api_key: { type: "string" },
+                channel_id: { type: "string" },
+                handle: { type: "string", description: "Channel handle without @ (alternative to channel_id)" },
+            },
+            required: ["api_key"],
+        },
+    },
+    {
+        name: "youtube_list_playlists",
+        description: "List playlists belonging to a YouTube channel.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                api_key: { type: "string" },
+                channel_id: { type: "string" },
+                max_results: { type: "number" },
+                page_token: { type: "string" },
+            },
+            required: ["api_key", "channel_id"],
+        },
+    },
+    {
+        name: "youtube_list_playlist_items",
+        description: "List videos in a YouTube playlist.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                api_key: { type: "string" },
+                playlist_id: { type: "string" },
+                max_results: { type: "number" },
+                page_token: { type: "string" },
+            },
+            required: ["api_key", "playlist_id"],
+        },
+    },
+    {
+        name: "youtube_get_captions",
+        description: "List available caption tracks for a YouTube video.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                api_key: { type: "string" },
+                video_id: { type: "string" },
+            },
+            required: ["api_key", "video_id"],
+        },
+    }
+];
+const HANDLERS = {
+    youtube_search: (args) => youtubeSearch(args),
+    youtube_get_video: (args) => youtubeGetVideo(args),
+    youtube_get_channel: (args) => youtubeGetChannel(args),
+    youtube_list_playlists: (args) => youtubeListPlaylists(args),
+    youtube_list_playlist_items: (args) => youtubeListPlaylistItems(args),
+    youtube_get_captions: (args) => youtubeGetCaptions(args),
+};
+const server = new Server({ name: "io.github.malamutemayhem/youtube", version: "0.1.0" }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const handler = HANDLERS[req.params.name];
+    if (!handler) {
+        return { content: [{ type: "text", text: `Unknown tool: ${req.params.name}` }], isError: true };
+    }
+    try {
+        const result = await handler((req.params.arguments ?? {}));
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: message }], isError: true };
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    process.stderr.write(`[youtube-mcp] fatal: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+});

package/dist/youtube-tool.js

@@ -0,0 +1,195 @@
+// YouTube Data API v3 integration for the UnClick MCP server.
+// Uses the YouTube Data API via fetch - no external dependencies.
+// Users must supply an API key from Google Cloud Console.
+const YT_API_BASE = "https://www.googleapis.com/youtube/v3";
+// ─── API helper ───────────────────────────────────────────────────────────────
+async function ytGet(apiKey, endpoint, params) {
+    const query = new URLSearchParams({ ...params, key: apiKey }).toString();
+    const res = await fetch(`${YT_API_BASE}/${endpoint}?${query}`);
+    const data = await res.json();
+    if (!res.ok) {
+        const err = data.error;
+        const msg = err?.message ?? `HTTP ${res.status}`;
+        const code = err?.code ? ` (code ${err.code})` : "";
+        throw new Error(`YouTube API error${code}: ${msg}`);
+    }
+    return data;
+}
+// ─── Auth validation ──────────────────────────────────────────────────────────
+function requireKey(args) {
+    const key = String(args.api_key ?? "").trim();
+    if (!key)
+        throw new Error("api_key is required. Create one at console.cloud.google.com.");
+    return key;
+}
+// ─── Operations ───────────────────────────────────────────────────────────────
+export async function youtubeSearch(args) {
+    const apiKey = requireKey(args);
+    const q = String(args.query ?? "").trim();
+    if (!q)
+        throw new Error("query is required.");
+    const maxResults = Math.min(50, Math.max(1, Number(args.max_results ?? 10)));
+    const type = String(args.type ?? "video");
+    const params = {
+        part: "snippet",
+        q,
+        type,
+        maxResults: String(maxResults),
+    };
+    if (args.order)
+        params.order = String(args.order);
+    if (args.published_after)
+        params.publishedAfter = String(args.published_after);
+    if (args.region_code)
+        params.regionCode = String(args.region_code);
+    if (args.page_token)
+        params.pageToken = String(args.page_token);
+    if (args.channel_id)
+        params.channelId = String(args.channel_id);
+    const data = await ytGet(apiKey, "search", params);
+    return {
+        total_results: data.pageInfo.totalResults,
+        next_page_token: data.nextPageToken ?? null,
+        items: (data.items ?? []).map((item) => ({
+            kind: item.id.kind,
+            id: item.id.videoId ?? item.id.channelId ?? item.id.playlistId,
+            title: item.snippet.title,
+            description: item.snippet.description,
+            channel_id: item.snippet.channelId,
+            channel_title: item.snippet.channelTitle,
+            published_at: item.snippet.publishedAt,
+            thumbnail: item.snippet.thumbnails?.medium?.url ?? item.snippet.thumbnails?.default?.url ?? null,
+            live_broadcast: item.snippet.liveBroadcastContent,
+        })),
+    };
+}
+export async function youtubeGetVideo(args) {
+    const apiKey = requireKey(args);
+    const videoId = String(args.video_id ?? "").trim();
+    if (!videoId)
+        throw new Error("video_id is required.");
+    const data = await ytGet(apiKey, "videos", {
+        part: "snippet,statistics,contentDetails",
+        id: videoId,
+    });
+    const video = data.items?.[0];
+    if (!video)
+        throw new Error(`Video not found: ${videoId}`);
+    return {
+        id: video.id,
+        title: video.snippet?.title ?? null,
+        description: video.snippet?.description ?? null,
+        channel_id: video.snippet?.channelId ?? null,
+        channel_title: video.snippet?.channelTitle ?? null,
+        published_at: video.snippet?.publishedAt ?? null,
+        tags: video.snippet?.tags ?? [],
+        duration: video.contentDetails?.duration ?? null,
+        definition: video.contentDetails?.definition ?? null,
+        view_count: video.statistics?.viewCount ?? null,
+        like_count: video.statistics?.likeCount ?? null,
+        comment_count: video.statistics?.commentCount ?? null,
+    };
+}
+export async function youtubeGetChannel(args) {
+    const apiKey = requireKey(args);
+    const channelId = String(args.channel_id ?? "").trim();
+    const forHandle = String(args.handle ?? "").trim();
+    if (!channelId && !forHandle)
+        throw new Error("Either channel_id or handle is required.");
+    const params = { part: "snippet,statistics" };
+    if (channelId)
+        params.id = channelId;
+    if (forHandle)
+        params.forHandle = forHandle.startsWith("@") ? forHandle.slice(1) : forHandle;
+    const data = await ytGet(apiKey, "channels", params);
+    const channel = data.items?.[0];
+    if (!channel)
+        throw new Error("Channel not found.");
+    return {
+        id: channel.id,
+        title: channel.snippet?.title ?? null,
+        description: channel.snippet?.description ?? null,
+        custom_url: channel.snippet?.customUrl ?? null,
+        published_at: channel.snippet?.publishedAt ?? null,
+        subscriber_count: channel.statistics?.subscriberCount ?? null,
+        video_count: channel.statistics?.videoCount ?? null,
+        view_count: channel.statistics?.viewCount ?? null,
+    };
+}
+export async function youtubeListPlaylists(args) {
+    const apiKey = requireKey(args);
+    const channelId = String(args.channel_id ?? "").trim();
+    if (!channelId)
+        throw new Error("channel_id is required.");
+    const maxResults = Math.min(50, Math.max(1, Number(args.max_results ?? 20)));
+    const params = {
+        part: "snippet,contentDetails",
+        channelId,
+        maxResults: String(maxResults),
+    };
+    if (args.page_token)
+        params.pageToken = String(args.page_token);
+    const data = await ytGet(apiKey, "playlists", params);
+    return {
+        total_results: data.pageInfo.totalResults,
+        next_page_token: data.nextPageToken ?? null,
+        playlists: (data.items ?? []).map((pl) => ({
+            id: pl.id,
+            title: pl.snippet?.title ?? null,
+            description: pl.snippet?.description ?? null,
+            channel_id: pl.snippet?.channelId ?? null,
+            channel_title: pl.snippet?.channelTitle ?? null,
+            published_at: pl.snippet?.publishedAt ?? null,
+            item_count: pl.contentDetails?.itemCount ?? null,
+        })),
+    };
+}
+export async function youtubeListPlaylistItems(args) {
+    const apiKey = requireKey(args);
+    const playlistId = String(args.playlist_id ?? "").trim();
+    if (!playlistId)
+        throw new Error("playlist_id is required.");
+    const maxResults = Math.min(50, Math.max(1, Number(args.max_results ?? 20)));
+    const params = {
+        part: "snippet",
+        playlistId,
+        maxResults: String(maxResults),
+    };
+    if (args.page_token)
+        params.pageToken = String(args.page_token);
+    const data = await ytGet(apiKey, "playlistItems", params);
+    return {
+        total_results: data.pageInfo.totalResults,
+        next_page_token: data.nextPageToken ?? null,
+        items: (data.items ?? []).map((item) => ({
+            id: item.id,
+            title: item.snippet?.title ?? null,
+            video_id: item.snippet?.resourceId.videoId ?? null,
+            position: item.snippet?.position ?? null,
+            published_at: item.snippet?.publishedAt ?? null,
+        })),
+    };
+}
+export async function youtubeGetCaptions(args) {
+    const apiKey = requireKey(args);
+    const videoId = String(args.video_id ?? "").trim();
+    if (!videoId)
+        throw new Error("video_id is required.");
+    const data = await ytGet(apiKey, "captions", {
+        part: "snippet",
+        videoId,
+    });
+    return {
+        count: (data.items ?? []).length,
+        captions: (data.items ?? []).map((c) => ({
+            id: c.id,
+            language: c.snippet.language,
+            name: c.snippet.name,
+            track_kind: c.snippet.trackKind,
+            is_cc: c.snippet.isCC,
+            is_auto_synced: c.snippet.isAutoSynced,
+            status: c.snippet.status,
+            last_updated: c.snippet.lastUpdated,
+        })),
+    };
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@unclick/youtube-mcp",
+  "version": "0.1.0",
+  "mcpName": "io.github.malamutemayhem/youtube",
+  "description": "Search YouTube and get video, channel, playlist, and caption details. By UnClick (https://unclick.world).",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "unclick",
+    "youtube",
+    "video",
+    "search",
+    "captions"
+  ],
+  "author": "UnClick (https://unclick.world)",
+  "type": "module",
+  "bin": {
+    "youtube-mcp": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "server.json"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.15.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0",
+    "@types/node": "^22.0.0"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/malamutemayhem/unclick.git",
+    "directory": "packages/standalone/youtube-mcp"
+  },
+  "homepage": "https://unclick.world"
+}

package/server.json

@@ -0,0 +1,33 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.malamutemayhem/youtube",
+  "title": "YouTube MCP by UnClick",
+  "description": "Search YouTube and get video, channel, playlist, and caption details. By UnClick.",
+  "version": "0.1.0",
+  "websiteUrl": "https://unclick.world",
+  "icons": [
+    {
+      "src": "https://unclick.world/favicon.png",
+      "mimeType": "image/png",
+      "sizes": [
+        "512x512"
+      ]
+    }
+  ],
+  "repository": {
+    "url": "https://github.com/malamutemayhem/unclick.git",
+    "source": "github",
+    "subfolder": "packages/standalone/youtube-mcp"
+  },
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "@unclick/youtube-mcp",
+      "version": "0.1.0",
+      "runtimeHint": "npx",
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}