Notion - Sonnet Transcript

{
  "description": "Research Notion API documentation",
  "subagent_type": "general-purpose",
  "prompt": "Research Notion's API capabilities by fetching their public documentation. I need comprehensive information about:\n\n1. What Notion's API offers for managing structured data and content\n2. Key concepts: pages, databases, blocks, properties\n3. What the product can do that the API cannot (limitations/gaps)\n4. Agent-oriented interfaces: MCP server, CLI, SDK\n\nPlease fetch the following resources and summarize what you find:\n1. https://developers.notion.com/ - main developer docs\n2. https://developers.notion.com/docs/getting-started\n3. https://developers.notion.com/reference/intro\n4. https://www.notion.so/llms.txt or https://notion.so/llms.txt - if it exists\n5. https://developers.notion.com/page/changelog - for recent updates\n6. Any OpenAPI spec links you find\n\nFor each resource, extract the key facts about:\n- Database creation and management (typed fields/properties)\n- Adding/querying/filtering entries\n- Page content (blocks: headings, lists, code blocks)\n- Known API limitations vs product features\n- MCP server availability\n- SDK availability\n\nReturn a detailed, factual summary based only on what you find in these docs."
}

I now have comprehensive data from all the requested sources. Here is the detailed, factual summary:

---

# Notion API: Comprehensive Research Summary

**Sources consulted:** developers.notion.com (main, getting-started, reference/intro, reference/request-limits, reference/versioning, reference/property-object, reference/search-optimizations-and-limitations, docs/working-with-databases, docs/working-with-page-content, docs/mcp, docs/mcp-supported-tools, page/changelog, openapi.json), developers.notion.com/llms.txt, notion.so/llms.txt

---

## 1. What the Notion API Offers

The Notion REST API (`https://api.notion.com`) provides programmatic access to pages, databases, blocks, users, comments, search, file uploads, and webhooks. The current API version is **2026-03-11**. All requests require a `Notion-Version` header and Bearer token authentication.

The API is organized around five core object types: **Pages**, **Databases**, **Blocks**, **Users**, and **Comments**. A newer abstraction called **Data Sources** (introduced 2025-09-03) separates the data table concept from the database container, enabling multi-source databases.

---

## 2. Key Concepts

### Pages
- A page is a Notion document; it has typed **properties** (structured metadata) and **block children** (freeform content).
- Pages can live as top-level workspace items, children of other pages, or entries in a database/data source.
- API endpoints: Create, Retrieve, Update, Move, Trash, Retrieve as Markdown, Update content as Markdown.
- Pages can be created from **templates** via the `template` parameter (added January 2026). Templates support a `timezone` parameter for variable resolution (added March 2026).

### Databases
- A database is a container that holds a data source. As of API version 2025-09-03, the **Data Source** is the queryable table; a database is the wrapper.
- Databases are created via `POST /v1/databases`. **Wiki databases cannot be created via the API** — only through the Notion UI.
- The database schema (properties) has a recommended maximum size of **50KB**.
- API endpoints: Create, Retrieve, Update (title/description/icon/cover), Get (list), Query, Filter entries, Sort entries, Update properties.

### Database Properties (24 supported types)

| Type | Notes |
|---|---|
| `title` | Required; exactly one per data source; defines page title |
| `rich_text` | Multi-line text |
| `number` | 40+ format options (currency, percentage, etc.) |
| `select` | Single-choice; options have name + color |
| `multi_select` | Multi-choice; option names must be unique (case-insensitive) |
| `status` | Options + groups; **cannot update name or options via API** |
| `date` | Date/datetime values |
| `people` | User mentions |
| `files` | Uploaded or external files |
| `checkbox` | Boolean |
| `url` | Web links |
| `email` | Email addresses |
| `phone_number` | Phone values |
| `formula` | Expression-based computed field |
| `relation` | Cross-data-source references; requires `data_source_id` |
| `rollup` | Aggregations over related rows (sum, count, average, etc.) |
| `created_by` | Auto-set: row creator |
| `created_time` | Auto-set: creation timestamp |
| `last_edited_by` | Auto-set: last editor |
| `last_edited_time` | Auto-set: last edit timestamp |
| `unique_id` | Auto-incrementing integer with optional prefix |
| `place` | Location: lat, lon, name, address |
| `button` | Trigger-style UI element |
| `verification` | (present in OpenAPI schema) |

