The Complete n8n Node Guide: 30 Essential Nodes You Should Know

n8n has over 400 nodes, but you only need to master about 30 to build almost anything. This guide covers the essential nodes by category, with practical examples for each one.

Category 1: Trigger Nodes (How Workflows Start)

Webhook Node

The most flexible trigger. Creates a URL that external services can call.

// Receiving a POST request:
// Your webhook URL: https://your-n8n.com/webhook/test

// Response configuration:
// Respond Immediately (for fast APIs)
// Respond After Last Node (when you need to process first)
// Using Respond to Webhook node (custom responses)

Common uses: Form submissions, Stripe events, GitHub webhooks, custom integrations.

Schedule Trigger

Run workflows on a timer.

Options:
• Every X minutes/hours
• At specific times (8 AM, 5 PM)
• Custom cron: 0 9 * * 1-5 (weekdays at 9 AM)
• Every X days at Y time

Common uses: Daily reports, data sync, cleanup tasks, recurring checks.

Cron Trigger

Advanced schedule with cron syntax:

# Every hour
0 * * * *

# Every weekday at 9 AM
0 9 * * 1-5

# Every Monday at midnight
0 0 * * 1

# First day of each month
0 0 1 * *

# Every 15 minutes
*/15 * * * *

Email Trigger (IMAP)

Trigger on new emails matching criteria.

Configuration:
• Host: imap.gmail.com (or your provider)
• Port: 993
• Format: Resolved (parsed HTML) or Raw
• Filters: From, Subject, Has attachment, Read/Unread

RSS Feed Trigger

Monitor blogs and news for new posts.

// Monitor multiple feeds
const feeds = [
  'https://blog.example.com/feed.xml',
  'https://news.site.com/rss'
];

// Filter by keywords
// Only trigger if title contains "n8n" or "automation"

Category 2: Communication Nodes

Slack Node

// Send message to channel
slack.sendMessage({
  channel: '#general',
  text: `New user signed up: ${name} (${email})`
});

// Send direct message
slack.sendDirectMessage({
  user: 'U123456',
  text: 'Your report is ready!'
});

// Create channel
slack.createChannel({
  name: 'project-alpha-updates',
  is_private: false
});

Gmail Node

// Send email
gmail.send({
  to: '[email protected]',
  subject: 'Your order confirmation',
  body: '<h1>Thank you!</h1><p>Your order is confirmed.</p>',
  html: true,
  attachments: fileData
});

// Read emails
gmail.read({
  query: 'from:[email protected] is:unread',
  limit: 10
});

// Reply to thread
gmail.reply({
  threadId: 'abc123',
  body: 'Got it, working on this now.'
});

Telegram Node

// Send message
telegram.sendMessage({
  chatId: '-10012345',
  text: '🔔 Alert: Server CPU at 95%',
  parseMode: 'Markdown'
});

// Send photo with caption
telegram.sendPhoto({
  chatId: '-10012345',
  photo: imageUrl,
  caption: 'Daily dashboard screenshot'
});

Discord Node

// Send webhook message
discord.send({
  content: '🚀 New deployment to production!',
  embeds: [{
    title: 'Deploy v2.3.1',
    description: 'Fixed login bug, added dark mode',
    color: 0x00ff00,
    fields: [
      { name: 'Environment', value: 'Production', inline: true },
      { name: 'Deployed by', value: 'CI/CD', inline: true }
    ]
  }]
});

Category 3: Data Nodes

Google Sheets Node

// Read sheet data
const rows = await sheets.read({
  spreadsheetId: 'abc123',
  range: 'Sheet1!A1:Z1000'
});

// Append row
await sheets.append({
  spreadsheetId: 'abc123',
  range: 'Sheet1!A:C',
  values: [[name, email, date]]
});

// Update cell
await sheets.update({
  spreadsheetId: 'abc123',
  range: 'Sheet1!D2',
  values: [['Processed']]
});

Notion Node

// Create database page
await notion.createPage({
  databaseId: 'abc123',
  properties: {
    Name: { title: [{ text: { content: 'New Task' } }] },
    Status: { select: { name: 'In Progress' } },
    Priority: { select: { name: 'High' } },
    Due: { date: { start: '2025-12-31' } }
  }
});

// Query database
const tasks = await notion.query({
  databaseId: 'abc123',
  filter: {
    property: 'Status',
    select: { equals: 'Not Started' }
  }
});

Airtable Node

// List records
const leads = await airtable.list({
  baseId: 'appXYZ',
  tableId: 'Leads',
  filterByFormula: '{Score} > 80'
});

// Create record
await airtable.create({
  baseId: 'appXYZ',
  tableId: 'Leads',
  fields: {
    Name: 'Jane Smith',
    Email: '[email protected]',
    Source: 'Website Form',
    Score: 85
  }
});

Database Nodes (PostgreSQL, MySQL, MongoDB)

// PostgreSQL - Query
const users = await pg.query(
  'SELECT * FROM users WHERE created_at > $1',
  [sevenDaysAgo]
);

// MongoDB - Find
const orders = await mongo.find('orders', {
  status: 'pending',
  created_at: { $gte: yesterday }
});

// Execute raw SQL with parameters (always use parameterized queries!)
const result = await db.execute(
  'INSERT INTO events (type, data, created_at) VALUES ($1, $2, NOW())',
  ['user_signup', JSON.stringify(userData)]
);

Category 4: AI and Machine Learning Nodes

OpenAI Node

// Chat completion
const response = await openai.chat({
  model: 'gpt-4o',
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'Summarize this article: ' + articleText }
  ],
  temperature: 0.3,
  max_tokens: 500
});

