# Notion MCP MCP Server

> **Notion MCP MCP Server** is a hosted, multitenant Model Context Protocol (MCP) server run by **MewCP** (https://mewcp.com), giving AI agents managed access to Notion MCP.
>
> MewCP takes care of all MCP infrastructure for you — credential storage, OAuth flows,
> token refresh, and production-grade auto-scaling — so your AI agents can connect to
> third-party services and run freely without you managing any MCP server yourself.
>
> Server page:  https://mewcp.com/mcp/notion-mcp
> MewCP docs:   https://docs.mewcp.com
> Full catalog: https://mewcp.com/llms.txt

---

## About

Search a connected Notion workspace and read any page, database or saved view. Create and update pages, create databases, and query data sources with SQL or structured filters. Also covers comments and discussions, moving and duplicating pages, file uploads, workspace users and teamspaces, and Notion Skills and Agents.

---

## Details

- Server ID: `notion-mcp`
- Version: 1.2.0
- Tools: 43
- Authentication: OAuth, managed by MewCP
- Calls served: 7
- Transport: http

---

## Access

The gateway URL below serves your **entire MewCP toolset**, not this server on its
own. Pasting a config snippet is not enough — Notion MCP has to be in the toolset
first. In order:

1. Add Notion MCP to your toolset at https://mewcp.com/mcp/notion-mcp
2. Connect your Notion MCP account (OAuth); MewCP stores the credential and attaches it to each call
3. Copy your MewCP API key from the dashboard (Developer)
4. Configure your client with the snippet for it below

Once connected, an agent does **not** see this server's tools as top-level tools.
It sees four meta-tools and reaches everything through them:

- `search(query)` — find tools by keyword across the toolset
- `get_schema(tools)` — full description and arguments for the tools you picked
- `list_accounts(provider)` — only when one app has several connected accounts
- `call_tool(server_maskedId, tool_name, args)` — execute

So the list below is what `search` can return for this server, not a set of
callable tool names on their own.

---

## Tools (43)

Descriptions are truncated to 160 characters; call `get_schema`
for the full text and the argument schema. Where a tool is annotated, its type
is shown — treat `destructive` as irreversible.

- `notion-search` _(read)_ — Before the first content search for this connection, call fetch with {"id":"self"} unless its current access result is already in context. Choose the…
- `notion-ai-search` _(read)_ — Use this tool for every content search when fetch with {"id":"self"} reports current_tool_access.ai_search.status="available". This includes exact keywords,…
- `notion-fetch` _(read)_ — Retrieves details about a Notion entity (page, database, data source, or saved database view) by URL or ID. Provide URL or ID in `id` parameter. Make multiple…
- `notion-create-attachment` _(write)_ — Create an attachment and upload it to Notion. Provide exactly one source: - content for small UTF-8 text artifacts such as HTML, Markdown, plain text, CSV,…
- `notion-create-file-upload` _(write)_ — Create a short-lived URL for uploading one local file directly to Notion. After calling this tool, send exactly one multipart/form-data POST request to…
- `notion-download-attachment` _(read)_ — Download the contents of a small UTF-8 text attachment created by the Notion MCP `create-attachment` tool. Pass the `file_upload_id` returned by…
- `notion-create-pages` _(write)_ — ## Overview Creates one or more Notion pages, with the specified properties and content. ## Parent If the user explicitly names a private or shared…
- `notion-update-page` _(destructive)_ — ## Overview Update a Notion page's properties or content. ## Properties Notion page properties are a JSON map of property names to SQLite values. For pages in…
- `notion-convert-page-to-skill` _(write)_ — Mark an existing Notion page as a skill without changing its content. The page must be in the current workspace, and the authenticated user must have…
- `notion-download-skill` _(read)_ — Download a spec-compliant Notion Skill as a complete tar.gz archive containing SKILL.md and its supporting files and nested folders. Pass the skill page ID.…
- `notion-search-skills` _(read)_ — Find active Notion Skills the authenticated user can access. A Skill is a user-owned Notion page with task-scoped instructions that an assistant can write and…
- `notion-move-pages` _(write)_ — Move one or more Notion pages or databases to a new parent.
- `notion-duplicate-page` _(write)_ — Duplicate a Notion page. The page must be within the current workspace, and you must have permission to access it. The duplication completes asynchronously, so…
- `notion-create-database` _(write)_ — Creates a new Notion database using SQL DDL syntax, or a canonical typed database for tasks, projects, or skills. Provide exactly one of: - schema: a CREATE…
- `notion-create-folder` _(write)_ — Creates an empty Notion Folder. Set parent.page_id for a top-level Folder owned by a page, or parent.folder_id to create a nested Folder inside another Folder.…
- `notion-update-folder` _(destructive)_ — Update an existing Notion Folder with an explicit Folder operation. - Use add_files with file upload IDs returned by the upload tools. - Fetch the Folder…
- `notion-update-data-source` _(destructive)_ — Update a Notion data source's schema, title, or attributes using SQL DDL statements. Returns Markdown showing updated structure and schema. Accepts a data…
- `notion-create-comment` _(write)_ — Add a comment to a page or specific content. Starts a new discussion unless `discussion_id` is provided. Provide `page_id` to identify the page, then choose…
- `notion-get-comments` _(read)_ — Get comments and discussions from a Notion page. Returns discussions with full comment content in XML format. By default, returns page-level discussions only.…
- `notion-get-async-task` _(read)_ — Retrieves the current status of an async task that was started by another tool (for example, "create_pages" called with "allow_async": true). The status is one…
- `notion-get-teams` _(read)_ — Retrieves a list of teams (teamspaces) in the current workspace. Shows which teams exist, user membership status, IDs, names, and roles. Teams are returned…
- `notion-get-users` _(read)_ — Retrieves a list of users in the current workspace. Shows workspace members and guests with their IDs, names, emails (if available), and types (person or bot).…
- `notion-query-data-sources` _(read)_ — Query Notion data sources using faithful structured rows, SQL, or a view. This is the canonical replacement for the deprecated query_database_view tool. By…
- `notion-query-multiple-data-sources` _(read)_ — Query data across multiple Notion data sources using read-only SQLite SQL. Use this tool for JOINs, UNIONs, comparisons, and aggregations that need two or more…
- `notion-query-meeting-notes` _(read)_ — Query the current user's meeting notes data source. Applies a filter over meeting note properties. Title keyword searching is done via filter on property…
- `notion-list-private-pages` _(read)_ — List the current user's top-level pages and databases in their Private sidebar section. Use this to browse private workspace structure. For content searches,…
- `notion-list-shared-pages` _(read)_ — List pages and databases in the current user's Shared sidebar section. Use this to browse content shared directly with the user. For content searches,…
- `notion-list-favorite-pages` _(read)_ — List the current user's favorite pages and databases in sidebar order. Use this when the user refers to a favorite or pinned workspace item. Follow cursor…
- `notion-list-recent-pages` _(read)_ — List pages and databases the current user recently viewed, ranked by recency and visit frequency. Use this to recover likely navigation context when the user…
- `notion-search-agents` _(read)_ — Search agents by name or description, or browse the current user's favorite agents and the workspace's newest agents. Queries return one page. Without a query,…
- `notion-search-sessions` _(read)_ — Search past agent sessions by topic in a periodically refreshed index and return matching session URLs and excerpts. Recently created or updated sessions may…
- `notion-query-sessions` _(read)_ — List agent sessions available to the integration. Filter, sort, or search by title. A bounded page can be empty while has_more is true; follow next_cursor…
- `notion-spawn-session` _(destructive)_ — Start a session with a published Custom Agent. Use get_session_status or wait_session to check its progress.
- `notion-get-session-status` _(read)_ — Get the latest turn's status for a Custom Agent session without waiting.
- `notion-wait-session` _(read)_ — Wait for the latest turn in a Custom Agent session to stop running.
- `notion-stop-session` _(destructive)_ — Stop a running Custom Agent session you can access.
- `notion-send-message-to-session` _(destructive)_ — Send a follow-up message to a Custom Agent session you can access.
- `notion-list-session-events` _(read)_ — List short summaries of saved events in a Custom Agent session.
- `notion-read-session-event` _(read)_ — Read the full visible content of one saved Custom Agent session event.
- `notion-create-view` _(write)_ — Create a new view on a Notion database. Exactly one of "database_id" or "parent_page_id" must be provided: - "database_id": add a new view tab to an existing…
- `notion-update-view` _(write)_ — Update a view's name, filters, sorts, or display configuration. Use "fetch" to get view IDs from database responses. Only include fields you want to change.…
- `notion-show-advanced-analysis-next-steps` _(read)_ — Use this exactly once at the end of a turn when query_multiple_data_sources requires the full version of Notion MCP. Call with no arguments. Do not call this…
- `notion-check-mcp-next-steps` _(read)_ — When to call: Only when a Notion fetch result instructs you to. Finish all Notion tool calls needed for the current request, then call at most once with no…

---

## Connect

Gateway URL: https://gateway.mewcp.com/personal/mcp

Every request carries one header:

    Authorization: Bearer <API_KEY>

Replace `API_KEY` with your own key from the dashboard (Developer).

## Apps

### Claude Desktop

Mac & Windows app

- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
- Windows: `%APPDATA%\Claude\claude_desktop_config.json`

```json
{
  "mcpServers": {
    "mewcp": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote@latest",
        "https://gateway.mewcp.com/personal/mcp",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer API_KEY"
      }
    }
  }
}
```

Already have an "mcpServers" section in your config? Just add the server entry inside it.

1. Open Claude Desktop → Settings → Developer → "Edit Config"
2. Paste the snippet inside the outer { } of the config file (merge with your existing "mcpServers" section if you have one)
3. Save the file, then quit Claude Desktop completely and reopen it
4. Start a new conversation — your tool will be available

### VS Code

Copilot / Cline

- Command Palette → "MCP: Open User Configuration" (opens mcp.json). For one project only, use .vscode/mcp.json instead.

```json
{
  "mcp.servers": {
    "mewcp": {
      "type": "http",
      "url": "https://gateway.mewcp.com/personal/mcp",
      "headers": {
        "Authorization": "Bearer API_KEY"
      }
    }
  }
}
```

Already have a "servers" section in your mcp.json? Just add the server entry inside it.

1. Open VS Code → Command Palette (Cmd+Shift+P / Ctrl+Shift+P)
2. Run "MCP: Open User Configuration" to open your mcp.json
3. Paste the snippet and save
4. Start the server when prompted (or from the MCP servers view) and use it in Copilot Chat

### Cursor

AI-first editor

- macOS: `~/.cursor/mcp.json`
- Windows: `%USERPROFILE%\.cursor\mcp.json`

```json
{
  "mcpServers": {
    "mewcp": {
      "url": "https://gateway.mewcp.com/personal/mcp",
      "headers": {
        "Authorization": "Bearer API_KEY"
      }
    }
  }
}
```

Already have an "mcpServers" section in your mcp.json? Just add the server entry inside it.

1. Open Cursor → Settings → Cursor Settings → MCP
2. Click "Add new global MCP server"
3. Paste the snippet and save
4. Restart Cursor

### Codex

OpenAI's CLI agent

- Add the snippet to your Codex MCP config or your standard MCP config file for the CLI tool you use.

```json
{
  "mcpServers": {
    "mewcp": {
      "type": "http",
      "url": "https://gateway.mewcp.com/personal/mcp",
      "headers": {
        "Authorization": "Bearer API_KEY"
      }
    }
  }
}
```

Codex generally reads a standard MCP server block, so you can add this alongside your other configured servers.

1. Open your Codex MCP config or project-level config file
2. Paste the MewCP server block inside the config JSON/TOML structure your tool expects
3. Save the file and restart Codex
4. Verify the tool is available inside a fresh session

### Claude Code

Anthropic's CLI agent

- ~/.claude.json (user scope) or .mcp.json in your project root — create it if it doesn't exist. Or skip the file and use the CLI command below.

```json
{
  "mcpServers": {
    "mewcp": {
      "type": "http",
      "url": "https://gateway.mewcp.com/personal/mcp",
      "headers": {
        "Authorization": "Bearer API_KEY"
      }
    }
  }
}
```

Already have an "mcpServers" section in your config? Just add the server entry inside it.

1. Open ~/.claude.json (or .mcp.json in your project root) in a text editor
2. Paste the snippet inside the outer { } (merge with your existing "mcpServers" section if you have one)
3. Save the file and start (or restart) Claude Code
4. Or skip the file entirely and run the CLI command below instead

### OpenCode

Open-source terminal agent

- ~/.config/opencode/opencode.json (global) or opencode.json in your project root — create it if it doesn't exist.

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "mewcp": {
      "type": "remote",
      "url": "https://gateway.mewcp.com/personal/mcp",
      "enabled": true,
      "headers": {
        "Authorization": "Bearer API_KEY"
      }
    }
  }
}
```

Already have an "mcp" section in your opencode.json? Just add the server entry inside it.

1. Open ~/.config/opencode/opencode.json (or opencode.json in your project root) in a text editor
2. Paste the snippet inside the outer { } (merge with your existing "mcp" section if you have one)
3. Save the file and start (or restart) OpenCode

### OpenClaw

Self-hosted agent gateway

- ~/.openclaw/openclaw.json — create it if it doesn't exist.

```json
{
  "mcp": {
    "servers": {
      "mewcp": {
        "transport": "streamable-http",
        "url": "https://gateway.mewcp.com/personal/mcp",
        "enabled": true,
        "headers": {
          "Authorization": "Bearer API_KEY"
        }
      }
    }
  }
}
```

Already have an "mcp" section in your openclaw.json? Just add the server entry inside "servers".

1. Open ~/.openclaw/openclaw.json in a text editor
2. Paste the snippet inside the outer { } (merge with your existing "mcp" section if you have one)
3. Save the file and restart OpenClaw

### Antigravity

Google's agentic IDE

- ~/.gemini/config/mcp_config.json (global) or .agents/mcp_config.json (workspace-local) — create it if it doesn't exist.

```json
{
  "mcpServers": {
    "mewcp": {
      "serverUrl": "https://gateway.mewcp.com/personal/mcp",
      "headers": {
        "Authorization": "Bearer API_KEY"
      }
    }
  }
}
```

Already have an "mcpServers" section in your config? Just add the server entry inside it. Remote servers must use the "serverUrl" field — the legacy "url"/"httpUrl" fields aren't supported.

1. In the editor's agent side panel, click "…" → "MCP Servers" → "Manage MCP Servers" → "View raw config" (Antigravity CLI: type /mcp instead to open the Interactive MCP Manager)
2. Paste the snippet inside the outer { } (merge with your existing "mcpServers" section if you have one)
3. Save the file — the server connects automatically

### Hermes

Nous Research's CLI agent

- config.yaml in your Hermes config directory (~/.hermes) — add this under a top-level "mcp_servers:" key.

```yaml
mcp_servers:
  mewcp:
    url: "https://gateway.mewcp.com/personal/mcp"
    headers:
      Authorization: "Bearer API_KEY"
