How to Connect Claude Code to a YouTube MCP Server

Prepublish serves a YouTube script audit over the Model Context Protocol at https://mcp.prepublish.ai, and it audits a script you have written but not recorded. Claude Code connects with one command:

claude mcp add --transport http prepublish https://mcp.prepublish.ai

The endpoint is stateless Streamable HTTP, free, and anonymous. It exposes six tools, returns scores, flagged passages and rewrites inside the conversation, and asks for no account.

Two ways, and the difference is only where the configuration lives.

The command above writes to local scope, which keeps the server to your machine. Run claude mcp list to confirm the entry, and /mcp inside a session to see the connection status and the tool list.

For a server that travels with a repository, create .mcp.json at the project root:

{
  "mcpServers": {
    "prepublish": {
      "type": "http",
      "url": "https://mcp.prepublish.ai"
    }
  }
}

The type field is load-bearing. Claude Code reads an entry that has a url and no type as a stdio server, skips it, and reports MCP server "prepublish" has a "url" but no "type". Adding "type": "http" fixes it, and "streamable-http" works as an alias, which matters because that is the name the MCP specification uses for the transport. A committed .mcp.json stays at pending approval until someone runs claude in the project and accepts the workspace trust dialog, so a cloned repository cannot silently approve its own servers.

https://mcp.prepublish.ai is the canonical connector URL. https://prepublish.ai/mcp and https://mcp.prepublish.ai/mcp serve the same handler and are listed as aliases on the server card, in prepublish-fe/app/mcp/route.ts.

Every client below takes the hosted URL directly. None of them requires the bridge for a basic connection, which is worth stating because the bridge exists and its presence invites the assumption that a remote endpoint is unavailable.

Claude Code

The CLI command above, or the .mcp.json block in the section above. Both are documented in the Claude Code MCP reference.

Claude Desktop

For a remote connector, open Customize then Connectors, choose Add custom connector, and paste https://mcp.prepublish.ai. Claude Desktop, claude.ai and Cowork connect to custom connectors from Anthropic's cloud infrastructure rather than from your machine, so the endpoint has to be reachable over the public internet, which this one is. Free plans are limited to one custom connector. The steps are in Get started with custom connectors using remote MCP.

The local file is a separate mechanism and takes only a command, so it needs the bridge:

{
  "mcpServers": {
    "prepublish": {
      "command": "npx",
      "args": ["-y", "prepublish-mcp"]
    }
  }
}

Save the file, quit Claude Desktop, and restart it. Local server logs land in ~/Library/Logs/Claude on macOS and %APPDATA%\Claude\logs on Windows, per the MCP quickstart for Claude Desktop.

Cursor

Create ~/.cursor/mcp.json for every project, or .cursor/mcp.json for one project:

{
  "mcpServers": {
    "prepublish": {
      "url": "https://mcp.prepublish.ai"
    }
  }
}

Cursor documents both file locations and the remote url shape in its MCP documentation.

Windsurf

Edit ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "prepublish": {
      "serverUrl": "https://mcp.prepublish.ai"
    }
  }
}

Windsurf docs now live under the Devin Desktop documentation; the MCP page still names ~/.codeium/windsurf/mcp_config.json as the file and accepts serverUrl or url for a remote server.

VS Code with Copilot

Create .vscode/mcp.json in the workspace, or run MCP: Open User Configuration for the user profile:

{
  "servers": {
    "prepublish": {
      "type": "http",
      "url": "https://mcp.prepublish.ai"
    }
  }
}

The wrapper key is servers, not mcpServers, which is the most common copy-paste error for this client. VS Code documents the file and the remote shape in Add and manage MCP servers in VS Code.

Codex CLI

Add a table to ~/.codex/config.toml:

[mcp_servers.prepublish]
url = "https://mcp.prepublish.ai"

Codex CLI, the ChatGPT desktop app and the Codex IDE extension share this configuration. The supported keys for a Streamable HTTP server are documented in the Codex MCP reference.

Six tools, discovered with tools/list. Names, inputs and outputs below come from prepublish-fe/lib/mcp/tools.ts, which is the single source of truth: the stdio bridge fetches its list from the hosted server at startup, so the names cannot drift between the two.

Every AI-backed result repeats the same constraint in its payload: the check is text-only, it maps relative attention risk inside an unrecorded script, and it does not measure or predict published YouTube retention.

audit_script

Use it when the draft is finished or nearly finished.

Audit this script for a video titled "I rebuilt my studio for 400 pounds". I plan to record about nine minutes. Send the result to me@example.com.

The tool starts an asynchronous audit and polls for up to 90 seconds inside the same request. If the audit has not settled by then, it returns the id and tells the assistant to collect it later. The five checks worth running by hand before you spend a call on this one are in the pre-recording method.

get_audit

Use it after a poll timeout, or when you come back to an audit from earlier in the conversation.

Collect the audit with analysis id 6f0b1c2e-9a44-4f0a-9c3d-1f7b2a8e5d10 and show me only the passages it flagged hardest.

audit_hook

The cheap check, for an opening alone. The browser version of the same check is the hook analyzer.

Score this opening and tell me which sentence loses people first: "Most creators lose half their viewers in the first fifteen seconds, and the reason is rarely the editing."

check_authenticity

For the fear that a repeating format reads as templated.

Check this script for reused-content risk. I publish the same format every week and I am worried it now reads as mass-produced: [paste the script]

The signals it returns come with quotes from the draft, so the report shows the repetition rather than asserting it.

policy_preflight

For a script that touches sensitive subject matter.

