Skip to main content
NOTION INTEGRATION

​
Every agent run becomes a structured Notion record.

Agents stop producing ephemeral chat and start building a permanent, browsable knowledge base: databases filled automatically, pages written with the right properties, and blocks appended to running docs your whole team can see.

Watch it happen

​
Agent updating a Notion database.

Three phases, zero manual steps: query the database, find the matching page, write the updated property. The stream below loops continuously.

agent · notion tool callsqueryingpage foundupdated
tool · notion:databasePages:getAll
step 1Query Projects database: filter: Status = “In review”, sort: Updated desc
step 13 rows returned. Top match: “Q3 Strategy Brief”: id: 3a7f…d2c9
tool · notion:databasePages:get
step 2Read page 3a7f…d2c9: simple: true: properties extracted
step 2Current Owner: unassigned · Due date: 2026-06-20 · Status: In review
tool · notion:databasePages:update
step 3Update page 3a7f…d2c9: set Owner: Maya, Status: Approved
step 3Properties written using display names, not Notion property IDs
step 3Page updated successfully
querypage foundupdatedloops every 9 s · real tool names · display-name properties
Query first, write second. Always call databasePages:getAll with a filter to find the target row before updating. Hardcoded page IDs break when databases are duplicated or moved.
Display names, not IDs. The databasePages:update tool keys properties by their visible column names. Case-sensitive. Run databases:get first to confirm the exact names.
Simplified output is on. simple: true flattens Notion’s nested property structure into a readable shape. Set simple: false only when you need raw API JSON for downstream processing.
15 tools

​
What Actionist can do with Notion.

One connection unlocks 15 tools spanning every major Notion surface. Select a group to see the exact tool names and what each one does.

notion:blocks:appendAppend child blocks to any existing page. Accepts a blocksJson array. Use this to grow a running document rather than creating new pages each run.
notion:blocks:getAllFetch the block tree of a page. Shallow by default. Set fetchNestedBlocks: true for deep document extraction (significantly more API calls on deeply nested pages).
notion:databases:getAllList all databases the integration can see. Default limit: 50. Returns titles and IDs. Use to discover databases before querying them by ID.
notion:databases:getFetch the full schema of a single database. All properties, their types, and options. Run this first to confirm exact column names before creating or updating rows.
notion:databases:searchSearch databases by name. Useful when the database ID is unknown. Search by a partial name, then pick the right result to retrieve the ID.
notion:databasePages:createCreate a new row with full property values. Pass propertiesJson keyed by display name (case-sensitive). The row appears immediately in the Notion database.
notion:databasePages:getAllQuery rows with filters and sorts. Pass filterJson and sortsJson as Notion API filter objects. Default limit: 50. Use filtering to narrow results rather than paging large databases.
notion:databasePages:getRead a single row by page ID. simple: true (default) flattens the property structure. Set simple: false for raw Notion API JSON with full rich text annotations.
notion:databasePages:updateUpdate one or more properties on an existing row. Properties are keyed by display name. Not internal Notion property IDs. Partial updates are supported; unspecified properties are unchanged.
notion:pages:createCreate a sub-page under a parent page. Pass parentPageId and a title. Optionally include content to populate the body immediately.
notion:pages:getRead the content and properties of a page by ID. Returns the page title, properties, and body blocks in simplified or raw format.
notion:pages:searchSearch pages by title. Default limit: 50. Returns matching pages across all shared workspaces the integration can access.
notion:pages:archiveSoft-delete a page by setting archived: true. Moves it to Notion’s Trash, not permanent deletion. Users can restore archived pages directly from Trash in Notion. Actionist does not expose an unarchive tool.
notion:users:getFetch a single user by Notion user ID. Returns name, email, and avatar URL. Use to resolve a user ID before assigning ownership or mentions.
notion:users:getAllList all workspace users the integration can see. Default limit: 50. Useful for building a name-to-ID lookup table when creating rows with person properties.
Setup

​
Connect Notion.

OAuth is the recommended path. It uses Notion’s standard authorization flow and stores your workspace token in Actionist’s encrypted credentials vault. An internal integration token is available as an alternative.

Before you start. You need a Notion account, and you pick which pages and databases to share during the authorization step. Anything you do not share stays invisible to your agents, so have the pages you want in mind before you begin.
1

Open Apps and find Notion

In the Actionist sidebar, open Apps. Search for “Notion” or scroll the grid and click the tile to open the detail panel.
2

Click Connect Notion

Under the Connection methods section, click Connect Notion. A browser window opens to the Notion OAuth authorization page.
3

Authorise the workspace

Select the workspace you want to connect and click Allow Access. Actionist stores the workspace token in your encrypted credentials vault. The detail panel updates to show Connected.
4

Share your databases and pages