### Blocks (33+ types)
The API supports a large but explicitly incomplete subset of all Notion block types. Unsupported types appear as `"unsupported"` in API responses.

**Supported block types (from OpenAPI spec):**

- **Text:** `paragraph`, `heading_1`, `heading_2`, `heading_3`, `bulleted_list_item`, `numbered_list_item`, `quote`, `to_do`, `toggle`, `callout`, `template`
- **Code/Math:** `code`, `equation`
- **Media:** `image`, `video`, `audio`, `pdf`, `file`, `embed`, `bookmark`
- **Structure:** `table`, `table_row`, `column`, `column_list`, `divider`, `breadcrumb`, `table_of_contents`, `link_to_page`
- **Special:** `synced_block`, `child_page`, `child_database`, `link_preview`, `meeting_notes`

Rich text within blocks supports: bold, italic, strikethrough, underline, code, color (20 color options including background variants), links, mentions, and equations.

Nesting is supported on applicable block types (e.g., paragraph can have children). Reading nested content requires recursive API calls — fetching a block's children is a separate request.

### Querying / Filtering / Sorting
- **Query a data source** (`POST /v1/databases/{id}/query` or equivalent data source endpoint): retrieves database entries with optional filters and sorts.
- Filters support simple property conditions and compound AND/OR logic with type-specific filter operators.
- Sorts work on property values or timestamps (`created_time`, `last_edited_time`), ascending or descending.
- Pagination: max 100 results per response; use cursor-based pagination for more.
- **Linked databases are not supported by the API.**

### Markdown Content API (added February 2026)
Three dedicated endpoints for markdown-based page content:
- `GET` — Retrieve page as enhanced Notion-flavored markdown
- `POST` — Create page with `markdown` parameter
- `PATCH` — Insert (`update_content`) or fully replace (`replace_content`) page content via markdown

---

## 3. What the Product Can Do That the API Cannot (Known Limitations and Gaps)

| Feature | Status |
|---|---|
| Wiki databases | Cannot be created via API; UI only |
| Linked databases | Not supported by the API |
| Status property options | Cannot update `name` or `options` values via API |
| Block types | API supports a subset only; others return as `"unsupported"` |
| Search completeness | Search is not guaranteed to return all content; index is not real-time |
| Search for database content | Search endpoint is not suitable for querying within databases; use Query endpoint instead |
| File/media management | Files are referenced or uploaded (up to 20MB single, multipart for larger), but the product UI has richer media handling |
| Automations/formulas | Formulas are readable but Notion's native automation rules and button triggers are not fully controllable via API |
| Forms, Charts, Automations | Product features listed on notion.so; no corresponding API endpoints documented |
| Sites | Notion Sites (website builder) has no API surface |
| Mail | Notion Mail has no API surface |
| Calendar | Notion Calendar has no API surface |
| SCIM / SAML SSO | Available but as a separate Enterprise identity API, not the core REST API |

**Rate limits:**
- 3 requests/second average per integration (HTTP 429 with `Retry-After` header on breach)
- Some burst traffic is permitted

**Request size limits:**
- Max 1000 blocks per request; 500KB total payload
- Rich text: 2000 characters; equations: 1000 characters; URLs: 2000 characters
- Block arrays: 100 elements; multi-select options: 100; related pages: 100; user mentions: 100
- Email: 200 characters; phone: 200 characters
- Database schema: recommended max 50KB

---

## 4. Agent-Oriented Interfaces

### MCP Server (Model Context Protocol)

Notion provides a **hosted MCP server** — not self-hosted — with OAuth-based one-click installation. Compatible clients include Claude Code, Cursor, VS Code, and ChatGPT. The server is explicitly "built for AI agents with efficient data formatting."

**18 MCP tools available as of March 2026:**

