A markdown-first MCP server that gives AI agents comprehensive Notion CRUD and workflow capabilities across pages, databases, blocks, comments, file uploads, search, and conversion.
Pages: create, get (as markdown), update, move, archive/restore, duplicate pages and database rows; read individual properties.
Databases: create/get databases, query with filters/sorts/search, bulk create/update/delete pages, manage data sources, list templates.
Blocks: get blocks, list children, append markdown at chosen positions, update text blocks, and delete blocks.
Workspace & users: search pages/databases, get workspace info, list/get users, identify the current bot, and extract users from accessible pages.
Comments: list, get, and create page comments and replies.
Content conversion: convert between Markdown and Notion block JSON for preview/validation.
File uploads: create, send (base64), complete, retrieve, and list uploads, supporting both single and multi-part uploads.
Configuration & help: check credential state, trigger/reset setup, open the relay config form, clear caches, and fetch full documentation for any tool.
Transports and ergonomics: runs via stdio with a Notion token or remote HTTP with OAuth 2.1, with auto-pagination and bulk operations.
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.
ARCHIVED 2026-09-13 — This repository is no longer maintained. Use the official Notion API instead of this MCP server. Existing installations keep working but receive no updates or support.
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, help, and a relay-setup tool)
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 (OAuth 2.1, no token to paste)
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": {
"better-notion-mcp": {
"command": "npx",
"args": ["--yes", "@n24q02m/better-notion-mcp@latest"],
"env": { "NOTION_TOKEN": "ntn_your_token_here" }
}
}
}Or run the published Docker image (stdio):
docker run --rm -i -e NOTION_TOKEN=ntn_your_token_here n24q02m/better-notion-mcp:latestClient | Install |
Claude Code |
|
Codex CLI |
|
OpenCode |
|
Cursor / Windsurf / Gemini CLI / any MCP client |
|
Full per-client walkthroughs: mcp.n24q02m.com/servers/better-notion-mcp/setup/. See the Documentation section for per-client setup (Claude Code, Codex, Gemini CLI, Cursor, Windsurf) and HTTP/OAuth mode.
Installing the package exposes a better-notion-mcp binary (run it with npx or after a global install). It has no subcommands -- running 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.
# Start the stdio server (default transport; requires NOTION_TOKEN)
NOTION_TOKEN=ntn_your_token_here npx --yes @n24q02m/better-notion-mcp@latest
# Start the remote HTTP server (OAuth 2.1) instead of stdio
npx --yes @n24q02m/better-notion-mcp@latest --httpArgument / env | Effect |
(none) | stdio transport (default); requires |
| HTTP transport with OAuth 2.1 (equivalent to |
See Configuration for the full environment-variable reference.
Deployed with the HTTP transport, the server is a remote endpoint gated by OAuth 2.1 -- no integration token to paste. Point an MCP client that supports remote HTTP servers at the host you deployed it on:
// MCP client config -- remote HTTP (OAuth 2.1)
{
"mcpServers": {
"better-notion-mcp": {
"type": "http",
"url": "https://<your-host>/mcp"
}
}
}On first connect the client opens Notion's OAuth consent screen; per-user access tokens are held in-process only (see Trust Model). To stand up such an instance, see Self-Hosting (Remote Mode) and Deploy to Cloudflare.
The repo ships a smithery.yaml config for Smithery. Smithery launches the server over stdio (npx -y @n24q02m/better-notion-mcp) and requires no install-time config -- provide your Notion credentials at runtime through the server's own setup flow (NOTION_TOKEN env, or the relay form; 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-mcp -- Web search + content extraction
mnemo-mcp -- Persistent AI memory
imagine-mcp -- Image/video understanding + generation
better-email-mcp -- Email management
better-telegram-mcp -- Telegram
better-godot-mcp -- Godot Engine
better-code-review-graph -- Code review knowledge graph
All plugins share the same architecture -- install once, learn pattern transfers.
Full docs at mcp.n24q02m.com/servers/better-notion-mcp/:
Setup -- install methods for Claude Code, Codex, Gemini CLI, Cursor, Windsurf, mcp.json
Modes overview -- stdio (local, integration token) and HTTP (remote, OAuth 2.1)
Multi-user setup -- per-JWT-sub credential model (HTTP mode)
Install with AI agent -- paste this to your AI coding agent:
Install MCP server
better-notion-mcpfollowing 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 three infrastructure tools (config, config__open_relay, 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 |
| - | Open the relay configuration form in the browser and return the relay URL + credential state |
| - | 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) | - | Server's public URL for OAuth redirect links |
| Yes (http) | - | Notion Public Integration client ID (or |
| Yes (http) | - | Notion Public Integration client secret (or |
| No (http) | - | Set to |
| No |
| Server port; set explicitly (e.g. |
| No | - | Bind address (http mode) |
You can self-host the remote server with your own Notion OAuth app.
Prerequisites:
Create a Public Integration at https://www.notion.so/my-integrations
Set the redirect URI to https://your-domain.com/callback
Note your client_id and client_secret
docker run -p 8080:8080 \
-e TRANSPORT_MODE=http \
-e PORT=8080 \
-e PUBLIC_URL=https://your-domain.com \
-e NOTION_OAUTH_CLIENT_ID=your-client-id \
-e NOTION_OAUTH_CLIENT_SECRET=your-client-secret \
n24q02m/better-notion-mcp:latestRun your own multi-user better-notion-mcp serverless on Cloudflare (Worker + Container + KV).
Managed deployments go through CI, never by hand: the deploy-cf job in
.github/workflows/cd.yml runs after a release,
checks out the released tag, builds the immutable http-slim image at the
released version, pushes it to the Cloudflare managed registry, deploys, and
gates on a canary check — a managed instance can therefore only ever run an
exact release tag. Manual wrangler deploy against a managed/operated
instance is not permitted: it breaks the release-tag ↔ live-image
correspondence, and the next CD run would overwrite it.
The job is gated by the CF_HOSTED_ENABLED repository Actions variable —
currently false, so releases do not publish a hosted endpoint. To run your
own instance, use the self-host steps below.
Prerequisites: a Cloudflare account on the Workers Paid plan — required for Containers (the Cloudflare free tier does not include Containers) — and the wrangler CLI.
git clone https://github.com/n24q02m/better-notion-mcp && cd better-notion-mcp
wrangler login
Provision the KV namespace and paste its id into wrangler.jsonc:
wrangler kv namespace create better-notion-kvSet secrets:
wrangler secret put CREDENTIAL_SECRET
wrangler secret put NOTION_OAUTH_CLIENT_ID
wrangler secret put NOTION_OAUTH_CLIENT_SECRETCREDENTIAL_SECRET is REQUIRED: it derives a deterministic OAuth signing key so
user identity survives container recreation.
Push the http image to the CF managed registry and deploy:
wrangler containers push better-notion-mcp:beta
wrangler deployComplete the Notion OAuth flow in the browser at your Worker domain.
Per-user Notion access tokens are encrypted into KV (MCP_STORAGE_BACKEND=cf-kv),
so they survive scale-to-zero. Do NOT set MCP_AUTH_DISABLE on a shared/public
deployment — it collapses all users into a single token bucket.
How better-notion-mcp stacks up against direct competitors in each pillar:
Capability | better-notion-mcp | 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 + OAuth 2.1 transport | Yes (per-JWT-sub multi-user) | partial (HTTP + bearer token, no OAuth) | No (stdio token only) | No (stdio token only) |
Self-hostable | Yes (Docker, own OAuth app) | Yes | Yes | Yes |
License | Apache-2.0 | ? | MIT | MIT |
OAuth 2.1 + PKCE S256 -- Secure authorization with code challenge
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/better-notion-mcp.git
cd better-notion-mcp
bun install
bun run devThis plugin implements TC-NearZK (in-memory, ephemeral). See the trust model reference for full classification.
Mode | Storage | Encryption | Who can read your data? |
HTTP n24q02m-hosted (default) | In-memory | In-process only | Server process (cleared on restart) |
HTTP self-host | Same as hosted | Same | Only you (admin = user) |
stdio (local) |
| AES-GCM, machine-bound key | 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, token source, setup URL
setup_status: credential/setup state only (alias-equivalent to status for notion; kept for cross-server parity)
setup_start (-> force): trigger relay setup to configure Notion token via browser
setup_reset: clear credentials and config, 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?
The description says setup_reset 'clear credentials and config, return to awaiting_setup', yet destructiveHint is false. This is a direct contradiction: clearing credentials and config is a destructive operation. The description also implies browser/relay-based setup activity that sits uncomfortably with openWorldHint=false, further reducing trust in the annotation profile.
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 concise, front-loaded action list where every line adds relevant behavioral information. It avoids filler and packs no-op, alias, and effect details into very few 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?
The description covers all seven actions, including edge-case behavior such as aliases and no-ops, while the output schema likely covers return shape. Completeness is undermined by the contradiction between the described clearing/setup behavior and the annotations, so the contextual picture is not fully reliable.
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 schema already covers all parameters, and the description adds meaningful semantics for the action enum values, including side effects, aliases, and no-ops. It clarifies that setup_start connects to the force parameter and that set is effectively informational for Notion, going beyond the schema's minimal 'Action to perform' description.
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 opens with a specific function verb and resource domain: 'Manage server configuration and credential state.' It clearly enumerates the action dispatch behavior, though it does not differentiate itself from sibling tool config__open_relay, so it stops short of full sibling differentiation.
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 action list provides clear contextual guidance, such as 'setup_complete: re-check credentials after external config changes', 'cache_clear: no-op for notion', and 'set: notion has no mutable settings'. It gives clear context but does not explicitly state when to prefer this tool over alternative sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Open the relay configuration form for better-notion-mcp in the user browser. Returns the relay URL, whether the browser launched, and the current credential state.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate the tool is not read-only (readOnlyHint=false) and not destructive. The description adds transparency by explaining the side effect (opening a browser form) and listing return fields, providing sufficient behavioral context beyond 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 two concise sentences. The first states the primary action, the second lists return values. No unnecessary words or repetition.
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 no parameters and an output schema exists, the description completely covers what the tool does, its side effects, and its return values. No gaps are present.
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?
There are no parameters, so schema coverage is 100%. The description adds meaning by describing the tool's action and return values, which is appropriate for a parameterless tool.
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 action ('Open the relay configuration form'), identifies the resource ('for better-notion-mcp'), and specifies the return values. It distinguishes from sibling tools like 'config' by focusing on opening a form in the browser.
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 does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention exclusions or prerequisites. The context is implied but not fully explicit.
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.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 11 tools
Tools are organized around distinct resources (pages, databases, blocks, users, etc.), and descriptions cross-reference each other to guide selection. However, some overlap remains between pages content operations and blocks append/update, and between databases row operations and pages CRUD, which could still cause occasional misselection.
All tool names use lowercase snake_case, and most are plural resource nouns (pages, databases, blocks, users, comments). Minor deviations exist: content_convert is action-oriented, while help, config, and workspace are singular or uncountable, but the overall pattern is readable and predictable.
With 10-11 tools, the server groups many related actions under resource-level tools rather than exposing dozens of action-specific tools. This is well-scoped for a Notion API surface and each tool clearly earns its place.
The surface covers core Notion workflows: page CRUD, move/archive/restore/duplicate, database schema/query/bulk rows, block-level content CRUD, users, workspace search, comments, and file uploads. Content conversion and configuration/help round out the set, leaving no obvious dead ends for typical agent tasks.
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.
MCP server connecting AI agents to 100+ apps (Gmail, Slack, Notion, GitHub) via one-click OAuth.
