Action Nodes

Action nodes process data, interact with external services, and implement workflow logic. They form the core of your automation workflows, transforming inputs into meaningful outputs.

Action Node Categories

Data Transformation

Manipulate, filter, and reshape data

API Operations

Interact with external services

Flow Control

Route and control workflow execution

Data Transformation Nodes

Transform data without writing code - these nodes provide powerful manipulation capabilities through intuitive interfaces.

Set (Edit Fields)

The primary node for data manipulation - add, remove, rename, and transform fields.

Overview
Examples
Use Cases

Operations:

Add/remove fields
Rename fields
Set values with expressions
Include/exclude fields
Keep only specific fields

Modes:

Manual - Define fields explicitly
Expression - Use code for field mapping
Include - Specify fields to keep
Exclude - Remove specific fields

When to Use:

Rename fields for consistency
Add calculated fields
Clean up data structure
Prepare data for next node
Type conversions

Add Calculated Fields:

{
  "mode": "manual",
  "fields": {
    "values": [
      {
        "name": "fullName",
        "type": "stringValue",
        "stringValue": "={{ $json.firstName }} {{ $json.lastName }}"
      },
      {
        "name": "age",
        "type": "numberValue",
        "numberValue": "={{ $now.year() - $json.birthYear }}"
      },
      {
        "name": "isPremium",
        "type": "booleanValue",
        "booleanValue": "={{ $json.subscriptionTier === 'premium' }}"
      }
    ]
  }
}

Rename and Transform:

{
  "mode": "manual",
  "fields": {
    "values": [
      {
        "name": "email",
        "type": "stringValue",
        "stringValue": "={{ $json.email_address.toLowerCase().trim() }}"
      },
      {
        "name": "createdDate",
        "type": "stringValue",
        "stringValue": "={{ $json.created_at.toDate().format('yyyy-MM-dd') }}"
      }
    ]
  },
  "options": {
    "dotNotation": true
  }
}

Keep Only Specific Fields:

{
  "mode": "include",
  "include": "selectedFields",
  "includeFields": "id, name, email, status"
}

Remove Sensitive Data:

{
  "mode": "exclude",
  "exclude": "selectedFields",
  "excludeFields": "password, ssn, creditCard"
}

Filter

Keep or remove items based on conditions - essential for data quality and routing.

Conditions
Examples
Best Practices

Comparison Operators:

String: equals, not equals, contains, not contains, starts with, ends with, regex
Number: equals, not equals, larger, smaller, larger or equal, smaller or equal
Boolean: true, false, equals
Date: equals, after, before, after or equal, before or equal
Array: contains, not contains, length equals, is empty, is not empty
Exists: is empty, is not empty, exists, does not exist

Logical Combinators:

AND - All conditions must match
OR - Any condition must match

Example - Complex Filter:

{
  "conditions": {
    "combinator": "and",
    "conditions": [
      {
        "leftValue": "={{ $json.status }}",
        "operator": "equals",
        "rightValue": "active"
      },
      {
        "leftValue": "={{ $json.amount }}",
        "operator": "gt",
        "rightValue": 100
      },
      {
        "leftValue": "={{ $json.email }}",
        "operator": "contains",
        "rightValue": "@company.com"
      }
    ]
  }
}

Filter Active Users:

{
  "conditions": {
    "conditions": [
      {
        "leftValue": "={{ $json.status }}",
        "operator": "equals",
        "rightValue": "active"
      },
      {
        "leftValue": "={{ $json.lastLoginDate }}",
        "operator": "after",
        "rightValue": "={{ $now.minus(30, 'days') }}"
      }
    ],
    "combinator": "and"
  }
}

Filter by Email Domain:

{
  "conditions": {
    "conditions": [
      {
        "leftValue": "={{ $json.email }}",
        "operator": "regex",
        "rightValue": ".*@(company\\.com|partner\\.com)$"
      }
    ]
  }
}

Filter Empty Values:

{
  "conditions": {
    "conditions": [
      {
        "leftValue": "={{ $json.description }}",
        "operator": "isNotEmpty"
      },
      {
        "leftValue": "={{ $json.tags }}",
        "operator": "isNotEmpty"
      }
    ],
    "combinator": "and"
  }
}

Date Range Filter:

{
  "conditions": {
    "conditions": [
      {
        "leftValue": "={{ $json.date }}",
        "operator": "afterOrEqual",
        "rightValue": "2024-01-01"
      },
      {
        "leftValue": "={{ $json.date }}",
        "operator": "before",
        "rightValue": "2024-12-31"
      }
    ],
    "combinator": "and"
  }
}

