Learn n8n Automation for Free - 100 Essential Nodes Tutorial

Complete n8n Learning Path

Our comprehensive guide includes 100 carefully documented n8n nodes covering everything from basic webhooks and HTTP requests to advanced AI agents and LLM integrations. Each node includes detailed parameter documentation, practical examples, use cases, pro tips, and links to official documentation.

Node Categories

Trigger Nodes

Start workflows automatically with webhooks, schedules, or events from 100+ apps. Learn Webhook, Schedule Trigger, MQTT Trigger, RabbitMQ, Kafka, and more.

Core Nodes

The essential building blocks of any workflow. Master HTTP Request, IF, Switch, Set, Code, Merge, Wait, and other fundamental nodes.

Data Transformation Nodes

Transform, filter, merge, and shape data exactly how you need it. Learn Aggregate, Sort, Limit, Filter, Split Out, Remove Duplicates, and more.

Integration Nodes

Connect to 100+ apps and services. Gmail, Slack, Discord, Google Sheets, Airtable, Notion, HubSpot, Salesforce, Stripe, Shopify, and many more.

AI & LLM Nodes

Build AI agents, RAG systems, and LLM-powered workflows. OpenAI, Claude, Gemini, Ollama, Hugging Face, embeddings, vector stores, and AI tools.

Advanced Nodes

Master complex automation scenarios. Execute Command, SSH, GraphQL, MQTT, Kafka, AWS Lambda, and n8n's own management nodes.

All 100 n8n Nodes - Complete Documentation

Below you'll find the complete documentation of all 100 nodes, including parameters, credentials, examples, use cases, and pro tips.

GET request to fetch user data:
URL: https://api.example.com/users/{{$json.userId}}
Method: GET
Authentication: Bearer Token
Headers: {'Accept': 'application/json'}

Receiving Stripe payment events:
Path: /stripe-webhook
Method: POST
Authentication: Header Auth (using Stripe signature)
Response Mode: Respond immediately

Check if order amount exceeds $100:
Value 1: {{$json.orderAmount}}
Operation: Greater Than
Value 2: 100

True → Send VIP notification
False → Send standard confirmation

Prepare data for API call:
Field 1: fullName = {{$json.firstName}} {{$json.lastName}}
Field 2: emailAddress = {{$json.email.toLowerCase()}}
Field 3: timestamp = {{Date.now()}}
Field 4: status = 'active'

JavaScript - Transform and filter data:

const results = [];
for (const item of $input.all()) {
  if (item.json.status === 'active') {
    results.push({
      json: {
        id: item.json.id,
        name: item.json.name.toUpperCase(),
        createdAt: new Date().toISOString()
      }
    });
  }
}
return results;

Daily report at 9 AM:
Trigger Interval: Days
Trigger at Hour: 9
Trigger at Minute: 0

Or using Cron: 0 9 * * * (every day at 9:00 AM)

Merge user data with order data:
Mode: Merge by Key
Input 1 Property: userId
Input 2 Property: customerId

Result: Combined records where userId matches customerId

Route orders by status:
Rule 1: status equals 'pending' → Output 0
Rule 2: status equals 'processing' → Output 1
Rule 3: status equals 'shipped' → Output 2
Fallback → Output 3 (handle unknown statuses)

Process 100 records in batches of 10:
Batch Size: 10

First iteration: items 1-10
Second iteration: items 11-20
... and so on
After all: Continues from 'Done' output

Wait 5 seconds between API calls:
Resume: After Time Interval
Wait Amount: 5
Wait Unit: Seconds

Rename API response fields:
Operation: Rename Keys
user_name → name
email_address → email
created_at → createdAt

Keep only active premium users:
Condition 1: status equals 'active' AND
Condition 2: plan equals 'premium'

Result: Only items matching both conditions pass through

Calculate sales summary:
Field: amount → Sum (Total Sales)
Field: orderId → Count (Number of Orders)
Field: amount → Average (Average Order Value)

Sort orders by priority then date:
Field 1: priority (Number, Descending) - high priority first
Field 2: createdAt (Date, Ascending) - oldest first within same priority

Get top 10 highest-value orders:
1. Sort by orderValue descending
2. Limit to 10 items (First items)

Remove duplicate email entries:
Compare: Selected Fields
Fields: email
Keep: First occurrence

Result: Only unique emails remain

Split order items:
Input: { orderId: 123, items: ['A', 'B', 'C'] }
Field to Split: items

Output: 3 items, each with orderId and one item value

Return processed data:
Response Code: 200
Response Body: {
  'success': true,
  'processedId': '{{$json.id}}',
  'timestamp': '{{$now}}'
}

Modular order processing:
Main workflow: Receive order → Execute 'Validate Order' workflow → Execute 'Process Payment' workflow → Execute 'Send Notification' workflow