OAuth succeeds even if nothing is shared yet, but all queries return empty until you grant access. In Notion: open each database or page you want the agent to reach, click Share → Invite, search for your Actionist integration bot, and grant Can edit (or the appropriate permission level).
NNotionConnected
WorkspaceAcme Corp
Connected onJun 10, 2026
Tools available15 tools
BlocksDatabasesPagesUsers
NNotionNot connected
Connection methods
OAuth (recommended)Authorize via Notion’s OAuth flow
Connect Notion
API tokenPaste an internal integration token
Add token
Share every target database or page with the integration immediately after connecting. The connection shows as healthy either way, but every tool call returns empty until the Notion-side share is in place.
Workflows

​
Common workflows.

Daily digest to Notion. A scheduled agent pulls yesterday’s unread Slack DMs and important channel mentions, summarises them, and writes a new row into a “Daily digests” database with a date property and the summary text. Every morning your team opens Notion instead of scrolling back through Slack.Agent run log. At the end of any workflow, write a database row recording what the agent did and what it produced. Every run becomes an auditable record the whole team can browse, no more ephemeral chat history.
In practice

​
Three automations people set up on day one.

Real workflows built from the tools above, each one running continuously without manual steps.

Maya · Marketing Manager
After every recorded team call, the agent reads the transcript, creates a dated notion:pages:create sub-page inside Meeting Notes, then uses notion:blocks:append to write a summary, attendee list, and numbered action items: all under the right team section. No copy-paste, no lost notes.
saves ~3 hrs/wk
Sam · Solo founder
Every Friday at 17:00, the agent calls notion:databasePages:getAll on the OKR database (filtering for the current quarter) pulls each key result’s latest value, and uses notion:databasePages:update to write a Weekly rollup property with a plain-English progress summary. One row per objective, updated before the weekend.
live in 10 min
Omar · Agency owner
A shared Client Status database is the single source of truth sent to 12 clients each week. The agent queries the project tracker, maps each open milestone to a client row, and calls notion:databasePages:update to set the Status, Next milestone, and Last updated properties. Keeping every client page current without a status-call to gather the numbers first.
saves ~5 hrs/wk
Limits

​
Limits and defaults.

50default result limit for all list and query tools
truesimplified output on by default, simple: false for raw JSON
shallowblock fetching depth by default. Enable fetchNestedBlocks for deep pages
Trasharchive is a soft-delete. Page moves to Trash, not permanent deletion
~3 rpsNotion public API rate limit per integration (from Notion docs, not verified in codebase)
2022-06-28Notion API version injected automatically on every call

Default result limit is 50

Every list and query tool (blocks:getAll, databases:getAll, databases:search, databasePages:getAll, pages:search, and users:getAll) defaults to a limit of 50 results. Use filterJson and sortsJson on databasePages:getAll to narrow results rather than paging large databases.
simple: true on database and page get tools flattens Notion’s nested property structure into a readable shape. Set simple: false only if you need raw Notion API JSON: for example, to preserve rich text annotations or relations for downstream processing.
fetchNestedBlocks defaults to false on blocks:getAll. Sub-pages inside a page are not recursively fetched. Enable it for deep document extraction, but expect significantly more API calls on pages with many levels of nesting.
notion:pages:archive sets archived: true on the page. It moves to Notion’s Trash, not permanent deletion. Users can restore archived pages directly from Trash in Notion. Actionist does not expose an unarchive tool; restoration must happen in Notion.
Notion’s public API rate limit is approximately 3 requests per second per integration (from Notion’s API documentation, not confirmed in the Actionist codebase). Design bulk operations accordingly and avoid sending large batches of sequential tool calls in tight loops.
Actionist injects the header Notion-Version: 2022-06-28 automatically on every API call. You do not need to set this manually.
Best practices

​
Tips before you go live.

share first OAuth connect succeeds even if no pages are shared. The connection appears healthy but all database queries return empty. Always share the target databases with the integration immediately after connecting.
strip the dashes The URL from a Notion database looks like notion.so/workspace/Title-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx. Strip all hyphens to get the 32-character UUID required for databaseId parameters.
use display names The databasePages:create and databasePages:update tools key properties by their visible column names (case-sensitive), not internal Notion property IDs. Run notion:databases:get first to see the exact names for a database.
avoid hardcoded IDs Store database IDs as workflow variables or memory entries so agents resolve them by name. Hardcoded IDs break silently when a database is duplicated or moved.
15 tools, one connection

​
Start writing to Notion today.

Connect Notion in the Apps panel. Share your databases with the integration. The agent does the rest, querying, writing, and updating without manual copy-paste.

Open the DashboardEmail the team

15 tools across blocks, databases, pages, and users.
OAuth or API token · Encrypted credentials vault · Simplified output by default.

Keep going

​
Related topics.

Apps

Browse the full app catalog and see every integration available in Actionist.

Credentials

Store and rotate Notion API tokens in the encrypted Credentials Vault without re-editing agents.

Memory

Use Notion databases as a persistent memory layer agents can query and write across runs.

Slack

Common pairing: pull a Slack digest and push a structured summary page into Notion automatically.