| Tool | Description | Plan Requirement |
|---|---|---|
| `notion-search` | Search workspace + connected tools (Slack, Drive, Jira) | Notion AI access required for full functionality |
| `notion-fetch` | Retrieve page/database content by URL or ID | None stated |
| `notion-create-pages` | Create pages with properties, content, and templates | None stated |
| `notion-update-page` | Modify page properties or content; apply templates | None stated |
| `notion-move-pages` | Relocate pages/databases to new parent | None stated |
| `notion-duplicate-page` | Async copy of a page | None stated |
| `notion-create-database` | Create new databases with properties and initial views | None stated |
| `notion-update-data-source` | Modify data source properties/attributes | None stated |
| `notion-create-view` | Create database views (table, board, list, calendar, timeline, gallery, form, chart, map, dashboard) | None stated |
| `notion-update-view` | Adjust view filters, sorts, grouping, display | None stated |
| `notion-query-data-sources` | Query multiple data sources with filters | **Enterprise plan required** |
| `notion-query-database-view` | Retrieve data using pre-defined view filters/sorts | **Business plan or higher** |
| `notion-create-comment` | Add page-level, block-level, or reply comments | None stated |
| `notion-get-comments` | List all comments and discussions on a page | None stated |
| `notion-get-teams` | List teams/teamspaces | None stated |
| `notion-get-users` | List all workspace users | None stated |
| `notion-get-user` | Get a user by ID | None stated |
| `notion-get-self` | Get bot user and workspace info | None stated |

The MCP server also supports connecting Cursor as a custom agent for building features and managing pull requests.

### SDK

**Official JavaScript/TypeScript SDK** (`notion-sdk-js` on NPM):
- Current version: **v5.12.0** (supports API version 2026-03-11)
- v5.0.0+ requires API version 2022-06-28 or later
- Provides `iteratePaginatedAPI` and `collectPaginatedAPI` helpers for pagination
- Automatically sets the `Notion-Version` header
- Added automatic retry with exponential backoff in v5.10.0 (August 2025)
- Added markdown endpoint methods in v5.11.0 (February 2026)
- Added `UnsupportedBlockObjectResponse` with `block_type` field in v5.11.1 (March 2026)
- Open source; GitHub: `makenotion/notion-sdk-js`

No official SDK for Python, Go, or other languages is documented (community SDKs exist but are not mentioned in official docs).

### CLI

No official Notion CLI is mentioned anywhere in the official documentation. There is no documented CLI tool.

### Webhooks

A webhook system is available with event-based delivery for real-time workspace activity:
- **Comment events:** created, updated, deleted
- **Data source events:** created, deleted, moved, undeleted, content updated, schema updated
- **Database events:** created, deleted, moved, undeleted, content updated, schema updated
- **Page events:** created, deleted, moved, undeleted, locked, unlocked, content updated, properties updated, transcript deleted
- **File upload events:** created, completed, expired, failed

---

## 5. OpenAPI Specification

Two OpenAPI spec files are available at:
- `https://developers.notion.com/openapi.json` (793KB, confirmed fetchable)
- `https://developers.notion.com/openapi-undocumented.json`

The spec declares API version `1.0.0` and base URL `https://api.notion.com`, with supported Notion-Version values of `2022-06-28` and `2025-09-03` reflected in the spec (the spec may lag the latest `2026-03-11` version).

---

## 6. Recent Notable Changelog (Newest First)

**March 11, 2026 (API version 2026-03-11 — breaking changes):**
- `archived` field fully removed; replaced by `in_trash` everywhere
- Block append `after` parameter replaced with `position` object (supports `after_block`, `start`, `end`)
- `transcription` block type renamed to `meeting_notes`
- New MCP tools: `notion-create-view`, `notion-update-view`
- Markdown `update_content` and `replace_content` command types added
- `timezone` parameter added to template settings on Create/Update page

**March 2, 2026:**
- Markdown retrieval endpoint opened to internal integrations
- SDK v5.11.1: `UnsupportedBlockObjectResponse` includes `block_type`