Use case: Debug point in workflow
Node before → NoOp (click to inspect data) → Node after

Send HTML email with dynamic content:
Resource: Message
Operation: Send
To: {{$json.customerEmail}}
Subject: Order #{{$json.orderId}} Confirmation
Email Type: HTML
Message: <h1>Thank you!</h1><p>Your order is confirmed.</p>

Post alert to channel:
Resource: Message
Operation: Post
Channel: #alerts
Text: :warning: *Alert*: {{$json.alertType}}\n{{$json.message}}

Send webhook message:
Webhook URL: https://discord.com/api/webhooks/...
Content: New deployment completed! :rocket:
Username: Deploy Bot

Send formatted message:
Operation: Send Message
Chat ID: {{$json.userId}}
Text: *Order Update*\nYour order #{{$json.orderId}} has shipped!
Parse Mode: Markdown

Post channel message:
Resource: Message
Operation: Send
Team: Development
Channel: General
Message: Build #{{$json.buildNumber}} completed successfully! :white_check_mark:

Send template email:
Resource: Email
Operation: Send
From: noreply@company.com
To: {{$json.email}}
Dynamic Template ID: d-xxxx
Template Data: { 'firstName': '{{$json.name}}', 'orderTotal': '{{$json.total}}' }

Send SMS notification:
Resource: SMS
Operation: Send
From: +15551234567
To: {{$json.phoneNumber}}
Body: Your verification code is {{$json.code}}

Send template message:
Resource: Template
Operation: Send
Recipient: +1234567890
Template Name: order_confirmation
Template Variables: [orderId, total]

Append new lead:
Operation: Append Row
Document ID: (from spreadsheet URL)
Sheet: Leads
Values: Name = {{$json.name}}, Email = {{$json.email}}, Date = {{$now}}

Create new record:
Operation: Create
Base: appXXXXXX
Table: Contacts
Fields: Name = {{$json.name}}, Email = {{$json.email}}, Status = 'New'

Create database entry:
Resource: Database
Operation: Append
Database ID: (from database URL)
Properties: Title = {{$json.name}}, Status = 'In Progress', Due Date = {{$json.dueDate}}

Create support ticket card:
Resource: Card
Operation: Create
List ID: {{$json.supportListId}}
Name: Support: {{$json.subject}}
Description: From: {{$json.email}}\n\n{{$json.message}}

Create bug from alert:
Resource: Issue
Operation: Create
Project: PROJ
Issue Type: Bug
Summary: [Auto] {{$json.alertTitle}}
Description: Alert triggered at {{$json.timestamp}}\n\n{{$json.details}}
Priority: High

Create issue from bug report:
Resource: Issue
Operation: Create
Owner: myorg
Repository: myrepo
Title: Bug: {{$json.title}}
Body: Reported by: {{$json.reporter}}\n\n{{$json.description}}
Labels: ['bug', 'needs-triage']

Create deployment issue:
Resource: Issue
Operation: Create
Project: group/project
Title: Deploy: {{$json.version}}
Description: Deployment scheduled for {{$json.deployTime}}
Labels: deployment, production

Create customer and subscription:
1. Create Customer: email = {{$json.email}}, name = {{$json.name}}
2. Create Subscription: customer = {{$json.customerId}}, price = price_xxx

Fulfill order:
Resource: Order
Operation: Update
Order ID: {{$json.orderId}}
Fulfillment Status: fulfilled
Tracking Number: {{$json.tracking}}

Create or update contact:
Resource: Contact
Operation: Upsert
Email: {{$json.email}}
Properties: firstname = {{$json.firstName}}, lastname = {{$json.lastName}}, company = {{$json.company}}

Create lead from form:
Resource: Lead
Operation: Create
Company: {{$json.company}}
LastName: {{$json.lastName}}
Email: {{$json.email}}
Lead Source: Web Form

Create support ticket:
Resource: Ticket
Operation: Create
Subject: {{$json.subject}}
Description: {{$json.message}}
Requester Email: {{$json.email}}
Priority: Normal
Type: Question

Insert record:
Operation: Insert
Table: users
Columns: name, email, created_at
Values from: {{$json.name}}, {{$json.email}}, {{$now}}

Query with parameters:
Operation: Execute Query
Query: SELECT * FROM orders WHERE customer_id = ? AND status = ?
Query Parameters: {{$json.customerId}}, 'pending'

Find documents with filter:
Operation: Find
Collection: products
Query: { 'category': '{{$json.category}}', 'price': { '$lte': 100 } }
Limit: 50
Sort: { 'createdAt': -1 }

Cache API response:
Operation: Set
Key: api_cache:{{$json.endpoint}}
Value: {{JSON.stringify($json.data)}}
Expire: 3600