```

Already have an "mcp_servers" section in your config.yaml? Just add the server entry inside it.

1. Open config.yaml in your Hermes config directory
2. Paste the snippet under the top-level "mcp_servers:" key (merge with existing entries if you have any)
3. Save the file, then run /reload-mcp in Hermes (or start a fresh session)
4. Ask Hermes "Tell me which MCP-backed tools are available right now" to confirm it connected

### DeepSeek Harness

DeepSeek's agent harness

- cordis.yml in your DSH project — or the patch file you mount plugins from.

```yaml
- id: mcp-mewcp
  name: '@deepseek-ai/dsh-mcp-client'
  config:
    serverName: mewcp
    transport: streamable-http
    url: https://gateway.mewcp.com/personal/mcp
    headers:
      Authorization: "Bearer API_KEY"
```

One plugin instance = one MCP server. Add this entry to your plugin list; don't nest it inside another entry.

1. Open cordis.yml (or your patch file) in your DSH project
2. Paste the entry into your plugin list, keeping the leading dash and indentation
3. Restart DSH (or let HMR reload) — tools register as mcp__mewcp__<tool_name>
4. Verify with: dsh web --dump-config | grep -A3 mcp

## SDKs

### Python

fastmcp client

```python
import asyncio
from fastmcp import Client
from fastmcp.client.transports import StreamableHttpTransport

