n8n

Provides a canvas-based UI for constructing directed acyclic graphs (DAGs) where users drag-and-drop nodes representing integrations or operations, connect them with edges to define data flow, and configure parameters through a visual parameter editor. The frontend uses Vue.js state management to track workflow structure, node positions, and connections in real-time, with the expression editor enabling dynamic parameter binding using n8n's expression language for data transformation between nodes.

Executes workflows through a pluggable execution engine (packages/core) that supports multiple runtime modes: single-process for development, worker-based for horizontal scaling, and sandboxed task runners for isolation. The engine manages the workflow lifecycle from parsing the DAG, executing nodes sequentially or in parallel based on dependencies, handling data transformation between node outputs/inputs, and persisting execution state. Uses Bull queue for job distribution in worker mode and supports both synchronous and asynchronous node execution with timeout and retry policies.

Provides comprehensive execution monitoring through execution logs (per-node logs with timestamps and data snapshots), execution metrics (duration, memory usage, node execution times), and error tracking with stack traces. The system stores execution history in the database with full audit trails including who triggered the workflow, when, and what data was processed. Integrates with external observability platforms (Datadog, New Relic, Sentry) through telemetry exports. The UI provides execution history views with filtering, search, and drill-down into individual node executions. Supports custom logging through workflow expressions.

Implements a project-based authorization model where workflows, credentials, and other resources are organized into projects with fine-grained access control. Users can be assigned roles (owner, editor, viewer) per project, and workflows can be shared with specific users or teams. The system supports role-based access control (RBAC) with custom role definitions. Credentials are scoped to projects and can be shared across workflows within a project. The authorization layer is enforced at the API level, preventing unauthorized access to resources. Audit logs track all access and modifications.

Supports self-hosted deployment through Docker containers with a docker-compose configuration for easy setup. The system uses environment variables for configuration (database connection, Redis URL, API keys, etc.), enabling different configurations per environment without code changes. Provides CLI commands for database migrations, user management, and workflow import/export. Supports multiple database backends (PostgreSQL, MySQL) and optional Redis for worker mode. The deployment model is stateless for the main instance, enabling horizontal scaling through load balancing.

Exposes a comprehensive REST API (packages/@n8n/api-types) for programmatic workflow management, including endpoints for creating/updating/deleting workflows, triggering executions, querying execution history, managing credentials, and user administration. The API uses JWT authentication and supports API keys for service-to-service communication. Responses follow a consistent JSON schema with pagination support for list endpoints. The API enables external systems to integrate with n8n, automate workflow deployment, and build custom UIs. OpenAPI/Swagger documentation is available for all endpoints.

Provides a node registry (packages/nodes-base) containing 400+ pre-configured integrations with external services (Slack, Salesforce, GitHub, etc.) and utility nodes (HTTP, database, code execution). Each node encapsulates API authentication, request/response transformation, and error handling. The credential system stores encrypted API keys, OAuth tokens, and connection strings in a secure vault, with support for dynamic credential injection at runtime and external secret management (AWS Secrets Manager, HashiCorp Vault). Nodes declare required credentials through a schema-based system, enabling automatic credential selection and validation.

Implements a custom expression language (packages/@n8n/expression-runtime) that evaluates JavaScript-like expressions at runtime to dynamically compute node parameters, transform data between nodes, and implement conditional logic. Expressions have access to execution context (previous node outputs, workflow variables, environment variables) through a scoped evaluation environment. The expression editor provides syntax highlighting, autocomplete, and real-time validation. Supports both simple variable references ({{ $node.NodeName.data.field }}) and complex transformations ({{ $node.Data.json.items.map(item => item.price * 1.1) }}).

Provides an AI Workflow Builder (packages/@n8n/nodes-langchain) that uses LLMs to generate workflow definitions from natural language descriptions. Users describe their automation goal in a chat interface, and the system uses Claude or GPT-4 to decompose the task into steps, select appropriate nodes, configure parameters, and generate the workflow JSON. The Chat Hub backend manages conversation history, maintains context about available nodes and integrations, and iteratively refines workflows based on user feedback. Supports multi-turn conversations where users can ask the AI to modify workflows, add error handling, or optimize performance.

Implements an Instance AI system (referenced in DeepWiki as 'Instance AI — Autonomous Agent System') that enables workflows to spawn autonomous agents that can make decisions, call tools (n8n nodes), and maintain state across multiple steps. Agents use an LLM as the reasoning engine, with access to a tool registry of available nodes, and can iteratively plan and execute actions based on feedback. The system maintains agent memory (conversation history, execution state) and supports both single-shot and multi-step agent execution. Agents can be triggered by workflow events or user requests and can modify workflow state or trigger other workflows.

Implements a distributed execution model using Bull queue (Redis-backed job queue) where the main n8n instance enqueues workflow executions as jobs, and multiple worker processes consume jobs from the queue. Workers are stateless and can be scaled horizontally by adding more instances. The system supports job prioritization, retry policies with exponential backoff, and execution affinity (pinning jobs to specific workers). Execution state is persisted to the database, enabling recovery if workers crash. The main instance monitors job status and provides execution history and logs through the API.

Provides multiple trigger mechanisms for workflow execution: cron-based scheduling (using standard cron syntax for recurring executions), webhook triggers (HTTP endpoints that accept POST requests to start workflows), event-based triggers (listening to external events like Slack messages or GitHub pushes), and manual triggers. The scheduler service (part of the CLI runtime) manages cron jobs and ensures they execute at the specified times. Webhooks are registered as HTTP routes and can pass request data into the workflow. Event triggers integrate with external services through polling or event subscriptions. All triggers support conditional execution based on input data.

Provides workflow versioning capabilities where each workflow change creates a new version with metadata (timestamp, author, change description). Versions can be compared to see what changed, and workflows can be reverted to previous versions. Integrates with Git for source control, enabling workflows to be stored in Git repositories with automatic sync. The system tracks workflow definitions as JSON files, supports branching and merging workflows, and enables CI/CD integration. Environment-based configuration allows workflows to use different credentials and parameters per environment (dev, staging, prod).

Provides a Node Development Kit (packages/node-dev) that enables developers to create custom nodes using TypeScript. Custom nodes extend a base Node class, define input/output parameters through a schema, implement execute() method for the node logic, and can be packaged as npm modules. The system supports community packages (npm packages with n8n nodes) that can be installed into n8n instances. Node registration is automatic through package.json metadata. Developers can use the n8n CLI to scaffold new nodes, test locally, and publish to npm. The SDK includes utilities for common patterns (HTTP requests, credential handling, error handling).