Mankomail

Notion ​

Reads and feeds your Notion pages and databases: entries, properties, Markdown content, comments and attachments.

The Notion node reads and feeds your Notion pages and databases: it queries and creates database entries, updates their properties, reads or writes page content as Markdown, appends blocks, comments, and moves files in both directions between a page and the run's attachments.

It works with a Notion integration token stored once in Connections. See Notion to create the connection. A Notion token sees nothing until a page or database is shared with it: in Notion, open the page or database, then the ··· menu, Connections, and add your integration.

To react to Notion without polling yourself, use the Notion entry changed trigger or the Notion — event trigger.

In Notion, a database is a container holding one or more data sources, and the data source carries the columns. The editor therefore asks for the Database (the one you see in Notion, or its URL), then the Data source; most databases have only one. Page identifiers can be typed as an id or pasted as a Notion URL.

At a glance ​

  • Type: notion.api · version 1
  • Category: Data
  • Kind: Step — one stage of a run
  • Effect: Writes outside (external_write) — writes outside Mankomail; described instead of performed during a test run
  • Needs a carrier email: No
  • Connection: Notion
  • Inputs: main
  • Outputs: main

Connection ​

This node needs a Notion connection.

Parameters ​

connection ​

Notion connection — The Notion connection to use. Create it once in Connections; its key never appears in the workflow.

  • Type: Connection (credential)
  • Required: Yes
  • Default: "" (empty)

resource ​

Resource

  • Type: One choice (options)
  • Required: Yes
  • Default: dataSource
  • Options:
    • dataSource — Database: Read, filter and feed the entries of a database.
    • page — Page: Create, read, update a page — and its content as Markdown.
    • block — Block: Append content at the bottom of a page, or read what it holds.
    • comment — Comment: Comment a page to notify someone, or read the thread back.
    • file — File: Upload an attachment (from the email or added by a step) and attach it to a page, or fetch a page’s files as attachments.
    • user — User: The workspace members, and the connection’s own account.
    • search — Search: Search by title across everything that is shared.

dataSourceOperation ​

Operation

  • Type: One choice (options)
  • Required: Yes
  • Default: query
  • Options:
    • query — Query entries: With a filter and a sort — the most used operation.
    • changes — Entries created or edited since…: The polling shape: put a “Schedule” trigger upstream and hand it the previous run time.
    • createEntry — Create an entry: One row of the database, with its typed properties.
    • getSchema — Read the schema: The source properties, their type and their options.
    • list — List databases: Everything shared with the connection.
  • Shown when: resource is dataSource

pageOperation ​

Operation

  • Type: One choice (options)
  • Required: Yes
  • Default: create
  • Options:
    • create — Create a page
    • get — Get a page: Its properties — not its content, which reads as Markdown.
    • update — Update the properties: Only the properties you fill in change.
    • archive — Move to trash / restore
    • getMarkdown — Read the content as Markdown: The whole page in one call, ready for an AI node.
    • updateMarkdown — Write content as Markdown
  • Shown when: resource is page

blockOperation ​

Operation

  • Type: One choice (options)
  • Required: Yes
  • Default: append
  • Options:
    • append — Append blocks
    • children — List blocks
  • Shown when: resource is block

commentOperation ​

Operation

  • Type: One choice (options)
  • Required: Yes
  • Default: create
  • Options:
    • create — Create a comment
    • list — List comments
  • Shown when: resource is comment

fileOperation ​

Operation

  • Type: One choice (options)
  • Required: Yes
  • Default: upload
  • Options:
    • upload — Upload the attachments: Those of the email and the files added by an earlier step, filtered as everywhere else.
    • download — Fetch a page’s files as attachments: Fetches the files into the run’s attachments: a “Compose an email” can then attach them by their position.
  • Shown when: resource is file

userOperation ​

Operation

  • Type: One choice (options)
  • Required: Yes
  • Default: list
  • Options:
    • list — List people
    • me — Read the connection account
  • Shown when: resource is user

