Notion

Inserts new content directly after a specific block so the agent extends a page exactly where it matters, not at the bottom.

Adds any block type — heading, to-do, toggle, code, table — to a page so the agent builds out structured content the way a person would type it.

Reads every block nested under a given block so the agent can parse the full structure of a section before acting on it.

Moves a database row out of active view by archiving it, keeping databases clean without permanently losing the record.

Retrieves a single database's metadata and schema so the agent knows exactly which properties and field types it can work with.

Posts a comment on a page or block so the agent can leave context, ask questions, or acknowledge work right where the team is looking.

Pulls a batch of rows from a database in one call so the agent can roll up, compare, or report across many records at once.

Creates a new row in a database with fully populated properties, turning an inbound event into a tracked, queryable record.

Searches across your databases by name or keyword so the agent can locate the right table without you supplying an ID.

Creates a brand-new page anywhere in the workspace, fully titled and populated, so the agent spins up docs the moment they're needed.

Adds a new entry as a full page inside a database, so the record carries both structured properties and a rich body of content.

Appends rich formatted content to an existing page so the agent grows living documents over time instead of replacing them.

Brings a previously archived database row back into active status, reversing an archive cleanly when work resumes.

Modifies a database's title, description, or properties so the agent can evolve a table's structure as the team's needs change.

Updates the properties of an existing database entry so the agent keeps records accurate as their state moves forward.

Patches specific properties on a database row so the agent makes targeted updates without rewriting the whole record.

Archives a standalone page so outdated docs disappear from navigation while staying recoverable if anyone needs them again.

Changes a database's underlying property schema — adding, renaming, or retyping fields — so structures keep pace with the workflow.

Attaches a file directly to a database row so supporting documents live with the record they belong to.

Embeds a file into a page or specific block so documentation carries its evidence inline where readers expect it.

Fetches a database's full definition by ID so the agent has its exact title, properties, and configuration before operating on it.

Fetches a single page's properties and metadata by ID so the agent grounds its next step in the page's current real state.

Reads the ordered child blocks of a page or block so the agent can extract, summarise, or restructure existing content faithfully.

Reads all comments on a page so the agent surfaces open discussion threads, unanswered questions, and unresolved feedback.

Fires the moment a new page lands in a watched Notion database, and can be scoped to a single database so unrelated boards stay quiet.

Fires whenever someone posts a comment on a page or block in your workspace, delivering the comment text and author in real time.

Fires when any page inside a watched database is edited, so the agent reacts to status flips, owner changes, or field edits as they happen.

Fires the instant a new item is created in a connected data source, pushing the full record without waiting on a polling cycle.

Fires when the body content of a data source item changes, distinct from property edits, so the agent reacts only to substantive rewrites.

Fires when one or more properties on a data source item change, ideal for watching a specific status, owner, or date field.

Fires when the blocks inside a standalone page are edited, letting the agent respond to body changes on wikis, specs, and notes.

Fires when a page's properties change, perfect for tracking a single field like Status or Approver moving on a tracked document.