Upload file to S3:
Operation: Upload
Bucket: my-bucket
File Name: uploads/{{$json.fileName}}
Binary Property: data
ACL: public-read

Upload and share report:
1. Upload: Binary data, Name = report-{{$now.format('YYYY-MM-DD')}}.pdf
2. Share: File ID = {{$json.id}}, Email = {{$json.recipientEmail}}, Role = reader

Backup to Dropbox:
Operation: Upload
Path: /backups/data-{{$now.format('YYYY-MM-DD')}}.json
Binary Property: data

Download latest file:
Operation: List
Path: /incoming
→ Filter most recent
→ Download: path = {{$json.path}}

Write log file:
Operation: Write
File Path: /data/logs/process-{{$now.format('YYYY-MM-DD')}}.log
Text: {{$now}} - {{$json.message}}\n
Append: true

Read Excel file:
Operation: Read from File
Binary Property: data
File Format: xlsx
Header Row: true
Sheet: Sheet1

Parse XML API response:
Mode: XML to JSON
Property Name: data
Options: Explicit Array = false

Extract product prices:
Operation: Extract HTML Content
Source: {{$json.html}}
Extractions:
  - CSS Selector: .product-price
    Attribute: text
    Key: price

Convert Markdown to HTML email:
Mode: Markdown to HTML
Markdown: # Order Confirmed\n\nYour order **#{{$json.orderId}}** has been confirmed.

Verify webhook signature:
Action: Hmac
Type: SHA256
Value: {{$json.body}}
Secret: {{$env.WEBHOOK_SECRET}}
Encoding: hex
→ Compare with received signature

Calculate due date:
Operation: Add to Date
Date: {{$now}}
Duration: 7
Unit: days

Format result:
Operation: Format Date
Format: YYYY-MM-DD

Generate product description:
Resource: Chat
Model: gpt-4-turbo
System: You are a marketing copywriter.
User: Write a compelling 100-word description for: {{$json.productName}}
Temperature: 0.7

Analyze customer feedback:
Model: claude-3-sonnet
System: You are a customer insights analyst.
User: Analyze this feedback and identify key themes: {{$json.feedback}}

Analyze image and describe:
Model: gemini-pro-vision
Messages: What's in this image? Describe in detail.
Image: {{$binary.data}}

Research agent:
Agent Type: ReAct
System: You are a research assistant. Use tools to find and summarize information.
Tools: Wikipedia, Web Search, Calculator
Max Iterations: 10

Categorize support tickets:
Prompt: Categorize this support ticket into one of: billing, technical, account, other.\n\nTicket: {{$json.message}}\n\nCategory:
Model: GPT-4
Output: Structured parser for category

Document Q&A:
Question: {{$json.question}}
Retriever: Pinecone vector store
Model: GPT-4
Return Source: true

Chunk PDF for embedding:
Chunk Size: 1000
Chunk Overlap: 200
Separator: \n\n (paragraphs)

Create embeddings for documents:
Model: text-embedding-3-small
Input: {{$json.text}}
→ Store in vector database

Query similar documents:
Mode: Get Many
Index: knowledge-base
Query: {{$json.question}}
Top K: 5

Chatbot with memory:
Session ID: {{$json.userId}}
Window Length: 10
→ Connect to AI Agent/Chain

Parse product details:
Type: Structured
Schema: { name: string, price: number, description: string }
→ LLM outputs valid JSON

Summarize meeting transcript:
Type: Map Reduce
Document: {{$json.transcript}}
Model: GPT-4
Output: Executive summary with key decisions

Analyze customer review:
Text: {{$json.review}}
Output: { sentiment: 'positive', score: 0.85, confidence: 0.92 }

Agent uses Wikipedia:
Query: Albert Einstein contributions to physics
Top K: 3
→ Returns Wikipedia summaries

Agent uses Calculator:
Expression: (150 * 12) + (75 * 0.15)
→ Returns: 1811.25

Agent analyzes data:
Input: CSV data
Action: Agent writes Python to analyze, create charts
Output: Analysis results and visualizations

Agent researches topic:
Query: latest AI developments 2024
→ Returns current search results

Custom database lookup tool:
Name: CustomerLookup
Description: Retrieves customer information by email
Workflow: customer-lookup-workflow
Input: { email: string }

Local code assistant:
Model: codellama
Prompt: Explain this Python code: {{$json.code}}
Temperature: 0.3

Translation with mBART:
Model: facebook/mbart-large-50-many-to-many-mmt
Task: Translation
Input: {{$json.text}}
Source Language: English
Target Language: French

Error notification workflow:
Error Trigger → Parse error details → Send Slack alert with workflow name and error message

Generate PDF report:
Command: wkhtmltopdf {{$json.htmlPath}} /tmp/report-{{$json.id}}.pdf
Timeout: 30000