parentType ​

Create the page…

  • Type: One choice (options)
  • Required: Yes
  • Default: dataSource
  • Options:
    • dataSource — Inside a database
    • page — Under a page
  • Shown when: resource is page and pageOperation is one of create

database ​

Database — The one you see in Notion. You can also paste its URL.

  • Type: Remote resource (resourceLocator)
  • Required: No
  • Ways to choose: pick from a list, type an ID, paste a URL (notion.database)
  • Listed with the connection in: connection
  • Shown when: (resource is dataSource and dataSourceOperation is one of query, changes, createEntry, getSchema) or (resource is page and pageOperation is create and parentType is dataSource)

dataSource ​

Data source — The schema belongs to the source, not to the database. Most databases only have one.

  • Type: Remote resource (resourceLocator)
  • Required: No
  • Ways to choose: pick from a list, type an ID (notion.dataSource)
  • Listed inside: database
  • Listed with the connection in: connection
  • Shown when: (resource is dataSource and dataSourceOperation is one of query, changes, createEntry, getSchema) or (resource is page and pageOperation is create and parentType is dataSource)

page ​

Page — The page id or URL. A database entry is a page: {{ data.notion.pageId }} works here.

  • Type: Remote resource (resourceLocator)
  • Required: No
  • Ways to choose: pick from a list, type an ID, paste a URL (notion.page)
  • Listed with the connection in: connection
  • Shown when: (resource is page and pageOperation is one of get, update, archive, getMarkdown, updateMarkdown) or (resource is page and pageOperation is create and parentType is page) or resource is block or resource is comment or resource is file

title ​

Title — The page title. In a database it fills the “title” column, whatever its name.

  • Type: Text (string)
  • Required: No
  • Default: "" (empty)
  • 2000 characters at most
  • Shown when: (resource is page and pageOperation is one of create) or (resource is dataSource and dataSourceOperation is one of createEntry)
  • Expressions: {{ }} accepted

properties ​

Properties — The property name, and its value. Conversion follows the type declared in Notion: an ISO date, a comma-separated list, “yes” for a checkbox. An empty value clears the property; computed columns are ignored.

  • Type: Key / value pairs (keyValue)
  • Required: No
  • Shown when: (resource is page and pageOperation is one of create, update) or (resource is dataSource and dataSourceOperation is one of createEntry)
  • Expressions: {{ }} accepted

markdown ​

Content (Markdown) — Notion turns Markdown into blocks itself: the safest way to write an email body, which almost always exceeds the 2,000 characters of a text fragment.

  • Type: Long text (text)
  • Required: No
  • Default: "" (empty)
  • 100000 characters at most
  • Shown when: (resource is page and pageOperation is one of create, updateMarkdown) or (resource is dataSource and dataSourceOperation is one of createEntry)
  • Expressions: {{ }} accepted

markdownMode ​

How to write

  • Type: One choice (options)
  • Required: No
  • Default: append
  • Options:
    • append — Append at the end: Nothing is erased — the default, and what a log wants.
    • replace — Replace the whole content: Destructive: the previous content is gone.
  • Shown when: resource is page and pageOperation is one of updateMarkdown

inTrash ​

Move to trash — Unchecked, the page is restored from the trash.

  • Type: Yes / no (boolean)
  • Required: No
  • Default: true
  • Shown when: resource is page and pageOperation is one of archive

filterProperty ​

Filter on property — Left empty, every entry is returned.

  • Type: Remote resource (resourceLocator)
  • Required: No
  • Ways to choose: pick from a list, type an ID (notion.property)
  • Listed inside: dataSource
  • Listed with the connection in: connection
  • Shown when: resource is dataSource and dataSourceOperation is one of query

filterCondition ​

