# Set up the MCP server

_Connect Claude, Cursor, Codex, or any MCP client to your workspace — sign in with your Snoze account, no API key needed._

Canonical: https://snoze.dev/help/set-up-the-mcp-server/

Snoze runs a hosted [Model Context Protocol](https://modelcontextprotocol.io)
server, so AI clients can search and act on your workspace directly — no local
bridge to install or keep updated. It speaks Streamable HTTP at
`https://api.snoze.dev/mcp`.

Connecting takes one step: add the server to your client, and when the client
first talks to Snoze your browser opens to sign in and approve access. The
agent then works as you — it can see and change exactly what your workspace
role allows, nothing more. No API key required.

## Claude Code

Add the server with the official command, then sign in:

```bash
claude mcp add --transport http snoze https://api.snoze.dev/mcp
```

Run `/mcp` inside Claude Code and pick **snoze** to sign in through your
browser. The default command enables the server for you in the current
project only. Two other scopes are worth knowing:

```bash
# For you, in every project on this machine
claude mcp add --transport http --scope user snoze https://api.snoze.dev/mcp

# For everyone on this project — writes a shared .mcp.json you commit
claude mcp add --transport http --scope project snoze https://api.snoze.dev/mcp
```

## Claude (web and desktop)

In Claude, open **Settings → Connectors → Add custom connector** and paste
`https://api.snoze.dev/mcp`. Claude walks you through the sign-in.

## Codex

```bash
codex mcp add snoze --url https://api.snoze.dev/mcp
codex mcp login snoze
```

The second command opens your browser to sign in.

## Cursor

On the web version of this page, use the **Add to Cursor** button — Cursor
opens, installs the server, and shows a **Login** prompt that completes the
sign-in. Or add it by hand in **Cursor Settings → MCP** with the JSON below.

## VS Code

```bash
code --add-mcp '{"name":"snoze","type":"http","url":"https://api.snoze.dev/mcp"}'
```

VS Code prompts you to sign in the first time Copilot uses the server. The web
version of this page also has a one-click **Add to VS Code** button.

## Any other MCP client

Point the client at the server URL — every MCP client that supports remote
servers understands this shape:

```json
{
  "mcpServers": {
    "snoze": { "type": "http", "url": "https://api.snoze.dev/mcp" }
  }
}
```

> [!TIP]
> In more than one workspace? The bare URL connects to the workspace you chose
> when you signed in (or your oldest one) and tells the agent which one it
> landed in. To pin a specific workspace, add `?workspace=your-workspace-slug`
> to the server URL, e.g. `https://api.snoze.dev/mcp?workspace=acme`.

## Read-only access

Want an agent that searches and summarizes without changing anything? Use
`https://api.snoze.dev/mcp/readonly` instead. That connection offers only the
read tools, whatever your role allows, and takes the same `?workspace=` pin.
For a hard guarantee in scripts and CI, use an API key with only read scopes.

## Running headless? Use an API key

Scripts, CI jobs, and servers can't open a browser to sign in. For those,
create a workspace API key at **Settings → API keys** and send it as a bearer
token instead — no sign-in step:

```json
{
  "mcpServers": {
    "snoze": {
      "type": "http",
      "url": "https://api.snoze.dev/mcp",
      "headers": { "Authorization": "Bearer snoze_sk_YOUR_KEY" }
    }
  }
}
```

An API key is also the right choice when you want the agent to have _less_
access than you: a read-only key lets an assistant search and summarize with
no risk of it changing your data — see
[API keys and scopes](https://snoze.dev/help/api-keys-and-scopes/).

## What the agent can do

Once connected, the client discovers Snoze's tools automatically. They are
the same tools Snoze's own assistant uses, so an outside agent can do what
the assistant can:

- **Find and read** — search everything you can see, open pages, records,
  databases and files, and query records by condition
- **Build** — create databases with typed fields and views, add and update
  records, write pages in Markdown, and build dashboards, forms, automations
  and whiteboards
- **Organize** — move, rename, duplicate and delete items, comment, and
  work with your calendar and connected apps

You describe things in plain words — field names, options, people, dates —
and Snoze fills in the details and checks every change. When something can't
be done, the agent is told exactly why and what would work instead.

Workspace items are also available as MCP **resources**, so a client can
attach a page or database by mentioning it. The server's **prompts** are the
recipes Snoze's assistant follows — a CRM pipeline, a project tracker, a
weekly report and more — ready to run from your client.

## Safety

Signed in with your account, the server can never do more than your workspace
role allows; with an API key, never more than the key's scopes; on the
read-only address, the connection offers nothing but reads. The workspace comes from your
authenticated identity, never from anything the model says. Every change goes
through the same checks and history as changes you make in the app, and
deleting moves items to the trash. Your MCP client is where you approve each
tool call. Snoze marks deletions and anything that leaves Snoze for
confirmation, but your client decides whether to ask: one set to approve
everything won't. To make sure an agent can only look, use the read-only
address.

## Building your own integration?

The full protocol surface, tool reference, and API details live in the
[developer docs](https://developers.snoze.dev/docs/mcp).