Hubbry Logo
Node-REDNode-REDMain
Open search
Node-RED
Community hub
Node-RED
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Node-RED
Node-RED
Node-RED
View on Wikipedia
from Wikipedia
Node-RED
Original authorsIBM Emerging Technology
• Nick O'Leary
• Dave Conway-Jones
DeveloperJS Foundation
Initial release2013[1]
Stable release
4.1.1[2]Edit this on Wikidata / 13 October 2025; 30 days ago (13 October 2025)
Repository
Written inJavaScript
Operating systemCross-platform
PlatformNode.js
TypeFlow-based programming for wiring the Internet of things
LicenseApache License 2.0
Websitenodered.org Edit this at Wikidata

Node-RED is a flow-based, low-code development tool for visual programming, originally developed by IBM for wiring together hardware devices, APIs and online services as part of the Internet of things.[3]

Node-RED provides a web browser-based flow editor, which can be used to create JavaScript functions. Elements of applications can be saved or shared for re-use. The runtime is built on Node.js. The flows created in Node-RED are stored using JSON.

In 2016, IBM contributed Node-RED as an open source OpenJS Foundation project.[4][5][6]

Projects

[edit]

The Node-RED project has a number of components:

  • Node-RED – the visual designer tool accessed through a web browser, usually on port 1880.[7]
  • Node-RED Dashboard – a dashboard user interface for Node-RED.
  • Node generator, a command-line tool to generate Node-RED node modules from several sources, including OpenAPI documents and a function node's source.
  • Node-RED Command Line Tool, a command-line tool that allows for remotely administering a Node-RED instance.

Flows

[edit]

A Node-RED flow describes the connection and sequencing of various input, output, and processing nodes within the Node-RED platform. Each node within a flow performs a unique and specific task. When data is transmitted to a node, the node processes it according to its designated function, before passing it on to the subsequent node in the flow. This system allows for the controlled execution and regulation of a wide range of operations. Node-RED flows represent the primary visual programming mechanism of the tool.

Node-RED Flow
Node-RED Flow

Adoption

[edit]

Node-RED has gained traction in the industrial internet of things (IIoT) and edge computing sectors.[8][9][10] Node-RED's open-source nature and large community have led to the creation of over 4000 connectors[11] supporting a wide range of data sources and protocols such as Modbus, OPC-UA, Siemens S7, and MQTT. Several PLC and IoT vendors[12] have adopted Node-RED as a standard.

Community survey

[edit]

The 2023 Node-RED Community Survey[13] provided insights into the usage patterns, preferences, and feedback from 780 individuals who are part of the Node-RED community. The survey, conducted in March 2023, revealed that Node-RED's usage extends beyond DIY home automation, with a trend towards professional use in a variety of industries. Over half of the respondents had been using Node-RED for over two years, indicating a well-established community. The most common messaging technologies used in conjunction with Node-RED are MQTT and HTTP, while InfluxDB emerged as the most popular database within the community. The survey also shed light on perceived barriers to adoption, pointing towards the perception of Node-RED as a proof of concept tool and the lack of certain key features. Despite these challenges, the survey highlighted a high level of satisfaction within the community, with over two-thirds of respondents rating Node-RED a 5 out of 5.

Commercial offerings

[edit]

FlowFuse[14] (formerly known as FlowForge[15]) is an open-core company investing in Node-RED. Nick O’Leary, co-creator of Node-RED, is FlowFuse co-founder and CTO. FlowFuse adds collaborative development, management of remote deployments, support for DevOps delivery pipelines, and the ability to host Node-RED applications on FlowFuse Cloud.

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Node-RED

View on Grokipedia
from Grokipedia
Node-RED is a flow-based, low-code built on that enables visual development of event-driven applications by wiring together hardware devices, APIs, and online services in a browser-based editor. It allows users to create lightweight flows for collecting, transforming, and visualizing data, with single-click deployment and support for running on low-cost hardware like the or in cloud environments. Originally developed in early 2013 as a side project by Nick O’Leary and Dave Conway-Jones at ’s Emerging Technology Services, Node-RED was open-sourced in September 2013 to facilitate rapid prototyping of (IoT) solutions. It quickly gained popularity for its intuitive interface and extensibility, becoming a founding project of the JS Foundation in 2016, which later merged into the in 2019, under whose governance it continues to be maintained as an open-source project. The tool's name playfully references "Code Red," highlighting its foundation and node-centric flow model. Key features include a vast library of over 5,000 community-contributed nodes available for sharing via JSON-based exports on an online flow repository, integration of custom functions, and broad applicability in industrial and IoT contexts for automating workflows and . Widely adopted for its accessibility to non-programmers while supporting advanced customization, Node-RED has evolved to include enterprise enhancements, such as those provided by FlowFuse, Inc., founded in by its original creator to scale deployments.

