n8n (n8n-io/n8n-docs)

n8n

https://github.com/n8n-io/n8n-docs
Admin
n8n is an extendable workflow automation tool that connects anything to everything, enabling users...

Tokens:576,097
Snippets:1,389
Trust Score:9.7
Update:1 week ago
Show doc for...
Context Summary (auto-generated)
Raw
# n8n Documentation

n8n (pronounced n-eight-n) is an extendable workflow automation platform that enables you to connect any app with an API with any other, manipulating data with little or no code. It combines AI capabilities with business process automation, offering customizable workflows, the option to build custom nodes, and multiple deployment options including npm, Docker, and Cloud hosting. n8n is fair-code licensed under the Sustainable Use License and can be self-hosted for privacy and security.

The platform uses a node-based architecture where nodes are the building blocks of workflows. Nodes serve as entry points for retrieving data, functions to process data, or exits for sending data. n8n provides built-in integrations for hundreds of services, supports community-built nodes, and offers advanced AI functionality through LangChain integrations for building AI-powered workflows including chatbots and document processing.

## n8n Public REST API

The n8n Public API (v1) provides programmatic access to manage workflows, executions, credentials, users, projects, tags, variables, and data tables. All API requests require authentication via an API key passed in the `X-N8N-API-KEY` header.

### Authentication

All API endpoints require API key authentication via the `X-N8N-API-KEY` header.

```bash
# Set your API key for all requests
export N8N_API_KEY="your-api-key-here"
export N8N_BASE_URL="https://your-instance.app.n8n.cloud/api/v1"

# Example: List all workflows
curl -X GET "$N8N_BASE_URL/workflows" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json"

# Response:
# {
#   "data": [
#     {
#       "id": "2tUt1wbLX592XDdX",
#       "name": "My Workflow",
#       "active": true,
#       "createdAt": "2024-01-15T10:00:00.000Z",
#       "updatedAt": "2024-01-15T12:30:00.000Z"
#     }
#   ],
#   "nextCursor": null
# }
```

### Workflow Management

Create, retrieve, update, delete, publish, and manage workflows. Workflows contain nodes and connections that define automation logic.

```bash
# Create a new workflow
curl -X POST "$N8N_BASE_URL/workflows" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My New Workflow",
    "nodes": [
      {
        "id": "start-node",
        "name": "Start",
        "type": "n8n-nodes-base.start",
        "typeVersion": 1,
        "position": [250, 300],
        "parameters": {}
      },
      {
        "id": "http-node",
        "name": "HTTP Request",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4,
        "position": [450, 300],
        "parameters": {
          "url": "https://api.example.com/data",
          "method": "GET"
        }
      }
    ],
    "connections": {
      "Start": {
        "main": [[{"node": "HTTP Request", "type": "main", "index": 0}]]
      }
    },
    "settings": {
      "executionTimeout": 3600,
      "saveDataSuccessExecution": "all",
      "saveDataErrorExecution": "all"
    }
  }'

# Get a specific workflow
curl -X GET "$N8N_BASE_URL/workflows/2tUt1wbLX592XDdX" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Update a workflow
curl -X PUT "$N8N_BASE_URL/workflows/2tUt1wbLX592XDdX" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Updated Workflow Name",
    "nodes": [...],
    "connections": {...},
    "settings": {...}
  }'

# Publish (activate) a workflow
curl -X POST "$N8N_BASE_URL/workflows/2tUt1wbLX592XDdX/activate" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Deactivate a workflow
curl -X POST "$N8N_BASE_URL/workflows/2tUt1wbLX592XDdX/deactivate" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Delete a workflow
curl -X DELETE "$N8N_BASE_URL/workflows/2tUt1wbLX592XDdX" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Transfer workflow to another project
curl -X PUT "$N8N_BASE_URL/workflows/2tUt1wbLX592XDdX/transfer" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"destinationProjectId": "VmwOO9HeTEj20kxM"}'
```

### Execution Management

Retrieve, monitor, retry, and manage workflow executions. Executions represent individual runs of workflows.

