home / skills / trevors / dot-claude / notion-formatter

notion-formatter skill

/skills/notion-formatter

This skill formats Markdown for Notion imports, applying standard markdown, Notion-specific syntax, and clear annotations for manual steps to ensure smooth

npx playbooks add skill trevors/dot-claude --skill notion-formatter

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

Files (2)
SKILL.md
3.3 KB
---
name: notion-formatter
description: Format markdown content for Notion import with proper syntax for toggles, code blocks, and tables. Use when formatting responses for Notion, creating Notion-compatible documentation, or preparing markdown for Notion paste/import.
---

# Notion Formatter

## Quick Start

Notion is a **block-based editor**, not a pure markdown system. It supports standard markdown for basic formatting (headers, lists, bold, italic, inline code), but many features require Notion-specific syntax or manual creation. This skill helps you format markdown optimally for Notion import by applying the right syntax, annotating manual steps, and warning about limitations.

## Core Workflow

### 1. Identify Your Content Type

- **Claude response**: Formatting text I just generated for Notion
- **Documentation**: Converting existing `.md` files to Notion format
- **Mixed content**: Markdown with images, code, tables

### 2. Apply Standard Markdown (What Works Everywhere)

Use standard markdown for these features—they'll convert automatically when pasted into Notion:

```markdown
**bold** _italic_ `inline code` ~strikethrough~

# Heading 1

## Heading 2

### Heading 3

- Bullet point
- Another point
  - Nested bullet

1. Numbered item
2. Second item

[] Checkbox item
```

### 3. Use Notion-Specific Syntax

**Key distinction:** Use `>` for toggles (collapsible sections), `"` for blockquotes. See REFERENCE.md for detailed syntax and examples of all features.

**Quick syntax:**

```markdown
> Toggle heading
> Hidden content here

" Blockquote text
```

```javascript
code here
```

| Column 1 | Column 2 |
| -------- | -------- |
| Data 1   | Data 2   |

![alt](https://example.com/image.png)

### 4. Annotate Manual Steps

Mark features that need manual creation in Notion with annotations:

- **Equations:** Use `[NOTION: Recreate equation manually]`
- **Other unsupported features:** Use `[NOTION: Feature name here]`

### 5. Verify Output

Before sending to Notion, check:

- [ ] Standard markdown is correct (headers, lists, formatting)
- [ ] Toggle syntax uses `>` followed by space (greater-than space)
- [ ] Blockquotes use `"` followed by space (quote space)
- [ ] Code blocks have language labels
- [ ] Images use full URLs, not local paths
- [ ] Tables use pipe syntax
- [ ] Manual step annotations are clear

## Examples

### Example 1: Formatting a Response

If I generate a response with code and a table, format it with language-labeled code blocks and pipe-syntax tables.

**Code block example:**

```python
# Example code
def process_data(items):
    return [x * 2 for x in items]
```

**Table example:**

| Input | Output |
| ----- | ------ |
| 1     | 2      |
| 5     | 10     |

### Example 2: Converting Documentation

For multi-section documents, use toggles to create collapsible sections with `> Section Title` and content indented underneath.

## Best Practices

- **Keep it simple**: Avoid deeply nested structures
- **Test tables first**: If a table is complex, consider creating it manually in Notion
- **Image URLs**: Always verify images are accessible online
- **Break large docs**: Paste in chunks if a document fails to import entirely
- **Manual polish**: Always review in Notion after paste—fix extra line breaks and language detection

---

For detailed syntax, gotchas, and troubleshooting, see REFERENCE.md

Overview

This skill formats Markdown for smooth Notion import and paste. It converts standard Markdown, applies Notion-friendly toggles, blockquotes, code-block labels, and pipe-table syntax. It annotates features that require manual recreation in Notion and flags common import pitfalls. The goal is predictable, editable content after pasting into Notion.

How this skill works

The formatter scans Markdown and enforces conventions Notion expects: toggles use "> ", blockquotes use '" ', fenced code blocks include language identifiers, and tables use pipe syntax. It replaces or annotates unsupported items (equations, complex embeds) with clear [NOTION: ...] notes so you can recreate them manually. It also validates image URLs, local path warnings, and basic structural checks before output.

When to use it

  • Preparing AI-generated responses for direct paste into Notion
  • Converting existing .md documentation into Notion-compatible Markdown
  • Creating Notion-friendly export from technical notes with code and tables
  • Preparing mixed-content pages with images, tables, or collapsible sections
  • Splitting large documents into importable chunks

Best practices

  • Keep document structure shallow; avoid deep nesting of lists or toggles
  • Label fenced code blocks with the language (```python) to preserve syntax blocks
  • Use > (greater-than + space) for toggles and " (quote + space) for blockquotes consistently
  • Annotate anything Notion cannot recreate (equations, complex embeds) with [NOTION: ...]
  • Verify image links are public URLs and replace local paths before importing

Example use cases

  • Format a chat response that contains code, a table, and notes for import into a Notion page
  • Convert a project's README sections into toggles so each section becomes collapsible in Notion
  • Prepare API docs with language-labeled code samples and pipe-style tables for clean import
  • Split a long guide into smaller chunks and mark manual polish items for final editing in Notion
  • Annotate equations and advanced embeds so reviewers know which blocks need manual recreation

FAQ

Will this convert every Markdown feature perfectly into Notion?

No. Standard formatting, code blocks, lists, and simple tables convert well. Complex features like equations, some embeds, and advanced table behavior need manual recreation or verification.

How should I represent toggles and blockquotes?

Use "> " at the start of a line for toggles (collapsible sections) and '" ' at the start for blockquotes. Ensure a single space follows the marker.

What should I do with local image paths?

Replace local paths with public, accessible URLs before importing. If an image cannot be hosted externally, note it as [NOTION: Add image manually].