notion-overlimit-writer

Enhanced n8n node for unlimited Notion content with professional markdown-to-rich-text conversion, robust property management, and comprehensive file support

Package Information

Downloads: 38 weekly / 281 monthly

Latest Version: 2.8.0

Author: Your Name

Available Nodes

Notion Overlimit Writer

Create pages or write unlimited content to multiple Notion properties with multi-mapping support

Documentation

n8n-nodes-notion-overlimit-writer

A powerful n8n community node that enables writing unlimited content to Notion properties with advanced multi-mapping capabilities, smart processing order, professional format conversion, intelligent allocation strategies, and comprehensive page data output.

🚀 Enhanced Features (v2.5+)

Enhanced Output with Complete Page Data (v2.7.0) ⚡

Complete Page Output: Returns full Notion page content and properties after processing
Human-Readable Format: Simplified property values and markdown body content by default
Configurable Output: Control input data inclusion, page data format, and fetch behavior
Advanced Page Fetching: Powered by notion-to-md v4 with concurrent processing and rate limiting
Conflict Resolution: Notion page data takes precedence over input data for property conflicts
Performance Optimized: Smart fetching only when needed with configurable API rate limits
Optional Dependencies: Enhanced features require additional setup (see Enhanced Output Setup)

Robust Property Management (v2.6.0)

Property ID Resolution: Uses immutable Notion property IDs for rename-proof operation
Fresh Property Data: Fetches current property names on each execution to handle renames
Deleted Property Detection: Clear error messages when properties are removed from Notion
Zero Cache Staleness: No outdated property names in UI dropdowns after changes
Breaking Change: Existing workflows need reconfiguration for enhanced reliability

Professional Error Handling (v2.5.0)

n8n-Compliant Error System: Full NodeApiError and NodeOperationError integration
Hybrid Error Processing: Individual mappings can fail without stopping execution
continueOnFail Support: Complete respect for n8n's error handling preferences
Enhanced Rate Limiting: Intelligent throttling with proactive API management
Detailed Error Context: Rich error information with suggestions and error codes

Smart Processing Order (v2.4.1)

Intelligent Order Detection: Automatically maintains content order for multiple page body mappings
Performance Optimization: Uses parallel processing by default, switches to sequential when needed
Content Integrity: Preserves intended sequence of page body content

Advanced Format Support (v2.4.1)

HTML Conversion: Professional HTML to Notion block conversion
Advanced Markdown: Enhanced markdown processing with rich formatting
Format Detection: Automatic content format recognition and processing
Fallback Support: Graceful degradation when advanced libraries are unavailable

Multi-Input/Output Mapping

Multiple Content Fields: Process multiple input fields in a single execution
Independent Settings: Each mapping can have its own chunk size and allocation strategy
Property Isolation: No conflicts between different content mappings
Smart Processing: Parallel processing with sequential order when needed

Dynamic Page Selection

Manual Entry: Enter page ID or URL directly
Database Selection: Choose from databases, then select specific pages
Global Search: Search and select from all accessible pages
Smart Validation: Pre-execution validation of page access and properties

Advanced Content Processing

Unlimited Content: Write text of any size to Notion properties
Intelligent Chunking: Automatically splits content into optimal chunks (1900 chars by default)
Greedy Allocation: Fills one property completely before moving to the next (maximizes efficiency)
Balanced Allocation: Distributes content evenly across all available properties
Global + Override Settings: Set defaults globally, override per mapping as needed

Enhanced User Experience

Pre-Execution Validation: Validate all configurations before processing any content
Professional Error Handling: n8n-standard error reporting with detailed context
Hybrid Processing: Continue on partial failures with detailed results
Rich Text Support: Maintains proper Notion rich text formatting
Comprehensive Logging: Detailed execution metrics and error reporting

📦 Installation

Install via n8n Community Nodes

Go to Settings → Community Nodes in your n8n instance
Click Install a community node
Enter: n8n-nodes-notion-overlimit-writer
Click Install

Install via npm (for self-hosted n8n)

npm install n8n-nodes-notion-overlimit-writer

Then restart your n8n instance.

🔧 Configuration

Prerequisites

