Notion

Add a column to a database: a name it does not have yet, a type, and that type's settings (options, a number's format, a formula's expression, a relation's target). Checked against the table as it is now before anything is sent; answers the column as Notion made it. Renaming and deleting columns are left to Notion's app.

A comment on a page, or a reply in one of its discussions, shown in Notion as the workspace's integration. Not resent after a lost answer (outcome_unknown): get_comments says whether it arrived.

Add options to a select, multi-select or status column (a status option in a group: To-do, In progress, Complete). The options already there are kept and sent back by id, and the column is read back after: an option that went missing fails the call. Names already there are skipped and listed under alreadyThere. For one new option while writing a row, create_page's allow_new_options is enough.

Markdown added to a page's body: at the end (default), at the start, or after a passage. Not resent after a lost answer: that is outcome_unknown, and read_page says whether it went through.

How many rows match where, and with by, how many hold each value of one column ("how many tasks per status"), most first; an empty value counts as "(empty)", and a multi-select row counts once per option. Reads the matching rows without sending them, up to Notion's 10,000 per query.

Create a database under a page, with a title column and the other columns given, each checked against the others before anything is made (and a relation's target found in the same workspace). Answers its id, URL and table. A database is not created twice: if the answer is lost it is outcome_unknown, and search says whether it exists.

A new row in a database, its properties checked against the columns first (an unknown column or option is refused with the ones that exist), a child page under a page, or with no parent a private page at the top of a workspace (a title and a body, no properties). The body is Notion's Markdown. A row can start from one of its database's templates (template): Notion applies it just after the page is made, so read_page a moment later shows what it filled in. Answers the new page's workspace, id and URL. A page is not created twice: if the answer is lost it is outcome_unknown, and search or query_database says whether it exists.

A database's columns: name, type, the options of a select, multi-select or status (with a status's groups), where a relation points, a formula's expression. Read it before writing where, sort or properties: every one of those names these columns. A database holding several tables (data sources) lists each.

Save the files Notion hosts for a page to this server's outbox: its files columns and the file blocks of its body (up to 50 MiB each). Answers each file's path, size and SHA-256, and where it was on the page. External links are listed, not fetched. A file that fails is listed with why, beside the others.

Find and replace in a page's body, in its Markdown as read_page shows it. The smallest change that does the job: the rest of the page, its comments and its history stay as they were. Not resent after a lost answer: that is outcome_unknown, and read_page says whether it went through.

The open comments on a page, oldest first, each with its discussion, author, time and text. Resolved ones are not listed by Notion.

Ask each workspace: is its integration token accepted, which workspace and integration it is, and whether it sees any page at all (a new integration sees nothing until pages are shared with it). One broken workspace never hides the others' answers. Run this before concluding the server is broken.

The Notion workspaces this server reaches, by label (one per token file), from the token files alone: no request to Notion. Every other tool finds an id's workspace by itself, so a label is needed only to narrow a search. Says nothing about whether a token works; that is health.

The page templates of a database or data source, with their page ids, names and default flags. Use this catalog to distinguish templates from ordinary rows; search can return both. Inspect their pages before editing recurring content. Follow nextCursor when hasMore is true.

The people (and bots) of every workspace, or of the one account names: each one's id, name, and email when the token may read it. A person column's where takes a name or an email directly, so this is for checking who is who, or for the id when two people share a name.

A database's saved views (table, board, calendar, ...): each one's id, name, type, the table it shows, and the filter and sorts saved in it, in Notion's query grammar with columns by name. Use it to find the view a person means ("my Open tasks"), then query_view to read its rows exactly as Notion shows them.

Under another page, or into a database as a row. Only within the page's own workspace: Notion cannot move a page between workspaces.

Rows of a database, filtered by where (checked against the columns first), sorted, with the columns asked for. Each row is its id, its title and its non-empty columns as plain values. A relation lists its first 25 pages here (truncated names it); read_page lists them all. nextCursor reads on; Notion stops one query at 10,000 rows (incomplete says so). Works on the Free plan, unlike the hosted connector's SQL query.

The rows a saved view shows, in its order, filtered and sorted exactly as Notion applies the view (quick filters and 'me' included), with total, the number of rows the view holds. Each row is its id, title and non-empty columns as query_database answers them. Notion keeps a view's result about 15 minutes: nextCursor reads on in that same result, and after that a new call without cursor starts again. A view takes no extra filter: for that, query_database with where.

The blocks directly inside a page or a block, in order, one level down: each one's id, type and plain text, and hasChildren when it holds more (read those by its id). An AI meeting-notes block answers its title, status, recording and calendar times, and the ids of the blocks that hold its summary, notes and transcript, each readable here in turn. A type the API does not support says its Notion name under unsupported. For a page's body as one text, read_page is cheaper.

One page by id or URL, in whichever workspace has it: its title, parent and properties as plain values (a select is its option's name, a relation its page ids, all of them), and its body as Notion's Markdown. Empty properties are left out. A body past Notion's limit (~20,000 blocks) comes back cut, with contentTruncated and the ids of the parts left out, each readable as a page. A database's id is refused: use describe_database.

A page's whole body, replaced by this Markdown. Properties are untouched. Child pages and databases in the body are kept unless allow_deleting. An empty body needs clear: true. Answers with the page's title and how many blocks its body held before and after; check both. Prefer edit_content for a change to part of a page.

Out of Notion's trash, back where it was. Notion's API cannot restore a page from the top level of a workspace (it answers a validation error); that one is restored from the Trash in Notion.

Pages and databases by title, in every workspace at once unless account names one. Notion matches words in titles, not in page bodies. Each hit says its workspace, kind, id and parent; a database hit also carries the dataSourceId of its table. Only what is shared with the workspace's integration can be found. A workspace that fails is listed under failed, beside the others' hits.

Into Notion's trash, with everything under it. Direct deletion of database templates is refused unless allow_template is explicit. Notion keeps trash 30 days; restore_page brings it back.

Change a page's properties (a row's columns, checked against the database's schema; a page's title as properties: {title: ...}) and its icon. Only the columns named change. Answers the page as read_page does, without the body. The body is changed with append_content, edit_content and replace_content.

Upload a file to Notion and attach it to a page: to one of a row's files columns, or as a block at the end of the page's body (an image, PDF, video or sound shows as such). The file goes by path, never as text you type. Answers with its size and SHA-256 as sent: compare them with the source. A column's own Notion-hosted files are kept unless the API cannot write them back, which is refused unless replace says so; nothing is uploaded before every check passes.