### Install Example Dependencies

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/intro-to-notion-api/README.md

Navigate to the specific example directory and install its Node.js dependencies.

```zsh
cd examples/intro-to-notion-api
npm install
```

--------------------------------

### Run Example

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/README.md

Execute this command to run the examples after setup. Specific instructions may vary per example.

```bash
npm start
```

--------------------------------

### Install Dependencies with npm

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/README.md

Use this command to install the necessary Node.js dependencies for the examples.

```bash
npm install
```

--------------------------------

### Clone Repository and Install Dependencies

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/web-form-with-express/README.md

Clone the Notion Cookbook repository and navigate to the web form example directory. Install the necessary project dependencies using npm.

```zsh
git clone https://github.com/makenotion/notion-cookbook.git

cd notion-cookbook/examples/javascript/web-form-with-express

npm install
```

--------------------------------

### Clone Repository and Install Dependencies

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/notion-github-sync/README.md

Clone the notion-cookbook repository and install the necessary dependencies for the notion-github-sync example.

```zsh
git clone https://github.com/makenotion/notion-cookbook.git

cd notion-cookbook/examples/javascript/notion-github-sync

npm install
```

--------------------------------

### Clone Repository and Install Dependencies

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/generate-random-data/README.md

Clone the notion-cookbook repository and install the necessary Node.js dependencies for the JavaScript example.

```zsh
git clone https://github.com/makenotion/notion-cookbook.git

cd notion-cookbook/examples/javascript/generate-random-data

npm install
```

--------------------------------

### Run Basic Examples with npm Scripts

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/intro-to-notion-api/README.md

Execute individual basic Notion API examples using predefined npm scripts.

```zsh
npm run basic:1    # Runs basic/1-add-block.ts
npm run basic:2    # Runs basic/2-add-linked-block.ts
npm run basic:3    # Runs basic/3-add-styled-block.ts
```

--------------------------------

### Clone Repository and Install Dependencies

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/parse-text-from-any-block-type/README.md

Clone the notion-cookbook repository and install the necessary dependencies for the JavaScript parsing example.

```zsh
# Clone this repository locally
git clone https://github.com/makenotion/notion-cookbook.git

# Switch into this project
cd notion-cookbook/examples/javascript/parse-text-from-any-block-type

# Install the dependencies
npm install
```

--------------------------------

### Run Examples with npm exec

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/intro-to-notion-api/README.md

Execute specific example files using `npm exec` with their relative paths.

```zsh
npm run exec basic/1-add-block.ts
npm run exec intermediate/1-create-a-database.ts
```

--------------------------------

### Create How-To Guide Entry

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/knowledge-capture/reference/how-to-guide-database.md

Use this JSON structure to create a new how-to guide entry, specifying its properties.

```json
{
  "Title": "How to Set Up Local Development Environment",
  "Complexity": "Beginner",
  "Time Required": 30,
  "Category": "Development",
  "Last Tested": "2025-10-01",
  "Tags": "setup, environment, docker"
}
```

--------------------------------

### Clone Repository and Install Dependencies

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/database-email-update/README.md

Clone the repository locally, navigate to the project directory, and install the necessary npm packages.

```zsh
git clone https://github.com/makenotion/notion-cookbook.git

cd notion-cookbook/examples/javascript/database-email-update

npm install
```

--------------------------------

### Configure Environment Variables

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/README.md

Copy the example environment file and add your Notion API key and other required variables.

```bash
cp .env.example .env
```

--------------------------------

### Full MCP Client Integration Example

Source: https://github.com/makenotion/notion-cookbook/blob/main/docs/mcp-client-integration.md

A comprehensive example demonstrating the integration of the MCP client, including initialization, authentication flow, callback handling, and connection establishment with fallback to SSE.