Condition

  • Type: One choice (options)
  • Required: No
  • Default: equals
  • Options:
    • equals — equals
    • does_not_equal — does not equal
    • contains — contains
    • does_not_contain — does not contain
    • starts_with — starts with
    • is_empty — is empty
    • is_not_empty — is not empty
    • on_or_after — on or after (date)
    • on_or_before — on or before (date)
    • greater_than — greater than (number)
    • less_than — less than (number)
  • Shown when: resource is dataSource and dataSourceOperation is one of query

filterValue ​

Value

  • Type: Text (string)
  • Required: No
  • Default: "" (empty)
  • 2000 characters at most
  • Shown when: resource is dataSource and dataSourceOperation is one of query
  • Expressions: {{ }} accepted

filterJson ​

Advanced filter (JSON) — A full Notion filter (and / or, at most two nesting levels). When filled, it replaces the simple filter above.

  • Type: Long text (text)
  • Required: No
  • Default: "" (empty)
  • 8000 characters at most
  • Example: {"property":"Status","status":{"does_not_equal":"Closed"}}
  • Shown when: resource is dataSource and dataSourceOperation is one of query
  • Expressions: {{ }} accepted

sortProperty ​

Sort on property — Empty: Notion sorts by last edited time, most recent first.

  • Type: Remote resource (resourceLocator)
  • Required: No
  • Ways to choose: pick from a list, type an ID (notion.property)
  • Listed inside: dataSource
  • Listed with the connection in: connection
  • Shown when: resource is dataSource and dataSourceOperation is one of query

sortDirection ​

Sort direction

  • Type: One choice (options)
  • Required: No
  • Default: ascending
  • Options:
    • ascending — Ascending
    • descending — Descending
  • Shown when: resource is dataSource and dataSourceOperation is one of query

since ​

Since — An ISO 8601 instant (2026-09-22T07:00:00Z). Put a “Schedule” trigger upstream and pass {{ data.schedule.plannedFor }}: each run only brings what changed since the previous one.

  • Type: Text (string)
  • Required: Yes
  • Default: "" (empty)
  • 40 characters at most
  • Example: {{ data.schedule.plannedFor }}
  • Shown when: resource is dataSource and dataSourceOperation is one of changes
  • Expressions: {{ }} accepted

changeType ​

What counts as a change

  • Type: One choice (options)
  • Required: No
  • Default: any
  • Options:
    • any — Created or edited
    • created — New entries only
    • edited — Edited entries only
  • Shown when: resource is dataSource and dataSourceOperation is one of changes

blockText ​

Text — An empty line separates two blocks. Each block is split at 2,000 characters, Notion’s limit.

  • Type: Long text (text)
  • Required: No
  • Default: "" (empty)
  • 100000 characters at most
  • Shown when: resource is block and blockOperation is one of append
  • Expressions: {{ }} accepted

blockType ​

Block type

  • Type: One choice (options)
  • Required: No
  • Default: paragraph
  • Options:
    • paragraph — Paragraph
    • heading_1 — Heading 1
    • heading_2 — Heading 2
    • heading_3 — Heading 3
    • bulleted_list_item — Bulleted item
    • numbered_list_item — Numbered item
    • to_do — To-do
    • quote — Quote
    • callout — Callout
    • code — Code
  • Shown when: resource is block and blockOperation is one of append

blockPosition ​

Where to put them

  • Type: One choice (options)
  • Required: No
  • Default: end
  • Options:
    • end — At the end of the page
    • start — At the start of the page
  • Shown when: resource is block and blockOperation is one of append

commentText ​

Comment — Inline Markdown: bold, italics, links. No blocks — a comment is not a page.

  • Type: Long text (text)
  • Required: No
  • Default: "" (empty)
  • 10000 characters at most
  • Shown when: resource is comment and commentOperation is one of create
  • Expressions: {{ }} accepted

discussionId ​

Reply to the thread — An existing discussion id. Empty: the comment opens a new thread on the page.

  • Type: Text (string)
  • Required: No
  • Default: "" (empty)
  • 100 characters at most
  • Shown when: resource is comment and commentOperation is one of create
  • Expressions: {{ }} accepted