```bash
# List all executions with filtering
curl -X GET "$N8N_BASE_URL/executions?status=success&workflowId=1000&limit=50" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Response:
# {
#   "data": [
#     {
#       "id": 1001,
#       "finished": true,
#       "mode": "trigger",
#       "status": "success",
#       "startedAt": "2024-01-15T10:00:00.000Z",
#       "stoppedAt": "2024-01-15T10:00:05.000Z",
#       "workflowId": "1000"
#     }
#   ],
#   "nextCursor": "MTIzZTQ1NjctZTg5Yi0xMmQzLWE0NTYtNDI2NjE0MTc0MDA"
# }

# Get execution details with data
curl -X GET "$N8N_BASE_URL/executions/1001?includeData=true" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Retry a failed execution
curl -X POST "$N8N_BASE_URL/executions/1001/retry" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"loadWorkflow": true}'

# Stop a running execution
curl -X POST "$N8N_BASE_URL/executions/1001/stop" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Stop multiple executions by status
curl -X POST "$N8N_BASE_URL/executions/stop" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "status": ["queued", "running", "waiting"],
    "workflowId": "2tUt1wbLX592XDdX",
    "startedAfter": "2024-01-01T00:00:00.000Z"
  }'

# Delete an execution
curl -X DELETE "$N8N_BASE_URL/executions/1001" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"
```

### Credential Management

Create, retrieve, update, and delete credentials used by nodes for authentication with external services.

```bash
# List all credentials
curl -X GET "$N8N_BASE_URL/credentials?limit=100" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Get credential schema for a specific type
curl -X GET "$N8N_BASE_URL/credentials/schema/githubApi" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Response:
# {
#   "additionalProperties": false,
#   "type": "object",
#   "properties": {
#     "accessToken": {"type": "string"}
#   },
#   "required": ["accessToken"]
# }

# Create a credential
curl -X POST "$N8N_BASE_URL/credentials" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My GitHub API",
    "type": "githubApi",
    "data": {
      "accessToken": "ghp_xxxxxxxxxxxxxxxxxxxx"
    }
  }'

# Update a credential (partial update)
curl -X PATCH "$N8N_BASE_URL/credentials/vHxaz5UaCghVYl9C" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Updated GitHub Credential",
    "data": {"accessToken": "new_token_value"},
    "isPartialData": true
  }'

# Delete a credential
curl -X DELETE "$N8N_BASE_URL/credentials/vHxaz5UaCghVYl9C" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Transfer credential to another project
curl -X PUT "$N8N_BASE_URL/credentials/vHxaz5UaCghVYl9C/transfer" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"destinationProjectId": "VmwOO9HeTEj20kxM"}'
```

### User Management

Manage users on your n8n instance (Enterprise feature). Only available to instance owners.

```bash
# List all users
curl -X GET "$N8N_BASE_URL/users?includeRole=true&limit=50" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Response:
# {
#   "data": [
#     {
#       "id": "123e4567-e89b-12d3-a456-426614174000",
#       "email": "john.doe@company.com",
#       "firstName": "John",
#       "lastName": "Doe",
#       "isPending": false,
#       "role": "global:owner",
#       "createdAt": "2024-01-01T00:00:00.000Z"
#     }
#   ],
#   "nextCursor": null
# }

# Get a specific user by ID or email
curl -X GET "$N8N_BASE_URL/users/john.doe@company.com?includeRole=true" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Create/invite users
curl -X POST "$N8N_BASE_URL/users" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[
    {"email": "newuser@company.com", "role": "global:member"},
    {"email": "admin@company.com", "role": "global:admin"}
  ]'

# Change a user's global role
curl -X PATCH "$N8N_BASE_URL/users/123e4567-e89b-12d3-a456-426614174000/role" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"newRoleName": "global:admin"}'

# Delete a user
curl -X DELETE "$N8N_BASE_URL/users/123e4567-e89b-12d3-a456-426614174000" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"
```

### Project Management

Manage projects to organize workflows and credentials (Enterprise feature).

```bash
# List all projects
curl -X GET "$N8N_BASE_URL/projects?limit=50" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Create a new project
curl -X POST "$N8N_BASE_URL/projects" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "Marketing Automation"}'

# Update a project
curl -X PUT "$N8N_BASE_URL/projects/VmwOO9HeTEj20kxM" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "Marketing Automation v2"}'

# List project members
curl -X GET "$N8N_BASE_URL/projects/VmwOO9HeTEj20kxM/users" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Add users to a project
curl -X POST "$N8N_BASE_URL/projects/VmwOO9HeTEj20kxM/users" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "relations": [
      {"userId": "123e4567-e89b-12d3-a456-426614174000", "role": "project:admin"},
      {"userId": "91765f0d-3b29-45df-adb9-35b23937eb92", "role": "project:viewer"}
    ]
  }'

# Change user role in project
curl -X PATCH "$N8N_BASE_URL/projects/VmwOO9HeTEj20kxM/users/123e4567-e89b-12d3-a456-426614174000" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"role": "project:editor"}'

# Remove user from project
curl -X DELETE "$N8N_BASE_URL/projects/VmwOO9HeTEj20kxM/users/123e4567-e89b-12d3-a456-426614174000" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Delete a project
curl -X DELETE "$N8N_BASE_URL/projects/VmwOO9HeTEj20kxM" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"
```