```typescript
import { Client } from "@modelcontextprotocol/sdk/client/index.js"
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js"
import { randomBytes, createHash } from "crypto"

class NotionMcpClient {
  private serverUrl = "https://mcp.notion.com"
  private metadata!: OAuthMetadata
  private clientId!: string
  private clientSecret?: string
  private accessToken?: string
  private refreshToken?: string
  private client?: Client

  async initialize(redirectUri: string): Promise<void> {
    this.metadata = await discoverOAuthMetadata(this.serverUrl)
    const credentials = await registerClient(this.metadata, redirectUri)
    this.clientId = credentials.client_id
    this.clientSecret = credentials.client_secret
  }

  async startAuthFlow(redirectUri: string): Promise<string> {
    const codeVerifier = generateCodeVerifier()
    const codeChallenge = generateCodeChallenge(codeVerifier)
    const state = generateState()

    // Store these securely
    this.storeSecurely("codeVerifier", codeVerifier)
    this.storeSecurely("state", state)

    return buildAuthorizationUrl(
      this.metadata,
      this.clientId,
      redirectUri,
      codeChallenge,
      state
    )
  }

  async handleCallback(
    callbackUrl: string,
    redirectUri: string
  ): Promise<void> {
    const storedState = this.retrieveSecurely("state")
    const codeVerifier = this.retrieveSecurely("codeVerifier")

    const code = await handleCallback(callbackUrl, storedState, codeVerifier)

    const tokens = await exchangeCodeForTokens(
      code,
      codeVerifier,
      this.metadata,
      this.clientId,
      this.clientSecret,
      redirectUri
    )

    this.accessToken = tokens.access_token
    this.refreshToken = tokens.refresh_token

    // Clean up stored values
    this.deleteSecurely("state")
    this.deleteSecurely("codeVerifier")
  }

  async connect(): Promise<Client> {
    if (!this.accessToken) {
      throw new Error("Not authenticated")
    }

    try {
      this.client = await createMcpClient(
        this.serverUrl,
        this.accessToken,
        false
      )
    } catch (error) {
      console.warn("Streamable HTTP failed, falling back to SSE")
      this.client = await createMcpClient(
        this.serverUrl,
        this.accessToken,
        true
      )
    }

    return this.client
  }

  async ensureValidToken(): Promise<void> {
    if (!this.refreshToken) {
      throw new Error("No refresh token available")
    }

    try {
      const tokens = await refreshAccessToken(
        this.refreshToken,
        this.metadata,
        this.clientId,
        this.clientSecret
      )

      this.accessToken = tokens.access_token
      if (tokens.refresh_token) {
        this.refreshToken = tokens.refresh_token
      }
    } catch (error) {
      if (error instanceof Error && error.message === "REAUTH_REQUIRED") {
        throw new Error("Re-authentication required")
      }
      throw error
    }
  }

  private storeSecurely(key: string, value: string): void {
    // Implement secure storage
  }

  private retrieveSecurely(key: string): string {
    // Implement secure retrieval
    return ""
  }

  private deleteSecurely(key: string): void {
    // Implement secure deletion
  }
}

```

--------------------------------

### Example Code Block Usage

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/research-documentation/reference/format-selection-guide.md

Use code blocks to include technical specifications, configuration examples, or command examples in your documentation.

```text
Example code or configuration here
```

--------------------------------

### Run Examples with Node and ts-node

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/intro-to-notion-api/README.md

Execute TypeScript example files directly using Node.js with the `ts-node` loader.

```zsh
node --loader ts-node/esm basic/1-add-block.ts
```

--------------------------------

### Clone and Install Project Dependencies

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/workers/tools/ppt-creator/README.md

Clone the Notion Cookbook repository and install project dependencies for the PPT Creator worker. Navigate into the project directory and run npm install.

```zsh
# Clone this repository
git clone https://github.com/makenotion/notion-cookbook.git

# Switch into this project
cd notion-cookbook/examples/workers/tools/ppt-creator

# Install dependencies
npm install
```

--------------------------------

### Run the Integration

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/database-email-update/README.md

Execute the script to start the integration using npm.

```zsh
npm run ts-run
```

--------------------------------

### Start Database Service (Bash)

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/knowledge-capture/examples/conversation-to-faq.md

Commands to start PostgreSQL service or a PostgreSQL container via Docker.

```bash
# Start PostgreSQL
sudo systemctl start postgresql
```

```bash
# Start via Docker
docker start postgres-container
```

--------------------------------

### Run Intermediate Examples with npm Scripts

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/intro-to-notion-api/README.md

Execute individual intermediate Notion API examples using predefined npm scripts.

```zsh
npm run intermediate:1    # Runs intermediate/1-create-a-database.ts
npm run intermediate:2    # Runs intermediate/2-add-page-to-database.ts
```

--------------------------------

### Create Decision Record Example

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/knowledge-capture/reference/decision-log-database.md

Example of creating a decision record with specified properties. Ensure all required fields are populated.