displayName ​

Sign the comment — The name shown next to the comment. Empty: the integration name.

  • Type: Text (string)
  • Required: No
  • Default: "" (empty)
  • 100 characters at most
  • Shown when: resource is comment and commentOperation is one of create
  • Expressions: {{ }} accepted

selection ​

Attachments to use

  • Type: One choice (options)
  • Required: Yes
  • Default: all
  • Options:
    • all — All attachments: Those of the triggering email, then the files added by earlier steps (a fetched deed, a signed PDF), in that order.
    • first — The first one only: The first attachment, when only one matters.
    • byMime — By file type: By MIME type: application/pdf, or a whole family with image/*.
    • byName — By file name: By name pattern: *.pdf, invoice-*.
  • Shown when: resource is file and fileOperation is one of upload

mime ​

File type — Exact MIME type (application/pdf) or a whole family (image/*). Left empty, no attachment is kept.

  • Type: Text (string)
  • Required: No
  • Default: "" (empty)
  • 200 characters at most
  • Example: application/pdf
  • Shown when: resource is file and fileOperation is one of upload
  • Expressions: {{ }} accepted

namePattern ​

File name — Simple pattern: * matches anything, ? one character (*.pdf, invoice-*). Case is ignored.

  • Type: Text (string)
  • Required: No
  • Default: "" (empty)
  • 200 characters at most
  • Example: *.pdf
  • Shown when: resource is file and fileOperation is one of upload
  • Expressions: {{ }} accepted

fileTarget ​

Location

  • Type: One choice (options)
  • Required: No
  • Default: block
  • Options:
    • block — The page content: Upload: one file block per attachment, at the bottom of the page. Fetch: the page’s file, PDF and image blocks.
    • property — A “Files” property: For a database entry with a files column.
  • Shown when: resource is file

filesProperty ​

Property name — The “Files & media” column of the database. On upload, files already there are replaced.

  • Type: Text (string)
  • Required: No
  • Default: "" (empty)
  • 200 characters at most
  • Example: Attachments
  • Shown when: resource is file and fileTarget is property
  • Expressions: {{ }} accepted

maxDownloadMb ​

Maximum size per file (MB)

  • Type: Number (number)
  • Required: No
  • Default: 10
  • Whole number, from 1 to 10
  • Shown when: resource is file and fileOperation is one of download

searchQuery ​

Search for — Search matches titles only. To search inside a database, prefer “Query entries”: the global index lags slightly behind.

  • Type: Text (string)
  • Required: No
  • Default: "" (empty)
  • 500 characters at most
  • Shown when: resource is search
  • Expressions: {{ }} accepted

searchObject ​

Look for

  • Type: One choice (options)
  • Required: No
  • Default: page
  • Options:
    • page — Pages
    • data_source — Databases
    • any — Both
  • Shown when: resource is search

limit ​

Maximum count — A database query cannot exceed 10000 results anyway: past that, split by date range.

  • Type: Number (number)
  • Required: No
  • Default: 50
  • Whole number, from 1 to 500
  • Shown when: (resource is dataSource and dataSourceOperation is one of query, changes, list) or (resource is block and blockOperation is one of children) or (resource is comment and commentOperation is one of list) or (resource is user and userOperation is list) or resource is search

Outputs ​

  • main — Taken once the Notion operation has succeeded. An error answer from Notion fails the step instead.

Data produced ​

What this node adds to the run data, and how to read it in an expression. <step> stands for the step key: the node name turned into an identifier (see Data and expressions).

  • {{ data.<step>.pageId }} — string. The id of the page concerned: the first entry or result found (Query entries, Entries created or edited since, Search), the page created, read or written. A database entry is a page, so this id fits every Page parameter. Empty in a test run for a creation.
  • {{ data.<step>.url }} — string. Create an entry, Create a page, Get a page, Update the properties: the Notion link of the page.
  • {{ data.<step>.page }} — { id, url, title, properties, createdTime, lastEditedTime, inTrash, dataSourceId }. Create an entry, Create a page, Get a page, Update the properties: the page. properties holds each property as a plain value (see entries).
  • {{ data.<step>.entries }} — array of { id, url, title, properties, createdTime, lastEditedTime, inTrash, dataSourceId }. Query entries and Entries created or edited since: the entries found. properties is keyed by property name, each value simplified: text for title, text, select and status; a number; true/false for a checkbox; comma-separated names for a multi-select; start..end or start for a date; comma-separated ids for people and relations; comma-separated URLs for files.
  • {{ data.<step>.found }} — boolean. Query entries, Entries created or edited since, Search: true when at least one item was found.
  • {{ data.<step>.count }} — number. The number of items returned or written: entries, databases, properties, blocks appended or listed, comments, people, results.
  • {{ data.<step>.truncated }} — boolean. On list operations: true when more items existed than Maximum count allowed. On Read the content as Markdown: true when Notion itself cut the page (very long pages).
  • {{ data.<step>.cursor }} — string. Entries created or edited since only: the last edit time of the last entry returned, or Since when nothing was found. Pass it as Since on the next run when the workflow keeps its own position.
  • {{ data.<step>.refusedProperties }} — array of string. Create an entry, Create a page in a database, Update the properties: the properties that were not written (unknown name, computed column, unreadable number, or title when the database has no title column).
  • {{ data.<step>.truncatedChars }} — number. Create an entry, Create a page, Update the properties: the number of characters cut from text values beyond Notion's limit (100 fragments of 2,000 characters per value). 0 in the normal case.
  • {{ data.<step>.created }} — boolean. Create an entry and Create a page: true when the page was created, false in a test run.
  • {{ data.<step>.parentPageId }} — string. Create a page under a page only: the id of the parent page.
  • {{ data.<step>.updatedProperties }} — array of string. Update the properties only: the names of the properties written.
  • {{ data.<step>.properties }} — object or array. Get a page: the page properties as plain values, keyed by name. Read the schema: an array of { name, type, writable }, one per property of the data source.
  • {{ data.<step>.dataSourceId }} — string. Read the schema only: the id of the data source read.
  • {{ data.<step>.databaseId }} — string. Read the schema only: the id of the database that holds the data source.
  • {{ data.<step>.title }} — string. Read the schema only: the title of the data source.
  • {{ data.<step>.databases }} — array of { dataSourceId, databaseId, title, url }. List databases only: the data sources shared with the connection, most recently edited first.
  • {{ data.<step>.inTrash }} — boolean. Move to trash / restore only: true when the page was moved to the trash, false when it was restored.
  • {{ data.<step>.markdown }} — string. Read the content as Markdown only: the whole page content as Markdown.
  • {{ data.<step>.unreadableBlocks }} — number. Read the content as Markdown only: the number of blocks Notion could not convert.
  • {{ data.<step>.length }} — number. Read the content as Markdown and Write content as Markdown: the number of characters read or written.
  • {{ data.<step>.mode }} — string. Write content as Markdown only: append or replace.
  • {{ data.<step>.appended }} — number. Append blocks only: the number of blocks sent.
  • {{ data.<step>.skippedBlocks }} — number. Append blocks only: the number of paragraphs left out beyond the 100 blocks of one call.
  • {{ data.<step>.blocks }} — array of { id, type, text, hasChildren }. List blocks only: the top-level blocks of the page, with their plain text.
  • {{ data.<step>.text }} — string. List blocks only: the text of the listed blocks, one per line.
  • {{ data.<step>.commentId }} — string. Create a comment only: the id of the comment, empty in a test run.
  • {{ data.<step>.discussionId }} — string. Create a comment only: the id of the discussion the comment belongs to.
  • {{ data.<step>.comments }} — array of { id, discussionId, createdTime, authorId, text }. List comments only: the comments of the page.
  • {{ data.<step>.files }} — array. Upload the attachments: the files selected, as { filename, size, origin, addedByNodeId? } (origin is email or added). Fetch a page's files: the files fetched, as { name, source, mime, size, attachmentPosition, deduplicated }, where source is property:<name> or block:<id>.
  • {{ data.<step>.uploaded }} — number. Upload the attachments only: the number of files actually uploaded to Notion (0 in a test run).
  • {{ data.<step>.attached }} — number. Upload the attachments only: the number of files attached to the page (0 in a test run).
  • {{ data.<step>.skipped }} — array. Upload the attachments: the names of the files over 20 MiB, left out. Fetch a page's files: the files beyond the tenth, as { name, url, source, reason }.
  • {{ data.<step>.target }} — string. File operations only: block (page content) or property (a Files property).
  • {{ data.<step>.positions }} — array of number. Fetch a page's files only: the positions of the fetched files in the run's attachments, ready for a Compose step.
  • {{ data.<step>.botId }} — string. Read the connection account only: the id of the integration's bot user.
  • {{ data.<step>.name }} — string. Read the connection account only: the name of the integration.
  • {{ data.<step>.workspace }} — string. Read the connection account only: the name of the workspace.
  • {{ data.<step>.maxFileBytes }} — number. Read the connection account only: the largest file the workspace accepts, in bytes (0 when Notion does not say).
  • {{ data.<step>.users }} — array of { id, name, email }. List people only: the people of the workspace (bots are left out).
  • {{ data.<step>.results }} — array of { id, object, title, url, lastEditedTime }. Search only: the pages or databases whose title matches, most recently edited first.
  • {{ data.<step>.simulated }} — boolean. true when a write was described rather than performed (test run). Reads, including the searches and queries Notion handles as POST requests, are never simulated.
  • {{ data.<step>.summary }} — string. A one-line summary in the member's language, for example 'Entry “Dupont — lease” created.' (with summaryKey and summaryParams).

Operations ​

The node first asks for a Resource (resource), then for the operation of that resource.

Database (resource: dataSource, operation in dataSourceOperation) ​

  • Query entries (query, the default). Reads the schema of the data source, then queries its entries (POST /v1/data_sources/{id}/query), up to Maximum count (limit, 1 to 500, default 50). Simple filter: Filter on property (filterProperty), Condition (filterCondition) and Value (filterValue); the filter family follows the property type. Advanced filter (JSON) (filterJson), when filled, replaces the simple filter. Sort on property (sortProperty) and Sort direction (sortDirection); without a sort property, the most recently edited entries come first. Publishes entries, count, found, pageId, truncated.
  • Entries created or edited since… (changes). Returns the entries whose last edit time (or creation time with New entries only) is after Since (since, an ISO 8601 instant), oldest first. What counts as a change (changeType): any, created or edited (edited leaves out entries never edited since their creation). Publishes entries, count, found, cursor, truncated.
  • Create an entry (createEntry). Reads the schema, converts Title (title) and Properties (properties) to the declared types, then creates the page in the data source (POST /v1/pages). Content (Markdown) (markdown) fills the page body. Publishes page, pageId, url, refusedProperties, truncatedChars, created.
  • Read the schema (getSchema). Reads the properties of the data source with their type. Publishes dataSourceId, databaseId, title, properties, count.
  • List databases (list). Lists the data sources shared with the connection (POST /v1/search). Publishes databases, count, truncated.

Page (resource: page, operation in pageOperation) ​

  • Create a page (create, the default). With Create the page… (parentType) set to Inside a database, it behaves exactly as Create an entry. Set to Under a page, it creates a sub-page of Page (page) with Title and Content (Markdown), and also publishes parentPageId.
  • Get a page (get). Reads the properties of Page, not its content. Publishes page, pageId, url, properties.
  • Update the properties (update). Reads the page and the schema of its data source, then writes the Properties given (PATCH /v1/pages/{id}); the others are left unchanged. Publishes page, pageId, url, updatedProperties, refusedProperties, truncatedChars.
  • Move to trash / restore (archive). With Move to trash (inTrash, on by default) the page goes to the trash; unchecked, it is restored. Publishes pageId, inTrash.
  • Read the content as Markdown (getMarkdown). Returns the whole page as Markdown in one call, ready for an AI node. Publishes pageId, markdown, truncated, unreadableBlocks, length.
  • Write content as Markdown (updateMarkdown). Writes Content (Markdown) with How to write (markdownMode): Append at the end (the default) or Replace the whole content. Replacing never deletes the sub-pages and databases the page contains. Publishes pageId, mode, length.

Block (resource: block, operation in blockOperation) ​

  • Append blocks (append, the default). Turns Text (blockText) into blocks of Block type (blockType), an empty line separating two blocks, and adds them At the end of the page or At the start of the page (blockPosition). At most 100 blocks per call. Publishes pageId, appended, skippedBlocks.
  • List blocks (children). Lists the top-level blocks of Page with their text. Publishes pageId, blocks, count, text, truncated.

Comment (resource: comment, operation in commentOperation) ​

  • Create a comment (create, the default). Posts Comment (commentText, inline Markdown) on Page, or in the existing discussion given in Reply to the thread (discussionId). Sign the comment (displayName) sets the name shown next to it. Publishes pageId, commentId, discussionId.
  • List comments (list). Lists the comments of Page. Publishes pageId, comments, count, truncated.

File (resource: file, operation in fileOperation) ​

  • Upload the attachments (upload, the default). Selects files of the run with Attachments to use (selection: all, the first one, by file type mime, by file name namePattern), uploads each one to Notion (POST /v1/file_uploads, then …/send), then attaches them according to Location (fileTarget): one file block per file at the bottom of the page (The page content), or in a “Files” property whose name is in Property name (filesProperty), where the files already there are replaced. Publishes pageId, files, uploaded, attached, skipped, target.
  • Fetch a page's files as attachments (download). Finds the files of the page, in its file, PDF, image, video and audio blocks (The page content) or in its Files properties (A “Files” property; all of them when Property name is empty), downloads up to 10 of them, each up to Maximum size per file (MB) (maxDownloadMb), and adds them to the run's attachments. Publishes pageId, target, files, positions, count, skipped.

User (resource: user, operation in userOperation) ​

  • List people (list, the default). Lists the people of the workspace. Publishes users, count, truncated.
  • Read the connection account (me). Reads the integration's own account. Publishes botId, name, workspace, maxFileBytes.

Searches Search for (searchQuery) in the titles of everything shared with the connection, among Look for (searchObject): pages, databases or both. Publishes results, count, found, pageId, truncated.

Every operation also publishes simulated and summary.

Example ​

Requests sent by clients must become entries of a "Requests" database. An Extract step named "Extract request" declares the fields client, case_ref and deadline (a date). The Notion node is named "Notion entry", so its data lives under notion_entry:

text
resource             dataSource
dataSourceOperation  createEntry
database             (URL mode) https://www.notion.so/acme/Requests-1a2b3c…
dataSource           (list mode) Requests
title                {{ data.extract_request.client }} — {{ email.subject }}
properties           Reference  → {{ data.extract_request.case_ref }}
                     Deadline   → {{ data.extract_request.deadline }}
                     Status     → New
                     Sender     → {{ email.from.email }}
markdown             {{ email.bodyText }}

Each value is converted according to the column type in Notion: Deadline is a date column and receives 2026-11-15, Status is a status column and receives the option named New, Sender is an email column. If a column name is misspelled, the entry is still created and the name appears in refusedProperties. The step data reads:

json
{
  "page": {
    "id": "2f1c9a4e-0b7d-4c55-9e3a-8d1f6b2a7c90",
    "url": "https://www.notion.so/Dupont-New-request-2f1c9a4e0b7d4c559e3a8d1f6b2a7c90",
    "title": "Dupont — New request",
    "properties": { "Reference": "2026-0412", "Deadline": "2026-11-15", "Status": "New", "Sender": "marie@example.com" },
    "createdTime": "2026-10-04T08:12:00.000Z",
    "lastEditedTime": "2026-10-04T08:12:00.000Z",
    "inTrash": false,
    "dataSourceId": "7e3d…"
  },
  "pageId": "2f1c9a4e-0b7d-4c55-9e3a-8d1f6b2a7c90",
  "url": "https://www.notion.so/Dupont-New-request-2f1c9a4e0b7d4c559e3a8d1f6b2a7c90",
  "refusedProperties": [],
  "truncatedChars": 0,
  "created": true,
  "simulated": false
}

A Compose step can send the link {{ data.notion_entry.url }} to the team, and a later Notion node can comment the entry with Page set to {{ data.notion_entry.pageId }}.

Tips ​

  • Share before you use. integration.not_found on an id that looks right almost always means the page or database is not shared with the connection. The error message says so; add the connection from the ··· menu of the page, under Connections. A Search or List databases that returns nothing has the same cause.
  • Property values. Values are converted according to the declared type: a date as ISO (2026-11-15, or 2026-11-15..2026-11-20 for a range), a number with a dot or a comma, a list as comma-separated names, yes, true, 1 or oui for a checkbox, user ids for people, page ids or URLs for relations, URLs for files. An empty value clears the property. Computed columns (formula, rollup, created time, unique id…) are never written and are listed in refusedProperties.
  • Long text. A text property holds at most 100 fragments of 2,000 characters; beyond that, the cut characters are counted in truncatedChars. For an email body, prefer Content (Markdown), which Notion turns into blocks itself.
  • Property names in expressions. Expressions only reach keys made of letters, digits, _ and $. A property named Due date cannot be read with {{ data.<step>.page.properties.Due date }}: name the properties you read without spaces or accents, or read the whole properties object.
  • Polling. Put a Schedule trigger before Entries created or edited since… and pass {{ data.schedule.plannedFor }} as Since: each run only brings what changed since the previous one. To keep your own position instead, store cursor in a table and pass it back.
  • Query limit. A database query cannot return more than 10,000 results in Notion, whatever Maximum count says; past that, split by date range. The global Search matches titles only and its index lags slightly behind: inside one database, prefer Query entries.
  • Upload size. Files over 10 MiB (the server's limit per uploaded file, below Notion's 20 MiB) are left out before anything is sent to Notion, and listed in skipped. If no attachment matches the selection, the step fails with node_nothing_to_do.
  • Download size. Maximum size per file (MB) goes from 1 to 10, the server's real limit per downloaded file; a larger file fails the step. Notion's file links are signed and expire after an hour, which is why the node stores the file in the run rather than returning its link.
  • Replays. Creating an entry or a page, appending blocks, commenting and uploading are not idempotent: if the engine replays the step after an incident, the page, blocks, comment or files can be created twice. Before creating, a Query entries on a business key followed by a Condition (If) on found avoids duplicates.
  • Test runs. In test runs, every read runs for real, including Query entries, Search and List databases. Creations, updates, trash moves, Markdown writes, block appends, comments and uploads are only described: nothing is written, simulated is true, and a created page has no id or link.
  • Trigger data. In a workflow started by a Notion trigger, the trigger's data lives under data.notion. Do not name this node "Notion" there: its data would only be reachable through the node id.
  • Errors. integration.unauthorized: the token was refused or revoked. integration.rejected: Notion refused the request (for example an invalid advanced filter or a value Notion does not accept for the property). integration.rate_limited and integration.unavailable are retried automatically: requests are paced to 180 per minute per connection, and a 409, 429 or 5xx answer gets up to four attempts before the engine retries the step later. node_invalid_param: a required value is empty, or the advanced filter is not valid JSON. See Error handling.