Deploy update to server:
Operation: Execute Command
Command: cd /app && git pull && pm2 restart all

Query GitHub GraphQL:
Endpoint: https://api.github.com/graphql
Query: query { viewer { login repositories(first: 5) { nodes { name } } } }
Headers: Authorization: Bearer {{$env.GITHUB_TOKEN}}

IoT sensor data:
Topics: sensors/+/temperature, sensors/+/humidity
QoS: 1
→ Process sensor readings

Process background jobs:
Queue: email-jobs
Acknowledge: After successful processing
Parallel: 5 concurrent messages

Event streaming:
Topic: user-events
Group ID: n8n-processor
From Beginning: false
→ Process user activity events

S3 event notification:
Topic: arn:aws:sns:us-east-1:123456789:s3-events
→ Trigger on file uploads

Invoke image processor:
Function: image-thumbnail-generator
Payload: { 's3Key': '{{$json.key}}', 'bucket': '{{$json.bucket}}' }
Invocation: Request-Response

Invoke processing function:
Project: my-project
Region: us-central1
Function: process-document
Body: { 'documentUrl': '{{$json.url}}' }

Create bug from alert:
Resource: Issue
Operation: Create
Team: Engineering
Title: [Alert] {{$json.alertName}}
Description: {{$json.details}}
Priority: Urgent

Create task from form:
Resource: Task
Operation: Create
Project: {{$json.projectId}}
Name: {{$json.taskTitle}}
Assignee: {{$json.assigneeEmail}}
Due Date: {{$json.dueDate}}

Create task with checklist:
Resource: Task
Operation: Create
List: {{$json.listId}}
Name: Review: {{$json.documentTitle}}
Priority: High
Due Date: {{$json.deadline}}

Create item from lead:
Resource: Board Item
Operation: Create
Board: CRM Board
Group: New Leads
Name: {{$json.companyName}}
Column Values: { 'email': '{{$json.email}}', 'phone': '{{$json.phone}}' }

Add daily task:
Resource: Task
Operation: Create
Project: Work
Content: Review inbox and respond to emails
Priority: 2
Due: today

New booking workflow:
Calendly Webhook (booking created) → Get event details → Create CRM contact → Send confirmation email

Schedule meeting:
Operation: Create
Calendar: primary
Title: Team Standup
Start: {{$json.meetingTime}}
Duration: 30 minutes
Attendees: team@company.com

Publish blog post:
Resource: Item
Operation: Create
Collection: Blog Posts
Fields: title = {{$json.title}}, content = {{$json.content}}, publish-date = {{$now}}
Live: true

Auto-publish article:
Resource: Post
Operation: Create
Title: {{$json.title}}
Content: {{$json.htmlContent}}
Status: publish
Categories: [{{$json.categoryId}}]

Add subscriber:
Resource: Member
Operation: Upsert
List: {{$json.listId}}
Email: {{$json.email}}
Status: subscribed
Merge Fields: FNAME = {{$json.firstName}}, LNAME = {{$json.lastName}}

Add lead to sequence:
Resource: Subscriber
Operation: Add to Sequence
Email: {{$json.email}}
First Name: {{$json.firstName}}
Sequence: Welcome Sequence

Complex schedule:
- Weekdays at 9am: 0 9 * * 1-5
- First Monday monthly: 0 10 1-7 * 1
- Every 15 minutes: */15 * * * *

Transform items:
return items.map(item => {
  return {
    json: {
      fullName: item.json.first + ' ' + item.json.last,
      email: item.json.email.toLowerCase()
    }
  };
});

Document workflow section:
## Data Validation
This section validates incoming data:
- Checks required fields
- Validates email format
- Filters duplicates

Monitor failed executions:
Resource: Execution
Operation: Get Many
Status: error
Limit: 10
→ Send alerts for failures

Key Learning Outcomes

• Understanding n8n's workflow automation architecture
• Building trigger-based automations with webhooks and schedules
• Making HTTP requests and working with REST APIs
• Implementing conditional logic with IF and Switch nodes
• Transforming and manipulating data efficiently
• Connecting to popular apps and services
• Building AI-powered workflows with LLM integration
• Creating reusable sub-workflows and error handling
• Working with databases, files, and cloud storage
• Scaling automations for production use

Who This Tutorial Is For

• Complete beginners wanting to learn workflow automation
• Professionals looking to automate repetitive tasks
• Developers building integrations and automations
• Business owners streamlining operations
• Marketers automating campaigns and workflows
• Data analysts building data pipelines
• DevOps engineers implementing CI/CD automation
• Anyone wanting to leverage no-code/low-code automation

Get Started with n8n

n8n is free to use with their cloud platform or self-hosted option. Start building powerful automations today:

• n8n Cloud - Start Free
• Official n8n Documentation
• n8n Community Forum