Search pages and databases shared with the integration by title. Returns id, type, title, url, and last edited time. Use this to find ids before reading or editing. Only content shared with the integration is searchable.

Read a page: its properties as simple values, the database it belongs to (if any), and its content. format "outline" (default) lists every block with its id in ⟨…⟩, for surgical edits with notion_patch_block, notion_insert_blocks, notion_delete_blocks, notion_copy_blocks. format "markdown" returns the whole page as Notion-flavored markdown (colors, callouts, columns, tables, toggles, mentions), which notion_insert_blocks / notion_create_page accept back. last_edited_time can be passed to write tools as expected_last_edited_time to avoid overwriting someone else's edit.

Read the children of a page or block as an outline with block ids. Use for large pages to read one section at a time.

Find blocks on a page whose text matches a string or regex. Returns block id, type, text, and last_edited_time. Use this to locate exactly which block to edit instead of rewriting the page.

Read a database's properties: names, types, select/status options (with status groups), relation targets, and which are read-only. Read this before writing properties so values match exactly.

Query database rows. where takes equality ({"Status": "Done"}), operators ({"Due": {"before": "today"}}, {"Estimate": {">": 500}}, {"Task": {"contains": "x"}}, {"Owner": null}), lists ({"Status": {"in": ["Done", "Blocked"]}}), {"or": [...]}, relative dates ("today", "+7d", "-2w"), and "$created"/"$last_edited"; names and options are matched forgivingly and validated. filter takes raw Notion filter JSON; both are combined with AND. Returns rows with simple values and page ids. For counts or totals use notion_aggregate instead of reading every row.

Set properties on a database row using simple values: strings, numbers, booleans, arrays for multi-select/people/relations, ISO dates or {start,end}, null to clear. Property names and option values are matched forgivingly and validated against the schema before anything is written; all problems are reported together. Saves a snapshot so notion_undo can revert. Set dry_run to preview the before/after.

Create a page. If parent is a database, properties are validated against its schema (same rules as notion_update_properties) and title fills the title property; template applies one of the database's templates (see notion_list_templates). If parent is a page, a sub-page is created. Content can be markdown or structured blocks (same formats as notion_insert_blocks). icon is an emoji, image URL, or local image path; cover is an image URL or local path.

Update many rows at once, in one of two ways: set the same values on every row matching where/filter (same syntax as notion_query, including operators like {"Due": {"before": "today"}}), or give rows: [{page, set}] to set different values per row. Up to 500 rows. Defaults to dry_run=true, which returns the rows and their current values so you can confirm first. Values are validated before anything is written; every changed row is snapshotted, failures are reported per row, and the whole batch reverts with one notion_undo.

Move a page or database row to the Notion trash. Reversible with notion_undo or from Notion's trash.

Edit a single block in place by id without touching anything else on the page: replace its text (inline markdown, colors, mentions allowed), check/uncheck a to-do, set a code block's language or caption, change color, make a heading a toggle, change a callout's icon, or replace a table row's cells. Block type can't change (Notion API limit); to change type, insert a new block and delete the old one. Snapshots the old content for notion_undo.

