home / skills / idanbeck / claude-skills / notion-skill

notion-skill skill

/notion-skill

This skill reads and exports Notion databases and pages across workspaces to facilitate data migration and migration ready exports.

npx playbooks add skill idanbeck/claude-skills --skill notion-skill

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
5.7 KB
---
name: notion-skill
description: Read Notion databases and pages. Use when the user asks to pull data from Notion, list databases, query database entries, or export Notion content for migration.
allowed-tools: Bash, Read, Write
---

# Notion Skill - Database & Page Access

Read and query Notion databases and pages. Supports multiple workspaces. Useful for data migration and export.

## First-Time Setup (~3 minutes per workspace)

### 1. Create an Internal Integration (per workspace)

1. Go to [Notion Integrations](https://www.notion.so/my-integrations)
2. Click **+ New integration**
3. Name it (e.g., "Claude Assistant")
4. Select the workspace you want to access
5. Under **Capabilities**, ensure "Read content" is enabled
6. Click **Submit**
7. Copy the **Internal Integration Secret** (starts with `ntn_` or `secret_`)

**Note:** Each Notion workspace requires its own integration. Create one integration per workspace.

### 2. Share Pages/Databases with the Integration

**Important:** Notion integrations can only access pages explicitly shared with them.

1. Open any database or page you want to access
2. Click **...** (menu) in the top right
3. Click **Add connections**
4. Search for your integration name and select it
5. Repeat for all databases/pages you need

### 3. Configure Accounts

Create `~/.claude/skills/notion-skill/config.json`:

```json
{
  "default_account": "personal",
  "accounts": {
    "personal": {
      "email": "[email protected]",
      "workspace": "Personal",
      "token": "ntn_..."
    },
    "work": {
      "email": "[email protected]",
      "workspace": "Company",
      "token": "ntn_..."
    }
  }
}
```

## Commands

### List Accounts

```bash
python3 ~/.claude/skills/notion-skill/notion_skill.py accounts
```

### List Databases

```bash
python3 ~/.claude/skills/notion-skill/notion_skill.py databases [-a ACCOUNT]
```

Lists all databases shared with the integration.

**Examples:**
```bash
# Use default account
python3 ~/.claude/skills/notion-skill/notion_skill.py databases

# Use specific account
python3 ~/.claude/skills/notion-skill/notion_skill.py databases -a epoch
```

### Query Database

```bash
python3 ~/.claude/skills/notion-skill/notion_skill.py query DATABASE_ID [-a ACCOUNT] [--limit N] [--filter PROPERTY:VALUE]
```

**Arguments:**
- `DATABASE_ID` - The database ID (from URL or databases command)
- `-a` / `--account` - Account/workspace to use
- `--limit` / `-l` - Number of results (default: 100)
- `--filter` / `-f` - Filter by property (e.g., `--filter "Status:Active"`)

**Example:**
```bash
python3 ~/.claude/skills/notion-skill/notion_skill.py query abc123 -a personal --limit 50
```

### Get Page

```bash
python3 ~/.claude/skills/notion-skill/notion_skill.py page PAGE_ID [-a ACCOUNT]
```

Gets a page's properties and content.

### Search

```bash
python3 ~/.claude/skills/notion-skill/notion_skill.py search "query" [-a ACCOUNT] [--type database|page]
```

**Arguments:**
- `query` - Search term
- `-a` / `--account` - Account/workspace to use
- `--type` / `-t` - Filter by type: `database` or `page`

### Export Database to JSON

```bash
python3 ~/.claude/skills/notion-skill/notion_skill.py export DATABASE_ID [-a ACCOUNT] [--output FILE]
```

Exports all entries from a database to JSON for migration.

**Arguments:**
- `DATABASE_ID` - The database to export
- `-a` / `--account` - Account/workspace to use
- `--output` / `-o` - Output file (default: stdout)

## Migration Workflow

### 1. List Accounts
```bash
python3 ~/.claude/skills/notion-skill/notion_skill.py accounts
```

### 2. Find Your Databases
```bash
python3 ~/.claude/skills/notion-skill/notion_skill.py databases -a personal
python3 ~/.claude/skills/notion-skill/notion_skill.py databases -a epoch
```

### 3. Preview Data Structure
```bash
python3 ~/.claude/skills/notion-skill/notion_skill.py query DATABASE_ID -a personal --limit 5
```

### 4. Export Full Database
```bash
python3 ~/.claude/skills/notion-skill/notion_skill.py export DATABASE_ID -a personal --output people.json
```

### 5. Migrate to Obsidian
Use the exported JSON to create pages in the vault.

## Output Format

All commands output JSON. Database entries include:
- `id` - Page ID
- `url` - Notion URL
- `created_time` - Creation timestamp
- `last_edited_time` - Last edit timestamp
- `properties` - All database properties with values

## Property Types

The skill handles these Notion property types:
- `title` - Page title
- `rich_text` - Text content
- `number` - Numeric values
- `select` - Single select
- `multi_select` - Multiple selections
- `status` - Status field
- `date` - Date/date range
- `people` - Notion users
- `email` - Email addresses
- `phone_number` - Phone numbers
- `url` - URLs
- `checkbox` - Boolean
- `relation` - Links to other databases
- `rollup` - Computed values
- `formula` - Formula results
- `files` - File attachments
- `created_time` / `last_edited_time` - Timestamps
- `created_by` / `last_edited_by` - Users

## Finding Database IDs

Database IDs can be found in the URL:
```
https://www.notion.so/workspace/DATABASE_ID?v=VIEW_ID
                         ^^^^^^^^^^^^^^^^
```

Or use the `databases` command to list all accessible databases with their IDs.

## Requirements

No external dependencies - uses Python standard library only.

## Security Notes

- Integration tokens don't expire but can be revoked
- Token stored locally in `~/.claude/skills/notion-skill/config.json`
- Config file is gitignored (contains secrets)
- Revoke access: [Notion Integrations](https://www.notion.so/my-integrations) > Delete integration

## Sources

- [Notion API Docs](https://developers.notion.com/)
- [Database API](https://developers.notion.com/reference/database)
- [Query Database](https://developers.notion.com/reference/post-database-query)

Overview

This skill reads and queries Notion databases and pages across multiple workspaces. It is built for exporting data, previewing database structure, searching content, and migrating Notion content to other systems like Obsidian. Setup requires creating an internal integration and sharing pages with that integration.

How this skill works

The skill uses Notion internal integration tokens to list workspaces, enumerate databases, query database entries, fetch individual pages, and export databases to JSON. It outputs machine-readable JSON for all commands and supports pagination, simple property filters, and selecting the account/workspace to use. Tokens are stored locally in a config file and each workspace needs its own integration.

When to use it

  • You need to export a Notion database for migration or backup.
  • You want to preview database entries or schema before transforming data.
  • You need to list all databases accessible to a given integration.
  • You want to fetch a page’s properties and content programmatically.
  • You need to search Notion content by text, type, or workspace.

Best practices

  • Create one internal integration per Notion workspace and grant only the "Read content" capability.
  • Share every database or page you want the skill to access with the integration explicitly.
  • Store tokens in the local config file and keep that file out of source control (it is ignored).
  • Preview with a small --limit first before exporting large datasets to confirm structure.
  • Revoke integration tokens from the Notion Integrations dashboard if a token is compromised.

Example use cases

  • List accessible databases in a workspace to discover dataset IDs before migration.
  • Query a database with a property filter to extract active tasks or records.
  • Export a full database to JSON for import into Obsidian or another note system.
  • Fetch a single page to retrieve its properties and content for automated reporting.
  • Search across pages and databases to locate references or gather content for audits.

FAQ

How do I create the token for a workspace?

Create an internal integration at Notion Integrations, enable "Read content," select the workspace, then copy the Internal Integration Secret (starts with ntn_ or secret_).

Why can’t the skill see my database?

Notion integrations only access pages explicitly shared with them. Open the page or database, choose Add connections, and share it with your integration name.