Better Notion MCP gives AI agents a markdown-first interface to Notion — pages, databases, blocks, users, workspace, comments, and file uploads via 8 composite tools (39 actions) plus config and help.
pages — create, get (markdown content, bounded reads with cursor), get_property, update (title/content/append_content/properties/icon/cover/archive), move, archive/restore, duplicate; simple property values auto-convert to Notion format
databases — create, get, query (filters, sorts, limit, smart search), bulk create_page/update_page/delete_page, create/update data sources, update database, list templates; accepts database_id or data_source_id
blocks — get a block, list children, append markdown (start / end / after a given block), update text blocks, delete blocks
users — list workspace users, get one user, get the current bot (me), extract users from accessible pages
workspace — workspace info (name, plan, bot user) and search across pages and databases shared with the integration
comments — list a page's comments, get a comment, create a comment or reply to a discussion
content_convert — round-trip Markdown ↔ Notion block JSON for preview/validation (headings, lists, to-dos, code, callouts, toggles, tables, columns, embeds, equations, inline formatting)
file_uploads — create, send (base64), complete, retrieve, list uploads; single or multi-part for files over 20 MB
config / help — inspect and manage credential/setup state; fetch full per-tool docs on demand to save tokens
Workflow conveniences — markdown in/out instead of raw JSON, auto-pagination, bulk operations, and dual transport (local stdio with NOTION_TOKEN, or remote HTTP with per-user or shared bearer-token auth)
Provides markdown-first tools for managing Notion workspaces, including page lifecycle operations (create, update, archive, duplicate), database management with bulk operations, block-level editing, user management, workspace search, and comment operations. Features composite actions that combine multiple operations, auto-pagination, and smart database queries.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Better Notion MCP create a new page in my 'Projects' database with title 'Q4 Planning' and markdown content for our quarterly goals"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
mcp-name: io.github.n24q02m/better-notion-mcp
Markdown-first Notion for AI agents -- pages, databases, blocks, and comments in one call.
Project | Tagline | Tag |
Peer AI agents chat in a shared folder — no human relay, no orchestrator, wor... | Tooling | |
Knowledge graph for token-efficient code reviews -- semantic search and call-... | MCP | |
2-way Google Drive sync with .driveignore filter — rclone engine, Windows tray | Tooling | |
IMAP/SMTP email for AI agents -- read, send, organize folders, and manage att... | MCP | |
Composite MCP server for Godot Engine -- 17 composite tools for AI-assisted g... | MCP | |
Markdown-first Notion for AI agents -- pages, databases, blocks, and comments... | MCP | |
Drop-in python-semantic-release fork with built-in release-safety guards (orp... | Tooling | |
Telegram for AI agents -- messages, chats, media, and contacts across both bo... | MCP | |
Google Workspace MCP server (Docs/Drive/Calendar/Gmail/Sheets/Slides/Tasks/Ch... | MCP | |
Claude Code plugin marketplace for the n24q02m MCP servers -- install web sea... | Marketplace | |
Image and video understanding + generation for AI agents -- across Gemini, Op... | MCP | |
Chrome Extension for bulk operations on Jules tasks via batchexecute API -- a... | Tooling | |
Shared foundation for building MCP servers -- Streamable HTTP transport, OAut... | MCP | |
Persistent AI memory with hybrid search and embedded sync. Open, free, unlimi... | MCP | |
Lightweight Qwen3 text embedding and reranking via ONNX Runtime and GGUF | Library | |
Secrets without the server. | CLI | |
A self-distilling neuro-symbolic cascade that amortises LLM cost across knowl... | Tooling | |
Shared web infrastructure package for search, scraping, HTTP security, and st... | Library | |
Open-source MCP server for AI agents: web search, content extraction, and lib... | MCP |
Related MCP server: WET - Web Extended Toolkit
Markdown in, Markdown out -- human-readable content instead of raw JSON blocks
8 composite tools, 39 actions -- one call instead of chaining 2+ atomic Notion endpoints (plus config and help)
Auto-pagination and bulk operations -- no manual cursor handling or looping
Tiered token optimization -- ~77% reduction via compressed descriptions + on-demand help tool
Dual transport -- local stdio (integration token) or remote HTTP (per-user or shared bearer token)
Run with npx (Node.js >= 24) and a Notion integration token from https://www.notion.so/my-integrations (starts with ntn_):
// MCP client config (e.g. .mcp.json / Claude Code / Cursor)
{
"mcpServers": {
"notion": {
"command": "npx",
"args": ["--yes", "@n24q02m/notion@latest"],
"env": { "NOTION_TOKEN": "ntn_your_token_here" }
}
}
}The package is @n24q02m/notion (formerly @n24q02m/better-notion-mcp;
old package receives one final release then freezes). The MCP Registry id stays
io.github.n24q02m/better-notion-mcp, and the legacy better-notion-mcp
command is kept as an alias of notion.
Or run the published Docker image (stdio):
docker run --rm -i -e NOTION_TOKEN=ntn_your_token_here n24q02m/notion:latestClient | Install |
Claude Code |
|
Codex CLI |
|
OpenCode |
|
Cursor / Windsurf / Gemini CLI / any MCP client |
|
Full per-client walkthroughs: docs.n24q02m.com/servers/notion/setup/. See the Documentation section for per-client setup (Claude Code, Codex, Gemini CLI, Cursor, Windsurf) and HTTP mode.
Installing the package exposes a notion binary (plus the legacy better-notion-mcp alias; run it with npx or after a global install). With no arguments it starts the MCP server and speaks the protocol over stdin/stdout, so it is normally launched by an MCP client rather than by hand. Subcommands: auth stores the Notion integration token; config, status, logout, doctor, and token come from the shared hull CLI.
# Start the stdio server (default transport; requires NOTION_TOKEN)
NOTION_TOKEN=ntn_your_token_here npx --yes @n24q02m/notion@latest
# Start the remote HTTP server (bearer token) instead of stdio
npx --yes @n24q02m/notion@latest --httpArgument / env | Effect |
(none) | stdio transport (default); requires |
| HTTP transport; auth chosen by |
See Configuration for the full environment-variable reference.
Deployed with the HTTP transport, the server is a remote endpoint gated by bearer-token auth -- no integration token in the server config. Point an MCP client that supports remote HTTP servers at the host you deployed it on:
// MCP client config -- remote HTTP (bearer token)
{
"mcpServers": {
"notion": {
"type": "http",
"url": "https://<your-host>/mcp",
"headers": { "Authorization": "Bearer <your-token>" }
}
}
}In multi mode (default) each user is listed in the users file (MCP_USERS_FILE, default ~/.hull/users.toml) and gets their own token and credential namespace. In token mode every client shares one token whose scrypt hash is set in MCP_AUTH_TOKEN_HASH. To stand up such an instance, see Self-Hosting (Remote Mode).
The repo ships a smithery.yaml config for Smithery. Smithery launches the server over stdio (npx -y @n24q02m/notion) and requires no install-time config -- provide your Notion credentials at runtime through NOTION_TOKEN or the config tool (see Configuration).
2026-05-02 -- Architecture stabilization update
Past months saw significant churn around credential handling and the daemon-bridge auto-spawn pattern. This caused multi-process races, browser tab spam, and inconsistent setup UX across plugins. The architecture is now stable: 2 clean modes (stdio + HTTP), no daemon-bridge layer, no auto-spawn from stdio.
Apologies for the instability period. If you encountered issues with prior versions, please update to the latest release and follow the current Setup guide -- most prior workarounds are no longer needed.
Related plugins from the same author:
wet -- Web search + content extraction
mnemo -- Persistent AI memory
imagine-mcp -- Image/video understanding + generation
email -- Email management
telegram -- Telegram
better-godot-mcp -- Godot Engine
crg -- Code review knowledge graph
All plugins share the same architecture -- install once, learn pattern transfers.
Full docs at docs.n24q02m.com/servers/notion/:
Setup -- install methods for Claude Code, Codex, Gemini CLI, Cursor, Windsurf, mcp.json
Install with AI agent -- paste this to your AI coding agent:
Install MCP server
notionfollowing the steps at https://raw.githubusercontent.com/n24q02m/claude-plugins/main/plugins/better-notion-mcp/setup-with-agent.md
Eight composite Notion tools (39 actions) plus two infrastructure tools (config, help):
Tool | Actions | Description |
|
| Create, read, update, and organize pages |
|
| Database CRUD and page management within databases |
|
| Read and manipulate block content |
|
| List and retrieve user information |
|
| Workspace metadata and cross-workspace search |
|
| Page comments and discussion replies |
|
| Convert between Markdown and Notion blocks (uses a |
|
| Upload files to Notion (single or multi-part) |
|
| Inspect and manage credential state and configuration lifecycle |
| - | Get full documentation for any composite tool ( |
URI | Description |
| Page operations reference |
| Database operations reference |
| Block operations reference |
| User operations reference |
| Workspace operations reference |
| Comment operations reference |
| Content conversion reference |
| File upload reference |
Variable | Required | Default | Description |
| Yes (stdio) | - | Notion integration token |
| No |
| Set either to |
| No (http) |
|
|
| No (http, multi) |
| Users file for |
| Yes (token mode) | - |
|
| No (token mode) | - | Optional per-minute request cap in token mode |
| No |
| Server port; set explicitly (e.g. |
| No |
| Bind address (http mode) |
Run the HTTP server on your own host and choose an auth mode with MCP_AUTH_MODE:
multi (default): list each user in MCP_USERS_FILE; each user's Notion token is stored in their own namespace (~/.better-notion/subs/<ns>/config.json).
token: one shared bearer token. Mint the hash with token hash and pass it as MCP_AUTH_TOKEN_HASH.
no-auth: no bearer check. Use only on a trusted local network.
docker run -p 8080:8080 \
-e TRANSPORT_MODE=http \
-e PORT=8080 \
-e MCP_AUTH_MODE=token \
-e MCP_AUTH_TOKEN_HASH='scrypt$...' \
n24q02m/notion:latestdocker-compose.http.yml builds the http image target and publishes it on the host loopback interface only (127.0.0.1:8081), so the server is never reachable from other machines directly:
export MCP_AUTH_MODE=token
export MCP_AUTH_TOKEN_HASH='scrypt$...'
docker compose -f docker-compose.http.yml upThe server listens on http://localhost:8081/mcp. To expose it, put your own TLS reverse proxy in front of the loopback port.
Release images are published multi-arch (amd64 + arm64) to Docker Hub (n24q02m/notion) and GHCR (ghcr.io/n24q02m/notion). There is no n24q02m-hosted HTTP endpoint.
How notion stacks up against direct competitors in each pillar:
Capability | notion | makenotion/notion-mcp-server | suekou/mcp-notion-server | awkoy/notion-mcp-server |
Markdown in / out | Yes (round-trip on pages + blocks) | No (raw Notion JSON) | partial (experimental, append + opt-in convert) | Yes (round-trip + GFM) |
Composite tool design | Yes (8 composite tools, 39 actions) | No (22 endpoint-mapped tools) | partial (simplified + raw JSON tools) | Yes (2 dispatch tools, 35+ ops) |
File uploads to Notion | Yes ( | No | No | Yes ( |
Comments | Yes ( | Yes | Yes | Yes |
Remote HTTP + bearer-token auth | Yes (per-user namespaces or shared token) | partial (HTTP + bearer token) | No (stdio token only) | No (stdio token only) |
Self-hostable | Yes (Docker, own bearer token) | Yes | Yes | Yes |
License | Apache-2.0 | ? | MIT | MIT |
Bearer token auth -- per-user tokens (multi) or one scrypt-hashed shared token (token)
Rate limiting -- 120 req/min/IP on HTTP transport
Session owner binding -- IP check + TTL for pending token binds
Null safety -- Handles Notion API quirks (comments.list 404, undefined rich_text)
git clone https://github.com/n24q02m/notion.git
cd notion
bun install
bun run devCredentials are never sent to n24q02m: there is no hosted endpoint.
Mode | Storage | Protection | Who can read your data? |
HTTP self-host ( |
| File mode 0600 under the server's data dir | The server operator and anyone with access to that host |
HTTP self-host ( |
| File mode 0600 under the server's data dir | The server operator and anyone with access to that host |
stdio (local) |
| File mode 0600; machine key in | Only your OS user |
Apache-2.0 -- See LICENSE.
Read and modify block-level content within pages.
Actions (required params -> optional):
get (block_id): retrieve single block
children (block_id): list child blocks
append (block_id, content -> position, after_block_id): add markdown content at position
update (block_id, content): replace text block content
delete (block_id): remove block
Use pages for page metadata/properties. Page IDs are valid block IDs. update only works on text blocks (paragraph, headings, lists, quote, to_do, code). Image/file blocks contain signed URLs (1h expiry). append supports position: "start" (prepend), "end" (default), "after_block" (requires after_block_id).
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform | |
| content | No | Markdown content (for append/update) | |
| block_id | Yes | Block ID | |
| position | No | Insert position for append: start (prepend), end (default), after_block (requires after_block_id) | |
| after_block_id | No | Block ID to insert after (when position is after_block) |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description details important behaviors: update restricted to specific block types, image/file blocks contain signed URLs with 1h expiry, append supports different positions. Annotations do not contradict (readOnlyHint false, destructiveHint false).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured: a one-line summary, a clear list of actions with required params, followed by additional notes. While slightly verbose, every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (5 params, multiple actions) and the presence of an output schema, the description covers essential behavioral traits and constraints. Minor gaps like not specifying return values are acceptable due to output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds context beyond the schema, e.g., explaining position options and that content is markdown, and clarifies required params per action.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Read and modify block-level content within pages' and lists all actions (get, children, append, update, delete), distinguishing this tool from sibling `pages` which handles page metadata/properties.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description tells when to use this tool vs `pages` and specifies that update only works on text blocks (paragraph, headings, etc.), but does not explicitly mention when not to use the other actions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Manage page comments.
Actions (required params -> optional):
list (page_id): all comments on a page
get (comment_id): single comment
create (content -> page_id for new discussion, discussion_id for reply)
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform | |
| content | No | Comment content (for create) | |
| page_id | No | Page ID | |
| comment_id | No | Comment ID (for get action) | |
| discussion_id | No | Discussion ID (for replies) |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnlyHint=false and destructiveHint=false, meaning the tool may mutate data but is not explicitly destructive. The description adds behavioral context by separating read actions (list, get) from a mutation (create) and explaining param relationships, but does not disclose potential side effects or limitations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, using line breaks and bullet-like formatting to present actions and their required/optional parameters without any extraneous text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of an output schema (not shown) and full parameter descriptions, the description provides sufficient context for the tool's actions and parameter dependencies. It does not elaborate on return values or edge cases, but these are covered by structured fields.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with all parameters described, but the description adds value by mapping parameters to specific actions (e.g., 'comment_id for get action', 'discussion_id for replies'), clarifying usage beyond the schema's individual descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Manage page comments' and enumerates three actions (list, get, create) with required/optional parameters, establishing a specific verb-resource relationship. While it doesn't explicitly differentiate from sibling tools like 'pages' or 'users', the tool name 'comments' makes the resource unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides basic action-based parameter guidelines (e.g., 'page_id for new discussion, discussion_id for reply') but lacks explicit when-to-use or when-not-to-use advice, such as when to choose list over get or when create is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Manage server configuration and credential state.
Actions:
status: current credential state and token source
setup_status: credential/setup state only (alias-equivalent to status for notion; kept for cross-server parity)
setup_start (-> force): show how to store a Notion token with notion auth
setup_reset: clear stored credentials, return to awaiting_setup
setup_complete: re-check credentials after external config changes
set: update a runtime setting (notion has no mutable settings; returns info)
cache_clear: clear any cached state (no-op for notion)
| Name | Required | Description | Default |
|---|---|---|---|
| key | No | Setting key (for set action) | |
| force | No | Force setup_start even if already configured | |
| value | No | Setting value (for set action) | |
| action | Yes | Action to perform |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations, the description discloses important behavioral quirks: setup_reset clears stored credentials and returns to awaiting_setup, set is a no-op for notion, and cache_clear is a no-op. These no-op disclosures are exactly the kind of context annotations can't convey. Minor tension exists between destructiveHint=false and a credential-clearing action, but that reads as re-auth state loss rather than data destruction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The lead sentence is front-loaded and the bulleted action list is scannable with zero filler. The parenthetical about cross-server parity is useful but slightly verbose, keeping it just short of a 5.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, return values needn't be explained, and all seven actions are accounted for including the no-op cases. An agent has enough to select the right action correctly; only explicit failure/permission behavior is unstated.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and the enum documents each action, so the baseline is 3. The description clarifies action semantics (aliases, force behavior) but adds little about key/value/force beyond what the schema already says.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource ('Manage server configuration and credential state') and then enumerates the seven actions, so an agent knows exactly what the tool covers. It does not explicitly contrast with siblings (pages, databases, users), but those are clearly different resources so there is no real confusion.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Each action line carries implicit when-to-use guidance: setup_complete is 're-check credentials after external config changes', setup_start 'show how to store a Notion token', set is for runtime settings. It lacks explicit when-not-to-use or alternative routing, which keeps it below a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Convert between markdown and Notion block JSON. Directions: markdown-to-blocks (input: markdown string), blocks-to-markdown (input: JSON array of Notion blocks or JSON string). Most tools (pages, blocks) handle markdown automatically -- use this only for preview/validation. Supported markdown: headings, lists, to-do, code blocks, blockquotes, dividers, callouts (> [!NOTE]), toggles (), tables, images, bookmarks, embeds, equations ($$), columns (:::columns), [toc], [breadcrumb]. Inline: bold, italic, code, strike, link.
| Name | Required | Description | Default |
|---|---|---|---|
| content | Yes | Content to convert (string or array/JSON string) | |
| direction | Yes | Conversion direction |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable behavioral context on supported markdown features and inline formatting, but doesn't contradict annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured, starting with the main purpose, then usage guidance, followed by supported features. It is informative without being overly verbose, though could be slightly more concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of an output schema and comprehensive annotations, the description covers all necessary context: what it does, when to use, supported formats. It is complete for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% coverage with descriptions for both parameters. The description adds detail on direction values and content type, plus lists supported markdown, going beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool converts between markdown and Notion block JSON, with specific verb+resource. It distinguishes from siblings by noting that most tools handle markdown automatically, reserving this for preview/validation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use (only for preview/validation) and when not to (most tools handle markdown automatically). Also names the two conversion directions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Database schema, query, and bulk row operations.
Actions (required params -> optional):
create (parent_id -> title, properties, is_inline, icon, cover)
get (database_id)
query (database_id -> filters, sorts, limit, search)
create_page (database_id, pages[{properties}])
update_page (database_id, page_id, page_properties)
delete_page (database_id, page_ids)
create_data_source / update_data_source / update_database / list_templates
Use pages instead for single page CRUD. Accepts both database_id (from URL) and data_source_id (from workspace search) -- auto-resolved.
| Name | Required | Description | Default |
|---|---|---|---|
| icon | No | Icon (for update_database): emoji (e.g. "(icon)"), external URL (https://...), or built-in shorthand (name:color, e.g. "document:gray") | |
| cover | No | Cover image (for update_database): URL or built-in shorthand (gradient_1..11, solid_red/yellow/blue/beige, nasa_*, met_*, rijksmuseum_*, woodcuts_*) | |
| limit | No | Max query results | |
| pages | No | Array of pages for bulk create/update | |
| sorts | No | Query sorts | |
| title | No | Title (for database or data source) | |
| action | Yes | Action to perform | |
| search | No | Smart search across text fields (for query) | |
| filters | No | Query filters (for query action) | |
| page_id | No | Single page ID (for update_page) | |
| page_ids | No | Multiple page IDs (for delete_page) | |
| is_inline | No | Display as inline (for create/update_database) | |
| parent_id | No | Parent page ID (for create/update_database) | |
| properties | No | Schema properties (for create/update data source) | |
| database_id | No | Database ID (from Notion URL) or data_source_id (from workspace search). Auto-resolved for query/create_page/list_templates. | |
| description | No | Description | |
| data_source_id | No | Data source ID (for update_data_source action) | |
| page_properties | No | Page properties to update (for update_page) |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are minimal (readOnlyHint false, destructiveHint false), so description carries burden. It lists actions including delete_page (destructive) but doesn't explicitly warn about side effects. Provides some behavioral info like auto-resolution, but lacks details on mutation consequences.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is reasonably concise given the 10 actions and 18 parameters. Bullet points and action grouping make it scannable. Each sentence adds information, though could trim some redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (many actions, 18 parameters, nested objects), the description covers alternatives, parameter dependencies, and ID handling. With output schema existing, return values are not needed. No gaps in essential info.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% coverage, but description adds value by grouping parameters per action (e.g., 'create (parent_id -> title, ...)') and explaining ID auto-resolution. This goes beyond the schema's flat parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool handles database schema, query, and bulk row operations, listing specific actions like create, get, query, and page CRUD. It distinguishes itself from sibling tool 'pages' by noting to use pages for single page CRUD.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly advises when to use an alternative tool ('Use pages instead for single page CRUD'). Also explains ID auto-resolution between database_id and data_source_id, providing clear context for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Upload files to Notion.
Actions (required params -> optional):
create (filename -> content_type, mode="single"|"multi_part", number_of_parts)
send (file_upload_id, file_content -> part_number): base64-encoded content
complete (file_upload_id)
retrieve (file_upload_id)
list (-> limit)
Max 20MB direct, multi-part for larger files.
| Name | Required | Description | Default |
|---|---|---|---|
| mode | No | Upload mode (default: single) | |
| limit | No | Max results for list | |
| action | Yes | Action to perform | |
| filename | No | Filename (for create) | |
| part_number | No | Part number (for send in multi_part mode) | |
| content_type | No | MIME type (for create, e.g. "image/png") | |
| file_content | No | Base64-encoded file content (for send). Must be valid base64: only A-Z, a-z, 0-9, +, /, = chars. Use Buffer.from(bytes).toString("base64") to encode. | |
| file_upload_id | No | File upload ID (from create step) | |
| number_of_parts | No | Number of parts (for multi_part mode) |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are minimal (all hints false), placing the burden on the description to disclose behavior. The description outlines the upload workflow and size limits, but does not detail aspects like permission requirements, idempotency, or what happens on failure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and structured with a header and bullet-like action list. It front-loads the core purpose and uses minimal text, though it could be slightly more organized.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (9 params, 1 required), the description covers all necessary aspects: the sequence of actions, required vs optional params, size limits, and encoding. An output schema exists, so return values need not be detailed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds value by grouping parameters per action (e.g., 'create (filename -> content_type, mode)') and noting that file_content must be base64-encoded and that multi-part requires number_of_parts.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Upload files to Notion' and lists specific actions (create, send, complete, retrieve, list), making the purpose unambiguous. Among sibling tools like 'blocks' or 'pages', none handle file uploads, so it is well-distinguished.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context by mapping actions to required and optional parameters, and mentions the size limit (20MB direct vs multi-part for larger files). However, it does not explicitly state when not to use the tool or provide alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get full documentation for a tool. Use when compressed descriptions are insufficient.
| Name | Required | Description | Default |
|---|---|---|---|
| tool_name | Yes | Tool to get documentation for |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds that it returns 'full documentation', which is consistent with annotations. No contradictions or additional behavioral details needed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that is front-loaded with the core purpose. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple help tool with one parameter, no output schema, and clear annotations, the description is complete. It covers what the tool does and when to use it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with a descriptive parameter name and enum list. The description does not add meaning beyond what the schema provides, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get full documentation for a tool.' The verb 'Get' and resource 'tool' are specific, and it distinguishes itself from sibling tools that are the actual tools being documented.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear usage condition: 'Use when compressed descriptions are insufficient.' This tells when to use the tool, though it could be more explicit about when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Page CRUD for individual pages and database rows.
Actions (required params -> optional):
create (parent_id -> title, content, properties, icon, cover)
get (page_id -> content_limit, content_cursor): returns markdown content; bounded reads return content_truncated and next_cursor
get_property (page_id, property_id)
update (page_id -> title, content, append_content, properties, icon, cover, archived)
move (page_id, parent_id)
archive (page_id) / restore (page_id)
duplicate (page_id -> parent_id)
Use databases instead for querying or bulk row operations. Property format: simple values auto-convert -- string for title/rich_text/select/status, number for number, boolean for checkbox, string[] for multi_select, ISO date "2025-01-15" for date. Example: properties: {"Name": "My Page", "Status": "In Progress", "Tags": ["urgent", "work"]}
| Name | Required | Description | Default |
|---|---|---|---|
| icon | No | Icon: emoji (e.g. "(icon)"), external URL (https://...), or built-in shorthand (name:color, e.g. "document:gray") | |
| cover | No | Cover image: URL or built-in shorthand (gradient_1..11, solid_red/yellow/blue/beige, nasa_*, met_*, rijksmuseum_*, woodcuts_*) | |
| title | No | Page title | |
| action | Yes | Action to perform | |
| content | No | Markdown content | |
| page_id | No | Page ID (required for most actions) | |
| archived | No | Archive status | |
| page_ids | No | Multiple page IDs for batch operations | |
| parent_id | No | Parent page or database ID | |
| properties | No | Page properties (for database pages). Use simple values -- auto-converted to Notion format. String: title/rich_text/select/status. Number: number. Boolean: checkbox. String[]: multi_select. ISO date string: date. Object with Notion structure: pass through as-is. | |
| property_id | No | Property ID (for get_property action) | |
| content_limit | No | Max page blocks to return for get; use next_cursor to continue | |
| append_content | No | Markdown to append | |
| content_cursor | No | Cursor from a previous bounded pages get |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover the safety profile (readOnlyHint false, destructiveHint false), so the description adds useful context about get returning markdown, bounded reads returning content_truncated/next_cursor, update supporting append_content, and archive/restore semantics. It does not mention auth requirements or rate limits, but for a CRUD tool the added behavioral detail is substantial.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the tool's purpose, then uses a compact action list with required-to-optional parameter mappings. The property-format example is concise and earns its place by preventing format errors.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so the description need not explain return values in full, and it still notes truncation/cursor behavior for bounded reads. The action list matches the enum exactly, and the alternative-tool guidance plus property format covers the key invocation details for a 14-parameter tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents each parameter. The description goes beyond the schema by mapping which parameters are required or optional per action, and by giving a concrete property auto-conversion example that clarifies expected value shapes.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb+resource: 'Page CRUD for individual pages and database rows,' and enumerates all supported actions. It distinguishes the tool from the sibling 'databases' tool by directing querying and bulk row operations there.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly names the alternative 'databases' for querying or bulk row operations, which gives clear routing guidance. However, it does not address other sibling tools like 'blocks' or 'comments' that an agent might consider for related content operations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get user information.
Actions (required params):
list: all workspace users (requires admin permissions)
get (user_id): single user info
me: current bot/integration user
from_workspace: extract users from accessible pages (use if list fails)
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to perform | |
| user_id | No | User ID (for get action) |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnly and idempotent. Description adds valuable behavioral context: list requires admin permissions, from_workspace extracts from accessible pages. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is concise with bullet-point style for actions, no superfluous text. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers all actions, prerequisites, and fallback strategy. Since output schema exists, return values need not be explained. Complete for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% coverage, but description adds meaning by explaining each action's purpose and required params beyond their enum labels (e.g., 'list: all workspace users').
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Get user information' and lists four distinct actions (list, get, me, from_workspace) with specific purposes, distinguishing it from sibling tools like blocks, comments, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly provides when to use each action (list requires admin, get needs user_id, me for current user, from_workspace as fallback if list fails), including permission requirements and alternative usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search workspace and get workspace info.
Actions (required params -> optional):
info: workspace name, plan, and bot user
search (-> query, filter.object="page"|"data_source", sort, limit): find pages/databases shared with integration
| Name | Required | Description | Default |
|---|---|---|---|
| sort | No | ||
| limit | No | Max results | |
| query | No | Search query | |
| action | Yes | Action to perform | |
| filter | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, which the description reinforces with read actions (info and search). The description adds that 'info' returns workspace name, plan, and bot user, and 'search' finds pages/databases shared with the integration. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, front-loaded with the main purpose, and structured as a bullet list. The content is efficient with no wasted words, though the format could be slightly cleaner.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has two actions and five parameters, the description adequately covers the main functionality and important parameters. The output schema likely provides return details. However, pagination for search results is not mentioned, which is a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description explains the 'action' parameter's values and associated optional parameters (query, filter, sort, limit) in context. It clarifies the filter.object enum values. With 60% schema coverage, the description adds significant meaning beyond the schema's enum descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool provides workspace info and search, with two specific actions 'info' and 'search'. The verb usage is specific. Sibling tools like blocks, comments, etc. are distinct domains, so no confusion.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. The description lists actions but does not explain the choice between 'info' and 'search' or when to use other tools. No prerequisites or exclusions mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v2.42.0config__open_relayv2.41.4pages2 fields changedInput schema / properties / content_cursorAdded value: +{
+ "description": "Cursor from a previous bounded pages get",
+ "type": "string"
+}Input schema / properties / content_limitAdded value: +{
+ "description": "Max page blocks to return for get; use next_cursor to continue",
+ "maximum": 100,
+ "minimum": 1,
+ "type": "number"
+}v2.39.0configv2.38.0configv2.37.0blocks1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "type": "object"
+}comments1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "type": "object"
+}config1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "type": "object"
+}config__open_relay1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "type": "object"
+}content_convert1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "type": "object"
+}databases1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "type": "object"
+}file_uploads1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "type": "object"
+}pages1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "type": "object"
+}users1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "type": "object"
+}workspace1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "additionalProperties": true,
+ "type": "object"
+}Scored across 10 tools
Tools are largely separated by Notion resource (pages, blocks, databases, comments, users, workspace), so most selections are clear. There is some overlap between pages.update/append_content and blocks.append, and between databases row operations and pages CRUD, though the descriptions provide guidance.
The dominant pattern is resource-noun tools with action subcommands, which is predictable and readable. Minor deviations include singular config/workspace, plural file_uploads/users/pages, and utility names like help and content_convert.
At 10 tools, the server is well-scoped for the Notion API surface. Each tool groups a meaningful resource area without forcing an excessive number of separate tools.
The surface covers the main Notion workflows: pages, blocks, databases, comments, users, workspace search, file uploads, and content conversion. Minor gaps or unclear areas remain around database-level archive/delete and block reordering/moving.
Hosted Notion MCP server for Claude, ChatGPT and Cursor, with each action switched per account.
MCP-native open-source Notion alternative: read & write pages, databases and kanban boards.
Markdown-based note-taking with a hosted MCP server. Your notes serve you and your AI.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