```json
{
  "Decision": "Use PostgreSQL for Primary Database",
  "Date": "2025-10-15",
  "Status": "Accepted",
  "Domain": "Architecture",
  "Impact": "High",
  "Deciders": [tech_lead, architect],
  "Stakeholders": [eng_team]
}
```

--------------------------------

### Clone and Install Project Dependencies

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/notion-task-github-pr-sync/README.md

Clone the repository and install project dependencies using npm. This sets up the local environment for the integration.

```zsh
git clone https://github.com/makenotion/notion-cookbook.git

cd notion-cookbook/examples/javascript/notion-task-github-pr-sync

npm install
```

--------------------------------

### Create a new database and add new pages to it

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/intro-to-notion-api/README.md

This example shows how to first create a new database and then add new pages (entries) to it. It combines database creation with initial data population.

```typescript
import { Client } from "@notionhq/client";

const notion = new Client({ auth: process.env.NOTION_API_KEY });

async function createDatabaseAndAddPage() {
  const database = await notion.databases.create({
    parent: {
      type: "page_id",
      page_id: "YOUR_PAGE_ID",
    },
    title: [
      {
        type: "text",
        text: {
          content: "Tasks Database",
        },
      },
    ],
    properties: {
      Title: {
        title: {},
      },
      Status: {
        status: {},
      },
    },
  });

  const page = await notion.pages.create({
    parent: {
      type: "database_id",
      database_id: database.id,
    },
    properties: {
      Title: {
        title: [
          {
            type: "text",
            text: {
              content: "Buy groceries",
            },
          },
        ],
      },
      Status: {
        status: "To Do",
      },
    },
  });
  console.log(page);
}

createDatabaseAndAddPage();
```

--------------------------------

### Example Daily Progress Note

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/spec-to-implementation/reference/progress-tracking.md

An example of a filled-out daily progress note, demonstrating how to detail completed tasks, ongoing work, future steps, and any encountered blockers or decisions.

```markdown
## Progress: Oct 14, 2025

### Completed

- Implemented user authentication API endpoints (login, logout, refresh)
- Added JWT token generation and validation
- Wrote unit tests for auth service (95% coverage)

### In Progress

- Frontend login form integration
- Currently: Form submits but need to handle error states

### Next Steps

1. Complete error handling in login form
2. Add loading states
3. Implement "remember me" functionality

### Blockers

None

### Decisions Made

- Using HttpOnly cookies for refresh tokens (more secure than localStorage)
- Session timeout set to 24 hours based on security review

### Notes

- Found edge case with concurrent login attempts, added to backlog
- Performance of auth check is good (<10ms)
```

--------------------------------

### Install MCP SDK and OAuth libraries (npm)

Source: https://github.com/makenotion/notion-cookbook/blob/main/docs/mcp-client-integration.md

Install the necessary libraries for integrating an MCP client using TypeScript/JavaScript. This includes the MCP SDK, an OAuth library, and Node.js crypto module.

```bash
npm install @modelcontextprotocol/sdk
npm install oauth  # or openid-client
npm install crypto  # Built-in Node.js module
```

--------------------------------

### Example: Multi-Query Approach

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/research-documentation/reference/advanced-search.md

Demonstrates running parallel searches with related terms to build a comprehensive understanding of a topic. This method ensures related concepts are not missed.

```text
Query 1: "API integration"
Query 2: "API authentication"
Query 3: "API documentation"
```

--------------------------------

### Create FAQ Entry

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/knowledge-capture/reference/faq-database.md

Example of creating a new FAQ entry with specified properties. Ensure all required fields are populated according to the schema.

```json
{
  "Question": "How do I reset my password?",
  "Category": "Support",
  "Tags": "authentication, password, login",
  "Answer Type": "Quick Answer",
  "Last Reviewed": "2025-10-01",
  "Audience": "External"
}
```

--------------------------------

### Configure Environment Variables

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/database-email-update/README.md

Rename the example .env file and populate it with your Notion API key, SendGrid API key, Notion database ID, and email recipient/sender fields.

```zsh
NOTION_KEY=<your-notion-api-key>
SENDGRID_KEY=<your-sendgrid-api-key>
NOTION_DATABASE_ID=<your-notion-database-id>
EMAIL_TO_FIELD=<email-recipients>
EMAIL_FROM_FIELD=<email-from-field>
```

--------------------------------