Transform Nodes Collection

Aggregate

Purpose: Combine multiple items into a single item with aggregated values.Operations:

Sum, average, min, max
Count items
Concatenate strings
Collect arrays
Group by fields

Example - Sum by Category:

{
  "aggregate": "aggregateIndividualFields",
  "fieldsToAggregate": {
    "values": [
      {
        "fieldToAggregate": "amount",
        "operation": "sum",
        "outputFieldName": "totalAmount"
      },
      {
        "fieldToAggregate": "id",
        "operation": "count",
        "outputFieldName": "itemCount"
      }
    ]
  },
  "options": {
    "groupBy": "category"
  }
}

Use Cases:

Calculate totals
Generate statistics
Count occurrences
Group data

Split Out

Purpose: Split arrays into separate items - opposite of aggregation.Example:Input:

{
  "orders": [
    { "id": 1, "product": "A" },
    { "id": 2, "product": "B" }
  ]
}

Configuration:

{
  "fieldToSplitOut": "orders",
  "options": {
    "include": "selectedOtherFields",
    "includeFields": "customerId, date"
  }
}

Output:

{ "id": 1, "product": "A", "customerId": "123" }
{ "id": 2, "product": "B", "customerId": "123" }

Use Cases:

Process array items individually
Flatten nested data
Loop over items

Sort

Purpose: Order items by field values.Configuration:

{
  "sortFieldsUi": {
    "sortField": [
      {
        "fieldName": "date",
        "order": "descending"
      },
      {
        "fieldName": "amount",
        "order": "ascending"
      }
    ]
  }
}

Features:

Multiple sort fields
Ascending/descending
Type-aware sorting
Null handling

Use Cases:

Order by date
Prioritize items
Rank results

Limit

Purpose: Restrict the number of items returned.Configuration:

{
  "maxItems": 10,
  "keepMissing": false
}

Use Cases:

Take top N results
Pagination
Sample data
Prevent overload

Remove Duplicates

Purpose: Eliminate duplicate items based on field values.Configuration:

{
  "compare": "selectedFields",
  "fieldsToCompare": {
    "fields": [
      { "fieldName": "email" },
      { "fieldName": "userId" }
    ]
  }
}

Options:

All fields
Selected fields
Expression-based

Use Cases:

Deduplicate records
Unique emails
Clean data

Summarize

Purpose: Create pivot tables and data summaries.Configuration:

{
  "aggregate": "aggregateIndividualFields",
  "fieldsToAggregate": {
    "values": [
      {
        "fieldToAggregate": "revenue",
        "operation": "sum"
      }
    ]
  },
  "groupBy": "region, quarter"
}

Use Cases:

Pivot tables
Sales reports
Analytics summaries

Date & Time

DateTime Node

Operations:

Format dates
Calculate date differences
Add/subtract time
Convert timezones
Parse date strings

Examples:Format Date:

{
  "action": "format",
  "date": "={{ $json.createdAt }}",
  "format": "yyyy-MM-dd HH:mm:ss",
  "outputFieldName": "formattedDate"
}

Add Days:

{
  "action": "calculate",
  "date": "={{ $now }}",
  "operation": "add",
  "duration": 7,
  "timeUnit": "days"
}

Calculate Age:

{
  "action": "getTimeBetweenDates",
  "startDate": "={{ $json.birthDate }}",
  "endDate": "={{ $now }}",
  "units": "years"
}

Flow Control Nodes

Control workflow execution path based on conditions and logic.

If Node

Overview
Configuration
Use Cases

Purpose: Route items to True or False branches based on conditions.Outputs:

True - Items that match conditions
False - Items that don’t match

When to Use:

Binary decision points
Conditional routing
Error handling paths
Validation checks

vs. Filter Node:

If - Routes to different paths
Filter - Removes items from single path

Simple Condition:

{
  "conditions": {
    "conditions": [
      {
        "leftValue": "={{ $json.amount }}",
        "operator": "largerOrEqual",
        "rightValue": 1000
      }
    ]
  }
}

Multiple Conditions (AND):

{
  "conditions": {
    "combinator": "and",
    "conditions": [
      {
        "leftValue": "={{ $json.status }}",
        "operator": "equals",
        "rightValue": "pending"
      },
      {
        "leftValue": "={{ $json.priority }}",
        "operator": "equals",
        "rightValue": "high"
      }
    ]
  }
}

Multiple Conditions (OR):

{
  "conditions": {
    "combinator": "or",
    "conditions": [
      {
        "leftValue": "={{ $json.type }}",
        "operator": "equals",
        "rightValue": "urgent"
      },
      {
        "leftValue": "={{ $json.amount }}",
        "operator": "larger",
        "rightValue": 10000
      }
    ]
  }
}