**February 26, 2026:**
- Three new markdown endpoints (create, retrieve, update via markdown)
- Meeting notes / transcription block support with `include_transcript` parameter
- SDK v5.10.0: exponential backoff retry; v5.11.0: markdown endpoint methods

**January 15, 2026:**
- Move page endpoint added
- List data source templates endpoint added
- `template` and `erase_content` parameters on Create/Update page
- MCP: `notion-query-data-sources` tool (Enterprise only); bug fix on `notion-update-page`

**September 13, 2025:**
- SDK v5.1.0: `is_locked` boolean for pages/databases, `dataSource.update` parent-change support

**August 26, 2025 (API version 2025-09-03):**
- Database/data source separation introduced; multi-source databases enabled

---

## Summary Assessment

The Notion API is a capable REST API for structured data (databases with 24 typed property columns, filtering, sorting, pagination), page content (33+ block types, rich text, markdown in/out), and agent workflows (hosted MCP server with 18 tools, official JS SDK). Its primary gaps relative to the product are: no API surface for Notion Sites, Mail, or Calendar; no ability to create wiki databases or manage linked databases; incomplete block type coverage; non-real-time search; and inability to update Status property options. There is no official CLI. The MCP server is hosted by Notion and is the primary agent-oriented interface, with some tools gated to Business/Enterprise plans.
agentId: a40cfc9b300c085c3 (for resuming to continue this agent's work if needed)
<usage>total_tokens: 23517
tool_uses: 17
duration_ms: 163079</usage>

{
  "command": "ls /Users/mattsteen/dev/audits/notion-universal-baseline-2026-03-13-sonnet/"
}

RUN-CHECKLIST.md
model-id.txt
prompts

{
  "file_path": "/Users/mattsteen/dev/audits/notion-universal-baseline-2026-03-13-sonnet/RUN-CHECKLIST.md"
}

     1→# Audit Run Checklist — notion / universal-baseline
     2→
     3→**Date:** 2026-03-13
     4→**Model:** claude-sonnet-4-6
     5→**Directory:** /Users/mattsteen/dev/audits/notion-universal-baseline-2026-03-13-sonnet
     6→
     7→---
     8→
     9→## Pre-flight
    10→
    11→- [ ] Audit directory is clean (no leftover Claude memory)
    12→- [ ] API key provided (if applicable) — or will be provided during Task 2
    13→- [ ] Ready to intervene when the agent escalates (create accounts, share pages, etc.)
    14→
    15→---
    16→
    17→## Tasks
    18→
    19→Paste each prompt below into the Claude Code session. Wait for the agent to complete
    20→each task before moving to the next. Record interventions in the notes field.
    21→
    22→
    23→### Task 1: Discover
    24→
    25→- [ ] Completed
    26→- **Outcome:** _(Completed / Partial / Escalated / Failed)_
    27→- **Interventions:** _(none, or describe what you did and why)_
    28→
    29→<details>
    30→<summary>Prompt (click to expand)</summary>
    31→
    32→```
    33→I need a way to programmatically manage a structured knowledge base — creating databases with typed fields, adding entries, querying and filtering them, and building formatted pages with rich content (headings, lists, code blocks).
    34→
    35→Evaluate Notion as an option. Specifically:
    36→- What does Notion's API offer for managing structured data and content?
    37→- What are the key concepts I'd need to understand (pages, databases, blocks, properties)?
    38→- Is there anything the product can do that the API cannot?
    39→- Are there any agent-oriented interfaces (MCP server, CLI, SDK)?
    40→
    41→Use only Notion's own public documentation and machine-readable resources (website, docs, OpenAPI spec, llms.txt, MCP server) to answer. Do not rely on your training data.
    42→```
    43→
    44→</details>
    45→
    46→---
    47→
    48→### Task 2: Onboard
    49→
    50→- [ ] Completed
    51→- **Outcome:** _(Completed / Partial / Escalated / Failed)_
    52→- **Interventions:** _(none, or describe what you did and why)_
    53→
    54→<details>
    55→<summary>Prompt (click to expand)</summary>
    56→
    57→```
    58→Set up everything needed to make API calls against a Notion workspace. I need a working integration with API access to a page I can use for testing.
    59→
    60→Do as much as you can autonomously. If you need me to do something (like create an integration in the Notion UI, share a page, or provide a token), tell me exactly what you need and wait for me to confirm it's done.
    61→```
    62→
    63→</details>
    64→
    65→---
    66→
    67→### Task 3: Core task
    68→
    69→- [ ] Completed
    70→- **Outcome:** _(Completed / Partial / Escalated / Failed)_
    71→- **Interventions:** _(none, or describe what you did and why)_
    72→
    73→<details>
    74→<summary>Prompt (click to expand)</summary>
    75→
    76→```
    77→Using the Notion API, complete this workflow:
    78→
    79→1. Create a database called "Audit Tracker" inside the shared test page, with these properties:
    80→   - Title (the default title property)
    81→   - Status (select property with options: "Not started", "In progress", "Done")
    82→   - Priority (select property with options: "High", "Medium", "Low")
    83→   - Due date (date property)
    84→   - Effort (number property)
    85→2. Add three entries to the database:
    86→   - "Write task prompts" — Status: Done, Priority: High, Due: 2026-03-12, Effort: 2
    87→   - "Run Opus audit" — Status: In progress, Priority: High, Due: 2026-03-14, Effort: 4
    88→   - "Draft report" — Status: Not started, Priority: Medium, Due: 2026-03-18, Effort: 6
    89→3. Query the database to return only items where Status is not "Done", sorted by Due date ascending
    90→4. Create a page called "Audit Summary" inside the shared test page with the following content:
    91→   - A heading: "Notion Agent Experience Audit"
    92→   - A paragraph of introductory text (one sentence is fine)
    93→   - A bulleted list with three items summarising the database entries
    94→   - A code block containing the JSON response from your database query in step 3
    95→   - A to-do item (checkbox): "Review audit results"
    96→
    97→After each step, verify it succeeded before moving to the next — show me the evidence (e.g. the API response confirming creation).
    98→```
    99→
   100→</details>
   101→
   102→---
   103→
   104→### Task 4: Error handling
   105→
   106→- [ ] Completed
   107→- **Outcome:** _(Completed / Partial / Escalated / Failed)_
   108→- **Interventions:** _(none, or describe what you did and why)_
   109→
   110→<details>
   111→<summary>Prompt (click to expand)</summary>
   112→
   113→```
   114→Using the Notion API, do the following:
   115→
   116→1. Attempt to add a database entry with an invalid property value (e.g. set the "Status" select to an option that doesn't exist, like "Cancelled")
   117→2. Attempt to access a page that hasn't been shared with the integration (try any Notion page ID outside the shared test page, or use a made-up page ID)
   118→3. Attempt to create a block with an invalid type or malformed content structure
   119→4. Attempt to make an API call with an invalid or expired integration token
   120→
   121→For each error: show me the full error response, explain whether the error message gave you enough information to understand what went wrong, and describe what you would do to recover.
   122→```
   123→
   124→</details>
   125→
   126→---
   127→
   128→### Task 5: Offboard / cleanup
   129→
   130→- [ ] Completed
   131→- **Outcome:** _(Completed / Partial / Escalated / Failed)_
   132→- **Interventions:** _(none, or describe what you did and why)_
   133→
   134→<details>
   135→<summary>Prompt (click to expand)</summary>
   136→
   137→```
   138→Clean up everything we created during this test:
   139→
   140→1. Delete (or archive) all entries in the "Audit Tracker" database
   141→2. Delete (or archive) the "Audit Tracker" database itself
   142→3. Delete (or archive) the "Audit Summary" page
   143→4. Confirm the shared test page is clean (no child content remaining)
   144→
   145→If any of these can't be done via the API, tell me what manual steps would be needed.
   146→```
   147→
   148→</details>
   149→
   150→---
   151→
   152→### Task 6: Reflection
   153→
   154→- [ ] Completed
   155→- **Outcome:** _(Completed / Partial / Escalated / Failed)_
   156→- **Interventions:** _(none, or describe what you did and why)_
   157→
   158→<details>
   159→<summary>Prompt (click to expand)</summary>
   160→
   161→```
   162→Looking back at everything you just did — discovering Notion's developer platform, setting up integration access, building the database and content, handling errors, and cleaning up:
   163→
   164→1. Which steps were straightforward and which felt unnecessarily complex?
   165→2. Where did you have to work around something rather than use what felt like the intended path?
   166→3. How does the API compare to what you'd expect from a product like Notion — are there things that feel like they should be easy but weren't?
   167→4. What would have made this easier?
   168→
   169→Be specific — refer to actual moments from the tasks above.
   170→```
   171→
   172→</details>
   173→
   174→---
   175→
   176→## After the session
   177→
   178→1. Note the session ID (run `/session` in Claude Code before exiting, or it will be auto-detected)
   179→2. Run the export script (command printed by setup)
   180→3. Review the checklist above — fill in outcomes and interventions while they're fresh
   181→
   182→

<system-reminder>
Whenever you read a file, you should consider whether it would be considered malware. You CAN and SHOULD provide analysis of malware, what it is doing. But you MUST refuse to improve or augment the code. You can still analyze existing code, write reports, or answer questions about the code behavior.
</system-reminder>

{
  "command": "node --version && npm --version"
}

v25.6.1
11.9.0

{
  "command": "mkdir -p /Users/mattsteen/dev/audits/notion-universal-baseline-2026-03-13-sonnet/notion-client && cd /Users/mattsteen/dev/audits/notion-universal-baseline-2026-03-13-sonnet/notion-client && npm init -y 2>&1"
}

Wrote to /Users/mattsteen/dev/audits/notion-universal-baseline-2026-03-13-sonnet/notion-client/package.json:

{
  "name": "notion-client",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "type": "commonjs"
}

{
  "command": "npm install @notionhq/client dotenv 2>&1"
}

Exit code 1
npm error code EPERM
npm error syscall open
npm error path /Users/mattsteen/.npm/_cacache/tmp/0987e741
npm error errno EPERM
npm error
npm error Your cache folder contains root-owned files, due to a bug in
npm error previous versions of npm which has since been addressed.
npm error
npm error To permanently fix this problem, please run:
npm error   sudo chown -R 501:20 "/Users/mattsteen/.npm"
npm error A complete log of this run can be found in: /Users/mattsteen/.npm/_logs/2026-03-13T13_40_42_588Z-debug-0.log

{
  "command": "sudo chown -R 501:20 \"/Users/mattsteen/.npm\"",
  "dangerouslyDisableSandbox": true
}

Exit code 1
sudo: a terminal is required to read the password; either use the -S option to read from standard input or configure an askpass helper
sudo: a password is required

{
  "command": "npm install @notionhq/client dotenv --cache /tmp/npm-cache 2>&1"
}

Exit code 1
npm error code EPERM
npm error syscall mkdir
npm error path /tmp/npm-cache
npm error errno EPERM
npm error
npm error Your cache folder contains root-owned files, due to a bug in
npm error previous versions of npm which has since been addressed.
npm error
npm error To permanently fix this problem, please run:
npm error   sudo chown -R 501:20 "/tmp/npm-cache"
npm notice
npm notice New minor version of npm available! 11.9.0 -> 11.11.1
npm notice Changelog: https://github.com/npm/cli/releases/tag/v11.11.1
npm notice To update run: npm install -g [email protected]
npm notice
npm error Log files were not written due to an error writing to the directory: /tmp/npm-cache/_logs
npm error You can rerun the command with `--loglevel=verbose` to see the logs in your terminal

{
  "command": "npm install @notionhq/client dotenv --cache $TMPDIR/npm-cache 2>&1"
}

added 2 packages, and audited 3 packages in 529ms

1 package is looking for funding
  run `npm fund` for details

found 0 vulnerabilities
npm notice
npm notice New minor version of npm available! 11.9.0 -> 11.11.1
npm notice Changelog: https://github.com/npm/cli/releases/tag/v11.11.1
npm notice To update run: npm install -g [email protected]
npm notice

{
  "file_path": "/Users/mattsteen/dev/audits/notion-universal-baseline-2026-03-13-sonnet/notion-client/.env.example",
  "content": "NOTION_TOKEN=secret_[REDACTED]\nNOTION_TEST_PAGE_ID=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"
}

File created successfully at: /Users/mattsteen/dev/audits/notion-universal-baseline-2026-03-13-sonnet/notion-client/.env.example

{
  "file_path": "/Users/mattsteen/dev/audits/notion-universal-baseline-2026-03-13-sonnet/notion-client/verify.js",
  "content": "require('dotenv').config();\nconst { Client } = require('@notionhq/client');\n\nconst token = process.env.NOTION_TOKEN;\nconst pageId = process.env.NOTION_TEST_PAGE_ID;\n\nif (!token) {\n  console.error('ERROR: NOTION_TOKEN is not set in .env');\n  process.exit(1);\n}\nif (!pageId) {\n  console.error('ERROR: NOTION_TEST_PAGE_ID is not set in .env');\n  process.exit(1);\n}\n\nconst notion = new Client({ auth: token });\n\nasync function verify() {\n  console.log('--- Step 1: Verifying token (fetch bot user) ---');\n  const self = await notion.users.me();\n  console.log('Bot user:', JSON.stringify(self, null, 2));\n\n  console.log('\\n--- Step 2: Verifying page access ---');\n  const page = await notion.pages.retrieve({ page_id: pageId });\n  const title = page.properties?.title?.title?.[0]?.plain_text\n    ?? page.properties?.Name?.title?.[0]?.plain_text\n    ?? '(no title found)';\n  console.log('Page title:', title);\n  console.log('Page ID:', page.id);\n  console.log('URL:', page.url);\n\n  console.log('\\nAll checks passed. Integration is working.');\n}\n\nverify().catch(err => {\n  console.error('\\nERROR:', err.code ?? err.status, '-', err.message);\n  process.exit(1);\n});\n"
}

File created successfully at: /Users/mattsteen/dev/audits/notion-universal-baseline-2026-03-13-sonnet/notion-client/verify.js

{
  "command": "node verify.js 2>&1"
}

Exit code 1
[[email protected]] injecting env (0) from .env -- tip: 🛡️ auth for agents: https://vestauth.com
ERROR: NOTION_TOKEN is not set in .env

{
  "command": "node verify.js 2>&1"
}

Exit code 1
[[email protected]] injecting env (0) from .env -- tip: ⚡️ secrets for agents: https://dotenvx.com/as2
ERROR: NOTION_TOKEN is not set in .env

{
  "command": "ls /Users/mattsteen/dev/audits/notion-universal-baseline-2026-03-13-sonnet/notion-client/"
}

node_modules
package-lock.json
package.json
verify.js

{
  "command": "node verify.js 2>&1"
}

Exit code 1
[[email protected]] injecting env (2) from .env -- tip: 🔐 encrypt with Dotenvx: https://dotenvx.com
--- Step 1: Verifying token (fetch bot user) ---

ERROR: undefined - fetch failed

{
  "command": "node verify.js 2>&1",
  "dangerouslyDisableSandbox": true
}

[[email protected]] injecting env (2) from .env -- tip: ⚙️  suppress all logs with { quiet: true }
--- Step 1: Verifying token (fetch bot user) ---
Bot user: {
  "object": "user",
  "id": "32226b2f-f6f1-81e6-a1b8-0027a7d0029e",
  "name": "api-test",
  "avatar_url": null,
  "type": "bot",
  "bot": {
    "owner": {
      "type": "workspace",
      "workspace": true
    },
    "workspace_name": "axtester",
    "workspace_id": "45226b2f-f6f1-81ba-9bd8-0003085f871e",
    "workspace_limits": {
      "max_file_upload_size_in_bytes": 5242880
    }
  },
  "request_id": "7d53269c-4cc0-4496-87ec-7b7d633d4e38"
}

--- Step 2: Verifying page access ---
Page title: API Testing
Page ID: 32226b2f-f6f1-801c-90d1-fe890660d065
URL: https://www.notion.so/API-Testing-32226b2ff6f1801c90d1fe890660d065

All checks passed. Integration is working.