History and Development

Origins at

Node-RED was initiated in early 2013 as a side project by and Dave Conway-Jones, members of 's Emerging Technology Services group, with the primary goal of simplifying the integration of (IoT) devices, application programming interfaces (APIs), and online services. This effort stemmed from the need to address the complexities of connecting disparate systems in IoT environments, where traditional coding approaches often proved cumbersome for rapid development and prototyping. The project began as a proof-of-concept designed to enable low-code visual programming specifically for event-driven applications within IoT contexts, allowing users to create data flows through intuitive graphical representations rather than extensive scripting. At its core, this prototype focused on visualizing and manipulating message mappings, such as those using the protocol, to facilitate seamless event handling across connected devices and services. By emphasizing a declarative wiring paradigm, it aimed to make application assembly more accessible to non-programmers while supporting the dynamic, real-time nature of IoT interactions. A key aspect of the initial development was the creation of a browser-based editor, which provided an immediate, interactive canvas for users to drag, drop, and connect components without requiring traditional coding environments or installations. This editor enabled by allowing flows to be built, tested, and deployed in a single-click manner directly from the web interface, significantly lowering the barrier to entry for experimenting with IoT prototypes. The focus on this visual, no-code interface marked Node-RED's early innovation in making feel intuitive and aligned with how engineers conceptualize system integrations.

Open-Sourcing and Governance

Node-RED was initially developed internally at before being open-sourced in September 2013 under the 2.0, enabling broader community involvement and adoption. In October 2016, Node-RED became one of the founding projects of the JS Foundation, which provided a structured framework for its ongoing development and sustainability. In 2019, the JS Foundation merged with the Foundation to form the , under which Node-RED continues to operate as a key project. Governance of Node-RED is managed through the , emphasizing collaborative decision-making and transparency, with the project maintained by a dedicated team of contributors who handle code reviews, issue triage, and feature development. Key maintainers include , a co-creator of Node-RED, who leads much of the core development efforts. In 2021, O'Leary founded FlowFuse, Inc., to extend Node-RED's capabilities for enterprise environments, focusing on enhancements like collaborative tools and deployment management while keeping the core project open-source. The project's release cadence follows a structured plan, targeting major releases annually around April, supplemented by frequent minor updates for bug fixes and new features, with older versions entering maintenance for security patches. The latest stable version as of November 2025, 4.1.1, was released on October 13, 2025.

Core Architecture

Technology Stack

Node-RED is built on the runtime, leveraging its lightweight, to handle non-blocking I/O operations efficiently, which enables the creation of scalable applications for and automation. This foundation allows Node-RED to operate as a server-side environment, where flows execute asynchronously in response to events from various inputs, such as hardware devices or web services. The use of ensures that Node-RED can manage concurrent tasks with minimal resource overhead, making it suitable for both resource-constrained devices and larger deployments. Node-RED provides cross-platform support across major operating systems including Windows, macOS, and , as well as embedded systems like the , facilitating deployment in diverse environments from desktops to IoT edge devices. Node-RED 4.x (latest version 4.1.1 as of November 2025) requires version 18 or later; however, as 18 reached end-of-life in October 2025, 20 or later is recommended, with 22 as the current Active LTS version for optimal performance and security. This compatibility extends to containerized setups via Docker, supporting multiple architectures such as amd64, arm32v7, and arm64v8 to accommodate varied hardware. Flows in Node-RED are stored in a JSON-based format, typically in files named flows_<hostname>.json, which allows for straightforward , , and export of configurations. This structure promotes portability, enabling users to share flows across instances or integrate them with version control systems like for collaborative development and tracking changes. The modular design of Node-RED relies on npm for package management, allowing core functionality and community-contributed nodes to be installed, updated, or removed as discrete modules. Developers can publish custom nodes to the public npm registry, extending the platform's capabilities without altering the core codebase, which fosters a rich ecosystem of over thousands of reusable components. This approach aligns with conventions, ensuring seamless integration and dependency resolution through standard npm workflows.

Key Components