### Tag Management

Create and manage tags to organize and filter workflows and executions.

```bash
# List all tags
curl -X GET "$N8N_BASE_URL/tags" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Create a tag
curl -X POST "$N8N_BASE_URL/tags" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "Production"}'

# Update a tag
curl -X PUT "$N8N_BASE_URL/tags/2tUt1wbLX592XDdX" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "Production-Critical"}'

# Get workflow tags
curl -X GET "$N8N_BASE_URL/workflows/2tUt1wbLX592XDdX/tags" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Update workflow tags
curl -X PUT "$N8N_BASE_URL/workflows/2tUt1wbLX592XDdX/tags" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[{"id": "tag-id-1"}, {"id": "tag-id-2"}]'

# Delete a tag
curl -X DELETE "$N8N_BASE_URL/tags/2tUt1wbLX592XDdX" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"
```

### Variable Management

Manage instance-wide or project-scoped variables for use in workflows.

```bash
# List all variables
curl -X GET "$N8N_BASE_URL/variables?projectId=VmwOO9HeTEj20kxM" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Create a variable
curl -X POST "$N8N_BASE_URL/variables" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "key": "API_ENDPOINT",
    "value": "https://api.example.com",
    "projectId": "VmwOO9HeTEj20kxM"
  }'

# Update a variable
curl -X PUT "$N8N_BASE_URL/variables/var-id" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"key": "API_ENDPOINT", "value": "https://api-v2.example.com"}'

# Delete a variable
curl -X DELETE "$N8N_BASE_URL/variables/var-id" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"
```

### Data Tables

Create and manage data tables for storing structured data within n8n.

```bash
# List all data tables
curl -X GET "$N8N_BASE_URL/data-tables?sortBy=name:asc" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Create a data table
curl -X POST "$N8N_BASE_URL/data-tables" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "customers",
    "columns": [
      {"name": "email", "type": "string"},
      {"name": "status", "type": "string"},
      {"name": "age", "type": "number"},
      {"name": "active", "type": "boolean"}
    ]
  }'

# Get a data table
curl -X GET "$N8N_BASE_URL/data-tables/dt-id" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Update data table name
curl -X PATCH "$N8N_BASE_URL/data-tables/dt-id" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "customers_v2"}'

# Insert rows into a data table
curl -X POST "$N8N_BASE_URL/data-tables/dt-id/rows" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "data": [
      {"email": "john@example.com", "status": "active", "age": 30},
      {"email": "jane@example.com", "status": "pending", "age": 25}
    ],
    "returnType": "all"
  }'

# Query rows with filtering and sorting
curl -X GET "$N8N_BASE_URL/data-tables/dt-id/rows?filter=%7B%22type%22%3A%22and%22%2C%22filters%22%3A%5B%7B%22columnName%22%3A%22status%22%2C%22condition%22%3A%22eq%22%2C%22value%22%3A%22active%22%7D%5D%7D&sortBy=createdAt:desc" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Update rows matching filter
curl -X PATCH "$N8N_BASE_URL/data-tables/dt-id/rows/update" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filter": {
      "type": "and",
      "filters": [{"columnName": "status", "condition": "eq", "value": "pending"}]
    },
    "data": {"status": "active"},
    "returnData": true
  }'

# Upsert a row (update if exists, insert if not)
curl -X POST "$N8N_BASE_URL/data-tables/dt-id/rows/upsert" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "filter": {
      "type": "and",
      "filters": [{"columnName": "email", "condition": "eq", "value": "john@example.com"}]
    },
    "data": {"email": "john@example.com", "status": "premium", "age": 31},
    "returnData": true
  }'

# Delete rows matching filter
curl -X DELETE "$N8N_BASE_URL/data-tables/dt-id/rows/delete?filter=%7B%22type%22%3A%22and%22%2C%22filters%22%3A%5B%7B%22columnName%22%3A%22status%22%2C%22condition%22%3A%22eq%22%2C%22value%22%3A%22archived%22%7D%5D%7D" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"

# Delete a data table
curl -X DELETE "$N8N_BASE_URL/data-tables/dt-id" \
  -H "X-N8N-API-KEY: $N8N_API_KEY"
```