// Image generation
const image = await openai.generateImage({
  prompt: 'A professional blog header image about workflow automation',
  size: '1792x1024',
  quality: 'hd'
});

// Embeddings (for RAG/search)
const embedding = await openai.createEmbedding({
  model: 'text-embedding-3-small',
  input: documentText
});

Anthropic Claude Node

// Claude excels at long-form content and analysis
const analysis = await claude.complete({
  model: 'claude-3-5-sonnet-20241022',
  messages: [{
    role: 'user',
    content: 'Analyze this customer feedback and categorize by sentiment and topic.'
  }],
  max_tokens: 2000
});

Google AI (Gemini) Node

// Gemini for multimodal analysis
const analysis = await gemini.analyze({
  model: 'gemini-1.5-pro',
  contents: [{
    parts: [
      { text: 'What does this screenshot show?' },
      { inline_data: { mime_type: 'image/png', data: imageBase64 } }
    ]
  }]
});

Pinecone / Qdrant (Vector Databases)

// Store embeddings for semantic search
await pinecone.upsert({
  index: 'knowledge-base',
  vectors: [{
    id: 'doc-123',
    values: embedding,
    metadata: { title: 'How to install n8n', category: 'docs' }
  }]
});

// Semantic search
const results = await pinecone.query({
  index: 'knowledge-base',
  vector: queryEmbedding,
  topK: 5,
  includeMetadata: true
});

Category 5: Logic and Flow Control

IF Node

Branch your workflow based on conditions:

// Single condition
IF: {{ $json.amount > 1000 }}
  → true: Process as large order
  → false: Process as standard order

// Multiple conditions
IF: {{ $json.country === 'US' && $json.amount > 500 }}
  → true: US enterprise routing
  → false: Standard routing

Switch Node

Route to multiple paths based on value:

Switch on: {{ $json.priority }}
  → "critical": Page on-call
  → "high": Email team
  → "medium": Create ticket
  → "low": Add to backlog
  → Default: Log and ignore

Code Node

Run custom JavaScript or Python:

// JavaScript
const items = $input.all();
const result = items
  .filter(item => item.json.status === 'active')
  .map(item => ({
    json: {
      id: item.json.id,
      name: item.json.name.toUpperCase(),
      revenue: item.json.orders * item.json.avg_value
    }
  }))
  .sort((a, b) => b.json.revenue - a.json.revenue);

return result;

// Python
items = _input.all()
result = []
for item in items:
    data = item['json']
    if data['status'] == 'active':
        result.append({
            'json': {
                'id': data['id'],
                'name': data['name'].upper(),
                'revenue': data['orders'] * data['avg_value']
            }
        })
return result

Loop Over Items

Process each item individually:

Loop node processes:
Item 1 → Transform → Save
Item 2 → Transform → Save
Item 3 → Transform → Save
...

// In loop, reference current item:
{{ $json.email }}
{{ $json.name }}

Merge Node

Combine data from multiple branches:

Branch A → [User Data]
Branch B → [Order Data]
           ↓
         Merge
           ↓
    { user: ..., order: ... }

Category 6: Utility Nodes

HTTP Request Node

Call any REST API:

// GET request
const data = await $http.get('https://api.example.com/data', {
  headers: { 'Authorization': 'Bearer token123' },
  params: { limit: 50, offset: 0 }
});

// POST request
const response = await $http.post('https://api.example.com/create', {
  headers: { 'Content-Type': 'application/json' },
  body: { name: 'Test', value: 123 }
});

// Handle pagination
// Enable "Pagination" in node settings
// Set: Next Page URL expression

Date & Time Node

Manipulate dates easily:

// Format current date
{{ $now.format('YYYY-MM-DD') }}

// Add/subtract time
{{ $now.plus(7, 'days').format('YYYY-MM-DD') }}
{{ $now.minus(1, 'month').format('MMMM YYYY') }}

// Parse custom date
{{ DateTime.fromFormat('01/15/2025', 'MM/dd/yyyy') }}

// Calculate difference
{{ date1.diff(date2, 'days').days }}

Crypto Node

Hash, encrypt, and sign data:

// Hash
{{ $crypto.hash('sha256', $json.data) }}

// HMAC (for webhook verification)
{{ $crypto.hmac('sha256', $json.payload, secretKey) }}

// Random token generation
{{ $crypto.randomString(32) }}

Compression Node

Compress/decompress data:

// Compress large payloads
{{ $compression.gzip($json.largeData) }}

// Decompress
{{ $compression.gunzip($json.compressedData) }}

Node Organization Best Practices

Sticky Notes

Use sticky notes (Ctrl+Shift+N) to document sections:

╔══════════════════════════════╗
║ DATA INGESTION              ║
║ Handles all incoming data   ║
║ from API, forms, and email  ║
╚══════════════════════════════╝

Color Coding

🟢 Green: Triggers and inputs
🔵 Blue: Processing and transformation
🟡 Yellow: Logic and routing
🔴 Red: Error handling
🟣 Purple: AI/ML nodes

Sub-Workflows

For complex logic, extract into sub-workflows:

Main Workflow:
  [Trigger] → [Validate] → [Execute Sub-Workflow] → [Notify]

Sub-Workflow (enrich-user-data):
  [Input] → [Clearbit] → [Apollo] → [Format] → [Output]

Call with: $executeWorkflow('enrich-user-data', { email: lead.email })

Next Steps

Bookmark this guide as a reference
For each category, try building a simple workflow with one node
Combine nodes to create compound workflows
Explore the complete node library
Import templates from our workflow collection

Want practical examples? Browse our tutorial collection or premium templates with production-ready node configurations.