Insert new content at an exact spot: at the start or end of a page/block, or directly after a specific block id. Existing content is never rewritten. markdown accepts headings (# to ####), lists and to-dos nested by indentation to any depth, quotes, code (mermaid for diagrams), $$ equations $$, pipe tables, > [!NOTE]/[!TIP]/[!WARNING] callouts, and Notion's markdown tags as returned by notion_get_page format=markdown (, , , , , , mentions, {color="…"}). Or give structured blocks (tables via rows, columns, tabs, images/files from a URL or local path, bookmarks, embeds, equations, synced blocks, link_to_page, table_of_contents, breadcrumb). Everything is validated and uploaded before the first write. Returns the new block ids.

Find and replace text across a page while keeping bold/italic/links/colors and mentions intact: every text block, table cell, and code caption, plus the page title (include_title). Supports regex with $1-style groups. Defaults to dry_run=true, which shows every change (before/after) so you can confirm. Matches that cross a mention or equation are skipped and reported. Sub-pages are separate documents and aren't searched. All changes revert together with notion_undo.

Move specific blocks (by id) to the trash. Nothing else on the page is touched. Reversible with notion_undo.

Change a page's title, icon, or cover, lock or unlock it, or move it under another page or into a database. Icons: an emoji, image URL, or local image path; covers: an image URL or local path; "none" removes either. For database row fields use notion_update_properties. Reversible with notion_undo (an icon or cover that was an uploaded file is uploaded again on undo).

Copy a page with its icon, cover, content (every block type the API can create, with formatting), and, when it stays in the same database, all writable properties. Sub-pages and databases on the page are copied in place; databases get their schema and (by default) their rows with content, with relations inside the copy pointing at the copied rows. Views, linked database views, and read-only blocks are listed as skipped, and the result's status is "partial" when anything was. Database rows keep their own content, sub-pages, and databases. Uploaded files and images are re-uploaded so the copy doesn't depend on expiring links. dry_run shows what would be copied. notion_undo trashes the copy.

Copy blocks (with everything nested inside them) to another spot: a page or block, at the start, end, or after a block. With move=true the originals are trashed afterward (the API has no move, so moved blocks get new ids and lose their comments). Sub-pages among the given blocks are moved with Notion's page move, or duplicated when copying; they land at the end of the destination page. A move is refused if it would lose something the API can't recreate (databases, read-only blocks, original synced blocks whose references would break). Copying an original synced block creates a reference to it. Moves default to dry_run=true. One notion_undo reverts everything.

List a database's page templates (name, id, which is the default). Use a name or id as notion_create_page's template.

Read, add, or reply to comments. action=list returns a page's or block's open comments with discussion ids (Notion's API doesn't return resolved threads). action=add starts a discussion on a page or block; action=reply answers a discussion by discussion_id. text is markdown (bold, links, mentions such as ). Added comments can be removed with notion_undo; an integration can only delete its own comments.

Create a database under a page with its full schema in one call: select/multi-select/status options (status options can name their group: To-do, In progress, Complete), number formats, formulas, relations (one- or two-way, to another database or "self"), rollups over those relations, unique IDs with a prefix, people, dates, files, places, and more. If no title property is given, one called "Name" is added. Add rows with notion_bulk_create or notion_create_page. notion_undo trashes the database.

Change a database's properties. action=add adds a property (same definition as notion_create_database). action=rename renames one. action=delete removes one: it defaults to a dry run showing how many rows have values, and snapshots up to 2000 rows' values so notion_undo can re-create the property and restore them. action=add_options adds select/multi-select/status options (status options take a group). action=set_number_format and action=set_description change those settings. Notion's API can't rename or recolor options (it ignores or rejects it); rename them in Notion, or add a new option, move rows with notion_bulk_update, and delete the old one in Notion.

Answer "how many / how much by X" without reading every row into context. Filters with where/filter (same as notion_query), groups by any property (multi-select, people, and relations count a row in each of its groups; dates can be bucketed by day/week/month/quarter/year), and computes metrics: count, count_values, count_empty, distinct, sum, avg, min, max, median, checked, percent_checked (e.g. ["count", "sum:Points"]). Returns totals and the top groups.

Create up to 1000 database rows from JSON objects (rows) or CSV (csv text or csv_path). Column/key names match properties forgivingly; values follow notion_update_properties rules (relations accept related rows' titles). Empty CSV cells are left unset. Every row is validated before anything is written, and all problems are reported by row. Defaults to dry_run=true. Rows that fail while writing are reported; the rest stay. One notion_undo trashes every created row.

List, read, create, update, or delete database views. Types: table, board, list, calendar, timeline, gallery, form, map, and chart (Notion's native, live charts: column, bar, line, donut, number, with stacking). A view can be a tab on the database (default), a linked view placed on any page (on: {page, after_block}), or a widget on a dashboard view (on: {dashboard}). Views take where/filter like notion_query, sorts, group_by (e.g. board by Status, dates by week), visible properties, and a chart spec like {type: "column", x: "Owner", y: "count"} or y: "sum:Estimate". Every change is reversible with notion_undo.

Render a chart image (PNG, or SVG) and put it on a page, or refresh an existing chart image in place. Types: bar, column, stacked_bar, stacked_column, grouped_column, line, area, stacked_area, pie, donut, scatter, and histogram (one row per observation; y is the value (x is ignored). bins sets the number of bins.); heatmap (x = column, series = row, y = the cell's value.); boxplot (one row per observation; x = group, y = value.); waterfall (rows in order; y = change. A row with series "total" shows the running total instead.); funnel (rows in stage order; y = how many reached the stage.); bullet (per x: a row with series "actual" (or none) and a row with series "target".); small_multiples (x and y as for a line chart; one small panel per series.); dual_axis (exactly two series: the first as columns (left axis), the second as a line (right axis).); treemap (x = item, y = size; optional series groups items (one color per group).); sankey (one row per flow: x = from, series = to, y = amount. Flows must only go forward (no loops).); network (one row per link: x = one end, series = the other, y = weight (line thickness).). Data is inline data ([{x, y, series?}]) or a source query that groups a database (x, y like "count" or "sum:Estimate", optional series). annotations add labeled reference lines; palette picks colors (default is a validated colorblind-safe order). data_table adds a toggle under the chart with a description and the numbers, for readers who can't see the image. For anything the types don't cover, pass a full Vega-Lite spec as vega_lite (data inline only; nothing is fetched). The recipe is remembered, so refresh_block_id re-renders it from current data. Prefer notion_views chart views when a live Notion chart is enough. Reversible with notion_undo.

Build a report page for a database in one call: a summary callout (row count, completion, overdue), KPI numbers side by side, charts (live Notion chart views where Notion supports the type, rendered images otherwise), a table of key rows (e.g. overdue items), and a Mermaid Gantt chart of dated work. Every section is optional; where scopes the whole report. Image charts can be refreshed later with notion_create_chart. notion_undo trashes the page.

Revert a change made through this server. With no id, reverts the most recent change that hasn't been undone. Use notion_history to find ids. Undo restores the snapshot taken at write time. Before writing, it checks whether anything it would restore was edited later (by a person or a later change here) and refuses, listing those objects, unless force is true. Edits made within the same minute as the original write can't be detected (Notion rounds edit times to the minute).

List changes made through this server, newest first, with their undo ids and how much of each undo can revert. Entries marked interrupted or failed stopped part-way; their input is included so the objects can be checked.

Manage and run automation rules (rules.json in the local state folder, or NOTION_PLUS_RULES). A rule has a when condition (same where/filter as notion_query, plus relative dates), a schedule ("weekdays 09:00", "daily 18:00", "hourly", cron), or both. Row actions apply to each matching row: {set: {...}}, {append: markdown}, {comment: text}, {trash: true}. then actions run once per firing: {refresh_chart: block_id}, {build_report: {...notion_build_report args}}, {create_page: {parent, title, …}}. Strings accept {{today}}, {{now}}, {{page.}}. A rule must stop matching a row after acting on it (write a value outside its condition, trash, or use marker). Actions: list, get, add, update (merge fields), validate (checks against the live schema and previews), dry_run (never writes), enable, disable, delete, run (writes; one undo_id per rule), history (recent runs, paged), waive (mark a rule's unfinished firing as handled), export / import (the rules file as JSON), deploy (the rules file plus steps to run it on a schedule in GitHub Actions). Each row's actions run in order with progress saved after each step: values that keep the row matching, then content and comments, then the marker or values that take it out of the condition, then trash. A failed row is retried next run from the step that failed, and a scheduled occurrence only counts as fired when all of it succeeded. run reports status succeeded, partial, or failed, and is an error unless every rule succeeded. list and get return the file's revision; pass it as expected_revision on edits so a change made elsewhere in the meantime isn't overwritten.

Check that the server is set up and working, and say how to fix what isn't: settings, the token, the integration's capabilities, whether any pages are shared with it, the local state folder (undo journal, chart recipes, automation state), upload folders, the chart renderer, automation rules, and unfinished automation runs. Changes nothing. Run it first when something doesn't work.

What this server can do with the current integration: the areas it covers, the Notion API version, limits that matter for planning (rows copied, blocks per copy, run limits), and which integration capabilities are available (probed with read-only calls; write capabilities show as unknown until a write).

Build pages from reusable templates instead of many block calls. Built-in templates: weekly-executive-report, content-brief, launch-plan, research-dossier; save your own. Actions: list, get (a template's full spec, a good starting point), validate (check a template, and with variables that it compiles), preview (the page outline, block count, charts, views, estimated requests, and, with compare_to, what differs from an existing page; writes nothing), render (create the page under parent, or append to append_to; charts are rendered and uploaded, live views placed; notion_undo removes it), save, delete, export (your saved templates), import. A template is {version: 1, name, description?, variables: {name: {type: string|number|boolean|date|list|object, required?, default?, description?}}, parts?: {name: [nodes]}, title, icon?, blocks: [nodes]}. Strings use {{variable}} (also {{item.field}} in loops, {{item_index}}, {{today}}, {{now}}); a string that is exactly one {{variable}} passes lists and objects through. Nodes: {markdown}, {heading, level?}, {callout, icon?, color?}, {toggle, children}, {columns: [[nodes], …]}, {divider: true}, {kpis: [{label, value} | {label, metric: {database, value: "count"|"sum:Prop", where?}}]}, {chart: {spec (as notion_create_chart), data | source, data_table?, format?}}, {view: {database, view (as notion_views)}} (top level only), {table: {header?, rows} | {query: {database, properties?, where?, limit?}}}, {gantt: {title?, tasks}}, {each: "list", as: "item", blocks}, {if: "var" | {var, equals|not|in|gt|lt|empty}, then, else?}, {part: name, with?}, {slot: name, default?} (filled by slots), {blocks: [raw block specs]}.

Multi-step workflows (version 2 of automations): a trigger (manual, schedule, or Notion webhook events) and typed steps run in order. Step actions: query, set, append, comment, create_page, move_page, duplicate_page, trash, replace_text, export_markdown, render_template, http, slack, foreach, switch, approval, delay, run_workflow. Each step has an id; may have if (a ${…} reference), retry {attempts, backoff_seconds}, timeout_seconds, and continue_on_error. Steps read earlier outputs with ${steps..} (query returns rows with id, url, title, and each property), the trigger with ${trigger.}, inputs with ${inputs.}, loop items with ${item} (or the foreach as name), and secrets with ${secret:NAME} (environment variable NOTION_PLUS_SECRET_NAME; never stored or shown). approval pauses until a checkbox is checked or a comment with a keyword is posted; delay pauses for minutes; both resume on the next scheduler pass. Runs are durable: a crash, failure, or pause resumes after the last finished step, and creating steps check what an interrupted attempt already made, so nothing is created twice. http and slack steps only reach hosts in NOTION_PLUS_HTTP_ALLOW (Slack's hook host is always allowed for slack). on_failure notifies Slack, an HTTP endpoint, or a page comment. Actions: list, get, save, delete, validate, run (now, with inputs), runs (history), run_status, resume (continue a waiting or failed run), cancel, convert (a v1 rule into a workflow, saved disabled), events / replay / discard (the webhook queue and its dead letters). Webhook events: page.created, page.content_updated, page.properties_updated, page.moved, page.deleted, page.undeleted, comment.created, data_source.content_updated, data_source.schema_updated.