### Configure Connection Pooling (JavaScript)

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/knowledge-capture/examples/conversation-to-faq.md

Example of setting minimum and maximum connections for a database connection pool in JavaScript.

```javascript
pool: {
  min: 2,
  max: 10
}
```

--------------------------------

### Create Team Documentation Database

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/knowledge-capture/reference/database-best-practices.md

Example JSON payload for creating a 'Team Documentation' database with predefined select and multi-select properties.

```javascript
{
  "parent": {"page_id": "wiki-page-id"},
  "title": [{"text": {"content": "Team Documentation"}}],
  "properties": {
    "Type": {
      "select": {
        "options": [
          {"name": "How-To", "color": "blue"},
          {"name": "Concept", "color": "green"},
          {"name": "Reference", "color": "gray"},
          {"name": "FAQ", "color": "yellow"}
        ]
      }
    },
    "Category": {
      "select": {
        "options": [
          {"name": "Engineering", "color": "red"},
          {"name": "Product", "color": "purple"},
          {"name": "Design", "color": "pink"}
        ]
      }
    },
    "Tags": {"multi_select": {"options": []}},
    "Owner": {"people": {}},
    "Status": {
      "select": {
        "options": [
          {"name": "Draft", "color": "gray"},
          {"name": "Final", "color": "green"},
          {"name": "Deprecated", "color": "red"}
        ]
      }
    }
  }
}
```

--------------------------------

### Install TypeScript types for Node.js

Source: https://github.com/makenotion/notion-cookbook/blob/main/docs/mcp-client-integration.md

For TypeScript projects, install the Node.js type definitions to ensure proper type checking and autocompletion.

```bash
npm install --save-dev @types/node
```

--------------------------------

### Redis Configuration Example

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/research-documentation/examples/technical-investigation.md

Provides essential configuration parameters for a Redis cluster, focusing on memory management and connection settings. Ensure these align with your deployment environment.

```yaml
maxmemory: 8gb
maxmemory-policy: allkeys-lru
tcp-keepalive: 60
```

--------------------------------

### Testable vs. Non-Testable Criteria Examples

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/spec-to-implementation/reference/spec-parsing.md

Illustrates the difference between subjective/non-testable and objective/testable acceptance criteria.

```markdown
❌ **Not testable**: "System is fast"
✓ **Testable**: "Page loads in < 2 seconds"

❌ **Not testable**: "Users like the interface"
✓ **Testable**: "90% of test users complete task successfully"
```

--------------------------------

### Task Naming Convention Examples

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/spec-to-implementation/reference/task-creation.md

Illustrates best practices for task naming, emphasizing specificity, context inclusion, and the use of action verbs for clarity.

```plaintext
Be specific:
✓ "Implement user login with email/password"
✗ "Add login"

Include context:
✓ "Dashboard: Add revenue chart widget"
✗ "Add chart"

Use action verbs:

- Implement, Build, Create
- Integrate, Connect, Link
- Fix, Resolve, Debug
- Test, Validate, Verify
- Document, Write, Update
- Refactor, Optimize, Improve
```

--------------------------------

### Set Notion API Key Environment Variable

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/generate-random-data/README.md

Configure your Notion API key by renaming the example environment file and adding your key.

```zsh
NOTION_KEY=<api-key-you-created-in-the-previous-step>
```

--------------------------------

### Create a database, add pages, and filter/sort entries

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/intro-to-notion-api/README.md

This snippet extends the previous example by adding sorting capabilities to the database query. It demonstrates how to create a database, add pages, filter, and then sort the results.

```typescript
import { Client } from "@notionhq/client";

const notion = new Client({ auth: process.env.NOTION_API_KEY });

async function createDatabaseAddPagesQueryAndSort() {
  const database = await notion.databases.create({
    parent: {
      type: "page_id",
      page_id: "YOUR_PAGE_ID",
    },
    title: [
      {
        type: "text",
        text: {
          content: "Tasks",
        },
      },
    ],
    properties: {
      Name: {
        title: {},
      },
      Priority: {
        select: {
          options: [
            { name: "High" },
            { name: "Medium" },
            { name: "Low" },
          ],
        },
      },
      "Due Date": {
        date: {},
      },
    },
  });

  await notion.pages.create({
    parent: {
      type: "database_id",
      database_id: database.id,
    },
    properties: {
      Name: {
        title: [
          {
            type: "text",
            text: {
              content: "Task 1",
            },
          },
        ],
      },
      Priority: {
        select: {
          name: "High",
        },
      },
      "Due Date": {
        date: {
          start: "2024-08-15",
        },
      },
    },
  });

  await notion.pages.create({
    parent: {
      type: "database_id",
      database_id: database.id,
    },
    properties: {
      Name: {
        title: [
          {
            type: "text",
            text: {
              content: "Task 2",
            },
          },
        ],
      },
      Priority: {
        select: {
          name: "Medium",
        },
      },
      "Due Date": {
        date: {
          start: "2024-09-01",
        },
      },
    },
  });

  const queryResults = await notion.databases.query({
    database_id: database.id,
    sorts: [
      {
        property: "Due Date",
        direction: "ascending",
      },
    ],
  });
  console.log(queryResults);
}

createDatabaseAddPagesQueryAndSort();
```