Approval Workflows:

If amount >= 1000:
  True → Send to manager
  False → Auto-approve

Error Handling:

If API call successful:
  True → Continue workflow
  False → Send error notification

Data Validation:

If email is valid:
  True → Add to mailing list
  False → Log invalid entry

Tiered Processing:

If premium customer:
  True → Priority queue
  False → Standard queue

Switch Node

Purpose: Route items to multiple branches based on rules.Configuration:

{
  "mode": "rules",
  "rules": {
    "rules": [
      {
        "output": 0,
        "conditions": {
          "conditions": [
            {
              "leftValue": "={{ $json.priority }}",
              "operator": "equals",
              "rightValue": "urgent"
            }
          ]
        }
      },
      {
        "output": 1,
        "conditions": {
          "conditions": [
            {
              "leftValue": "={{ $json.priority }}",
              "operator": "equals",
              "rightValue": "high"
            }
          ]
        }
      },
      {
        "output": 2,
        "conditions": {
          "conditions": [
            {
              "leftValue": "={{ $json.priority }}",
              "operator": "equals",
              "rightValue": "medium"
            }
          ]
        }
      }
    ]
  },
  "fallbackOutput": 3
}

Use Cases:

Multi-tier routing
Category-based processing
Priority queues
Status-based workflows

Merge Node

Merge Modes
Examples
Use Cases

Append:

Combine all items from all branches
No matching required
Simple concatenation

Keep Key Matches:

Join items with matching field values
Like SQL JOIN
Merge on common key

Merge By Index:

Combine items at same position
Index-based matching
Pair items 1:1

Multiplex:

Create all combinations
Cartesian product
Each item paired with every other

Append All Items:

{
  "mode": "append"
}

Merge by Email:

{
  "mode": "combine",
  "mergeByFields": {
    "values": [
      {
        "field1": "email",
        "field2": "email"
      }
    ]
  },
  "options": {
    "joinMode": "keepMatches"
  }
}

Merge by Index:

{
  "mode": "mergeByPosition",
  "options": {
    "clashHandling": {
      "values": {
        "resolveConflict": "preferInput2"
      }
    }
  }
}

Code Execution Nodes

Use Code nodes as a last resort. Native nodes are faster, more maintainable, and easier to debug.

Code Node

JavaScript
Python
When to Use

Access Input Data:

// Get all items
const items = $input.all();

// Process each item
const results = items.map(item => ({
  json: {
    fullName: `${item.json.firstName} ${item.json.lastName}`,
    email: item.json.email.toLowerCase(),
    timestamp: new Date().toISOString()
  }
}));

return results;

Use Node Context:

// Access workflow data
const workflowData = $workflow.staticData;

// Get execution context
const executionId = $execution.id;
const mode = $execution.mode;  // 'manual' or 'trigger'

// Access environment variables
const apiKey = $env.API_KEY;

return $input.all();

Date Manipulation:

// Luxon is available
const { DateTime } = require('luxon');

const items = $input.all();

const processed = items.map(item => ({
  json: {
    ...item.json,
    formattedDate: DateTime.fromISO(item.json.date)
      .setZone('America/New_York')
      .toFormat('yyyy-MM-dd HH:mm:ss')
  }
}));

return processed;

Basic Processing:

import pandas as pd
from datetime import datetime

# Get input items
items = _input.all()

# Convert to DataFrame
data = [item['json'] for item in items]
df = pd.DataFrame(data)

# Process data
df['fullName'] = df['firstName'] + ' ' + df['lastName']
df['email'] = df['email'].str.lower()
df['timestamp'] = datetime.now()

# Return results
return df.to_dict('records')

Data Analysis:

import pandas as pd
import numpy as np

# Load data
items = [item['json'] for item in _input.all()]
df = pd.DataFrame(items)

# Calculate statistics
summary = df.groupby('category').agg({
    'amount': ['sum', 'mean', 'count'],
    'revenue': 'sum'
}).reset_index()

# Convert to records
return summary.to_dict('records')

Utility Nodes

Wait

Purpose: Pause workflow execution for a duration or until a specific time.Configuration:

{
  "unit": "minutes",
  "amount": 5
}

Use Cases:

Rate limiting
Scheduled delays
Cooldown periods
Waiting for async operations

Stop and Error

Purpose: Halt workflow execution with or without error.Configuration:

{
  "errorMessage": "Validation failed: {{ $json.error }}"
}

Use Cases:

Validation failures
Business rule violations
Graceful termination
Error propagation

Execute Workflow

Purpose: Call another workflow from current workflow.Configuration:

{
  "workflowId": "123",
  "waitForWorkflow": true,
  "jsonData": "={{ $json }}"
}

Use Cases:

Reusable sub-workflows
Modular design
Complex orchestration
Workflow composition

NoOp

Purpose: Do nothing - pass data through unchanged.Use Cases:

Workflow documentation
Visual organization
Placeholder for future nodes
Connection point

Sticky Note

Purpose: Add annotations and documentation to canvas.Use Cases:

Document workflow logic
Explain complex sections
Add warnings
Team collaboration notes

File Processing Nodes

Read/Write File

Operations:

Read binary files
Write binary files
Convert to/from base64
Handle file metadata

Example:

{
  "operation": "read",
  "filePath": "/data/reports/{{ $json.filename }}",
  "dataPropertyName": "fileData"
}

Convert to File

Purpose: Convert JSON/text data to file.Configuration:

{
  "operation": "toText",
  "options": {
    "fileName": "report.csv",
    "mimeType": "text/csv"
  }
}

Extract From File

Purpose: Extract data from files (CSV, JSON, XML, PDF).Example:

{
  "operation": "csv",
  "binaryPropertyName": "data",
  "options": {
    "delimiter": ",",
    "headerRow": true
  }
}

Compression

Operations:

Compress files (zip, gzip)
Decompress archives
Multiple file handling

Use Cases:

File archiving
Reduce transfer size
Backup compression

HTTP & API Nodes

HTTP Request

Detailed in Popular Nodes, the HTTP Request node is the most versatile action node for API integration.

GraphQL

GraphQL Node

Purpose: Execute GraphQL queries and mutations.Example Query:

query GetUser($id: ID!) {
  user(id: $id) {
    name
    email
    posts {
      title
      createdAt
    }
  }
}

Configuration:

{
  "operation": "query",
  "query": "...",
  "variables": {
    "id": "={{ $json.userId }}"
  }
}

Best Practices

Performance
Error Handling
Maintainability

Optimize Data Flow:

Filter data early
Use native nodes over Code
Limit API calls
Batch operations when possible

Avoid Bottlenecks:

Don’t process unnecessary fields
Remove unused data
Use Set node to clean up
Consider splitting large workflows

Memory Management:

Limit item count with Limit node
Clear large binary data
Avoid storing full responses

Use Try-Catch Pattern:

Action Node (continueOnFail: true)
  → If (check for error)
    True → Error handling path
    False → Continue workflow

Validate Data:

Use Filter for validation
Check required fields
Verify data types
Handle edge cases

Provide Context:

Log meaningful errors
Include item data in errors
Set error messages in Stop and Error

Next Steps

Trigger Nodes

Learn how to start workflows automatically

Popular Nodes

Explore commonly used integrations

Build Workflows

Create your first automated workflow

Expressions

Master data transformation with expressions

Integration Catalog

AI Integrations

Action Nodes

Action Nodes

Action Node Categories

Data Transformation

API Operations

Flow Control

Data Transformation Nodes

Set (Edit Fields)

Filter

Transform Nodes Collection

Date & Time

DateTime Node

Flow Control Nodes

If Node

Switch Node

Switch Node

Merge Node

Code Execution Nodes

Code Node

Utility Nodes

File Processing Nodes

HTTP & API Nodes

HTTP Request

GraphQL

GraphQL Node

Best Practices

Next Steps

Trigger Nodes

Popular Nodes

Build Workflows

Expressions

Integration Catalog

AI Integrations

​Action Nodes

​Action Node Categories

Data Transformation

API Operations

Flow Control

​Data Transformation Nodes

​Set (Edit Fields)

​Filter

​Transform Nodes Collection

​Date & Time

DateTime Node

​Flow Control Nodes

​If Node

​Switch Node

Switch Node

​Merge Node

​Code Execution Nodes

​Code Node

​Utility Nodes

​File Processing Nodes

​HTTP & API Nodes

​HTTP Request

​GraphQL

GraphQL Node

​Best Practices

​Next Steps

Trigger Nodes

Popular Nodes

Build Workflows

Expressions

Action Nodes

Action Node Categories

Data Transformation Nodes

Set (Edit Fields)

Filter

Transform Nodes Collection

Date & Time

Flow Control Nodes

If Node

Switch Node

Merge Node

Code Execution Nodes

Code Node

Utility Nodes

File Processing Nodes

HTTP & API Nodes

HTTP Request

GraphQL

Best Practices

Next Steps