Node-RED's primary interface is a browser-based flow editor, accessible by default at http://:1880, which provides a drag-and-drop interface for visually assembling applications from interconnected nodes. This editor consists of key elements including a header for deployment and menus, a left-side palette for node selection, a central workspace for arrangement, and a right sidebar for configuration and . The node palette serves as the central repository of building blocks, featuring a set of core nodes such as the inject node for triggering flows, the debug node for inspecting messages, and the function node for embedding custom logic. Beyond these essentials, the palette supports extensibility through over 5,600 community-contributed nodes and flows (as of November 2025) available via the official library at flows.nodered.org, enabling integration with diverse protocols, services, and hardware. For user interface development, community-contributed modules such as the deprecated (version 3.6.6, last updated in 2024) provide nodes for creating interactive web-based dashboards to visualize and control live data without additional coding. Administrative and development tasks are facilitated by command-line tools, including the primary node-red command for starting and managing the runtime, as well as node-red-nodegen for generating custom nodes from sources like OpenAPI specifications or existing function nodes. At the core of the system is the runtime engine, built on , which executes the defined flows by processing messages through nodes in a non-blocking, event-driven manner while supporting persistence through configurable context stores (such as memory or file-based) to retain state across restarts. handling is integrated via mechanisms like catch nodes to intercept exceptions and configurable levels to monitor runtime issues, ensuring robust operation in production environments.

Programming Model

Flows and Nodes

In Node-RED, flows represent sequences of connected nodes that form pipelines, operating within an event-driven model where messages are passed between nodes to trigger actions and transformations. A flow is organized as a tab in the editor workspace, allowing multiple sets of interconnected nodes to be grouped logically, with all nodes in a flow sharing the same flow-scoped for storing data across node executions. Node-RED provides three levels of context scope: node-specific (private to one node), flow (shared within the tab), and global (accessible across all flows). Context storage is in-memory by default but can be configured for persistence across restarts using file-based or other stores. This structure enables the creation of modular, visual representations of workflows, where data enters through input nodes, undergoes processing, and exits via output nodes, facilitating and iteration without traditional coding. Nodes serve as the fundamental modular building blocks within flows, each designed to perform specific tasks such as receiving input, processing data, or sending output. Input nodes, like the MQTT in node, capture events from external sources such as message brokers; processing nodes, exemplified by the function node, allow custom code to manipulate incoming messages; and output nodes, such as the HTTP response node, deliver results to endpoints like web servers. Every node features configurable properties accessible via a properties panel, enabling users to set parameters like topics, thresholds, or connection details without altering the node's core logic. Nodes typically have one input port and one or more output ports, with execution triggered either by an incoming message from a preceding node or by external events like timers or HTTP requests. Messages in Node-RED are simple objects that carry between nodes, conventionally including a payload property to hold the primary (which can be a string, number, boolean, array, object, or null), a topic string for or categorization, and optional metadata such as _msgid for unique identification and tracing. Additional properties like msg.parts support message sequences for handling chunked . For reusability, Node-RED provides subflows, which encapsulate a group of nodes into a single reusable node type that appears in the palette, allowing instances to be deployed across flows with customizable exposed as environment variables. The template node further enhances handling by generating dynamic text outputs using Mustache templating syntax, interpolating (e.g., {{payload}}) into strings or while supporting features like loops and conditional rendering. This conceptual flow—input → transform → output—underpins Node-RED's efficiency in building event-driven applications.

Node Status Indicators

Custom nodes in Node-RED can display status indicators in the editor to provide visual feedback on their current state. This is accomplished by calling the node.status() method in the node's JavaScript runtime code, passing an object with the properties fill, shape, and text. The fill property determines the color and can be one of: "red", "green", "yellow", "blue", or "grey". The shape property specifies either "dot" or "ring". The text property is any string to display beside the indicator. Common examples include:
  • node.status({fill:"green", shape:"dot", text:"connected"}); — displays a green dot with "connected"
  • node.status({fill:"green", shape:"ring", text:"connecting..."}); — displays a green ring with "connecting..."
  • node.status({fill:"red", shape:"ring", text:"error"}); — displays a red ring with "error"
  • node.status({fill:"yellow", shape:"dot", text:"warning"}); — displays a yellow dot with "warning"
  • node.status({fill:"grey", shape:"dot", text:"idle"}); — displays a grey dot with "idle"
To clear the status indicator, call node.status({});. The official Node-RED documentation includes images demonstrating how these status indicators appear in the editor, such as a green dot for operational status, a red ring for error conditions, and a green ring for connecting states.

Wiring and Deployment