--------------------------------

### Configure SSL/TLS in Connection String

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/knowledge-capture/examples/conversation-to-faq.md

Examples of how to configure SSL/TLS settings within a database connection string, including enabling it or disabling it for development.

```text
ssl=true&sslmode=require
```

```text
sslmode=disable
```

--------------------------------

### Formal Citation Style Example

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/research-documentation/reference/citations.md

Illustrates the formal citation style, which includes full mentions with clickable URLs for comprehensive referencing.

```markdown
Revenue grew 23% (<mention-page url="...">Q4 Financial Report</mention-page>). Customer count increased 18% (<mention-page url="...">Metrics Dashboard</mention-page>).
```

--------------------------------

### Inline Citation Style Example

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/research-documentation/reference/citations.md

Demonstrates the lightweight inline citation style for referencing sources directly within the text.

```markdown
Revenue grew 23% (Financial Report). Customer count increased 18% (Metrics Dashboard).
```

--------------------------------

### Example Page Properties for Documentation Database

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/knowledge-capture/reference/documentation-database.md

This JSON object demonstrates the properties to be set when creating a new page within the documentation database. Ensure 'current_user' is replaced with the actual user identifier.

```json
{
  "Title": "How to Deploy to Production",
  "Type": "How-To",
  "Category": "Engineering",
  "Tags": "deployment, production, DevOps",
  "Status": "Final",
  "Owner": [current_user],
  "Last Reviewed": "2025-10-01"
}
```

--------------------------------

### Update Task Checklist

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/spec-to-implementation/reference/progress-tracking.md

Mark completed tasks in your implementation phases using the `[x]` format. This example shows how to update tasks within Phase 1 and Phase 2.

```markdown
## Implementation Phases

### Phase 1: Foundation

- [x] <mention-page url=\"...\">Database schema</mention-page>
- [x] <mention-page url=\"...\">API scaffolding</mention-page>
- [x] <mention-page url=\"...\">Auth setup</mention-page>

### Phase 2: Core Features

- [x] <mention-page url=\"...\">User management</mention-page>
- [ ] <mention-page url=\"...\">Dashboard</mention-page>
- [ ] <mention-page url=\"...\">Reporting</mention-page>
```

--------------------------------

### Example: Temporal Research Strategy

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/research-documentation/reference/advanced-search.md

Shows how to search across different time periods using date ranges to track the evolution of a topic. This is useful for historical context and recent developments.

```text
Search 1: created_date_range 2023 → Historical context
Search 2: created_date_range 2024 → Recent developments
Search 3: created_date_range 2025 → Current state
```

--------------------------------

### Example: Broad to Narrow Search Strategy

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/research-documentation/reference/advanced-search.md

Illustrates a search strategy that begins broadly and progressively narrows down results using filters. This approach helps manage large result sets efficiently.

```text
Search 1: query="API integration" → 50 results across workspace
Search 2: query="API integration", teamspace_id="engineering" → 12 results
Fetch: Top 3-5 most relevant pages
```

--------------------------------

### Create a database, list its templates, and create pages using templates

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/intro-to-notion-api/README.md

This example demonstrates how to create a database, retrieve a list of its available templates, and then create new pages using those templates. It's useful for standardized content creation.