Notion Integration: Create a Notion integration and get your API key
- Go to Notion Developers
- Create a new integration
- Copy the "Internal Integration Token"
Page Access: Share your target page with the integration
- Open your Notion page
- Click "Share" → "Invite" → Select your integration
Property Setup: Ensure your page has the required text properties
- Add properties like "Text", "Text 2", "Text 3" to your page/database

Node Parameters

Required Parameters

Page ID: The Notion page ID (32-character hex string)
- Example: 29e81e6b477081aeab51f7a4a8a89642
- Can be found in the page URL
Content Field: The input field containing your large text content
- Default: content
- Must contain string data
Output Properties: Comma-separated list of Notion property names
- Example: Text, Text 2, Text 3
- Properties must exist on the target page

Advanced Options

Chunk Size: Characters per chunk (100-2000)
- Default: 1900 (recommended for safety margin)
- Lower values = more chunks, higher values = fewer chunks
Allocation Strategy: How to distribute content
- greedy (default): Fill Property 1 → Property 2 → Property 3
- balanced: Distribute evenly across all properties
Parallel Requests: Update multiple properties simultaneously
- Default: true (faster execution)
- Set to false for sequential updates
Validate Properties: Check property existence before processing
- Default: true (recommended)
- Validates page access and property names
Max Retries: Maximum API request retries
- Default: 3
- Helps handle temporary API issues

📋 Usage Examples

Basic Usage

{
  "pageId": "29e81e6b477081aeab51f7a4a8a89642",
  "contentField": "transcript",
  "outputProperties": {
    "propertyNames": "Text, Text 2, Text 3"
  }
}

Input Data:

{
  "transcript": "Your very long content here... (252,000 characters)",
  "title": "Meeting Notes",
  "date": "2024-01-15"
}

Result: Content automatically split and written to Text, Text 2, and Text 3 properties.

Advanced Configuration

{
  "pageId": "29e81e6b477081aeab51f7a4a8a89642",
  "contentField": "articleContent",
  "outputProperties": {
    "propertyNames": "Article Text, Article Text 2, Article Text 3, Article Text 4"
  },
  "advancedOptions": {
    "chunkSize": 1800,
    "allocationStrategy": "balanced",
    "parallelRequests": true,
    "validateProperties": true,
    "maxRetries": 5
  }
}

📊 Allocation Strategies

Greedy Allocation (Default)

Fills properties sequentially, maximizing content per property:

Content: 380,000 characters
├── Text: 190,000 chars (100% full)
├── Text 2: 190,000 chars (100% full)
└── Text 3: 0 chars (unused)

Best for: Most content types, minimizes property usage

Balanced Allocation

Distributes content evenly across all properties:

Content: 380,000 characters
├── Text: 126,667 chars (~67% full)
├── Text 2: 126,667 chars (~67% full)
└── Text 3: 126,666 chars (~67% full)

Best for: Visual balance, specific formatting requirements

📁 File Support & Limitations

✅ Supported File Input Types

URLs: Public file URLs from any web service

"https://example.com/document.pdf"
"https://drive.google.com/uc?id=FILE_ID&export=download"

Notion File IDs: Files already uploaded to Notion
```
"abc123def-456-789-ghi012jkl"
```

❌ NOT Supported: Binary Data

Important: Notion's API does NOT accept binary data directly. This is a Notion API limitation, not a node limitation.

❌ Binary data from "Convert to File" node
❌ File buffers from HTTP Request node  
❌ Direct file uploads from file system

🔄 Workarounds for Binary Files

If you have binary file data, use one of these approaches:

Option 1: Google Drive Upload

1. HTTP Request → Upload to Google Drive
2. Get public sharing URL
3. Use URL in this node

Option 2: AWS S3 Upload

1. AWS S3 → Upload file
2. Get public URL or signed URL
3. Use URL in this node

Option 3: External File Hosting

1. Upload to: Dropbox, OneDrive, CloudFlare R2, etc.
2. Get public URL
3. Use URL in this node

Option 4: Manual Notion Upload

1. Upload file directly in Notion interface
2. Get the file ID from the property
3. Use file ID in this node

File Handling Modes

Replace All Files: Overwrites all existing files in the property (default)
Append to Existing Files: Adds new files while keeping existing ones