In Node-RED, wiring involves a drag-and-drop interface within the editor workspace, where users select nodes from the palette on the left and place them on the . Connections are made by clicking and dragging from an output on one node to an input on another, creating wires that enable the passage of messages between nodes during runtime. These wires represent directed data flows, with messages propagating from upstream to downstream nodes upon triggering. To organize complex applications, the workspace uses tabs along the top, each representing a separate flow for grouping related nodes. Users can add new tabs via the or by double-clicking empty space in the tab bar, rename them through the Flow Properties dialog, and reorder or hide them as needed to manage multiple flows efficiently. Deployment occurs with a single click on the red Deploy button in the editor's top-right corner, which sends the configured flows to the Node-RED runtime for execution and restarts the flow context to apply changes. For versioning, Node-RED's Projects feature integrates to track modifications to flow files, allowing commits, branching, and history review directly in the sidebar. Remote deployment options include pushing changes to repositories via HTTP/SSH, enabling collaboration or distribution across instances, though the core runtime must be set up separately on target systems. Debugging is facilitated by the Debug node, which, when wired into a flow, outputs messages to the Debug sidebar in the editor for real-time inspection, showing structured details like , , and originating node ID. The sidebar filters messages by node and supports toggling output to the runtime log for persistent recording. For error handling, the Catch node intercepts runtime from other nodes, generating a with details (such as description, source node info, and occurrence count) to route into a dedicated recovery flow, preventing unhandled exceptions from disrupting the . Flows can be exported from the editor menu as files for backup or sharing, capturing the complete node configurations, wires, and properties in a portable format. Conversely, imports allow pasting or loading files to recreate flows, with options to replace or append to existing tabs, ensuring seamless transfer across installations.

Installation and Basic Usage

Setup Process