SERVER_URL = "https://gateway.mewcp.com/personal/mcp"
API_KEY = "API_KEY"

transport = StreamableHttpTransport(
    url=SERVER_URL,
    headers={
        "Authorization": f"Bearer {API_KEY}",
    }
)

async def main():
    client = Client(transport)
    async with client:
        tools = await client.list_tools()
        print(tools)

asyncio.run(main())
```

1. Install fastmcp: pip install fastmcp
2. Copy the snippet into your project
3. Replace API_KEY with your key from the dashboard
4. Run your script

### TypeScript

MCP SDK

```typescript
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const SERVER_URL = "https://gateway.mewcp.com/personal/mcp";
const API_KEY = "API_KEY";

const transport = new StreamableHTTPClientTransport(new URL(SERVER_URL), {
  requestInit: {
    headers: {
      Authorization: `Bearer ${API_KEY}`,
    },
  },
});

const client = new Client({ name: "mewcp-client", version: "1.0.0" });
await client.connect(transport);

const tools = await client.listTools();
console.log(tools.tools.map((t) => t.name));
```

1. Install: npm install @modelcontextprotocol/sdk
2. Copy the snippet into your project
3. Replace API_KEY with your key from the dashboard
4. Run with Node 18+ as an ES module (e.g. npx tsx script.ts)