🎨 Advanced Format Support (v2.4+)

Multi-Format Processing

The node supports comprehensive content conversion with professional-grade libraries:

Supported Input Formats (v2.4.1)

Plain Text: Standard text content
Basic Markdown: Standard markdown formatting
Advanced Markdown: Enhanced processing using @tryfabric/martian
HTML: Full HTML to Notion block conversion

Advanced Markdown Features

Headers: # H1, ## H2, ### H3
Bold: **bold text**
Italic: *italic text*
Code: `inline code`
Strikethrough: ~~strikethrough~~
Links: [text](url)
Lists: Ordered and unordered lists
Code blocks: ` language
Blockquotes: > quote text

HTML Conversion Features

Semantic Elements: Headers, paragraphs, lists, links
Formatting: Bold, italic, code, strikethrough
Structure: Proper block hierarchy and nesting
Fallback Support: Graceful degradation for unsupported elements

Usage Examples

Advanced Markdown:

{
  "contentFormat": "advanced_markdown",
  "pageBodyContentFormat": "advanced_markdown",
  "content": "# My Document\n\nThis is **bold** and *italic* text with `code`."
}

HTML Conversion:

{
  "contentFormat": "html",
  "pageBodyContentFormat": "html",
  "content": "<h1>My Document</h1><p>This is <strong>bold</strong> and <em>italic</em> text.</p>"
}

Processing Intelligence

Format Detection: Automatic content type recognition
Fallback Mechanisms: Graceful degradation when libraries are unavailable
Performance Optimization: Smart caching and processing strategies

📤 Enhanced Output Format (v2.7.0)

Complete Page Data Output

The node now returns comprehensive Notion page data following the specification in notion-output-spec.md:

Human-Readable Format (Default)

{
  // Conditionally included input data from previous node
  "inputField1": "value from previous node",
  "inputField2": "another value",
  
  // Always included execution metadata
  "success": true,
  "pageId": "29e81e6b-4770-81ae-ab51-f7a4a8a89642",
  "executionTime": 1250,
  "mappingsProcessed": 2,
  "mappingsSuccessful": 2,
  "mappingsFailed": 0,
  
  // Always included Notion page data (takes precedence in conflicts)
  "id": "29e81e6b-4770-81ae-ab51-f7a4a8a89642",
  "icon": "📝",
  "url": "https://www.notion.so/Meeting-Notes-29e81e6b477081aeab51f7a4a8a89642",
  "created_time": "2025-11-01T01:29:00.000Z",
  "last_edited_time": "2025-11-02T09:22:00.000Z",
  
  // Complete page content as markdown
  "body": "# Meeting Notes\n\nThis is the full page content.\nAll blocks are included here with no character limit.",
  
  // Simplified property values
  "properties": {
    "Title": "Meeting Notes",
    "Status": "In Progress", 
    "Tags": ["important", "Q4-2025"],
    "Date": "2025-11-02T10:00:00.000Z",
    "Text 1": "Complete text content without rich text metadata",
    "Text 2": "All property content in simplified, readable format"
  }
}

Raw API Format (Optional)

{
  // Same structure as human-readable but with:
  "properties": {
    "Title": {
      "type": "title",
      "title": [
        {
          "type": "text",
          "text": {"content": "Meeting Notes"},
          "annotations": {"bold": false, "italic": false},
          "plain_text": "Meeting Notes"
        }
      ]
    }
    // ... full Notion API property structure
  },
  "metadata": {
    // Complete page metadata from Notion API
  },
  "blocks": [
    // Complete block structure from page content
  ]
}

Output Configuration Options

Global Settings → Output Settings

Include Input Data: Toggle inclusion of previous node data (default: enabled)
Page Data Format: Choose between human-readable and raw API format
Include Page Properties: Control property fetching (default: enabled)
Include Page Body: Control body content fetching (default: enabled)
Include Comments: Optionally include page comments (default: disabled)
API Rate Limiting: Configurable requests per second (default: 3, range: 1-10)
Batch Processing: Configurable concurrent block processing (default: 3, range: 1-10)

Key Benefits

Complete Data Access: Get both your input data and full Notion page content
Conflict Resolution: Notion data takes precedence for property name conflicts
Format Flexibility: Choose between simplified or full API format
Performance Control: Configure API usage based on your needs
Backward Compatibility: Input data inclusion can be disabled to maintain existing behavior
Easy Integration: Simplified format perfect for markdown exports, reports, and downstream processing

🏗️ Technical Details

Notion API Limits

Max Rich Text Blocks: 100 per property
Max Characters per Block: 2000
Max Characters per Property: ~190,000 (100 × 1900)
Safe Chunk Size: 1900 characters (safety margin)

Content Processing Pipeline

Content Extraction: Get content from specified input field
Sanitization: Remove invalid characters and control codes
Chunking: Split into optimal-sized chunks
Allocation: Assign chunks to properties using chosen strategy
Rich Text Building: Convert chunks to Notion rich text blocks
Validation: Verify all limits are respected
API Updates: Send parallel/sequential PATCH requests
Result Aggregation: Combine all update results

Error Handling (v2.5.0)

The node provides professional n8n-compliant error handling with comprehensive coverage:

n8n-Standard Error Classes

NodeApiError: Notion API errors with HTTP status codes and descriptions
NodeOperationError: Configuration and validation errors with context
continueOnFail Support: Respects n8n's error handling preferences

Hybrid Error Processing

Individual Mapping Failures: One mapping can fail without stopping others
Detailed Error Context: Error type, code, message, and suggestions
Partial Success Handling: Continue processing even with some failures

Enhanced API Error Handling

Rate Limit Management: Intelligent throttling and retry logic
HTTP Status Translation: Clear error messages for all API responses
Authentication Issues: Detailed credential and permission guidance
Network Resilience: Automatic retries with exponential backoff

Common Error Scenarios

Invalid Page ID: Format validation and suggestions
Missing Properties: Lists available properties with recommendations
Content Too Large: Calculates required properties automatically
Permission Issues: Clear guidance on integration setup
API Limits: Rate limit handling with retry strategies

🔄 Migration from Workflow

If you're migrating from the manual workflow approach:

Old Workflow (5 nodes)

Trigger → Settings → Chunking → Allocation → HTTP Updates

New Node (1 node)

Trigger → Notion Overlimit Writer

Configuration Mapping

Workflow Setting	Node Parameter
`input_field`	Content Field
`output_field`	Output Properties
`page_id`	Page ID
Hardcoded chunks	Chunk Size
Greedy logic	Allocation Strategy

🧪 Testing

# Run tests
npm test

# Run tests with coverage
npm run test:coverage

# Run tests in watch mode
npm run test:watch

🛠️ Development

# Clone repository
git clone https://github.com/yourusername/n8n-nodes-notion-overlimit-writer.git
cd n8n-nodes-notion-overlimit-writer

# Install dependencies
npm install

# Build the node
npm run build

# Run in development mode
npm run dev

# Lint code
npm run lint

# Format code
npm run format

📈 Performance

Small Content (<10K chars): ~200ms execution time
Medium Content (50K chars): ~500ms execution time
Large Content (200K+ chars): ~1-2s execution time
Parallel Updates: 2-3x faster than sequential
Memory Usage: Minimal, processes content in chunks

🤝 Contributing

Fork the repository
Create a feature branch: git checkout -b feature/amazing-feature
Make your changes and add tests
Ensure tests pass: npm test
Commit changes: git commit -m 'Add amazing feature'
Push to branch: git push origin feature/amazing-feature
Open a Pull Request

🔧 Troubleshooting

Property Management Issues (v2.6.0+)

Renamed Properties Not Working

Problem: You renamed properties in Notion but the node shows old names or fails to update them.

Solution: The node now uses property IDs for robust operation:

For v2.6.0+: Property names are resolved automatically - your workflows should continue working
For older versions: You'll need to refresh/reconfigure your property selections

Property Dropdown Shows Old Names

Problem: Property dropdowns in the node UI still show old property names after renaming in Notion.

Solutions:

v2.6.0+: This issue is resolved - the node fetches fresh property names on each execution
Older versions: Try refreshing the node configuration or reconnecting your Notion credentials

"Property ID no longer exists" Error

Problem: You get an error saying property IDs don't exist.

Common Causes:

Properties were deleted in Notion database
Database permissions changed
Database structure was modified