# MCP install per client

> Add the Scribiz MCP server to Claude Code, Cursor, VS Code, Codex, Claude Desktop and claude.ai. No key to start, or run it locally with your account.

Page: https://scribiz.com/docs/mcp/install

The hosted server at `https://scribiz.com/mcp` is open today. Pick Remote to start with no key, With a key to run Listen and Watch from your minutes, or Local to run the server on your own machine. The tabs below use the same names in every section, so the one you pick stays selected as you scroll.

| Tab | What it is | Needs |
| --- | --- | --- |
| Remote | The hosted server, no key | A client that accepts a URL |
| With a key | The hosted server with your API key | An API key, made in the dashboard after you sign in |
| Local | `scribiz mcp`, started by your client, with your Scribiz account or your own Gemini key | The CLI on your machine |

Local needs the command-line tool and a credential: a free Scribiz account, or your own Gemini key. Install it once, then your client starts the server as a command:

```bash
npm install -g scribiz
scribiz login     # or: scribiz setup, for your own Gemini key
```

`scribiz login` signs in to a free Scribiz account (30 minutes a month) and `scribiz setup` saves your own Gemini key. The server uses whichever one is saved. The tool also needs `ffmpeg` and `yt-dlp` for local files and most links, and Node.js 24 or newer. It has been tested on macOS only. See [Install the CLI](https://scribiz.com/docs/cli.md) and [Connection modes](https://scribiz.com/docs/mcp/connection-modes.md#local). Claude Desktop has no Local tab below, because it needs its own setup: see its section.

Which one to use is covered in [Connection modes](https://scribiz.com/docs/mcp/connection-modes.md). In short, Remote works in a minute: captions, videos already processed and a model read of the link, with about 10 minutes of reading a day. A key adds Watch, and so does a credential on the Local server.

The examples with a key read it from an environment variable named `SCRIBIZ_API_KEY`. Do not paste the key into a file you commit. The Local examples hold no key: the server reads what `scribiz login` or `scribiz setup` saved, or `SCRIBIZ_API_KEY` or `GEMINI_API_KEY` from its environment.

## Claude Code

```bash tab="Remote"
claude mcp add --transport http scribiz https://scribiz.com/mcp
```

```bash tab="With a key"
claude mcp add --transport http scribiz https://scribiz.com/mcp \
  --header "Authorization: Bearer $SCRIBIZ_API_KEY"
```

```bash tab="Local"
claude mcp add scribiz -- scribiz mcp
```

In the Local command the `--` is required. It ends Claude Code's own options, so `scribiz mcp` is read as the command to start.

To share the remote setup with your team, commit a `.mcp.json` that reads the key from each person's environment:

```json title=".mcp.json"
{
  "mcpServers": {
    "scribiz": {
      "type": "http",
      "url": "https://scribiz.com/mcp",
      "headers": { "Authorization": "Bearer ${SCRIBIZ_API_KEY}" }
    }
  }
}
```

Run `/mcp` inside Claude Code to see the server and its tools.

## Claude Desktop

Add a custom connector for the hosted server.

```text title="Claude Desktop"
Customize, Connectors, Add custom connector.
Name: Scribiz
URL: https://scribiz.com/mcp
```

To run the local server instead, edit the config file (Settings, Developer, Edit config). Claude Desktop starts programs with a short `PATH`. The `scribiz` command starts with `#!/usr/bin/env node`, so it fails with `env: node: No such file or directory` when Node is not on that `PATH`. Give the full path of `node` (the output of `which node`) and of the package file (the output of `npm root -g`, then `/scribiz/scribiz.js`):

```json title="claude_desktop_config.json"
{
  "mcpServers": {
    "scribiz": {
      "command": "/path/to/node",
      "args": ["/path/to/scribiz.js", "mcp"]
    }
  }
}
```

Run `scribiz login` (or `scribiz setup`) once, then restart Claude Desktop. A client that starts the server in `/` or in your home folder must pass `--root` whenever it passes `--allow-files`.

## Cursor

Put this in `~/.cursor/mcp.json`, or in `.cursor/mcp.json` inside a project to scope it to that project.

```json tab="Remote"
{
  "mcpServers": {
    "scribiz": { "url": "https://scribiz.com/mcp" }
  }
}
```

```json tab="With a key"
{
  "mcpServers": {
    "scribiz": {
      "url": "https://scribiz.com/mcp",
      "headers": { "Authorization": "Bearer ${env:SCRIBIZ_API_KEY}" }
    }
  }
}
```

```json tab="Local"
{
  "mcpServers": {
    "scribiz": { "command": "scribiz", "args": ["mcp"] }
  }
}
```

## VS Code

Put this in `.vscode/mcp.json`. VS Code's file uses `servers`, not `mcpServers`.

```json tab="Remote"
{
  "servers": {
    "scribiz": { "type": "http", "url": "https://scribiz.com/mcp" }
  }
}
```

```json tab="With a key"
{
  "servers": {
    "scribiz": {
      "type": "http",
      "url": "https://scribiz.com/mcp",
      "headers": { "Authorization": "Bearer ${input:scribiz-key}" }
    }
  },
  "inputs": [{ "type": "promptString", "id": "scribiz-key", "description": "Scribiz API key", "password": true }]
}
```

```json tab="Local"
{
  "servers": {
    "scribiz": { "type": "stdio", "command": "scribiz", "args": ["mcp"] }
  }
}
```

For the hosted server, VS Code asks for the key the first time the server starts and keeps it out of the file.

## Codex

Add this to `~/.codex/config.toml`.

```toml tab="Remote"
[mcp_servers.scribiz]
url = "https://scribiz.com/mcp"
```

```toml tab="With a key"
[mcp_servers.scribiz]
url = "https://scribiz.com/mcp"
bearer_token_env_var = "SCRIBIZ_API_KEY"
```

```toml tab="Local"
[mcp_servers.scribiz]
command = "scribiz"
args = ["mcp"]
```

Or run `codex mcp add scribiz -- scribiz mcp`.

Codex gives a tool call about 60 seconds by default. Scribiz answers within 45 seconds and hands back a job when a video needs longer, so the default is fine.

## claude.ai

claude.ai takes a connector URL. Add a custom connector in the app's settings, paste the address, and choose no authentication:

```text title="Connector URL"
https://scribiz.com/mcp
```

- In claude.ai, open Settings, then Connectors, then Add custom connector. Menu names change, so look for the custom connector option.

We have not tested ChatGPT, so we do not give steps for it.

claude.ai connects without a key: captions, videos already processed and a model read of the link, inside the daily allowance. Watch needs a key, and OAuth sign-in is not built yet. Until then, use Claude Code, Cursor, VS Code or Codex with a key. See [Connection modes](https://scribiz.com/docs/mcp/connection-modes.md#oauth-coming-later).

## Check that it works

Ask your agent: "Use Scribiz to summarize https://www.youtube.com/watch?v=jNQXAC9IVRw". It is a 19 second public video, "Me at the zoo".

What to expect:

- A call to `get_video_context`, then a short summary: a visitor in front of the elephants, remarking on their long trunks.
- The result says how the transcript was made. When a model read the link, it says so, and its times are approximate (about 2 seconds either way). It says there are no on-screen notes without a key.
- The cost is on the `Layers` line of the result. Scribiz had already processed this video when this page was checked (4 October 2026), so it reported 0 minutes. For a video it has not processed, the first read uses a little of your day's 10 minutes: about 0.3 minutes for a 19 second video that a model reads, and about a tenth of that when the captions can be read. Ask again and it costs 0.

You can also try the server without a client. This asks the hosted server for its tools:

```bash
curl -s https://scribiz.com/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
```

Clients that only speak stdio can reach the hosted server through a bridge such as `mcp-remote`. We have not tested it, so it is not a supported setup.

---

Checked against the Scribiz build on 2026-10-05.