### Security Audit

Generate security audit reports for your n8n instance.

```bash
# Generate a full security audit
curl -X POST "$N8N_BASE_URL/audit" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "additionalOptions": {
      "daysAbandonedWorkflow": 90,
      "categories": ["credentials", "database", "nodes", "filesystem", "instance"]
    }
  }'

# Response includes risk reports for:
# - Credentials Risk Report (unused credentials, etc.)
# - Database Risk Report (SQL injection risks, etc.)
# - Filesystem Risk Report (file access risks)
# - Nodes Risk Report (community nodes, etc.)
# - Instance Risk Report (unprotected webhooks, etc.)
```

### Source Control

Pull changes from a connected Git repository (Enterprise feature).

```bash
# Pull changes from remote repository
curl -X POST "$N8N_BASE_URL/source-control/pull" \
  -H "X-N8N-API-KEY: $N8N_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "force": true,
    "autoPublish": "published",
    "variables": {
      "API_KEY": "production-key",
      "ENVIRONMENT": "production"
    }
  }'

# Response:
# {
#   "variables": {"added": ["API_KEY"], "changed": ["ENVIRONMENT"]},
#   "credentials": [{"id": "cred-1", "name": "API Cred", "type": "httpHeaderAuth"}],
#   "workflows": [{"id": "wf-1", "name": "Main Workflow"}],
#   "tags": {"tags": [...], "mappings": [...]}
# }
```

## Workflow Expressions

Expressions allow dynamic parameter values using n8n's `{{ ... }}` syntax. They access data from previous nodes, workflow metadata, or environment variables.

```javascript
// Access data from previous node output
{{ $json.body.city }}

// Access specific item properties
{{ $json.customer_name }}

// Format a message with multiple values
Hi {{ $json.customer_name }}. Your description is: {{ $json.customer_description }}

// Access environment variables
{{ $env.API_KEY }}

// Access workflow metadata
{{ $workflow.name }}
{{ $workflow.id }}

// Access execution metadata
{{ $execution.id }}
{{ $execution.mode }}

// Access input data from specific node
{{ $('NodeName').item.json.fieldName }}

// Mathematical operations
{{ $json.price * 1.1 }}

// String manipulation
{{ $json.email.toLowerCase() }}

// Conditional expressions
{{ $json.status === 'active' ? 'Yes' : 'No' }}
```

## Webhook Node

The Webhook node creates endpoints that can receive data from external apps and services to trigger workflows. It supports test and production URLs with different behaviors.

```javascript
// Webhook URLs are automatically generated:
// Test: https://your-instance.app.n8n.cloud/webhook-test/{path}
// Production: https://your-instance.app.n8n.cloud/webhook/{path}

// Custom path with route parameters:
// Path: /users/:userId/orders/:orderId
// Access parameters: {{ $json.params.userId }}, {{ $json.params.orderId }}

// HTTP Methods supported: GET, POST, PUT, PATCH, DELETE, HEAD

// Response options:
// - Immediately: Returns "Workflow got started"
// - When Last Node Finishes: Returns output from last executed node
// - Using 'Respond to Webhook' Node: Custom response
// - Streaming response: Real-time data streaming (for AI workflows)

// Authentication options: Basic Auth, Header Auth, JWT Auth, None

// Access webhook body data in subsequent nodes:
{{ $json.body }}          // Full body
{{ $json.body.fieldName }} // Specific field
{{ $json.headers }}       // Request headers
{{ $json.query }}         // Query parameters
```

## HTTP Request Node

The HTTP Request node makes REST API calls to any service. It supports all HTTP methods, authentication options, pagination, and can be used as an AI agent tool.