```typescript
import { Client } from "@notionhq/client";

const notion = new Client({ auth: process.env.NOTION_API_KEY });

async function createDatabaseWithTemplate() {
  const database = await notion.databases.create({
    parent: {
      type: "page_id",
      page_id: "YOUR_PAGE_ID",
    },
    title: [
      {
        type: "text",
        text: {
          content: "Templated Database",
        },
      },
    ],
    properties: {
      Name: {
        title: {},
      },
    },
    template: {
      name: "My Template",
      pages: [
        {
          properties: {
            Name: {
              title: [
                {
                  type: "text",
                  text: {
                    content: "Default Page Name",
                  },
                },
              ],
            },
          },
        },
      ],
    },
  });

  const templates = await notion.databases.getTemplates({
    database_id: database.id,
  });
  console.log("Templates:", templates);

  // Example of creating a page using the first template found
  if (templates.results.length > 0) {
    const templateId = templates.results[0].id;
    const pageFromTemplate = await notion.pages.create({
      parent: {
        type: "database_id",
        database_id: database.id,
      },
      template_id: templateId,
    });
    console.log("Page created from template:", pageFromTemplate);
  }
}

createDatabaseWithTemplate();
```

--------------------------------

### Extract Content for Notion

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/knowledge-capture/SKILL.md

Identify key information from conversation context to be captured in Notion. This includes concepts, decisions, how-to guides, insights, Q&A, and examples.

```text
From conversation context, extract:
- Key concepts and definitions
- Decisions made and rationale
- How-to information and procedures
- Important insights or learnings
- Q&A pairs
- Examples and use cases
```

--------------------------------

### Configure Environment Variables

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/web-form-with-express/README.md

Set up your Notion API key and the parent page ID by creating a .env file. Rename the provided .env.example file and update the NOTION_KEY and NOTION_PAGE_ID variables.

```zsh
NOTION_KEY=<your-notion-api-key>
NOTION_PAGE_ID=<notion-page-id>
```

--------------------------------

### Install Notion Workers CLI

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/workers/tools/ppt-creator/README.md

Install the Notion Workers CLI globally using npm. This command is necessary for managing and deploying Notion worker tools.

```zsh
npm install -g @notionhq/workers-cli
```

--------------------------------

### Configure Environment Variables

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/notion-github-sync/README.md

Set up your GitHub and Notion API keys, repository details, and Notion database ID in a .env file. Ensure you have created these credentials and shared the database with your integration.

```zsh
GITHUB_KEY=<your-github-personal-access-token>
NOTION_KEY=<your-notion-api-key>
NOTION_DATABASE_ID=<notion-database-id>
GITHUB_REPO_OWNER=<github-owner-username>
GITHUB_REPO_NAME=<github-repo-name>
```

--------------------------------

### Under-citing Example

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/research-documentation/reference/citations.md

Illustrates under-citing, where no specific attributions are made even when data is presented.

```markdown
The revenue increased, costs decreased, and margin improved.
```

--------------------------------

### Over-citing Example

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/research-documentation/reference/citations.md

Demonstrates excessive citation frequency, where nearly every sentence is individually cited.

```markdown
The revenue increased (<mention-page url="...">Report</mention-page>).
Costs decreased (<mention-page url="...">Report</mention-page>).
Margin improved (<mention-page url="...">Report</mention-page>).
```

--------------------------------

### Create Implementation Tasks

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/spec-to-implementation/SKILL.md

For each task in the implementation plan, create a new entry in the task database using Notion:notion-create-pages. Set properties like Name, Status, and Priority, and link to the spec and plan.

```text
For each task in plan:
1. Create task in task database using Notion:notion-create-pages
2. Use parent: { data_source_id: 'collection://...' }
3. Set properties from schema:
   - Name/Title: Task description
   - Status: To Do
   - Priority: Based on criticality
   - Related Tasks: Link to spec and plan
4. Add implementation details in content
```

--------------------------------

### Balanced Citation Example

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/research-documentation/reference/citations.md

Shows a balanced approach to citation by grouping related information under a single, consolidated reference.

```markdown
The revenue increased, costs decreased, and margin improved (<mention-page url="...">Q4 Financial Report</mention-page>).
```

--------------------------------

### Create a database, add pages, and filter entries

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/intro-to-notion-api/README.md

This snippet demonstrates creating a database, adding pages, and then filtering the database entries based on specific criteria. It covers data creation and retrieval with conditions.