Pre-flight this script against YouTube advertiser policy before I record. The title is "How I got banned from three platforms": [paste the script]

The category list cites YouTube's published policy pages. The quoted passages and their rewrites belong to the paid audit, so a free result can return counts with the quotes locked. The browser equivalent is the monetization checker.

script_runtime

Arithmetic, with no AI call and no budget consumed.

How long will this 2,400-word script run, and how many words do I need for a twelve-minute video?

Rates come from a measurement of 349 videos: 25th percentile 160 words per minute, median 181, 75th percentile 201 (prepublish-fe/lib/seo/wpm-data.ts). Speaking time only. Pauses, B-roll and demonstrations add time, so the estimate is a floor rather than a target.

Use the hosted URL for everything, unless the client cannot be handed a URL.

The endpoint is one path that answers POST and GET. A POST carries one JSON-RPC message and gets one JSON response, with no session id issued and no SSE stream opened. The specification allows that: a server handling a request may answer with application/json instead of a text/event-stream, and the Mcp-Session-Id header is a MAY. The handshake, tool discovery and every tool call are ordinary POST requests. A bare GET returns the server card instead of the 405 the specification permits, because humans and crawlers arrive at that URL from directory listings.

The registry entry is ai.prepublish/script-audit, version 1.0.1, marked latest, with a remote-only Streamable HTTP record pointing at https://mcp.prepublish.ai. Those are the fields in prepublish-mcp/server.json, read back from the official registry on 19 September 2026.

The bridge is published on npm as prepublish-mcp version 1.0.0, and the invocation documented in prepublish-mcp/README.md and on the MCP server documentation is npx -y prepublish-mcp. It starts a local process that connects to the same hosted server over Streamable HTTP and re-serves the tool list over stdio, which is the transport a client uses when it spawns a subprocess and talks over stdin and stdout. The bridge adds and hides nothing: prepublish-mcp/test/bridge.test.ts asserts that its sorted tool names equal the six names in the hosted list, and that a forwarded script_runtime call returns the same arithmetic.

Three cases where the bridge is the right answer:

• The client takes only a command and arguments. That is the claude_desktop_config.json path, plus some editors and local agent runtimes.
• The audit has to run from your own network. Custom connectors in Claude connect from Anthropic's cloud, so a private endpoint behind a firewall will not be reached that way. The bridge runs on your machine.
• You want to forward a bearer token from a local environment variable. PREPUBLISH_TOKEN sends an Authorization: Bearer header upstream, and PREPUBLISH_MCP_URL points the bridge at another deployment.

The bridge needs Node 20 or newer, per the engines field in prepublish-mcp/package.json. On startup it writes one line to stderr naming the upstream URL, the tool count and whether a token was supplied, which is the fastest way to confirm that the process launched and reached the server.

Free and anonymous, with two published counters. Both defaults come from prepublish-fe/lib/mcp/limits.ts, and both are environment variables on the deployment rather than constants in the client.

Two refusals, two different problems. When the global day is spent, the tool returns: Prepublish's free MCP endpoint has reached its daily limit of 100 AI-backed calls (it resets at 00:00 UTC). When one caller has used six checks inside ten minutes, it returns: This connection has used its 6 free Prepublish AI checks for now; the allowance resets in about N minute(s). Both are tool-level errors rather than protocol failures, so the message you see in the conversation is the message the server wrote.

The per-caller limit exists because the backend rate limiter keys on client IP and every MCP call reaches it from the web container's single IP address, which would otherwise put every user of the server in one shared bucket. Both counters are in-process. A restart resets them, which is a deliberate trade: a soft cap that forgets is better than wrongly blocking someone. Get the live numbers from GET https://mcp.prepublish.ai, where free_tier.ai_backed_calls_per_day and used_today are read from the same counters.

Two more gates sit behind the MCP layer, in the tools themselves. A free full audit needs an email address, and the backend answers without one with a 402 or a 400 whose message mentions email. Each individual check also has its own daily allowance on prepublish.ai, which returns a 429 that says the allowance for that check is spent. Neither is a fault in your configuration.

The endpoint implements protocol revisions up to 2025-11-25, and negotiates down for older clients; 2025-06-18, 2025-03-26 and 2024-11-05 are answered as asked. The revision in force is newer than that, and clients are required to handle older dialects, so a current client will connect, but the server cannot use capabilities added after 2025-11-25.

It does not predict retention. Every AI-backed payload carries the same constraint, stated for the model to relay: a text-only check of an unrecorded script, mapping relative attention risk inside the draft, with no ability to account for delivery, editing, thumbnail, topic or distribution.

It does not decide monetisation. policy_preflight reports the categories a draft may touch against YouTube's published policy text and links each one. Only YouTube decides, and it decides on the finished video.

It does not fetch a video, a transcript or a channel. All six tools take text you paste. If the draft does not deserve the check, no tool here will tell you that: it audits execution against the title's promise, not whether the topic was worth a video.

It does not write the script. The tools audit a draft you already wrote, and audit_script will return rewrites for flagged passages only, not a draft of its own.

It does not give you a per-user history. There are no API keys yet, and authenticated use means an existing magic-link token forwarded by the bridge. Anonymous use has no identity to attach a run history to, which is why get_audit takes the id that audit_script returned.

Every symptom below is a string the code produces. The server messages and JSON-RPC codes come from prepublish-fe/lib/mcp/tools.ts, prepublish-fe/lib/mcp/limits.ts, prepublish-fe/lib/mcp/protocol.ts and prepublish-fe/app/mcp/route.ts.