```javascript
// Basic GET request
// URL: https://api.example.com/users
// Method: GET
// Headers: Authorization: Bearer {{ $env.API_TOKEN }}

// POST request with JSON body
// URL: https://api.example.com/users
// Method: POST
// Body Content Type: JSON
// Body: {
//   "name": "{{ $json.name }}",
//   "email": "{{ $json.email }}"
// }

// Pagination example (Response Contains Next URL)
// Pagination Mode: Response Contains Next URL
// Next URL: {{ $response.body.next_page_url }}
// Complete When: {{ !$response.body.next_page_url }}

// Query parameters
// URL: https://api.example.com/search
// Query Parameters:
//   q: {{ $json.searchTerm }}
//   limit: 100
//   offset: {{ $json.page * 100 }}

// Form data upload
// Body Content Type: Form-Data
// Parameter Type: n8n Binary File
// Input Data Field Name: file

// Import from curl command (paste in Import cURL dialog):
// curl -X POST 'https://api.example.com/data' \
//   -H 'Authorization: Bearer token123' \
//   -H 'Content-Type: application/json' \
//   -d '{"key": "value"}'
```

## Looping and Iteration

n8n automatically processes multiple items through nodes. For specific scenarios, explicit loops can be created using the Loop Over Items node or conditional branching.

```javascript
// Automatic iteration: Most nodes process all incoming items automatically
// No explicit loop needed - connect nodes directly

// Loop Over Items node for batch processing:
// Batch Size: 1 (process one item at a time)
// Batch Size: 10 (process 10 items per batch)

// Access current item in loop:
{{ $json }}

// Access item index:
{{ $itemIndex }}

// Execute node only once (first item):
// Node Settings > Execute Once: true

// Create conditional loop with IF node:
// IF condition: {{ $json.hasMorePages === true }}
// True branch: loops back to HTTP Request
// False branch: continues to next step

// Break out of loop based on condition:
{{ $json.status === 'complete' }}
```

## Code Node

The Code node allows custom JavaScript or Python transformations with full access to n8n's built-in methods and incoming data.

```javascript
// JavaScript: Process all items
for (const item of $input.all()) {
  item.json.processed = true;
  item.json.timestamp = new Date().toISOString();
}
return $input.all();

// JavaScript: Return new items
return [
  { json: { name: 'Item 1', value: 100 } },
  { json: { name: 'Item 2', value: 200 } }
];

// JavaScript: Access data from specific node
const previousData = $('HTTP Request').all();
const firstItem = $('HTTP Request').first();

// JavaScript: Filter items
return $input.all().filter(item => item.json.status === 'active');

// JavaScript: Transform data structure
return $input.all().map(item => ({
  json: {
    fullName: `${item.json.firstName} ${item.json.lastName}`,
    email: item.json.email.toLowerCase()
  }
}));

// Python: Process items
for item in _input.all():
    item.json['processed'] = True
return _input.all()
```

## AI Agent Integration

n8n integrates with LangChain to build AI-powered workflows including chatbots, document processing, and intelligent agents. The AI functionality uses cluster nodes (root nodes and sub-nodes) that work together.

```javascript
// Chat Trigger: Start AI conversations
// Node: n8n Chat Trigger
// Mode: Production (embedded chat widget)

// AI Agent with Tools
// Root Node: AI Agent
// Agent Type: Tools Agent
// Connected Tools: HTTP Request, Code, Custom Functions

// Memory management
// Sub-node: Buffer Window Memory
// Context Window Length: 10

// Vector Store RAG (Retrieval Augmented Generation)
// Root Node: Vector Store
// Mode: Retrieve Documents
// Sub-node: Embeddings (OpenAI, Google, etc.)

// Structured Output
// Use JSON schema to define expected output format
// Schema Type: From JSON Example or Manual Definition

// Human-in-the-loop for AI tool calls
// Add human review step on agent-to-tool connections
// Configure approval workflow (Slack, Email, etc.)

// Chat node for multi-turn conversations
// Operation: Send a message and wait for response
// Supports inline approval buttons
```

## Summary

n8n provides a comprehensive workflow automation platform suitable for a wide range of use cases: from simple data transformations and API integrations to complex AI-powered workflows with human-in-the-loop capabilities. The node-based architecture allows visual workflow building while the Code node and expressions provide flexibility for custom logic. Common integration patterns include webhook-triggered workflows for real-time event processing, scheduled workflows for periodic data synchronization, and AI agent workflows for intelligent automation.

The public REST API enables programmatic management of n8n resources, making it suitable for CI/CD pipelines, infrastructure-as-code deployments, and custom management dashboards. Enterprise features like source control integration, projects, and RBAC support team collaboration and governance requirements. With support for both cloud and self-hosted deployments, n8n adapts to various security and compliance needs while maintaining consistent functionality across environments.