```typescript
import { Client } from "@notionhq/client";

const notion = new Client({ auth: process.env.NOTION_API_KEY });

async function createDatabaseAddPagesAndQuery() {
  const database = await notion.databases.create({
    parent: {
      type: "page_id",
      page_id: "YOUR_PAGE_ID",
    },
    title: [
      {
        type: "text",
        text: {
          content: "Projects",
        },
      },
    ],
    properties: {
      Name: {
        title: {},
      },
      Status: {
        status: {},
      },
      "Completion Date": {
        date: {},
      },
    },
  });

  await notion.pages.create({
    parent: {
      type: "database_id",
      database_id: database.id,
    },
    properties: {
      Name: {
        title: [
          {
            type: "text",
            text: {
              content: "Project Alpha",
            },
          },
        ],
      },
      Status: {
        status: "In Progress",
      },
      "Completion Date": {
        date: {
          start: "2024-12-31",
        },
      },
    },
  });

  const queryResults = await notion.databases.query({
    database_id: database.id,
    filter: {
      property: "Status",
      status: {
        equals: "In Progress",
      },
    },
  });
  console.log(queryResults);
}

createDatabaseAddPagesAndQuery();
```

--------------------------------

### Link Related Research Documents

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/research-documentation/reference/citations.md

This markdown structure is used to link to related research documents and implementation guides.

```markdown
## Related Research

This research builds on previous findings:

- <mention-page url="...">Market Analysis - Q2 2025</mention-page>
- <mention-page url="...">Competitor Landscape Review</mention-page>

For implementation details, see:

- <mention-page url="...">Technical Implementation Guide</mention-page>
```

--------------------------------

### Meeting Template Decision Tree

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/meeting-intelligence/reference/template-selection-guide.md

A text-based decision tree to guide the selection of meeting templates based on the primary purpose of the meeting.

```text
What's the primary purpose?

├─ Make a decision
│  └─ Use: Decision Meeting Template
│
├─ Update on progress
│  └─ Use: Status Update Template
│
├─ Generate ideas
│  └─ Use: Brainstorming Template
│
├─ Plan sprint work
│  └─ Use: Sprint Planning Template
│
├─ Reflect on past work
│  └─ Use: Retrospective Template
│
└─ Manager/report check-in
   └─ Use: 1:1 Meeting Template
```

--------------------------------

### Configure Environment Variables

Source: https://github.com/makenotion/notion-cookbook/blob/main/examples/javascript/notion-task-github-pr-sync/README.md

Set up your environment variables in a .env file with your GitHub Personal Access Token, Notion API Key, repository details, and configuration for updating Notion status.

```env
GITHUB_KEY=<your-github-personal-access-token>
NOTION_KEY=<your-notion-api-key>
GITHUB_REPO_OWNER=<github-owner-username>
GITHUB_REPO_NAME=<github-repo-name>
UPDATE_STATUS_IN_NOTION_DB = <true|false>
STATUS_PROPERTY_NAME = <your-status-property-name>
```

--------------------------------

### Create Implementation Plan Page

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/spec-to-implementation/SKILL.md

Use Notion:notion-create-pages to generate an implementation plan page. The page should include a structured plan with phases, tasks, and a timeline, and link back to the original specification.

```text
Use Notion:notion-create-pages:
- Title: "Implementation Plan: [Feature Name]"
- Content: Structured plan with phases, tasks, timeline
- Link back to original spec
- Add to appropriate location (project page, database)
```

--------------------------------

### Bulk Task Creation Process

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/spec-to-implementation/reference/task-creation.md

A general process outline for creating multiple tasks efficiently, emphasizing property determination, page creation, linking, and relationship setting.

```plaintext
For each work item in breakdown:
  1. Determine task properties
  2. Create task page
  3. Link to spec/plan
  4. Set relationships

Then:
  1. Update plan with task links
  2. Review sequencing
  3. Assign tasks (if known)
```

--------------------------------

### Related Tasks Pattern Example

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/spec-to-implementation/reference/task-creation.md

Utilize the Related Tasks Pattern for parallel work streams that are connected to a central feature or task but do not necessarily block each other.

```plaintext
Central: "Feature: Dashboard"
Related:
- "Backend API for dashboard data"
- "Frontend dashboard component"
- "Dashboard data caching"
```

--------------------------------

### Search for Content with Notion CLI

Source: https://github.com/makenotion/notion-cookbook/blob/main/skills/claude/knowledge-capture/examples/how-to-guide.md

Use the Notion CLI to search for existing documentation related to a specific topic. This helps in finding relevant information before creating new content.

```bash
Notion:notion-search
query: "deployment documentation"
```