Node-RED can be installed and set up on various platforms, with the primary method using Node Package Manager (npm) for local environments, while scripts and container images support embedded devices like or cloud deployments. To install locally, a supported version of is required, with Node-RED 4.x necessitating at least Node.js 18, though Node 20.x is recommended for optimal performance. On Linux or macOS, execute sudo npm install -g --unsafe-perm node-red to install globally, avoiding permission issues; on Windows, use npm install -g --unsafe-perm node-red without sudo. This places the node-red command in the system's PATH, allowing easy access from any directory. Once installed, start the server by running node-red in the terminal, which launches Node-RED on the default port 1880 and loads the editor. Access the web-based editor at http://:1880, where users can begin wiring flows using the browser interface. The runtime uses a default user directory at ~/.node-red, containing files like the flows configuration and settings. Initial configuration occurs via the settings.js file in the user directory, which exports a JavaScript object for customizing runtime behavior. Key options include setting the port (default 1880) for the HTTP server, enabling logging for console or file output, and configuring httpNodeRoot for endpoint paths; edits require uncommenting lines and ensuring valid to avoid startup errors. For , enable adminAuth in settings.js to require , defining users with hashed passwords generated via node-red admin hash-pw and permissions like read or full access. Upon first access, the editor prompts for admin user setup if not pre-configured, establishing credentials to protect the interface. Palette management allows adding nodes immediately through the editor's Manage Palette menu, where the Install tab searches and deploys modules from the Node-RED library, or via npm install in the user directory followed by a restart. For compatibility, Node-RED supports Raspberry Pi via a dedicated script (bash <(curl -sL https://github.com/node-red/linux-installers/releases/latest/download/update-nodejs-and-nodered-deb)) that installs Node.js 20 LTS, Node-RED, and optional Pi-specific nodes, setting it up as a system service. Containerized setups use Docker with docker run -it -p 1880:1880 -v node_red_data:/data --name mynodered nodered/node-red, persisting data in volumes for portability. Cloud hosting options include deploying on platforms like AWS, Azure, or Heroku, often via Docker images or npm in virtual machines.

Simple Examples

Node-RED's visual programming paradigm allows users to create basic flows by dragging nodes from the palette and wiring them together, often without writing code, though can be added in function nodes for custom logic. These simple examples demonstrate introductory uses, assuming Node-RED is installed and running locally. One basic example is a simple HTTP endpoint that echoes incoming requests. This flow uses an HTTP In node configured for a GET or POST method at a path like /echo, wired to a function node that sets the message to the request body or query parameters (e.g., msg.[payload](/page/Payload) = [JSON](/page/JSON).stringify(msg.req.body || msg.req.query);), and then to an HTTP Response node to send the echoed content back to the client. Deploying this flow creates an endpoint accessible via a browser or tool like , where sending a request returns the input data, illustrating Node-RED's ease in handling web interactions visually. Another introductory flow involves timer-based messaging for periodic data transformation. An Inject node is set to inject a every 5 seconds (configurable interval), connected to a function node that formats the into a readable date string using like var date = new Date(msg.[payload](/page/Payload)); msg.[payload](/page/Payload) = date.toString(); return msg;, and finally wired to a Debug node to output the result in the sidebar. This setup highlights automated triggering and simple processing without external dependencies, with the visual wires defining the data flow path. For IoT scenarios, a straightforward integration flow subscribes to a broker topic, processes the incoming , and publishes a response. An In node, configured with a broker (e.g., :1883) and topic like sensors/input, connects to a function node for manipulation (e.g., msg.[payload](/page/Payload) = msg.[payload](/page/Payload) * 1.8 + 32; // Convert to [Fahrenheit](/page/Fahrenheit)), then to an Out node publishing to sensors/output using the same broker configuration. This wire-based setup enables quick prototyping of message brokering, with optional for transformations, and requires no additional coding for basic subscribe-process-publish behavior.

Adoption and Applications

Community and Hobbyist Use

Node-RED has gained significant traction among hobbyists and individual users for smart , particularly through integrations with platforms like and protocols such as via . Users leverage Node-RED's nodes to connect devices coordinated by tools like Zigbee2MQTT, enabling seamless automation of lighting, sensors, and environmental controls without deep coding expertise. This approach is popular in DIY setups, where Node-RED acts as a visual bridge between diverse IoT hardware and home automation hubs. Hobbyist projects often involve practical applications like weather station data visualization and simple API chaining. For instance, enthusiasts build flows to fetch real-time weather data from APIs like , process it with Node-RED nodes, and display it on dashboards or send alerts via or . Similarly, API chaining allows chaining multiple services, such as pulling sensor data from a personal and forwarding it to or visualization tools, demonstrating Node-RED's utility in for personal monitoring systems. According to the 2023 Node-RED Community Survey of 780 respondents, 51.4% reported using Node-RED for personal purposes, with over 65% of users having utilized it for more than two years in such projects. The platform's low-code accessibility has driven its growth in and prototyping, enabling quick iteration on IoT concepts without traditional programming barriers. from the same survey indicates high user satisfaction, with 68.2% rating Node-RED 5 out of 5 for hobbyist workflows. The 2025 Node-RED modernization survey emphasizes user feedback on editor enhancements tailored to hobbyist needs, including improved for visual flow design and accessibility to streamline personal tasks. These updates aim to further empower individual creators by reducing the in non-commercial settings.

Industrial and Enterprise Applications

Node-RED has gained significant traction in (IIoT) applications, particularly for where it facilitates the integration of diverse hardware and protocols at the network periphery. In manufacturing environments, it enables seamless connectivity between programmable logic controllers (PLCs) and other industrial devices using protocols such as TCP/RTU and OPC UA, allowing for acquisition and processing without heavy reliance on centralized servers. For instance, integrations with S7 PLCs via OPC UA have been implemented to support industrial automation workflows, including data exchange in SIMATIC IOT2000 systems. Similarly, Node-RED serves as an integration platform for edge devices in manufacturing, wiring together sensors, actuators, and cloud services to enable low-latency decision-making. Node-RED is often compared to other workflow automation tools such as n8n, particularly in industrial and IoT contexts. Unlike n8n, which operates under a Sustainable Use License that restricts certain commercial uses such as selling products or services substantially derived from its functionality, Node-RED is released under the permissive Apache 2.0 license, allowing unrestricted use, modification, distribution, and commercial applications without such limitations. Furthermore, Node-RED's lightweight runtime, built on Node.js, makes it particularly suitable for resource-constrained IoT and embedded systems, such as those running on low-cost hardware like the Raspberry Pi, with support for custom JavaScript nodes enabling extensive developer customization while emphasizing simplicity and low resource usage compared to more feature-rich alternatives. In enterprise settings, Node-RED supports the development of robust data pipelines for sectors like utilities and finance, where real-time monitoring is essential for operational efficiency and compliance. Utilities leverage it for energy management systems, such as collecting and analyzing consumption data from electricity, water, and gas meters to enable fine-grained resource optimization. In finance, it aids in event-driven workflows for transaction processing and anomaly detection, though adoption often focuses on integrating APIs for secure data flows. The platform's ecosystem includes thousands of community-contributed nodes, with over 4,000 available for protocols like HTTP and databases; notably, InfluxDB integration is popular, used by 43.9% of respondents in the 2023 community survey for time-series data handling in monitoring applications. This extensibility, combined with support for Modbus (27.6% usage) and OPC UA (16.7% usage), underscores its role in industrial IoT, where manufacturing accounts for 40.3% of applications and PLC integrations represent 35.8%. Case studies highlight Node-RED's effectiveness in automation and , where it orchestrates data flows to minimize and enhance productivity. In one manufacturing initiative, a large U.S.-based company deployed Node-RED across global operations to connect legacy equipment with modern analytics, enabling automated fault detection and process optimization. For , it processes sensor data from PLCs on networks with S7-300 controllers, applying rules to forecast equipment failures and trigger alerts, as demonstrated in Industry 4.0 prototypes. automation examples include using Node-RED for SCADA-like systems in hybrid renewable power plants, where it handles and visualization to support isolated grid management. is achieved through clustering and distributed deployments, allowing high-load environments to handle thousands of messages per second by partitioning flows across multiple instances, as explored in enterprise IoT architectures. The release of Node-RED version 4.1 in July 2025 introduced enhancements tailored for industrial and enterprise reliability, including default-enabled update notifications to mitigate vulnerabilities and flagging of deprecated nodes in the Palette Manager for secure selections. Performance improvements encompass an Event Log widget for monitoring installation progress and optimized deployments that skip disabled nodes, reducing latency in production flows. Additionally, flow dependencies are now exported with configurations, simplifying module management in large-scale industrial setups, while the Palette Manager's sorting by download count prioritizes vetted nodes for critical applications. These updates address key concerns in high-stakes environments, bolstering and efficiency for IIoT deployments.

Community and Ecosystem

Surveys and Statistics

The 2019 Node-RED Community Survey, conducted to assess early adoption patterns, gathered responses from 871 users and found that 28.3% had been using the tool for over two years, with a significant portion (75.7%) applying it to projects. This survey underscored Node-RED's initial traction among hobbyists and tech professionals, particularly in (62.7%) and (31.5%) sectors. Building on this, the 2023 Community Survey, with 780 respondents, indicated substantial maturation in usage, as 65.2% reported employing Node-RED for two or more years. emerged as the top database integration, rising from 24.2% adoption in 2019 to 43.9% in 2023, reflecting growing needs in time-series data handling for IoT applications. Overall satisfaction remained high, with approximately 42% of respondents using Node-RED in professional contexts, particularly for industrial IoT and automation scenarios. In July 2025, the Node-RED team launched a modernization survey to gather feedback on improvements and learning resources, with results unveiled during the opening at Node-RED Con on November 4, 2025. Key findings from the survey, available via the project's repository, highlight priorities for enhancing editor accessibility, debugging tools, and documentation, guiding upcoming roadmap enhancements. Node-RED's built-in anonymous provides ongoing insights into its deployment, revealing widespread application in event-driven architectures across diverse environments. Post-2023 growth is evidenced by the expansion of the node library, which now hosts over 5,700 contributed nodes, supporting broader ecosystem integration.

Resources and Contributions

Node-RED provides comprehensive covering installation, user guides, core nodes, and advanced topics, accessible at nodered.org/docs. The project maintains an active community forum at discourse.nodered.org, where users discuss issues, share solutions, and collaborate on development. Additionally, the Node-RED flows at flows.nodered.org serves as a repository for over 5,700 community-shared nodes and flows, enabling users to discover, import, and contribute reusable components. The annual Node-RED Con event fosters knowledge exchange, with the 2025 edition held online on November 4, attracting over 1,100 participants to explore industrial applications, IoT solutions, and project innovations through talks and demos. Recordings from the conference are available for on-demand viewing, highlighting real-world implementations in sectors like energy and smart factories. Contributions to Node-RED are encouraged through its open-source repository at github.com/node-red/node-red, which includes detailed guidelines for submitting pull requests and adhering to the Contributor Covenant. Developers can extend the platform by creating custom nodes, following the official guidelines that emphasize clear purpose, simplicity, and robust error handling. Community engagement occurs via the forum, Slack workspace, and social channels like X (formerly Twitter), supporting discussions and collaborative improvements. For learning, Node-RED offers structured tutorials on its website, starting with basic editor usage and progressing to complex flows. The official YouTube channel provides video series on essentials, such as wiring nodes and debugging, totaling under an hour for foundational coverage. Open contributions have significantly expanded the ecosystem, with community-shared resources driving adoption and innovation across diverse applications.

Commercial Extensions

Enterprise Platforms

FlowFuse, founded in 2021 by , co-creator of Node-RED, is a commercial platform designed to extend Node-RED for enterprise-grade industrial IoT applications, emphasizing team collaboration, flow versioning, and remote device management. It enables multiple developers to work simultaneously on flows, supports through integration for tracking changes, and provides centralized administration of distributed Node-RED instances across edge devices and cloud environments. Key features of FlowFuse include multi-instance for overseeing deployments at scale, comprehensive logs for compliance and , and built-in scalability options such as load balancing and high-availability clustering, all while seamlessly integrating with the core Node-RED runtime. These enhancements address enterprise needs by offering role-based access controls, secure remote updates, and monitoring tools that surpass the limitations of standalone open-source Node-RED in production settings. For businesses, FlowFuse delivers improved security through encrypted communications and authentication protocols, along with reliable deployment capabilities that support mission-critical operations in industrial environments. Beyond FlowFuse, major corporations have incorporated Node-RED into their enterprise platforms for . Hitachi's Lumada IoT platform utilizes Node-RED as its primary application development environment, enabling rapid creation of edge-based solutions that process data from sensors and devices in real-time across various deployment scenarios. Similarly, Siemens integrates Node-RED through dedicated nodes that facilitate data ingestion, such as time-series uploads and event handling, allowing seamless connectivity between industrial assets and the cloud-based IoT operating system. These integrations highlight Node-RED's role in providing extensible, low-code tools for secure and scalable enterprise IoT workflows.

Third-Party Integrations

Node-RED's extensibility is enhanced through a vast ecosystem of third-party nodes available via its official library, which hosts over 5,000 community-contributed nodes and flows for integrating with external services and tools. For cloud platforms, dedicated nodes enable seamless connectivity to major providers. The AWS IoT nodes facilitate data ingestion and management in AWS IoT SiteWise, allowing flows to handle device telemetry and edge processing directly. Similarly, the node-red-contrib-azure-iot-hub package provides nodes for Azure IoT Hub operations, including device registry management, twin updates, and message routing. On Google Cloud, Node-RED integrates via nodes that support Pub/Sub messaging and Cloud Functions, enabling event-driven workflows for IoT data processing. Database integrations are supported through specialized nodes for both relational and non-relational systems. Nodes for allow querying, inserting, and aggregating documents in collections, while SQL nodes connect to databases like and for structured data operations such as SELECT, INSERT, and UPDATE queries. Beyond cloud and databases, Node-RED offers add-ons for and . As an add-on for , Node-RED runs natively within the platform, enabling custom automations that bridge , HTTP, and entity states. For solar and energy systems, Victron Energy's Venus OS includes built-in Node-RED support, allowing flows to monitor and control inverters, charge controllers, and battery systems via the VRM portal. Commercial dashboards like integrate through nodes that export Node-RED data to or , facilitating real-time visualization of IoT metrics. Additional tools extend Node-RED's reach to mobile and embedded environments. The Node-RED Companion app, integrated with , provides mobile access to flows via notifications and entity controls on and Android devices. Node-RED is also embeddable in platforms like Eclipse , an open-source framework for IoT orchestration, where it serves as a lightweight runtime for service-oriented architectures. As of 2025, Node-RED version 4.1 maintains compatibility with 20 and later, including improved support for newer integrations in environments like add-ons, which now leverage Node.js 22 for enhanced performance in third-party node execution.

References

  1. https://nodered.org/about/
  2. https://developer.ibm.com/tutorials/i-running-node-red/
  3. https://subscription.packtpub.com/book/web-development/9781800201590/2/ch02lvl1sec04/what-is-node-red
  4. https://developer.ibm.com/components/node-red
  5. https://github.com/node-red/node-red
  6. https://nodered.org/blog/2016/10/17/js-foundation
  7. https://nodered.org/about/governance/
  8. https://flowfuse.com/about/
  9. https://nodered.org/about/releases/
  10. https://www.npmjs.com/package/node-red
  11. https://nodered.org/
  12. https://nodered.org/docs/api/
  13. https://nodered.org/docs/getting-started/
  14. https://nodered.org/docs/getting-started/windows
  15. https://nodered.org/docs/getting-started/raspberrypi
  16. https://nodered.org/blog/2025/07/29/version-4-1-released
  17. https://nodered.org/docs/faq/node-versions
  18. https://nodejs.org/en/about/releases/
  19. https://nodered.org/docs/getting-started/docker
  20. https://nodered.org/docs/api/storage/methods/
  21. https://nodered.org/docs/user-guide/editor/workspace/import-export
  22. https://nodered.org/docs/user-guide/runtime/configuration
  23. https://nodered.org/docs/creating-nodes/
  24. https://nodered.org/docs/user-guide/runtime/adding-nodes
  25. https://nodered.org/docs/getting-started/local
  26. https://nodered.org/docs/user-guide/editor/
  27. https://nodered.org/docs/user-guide/editor/palette/
  28. https://nodered.org/docs/user-guide/nodes
  29. https://flows.nodered.org/
  30. https://flows.nodered.org/node/node-red-dashboard
  31. https://github.com/node-red/node-red-nodegen
  32. https://nodered.org/docs/user-guide/concepts
  33. https://nodered.org/docs/user-guide/context
  34. https://nodered.org/docs/user-guide/messages
  35. https://nodered.org/docs/user-guide/editor/workspace/subflows
  36. https://nodered.org/docs/creating-nodes/status
  37. https://nodered.org/docs/user-guide/editor/workspace/
  38. https://nodered.org/docs/user-guide/editor/workspace/wires
  39. https://nodered.org/docs/user-guide/editor/workspace/flows
  40. https://nodered.org/docs/tutorials/first-flow
  41. https://nodered.org/docs/user-guide/projects/
  42. https://nodered.org/docs/user-guide/editor/sidebar/debug
  43. https://nodered.org/docs/user-guide/handling-errors
  44. https://nodered.org/docs/user-guide/runtime/settings-file
  45. https://nodered.org/docs/user-guide/runtime/securing-node-red
  46. https://cookbook.nodered.org/http/create-an-http-endpoint
  47. https://cookbook.nodered.org/mqtt/connect-to-broker
  48. https://flows.nodered.org/node/node-red-node-openweathermap
  49. https://www.hackster.io/edwios/node-red-mqtt-and-the-new-weather-station-part-1-e6d882
  50. https://nodered.org/about/community/survey/2023/
  51. https://dl.acm.org/doi/10.1145/3581961.3609844
  52. https://discourse.nodered.org/t/node-red-survey-shaping-the-future-of-node-reds-user-experience/98346
  53. https://survey.nodered.org
  54. https://ubidots.com/blog/plc-data/
  55. https://sieportal.siemens.com/en-ww/support/forum/posts/opc-ua-client-with-node-red/159059
  56. https://www.linkedin.com/posts/harshalvpatel_industry40-nodered-siemens-activity-7366229653692350465-UsZ8
  57. https://flowfuse.com/blog/2023/03/integration-platform-for-edge-computing/
  58. https://docs.n8n.io/sustainable-use-license/
  59. https://github.com/node-red/node-red/blob/master/LICENSE
  60. https://sourceforge.net/software/compare/Node-RED-vs-n8n/
  61. https://www.pusr.com/blog/Industrial-application-scenarios-and-practical-cases-of-Node-red
  62. https://flowfuse.com/blog/2023/05/node-red-community-survey-results/
  63. https://flowfuse.com/customer-stories/manufacturing-digital-transformation/
  64. https://www.researchgate.net/publication/377439128_Node-RED_for_PLC_Automation
  65. https://psecommunity.org/wp-content/plugins/wpor/includes/file/2303/LAPSE-2023.20166-1v1.pdf
  66. https://www.youtube.com/watch?v=8NBYyO0bllY
  67. https://nodered.org/about/community/survey/2019/
  68. https://nodered.org/blog/2025/10/28/node-red-con
  69. https://github.com/node-red/community-survey
  70. https://discourse.nodered.org/t/node-red-con-2025-is-tomorrow/99570
  71. https://nodered.org/docs/telemetry/
  72. https://nodered.org/docs/
  73. https://discourse.nodered.org/
  74. https://nrcon.nodered.org/
  75. https://discourse.nodered.org/t/node-red-con-2025-recordings-now-available/99593
  76. https://nodered.org/about/community/
  77. https://nodered.org/docs/tutorials/
  78. https://flowfuse.com/product/features/
  79. https://flowfuse.com/handbook/product/versioning/
  80. https://www.youtube.com/watch?v=FWeHG6_wTIo
  81. https://aws.amazon.com/marketplace/pp/prodview-3ycrknfg67rug
  82. https://flowfuse.com/blog/2025/10/node-red-vs-flowfuse/
  83. https://flowfuse.com/node-red/
  84. https://www.startuptofollow.com/article/flowfuse-advances-industrial-ai-integration-for-node-red-automation
  85. https://www.hitachihyoron.com/rev/archive/2020/r2020_05/05a03/index.html
  86. https://developer.siemens.com/industrial-iot-open-source/node-red-contrib-mindconnect/index.html
  87. https://docs.aws.amazon.com/iot-sitewise/latest/userguide/windows-nodered-config.html
  88. https://flows.nodered.org/node/node-red-contrib-azure-iot-hub
  89. https://cloud.google.com/blog/products/application-development/using-node-red-with-google-cloud
  90. https://flowfuse.com/node-red/database/
  91. https://www.victronenergy.com/live/venus-os:large
  92. https://community.home-assistant.io/t/node-red-companion-do-i-need-it/767643
  93. https://arrowhead.eu/2021/12/12/nodered-users-can-now-easily-connect-to-eclipse-arrowhead-infrastructure/
  94. https://community.home-assistant.io/t/node-red-has-been-updated-from-v4-09-to-v4-1/903180
Add your contribution
Related Hubs
User Avatar
No comments yet.