Workflow automation · API / SDK

Node-RED APIs

OpenJS Foundation

Administer automation runtimes and extend behavior through documented APIs.

Official documentation Download development spec

NODE-RED / DEVELOPER FIELD GUIDE

Choose an interface. Define a verifiable result.

Company or project context, ten technical entry points and a practical analysis of every reference.

2026-10-08 · Integration not tested

Company / project overview

Original summary of official company or project statements; use the source for the full original page.

Node-RED · About
Project	Node-RED is a flow-based programming tool originally developed at IBM and now part of the OpenJS Foundation.
Architecture	Its browser editor wires nodes into event-driven applications running on Node.js.
Reuse	Flows use JSON for sharing; community nodes extend functionality but require their own review.

Complete official About page ↗

About reference — TA analysis
Audience	Buyers, partners and product owners shortlisting an AI provider.
Our assessment	Use positioning and company history for initial fit. Obtain project-specific deployment, support and commercial terms separately.

Official sources reviewed; no live API, inference or benchmark was run. Expected results are proposed internal contracts.

Top 10 technical entry points

Ten documented technical entry points selected by developer task; not ten separate SDKs or an official ranking.

Choose by the work you need to complete
Interface	Purpose and audience
01 · Admin HTTP APIAPI / SDK / developer guide	Read or administer runtime configuration remotely.Runtime administrators
02 · Hooks APIAPI / SDK / developer guide	Insert code at documented runtime hooks.Runtime extension developers
03 · Storage APIAPI / SDK / developer guide	Replace the runtime storage implementation.Persistence implementers
04 · LoggingAPI / SDK / developer guide	Configure runtime logs and custom destinations.Operations teams
05 · Context Store APIAPI / SDK / developer guide	Provide custom storage for node, flow and global context.Stateful flow developers
06 · Library Store APIAPI / SDK / developer guide	Add import/export library backends.Shared library maintainers
07 · Editor APIsAPI / SDK / developer guide	Use supported editor widgets and extension APIs.Custom node UI developers
08 · Module APIsAPI / SDK / developer guide	Embed Node-RED modules in a Node.js application.Embedded application teams
09 · Writing FunctionsAPI / SDK / developer guide	Transform and route message objects with JavaScript.Flow logic developers
10 · Creating NodesAPI / SDK / developer guide	Package reusable runtime and editor functionality.Node package authors

Reference analysis

Capabilities summarize official documentation. Constraints and proposed tests are our engineering assessment.

API / SDK / developer guide

Admin HTTP API

Admin HTTP API · TA
Target audience	Runtime administrators
Documented capability	Read or administer runtime configuration remotely.
Input → output	Authorized administration request → configuration response.
Execution environment	Pinned Node-RED and supported Node.js runtime
Our decision constraint	Admin endpoints control the runtime, not ordinary flow business outputs.
Our suggested validation	Verify authentication and deployed revision before mutations.

Official reference · Admin HTTP API ↗

API / SDK / developer guide

Hooks API

Hooks API · TA
Target audience	Runtime extension developers
Documented capability	Insert code at documented runtime hooks.
Input → output	Runtime event → extension behavior.
Execution environment	Pinned Node-RED and supported Node.js runtime
Our decision constraint	Hooks can affect message handling and must not silently drop work.
Our suggested validation	Test success and exception paths with correlated messages.

Official reference · Hooks API ↗

API / SDK / developer guide

Storage API

Storage API · TA
Target audience	Persistence implementers
Documented capability	Replace the runtime storage implementation.
Input → output	Runtime state → persisted and recovered data.
Execution environment	Pinned Node-RED and supported Node.js runtime
Our decision constraint	Backend failure must not be reported as a successful durable save.
Our suggested validation	Restart and verify flows and required stored settings recover.

Official reference · Storage API ↗

API / SDK / developer guide

Logging

Logging · TA
Target audience	Operations teams
Documented capability	Configure runtime logs and custom destinations.
Input → output	Runtime events → log entries.
Execution environment	Pinned Node-RED and supported Node.js runtime
Our decision constraint	Debug payloads may contain sensitive data and need explicit policy.
Our suggested validation	Verify error visibility and redact credentials before collection.

Official reference · Logging ↗

API / SDK / developer guide

Context Store API

Context Store API · TA
Target audience	Stateful flow developers
Documented capability	Provide custom storage for node, flow and global context.
Input → output	Context get/set → scoped values.
Execution environment	Pinned Node-RED and supported Node.js runtime
Our decision constraint	Store implementations can differ in synchronous and asynchronous access.
Our suggested validation	Check missing keys, write errors and restart persistence.

Official reference · Context Store API ↗

API / SDK / developer guide

Library Store API

Library Store API · TA
Target audience	Shared library maintainers
Documented capability	Add import/export library backends.
Input → output	Library lookup/save → reusable flow content.
Execution environment	Pinned Node-RED and supported Node.js runtime
Our decision constraint	Stored flow credentials and environment dependencies require separate handling.
Our suggested validation	Round-trip a fixture and check no secret enters shared exports.

Official reference · Library Store API ↗

API / SDK / developer guide

Editor APIs

Editor APIs · TA
Target audience	Custom node UI developers
Documented capability	Use supported editor widgets and extension APIs.
Input → output	Editor input → node configuration.
Execution environment	Pinned Node-RED and supported Node.js runtime
Our decision constraint	Editor validation cannot replace runtime input validation.
Our suggested validation	Check configuration save/reopen and invalid-input feedback.

Official reference · Editor APIs ↗

API / SDK / developer guide

Module APIs

Module APIs · TA
Target audience	Embedded application teams
Documented capability	Embed Node-RED modules in a Node.js application.
Input → output	Host application configuration → embedded runtime.
Execution environment	Pinned Node-RED and supported Node.js runtime
Our decision constraint	Host lifecycle and runtime startup/shutdown must be coordinated.
Our suggested validation	Exercise startup failure and clean shutdown without duplicate listeners.

Official reference · Module APIs ↗

API / SDK / developer guide

Writing Functions

Writing Functions · TA
Target audience	Flow logic developers
Documented capability	Transform and route message objects with JavaScript.
Input → output	msg object → zero, one or more downstream messages.
Execution environment	Pinned Node-RED and supported Node.js runtime
Our decision constraint	Returning null intentionally stops propagation; new objects can lose req/res fields.
Our suggested validation	Preserve correlation and required properties; complete asynchronous work explicitly.

Official reference · Writing Functions ↗

API / SDK / developer guide

Creating Nodes

Creating Nodes · TA
Target audience	Node package authors
Documented capability	Package reusable runtime and editor functionality.
Input → output	Node definition and messages → reusable processing node.
Execution environment	Pinned Node-RED and supported Node.js runtime
Our decision constraint	Third-party dependencies need version and runtime compatibility review.
Our suggested validation	Test deployment, message handling and close cleanup.

Official reference · Creating Nodes ↗

API reference

API reference · Supporting reference analysis
TA	Integration architects
Our validation advice	Choose administration, runtime extension or flow-level messaging interfaces explicitly.

Official reference · API reference ↗

04 / INPUT · EXPECTED OUTPUT · ACCEPTANCE

Expected results before implementation

Proposed flow message-processing receipt, not Node-RED Admin API output. No flow was deployed, message sent, or external system triggered.

Illustrative contract · no API call or model execution · not measured provider output

Message transformed

Expected behavior — illustrative, not executed
Input	Authorized sample with numeric temperature and correlation ID.
Expected result	ok with one normalized downstream message.
Acceptance	Preserve correlation and units; verify expected output exactly once.

Intentional filtering

Expected behavior — illustrative, not executed
Input	Message fails a declared filter and Function returns null.
Expected result	ok/filtered with output_count: 0 in our receipt.
Acceptance	Differentiate intended filtering from crash or disconnected nodes.

Asynchronous pending

Expected behavior — illustrative, not executed
Input	Node starts an external asynchronous operation.
Expected result	pending until completion; no premature delivery confirmation.
Acceptance	Call completion paths once and use a bounded timeout policy.

Invalid message

Expected behavior — illustrative, not executed
Input	Payload has wrong units or missing required value.
Expected result	error routed to explicit handling; no downstream action.
Acceptance	Catch the error with correlation; do not leak credentials in debug logs.

Map the expected result to your application

Map the actual SDK or service response into this proposed internal contract after integration. All IDs and values below are invented examples; no credentials or live requests are included.

Expected output JSON — illustrative, not measured · NodeREDAPI-expected-results.json

{
  "schema_version": "1.0.0",
  "example": true,
  "provider": "Node-RED",
  "status": "ok",
  "input_id": "sample-001",
  "data": {
    "flow_id": "example-flow",
    "message_id": "example-message",
    "output_count": 1,
    "payload": {
      "temperature_c": 24
    },
    "side_effect_confirmed": false
  },
  "error": null,
  "verification": "illustrative-only;not-provider-response"
}

Download specification, example and acceptance plan

Engineering handoff — our proposed contract and gates
Result interpretation	Successful transport or execution does not establish model accuracy. Preserve valid empty results separately from operational failure.
Reproducibility	Record model, runtime, configuration and input identifiers; agree quality and latency criteria before representative tests. No measured performance is claimed.
Operation boundary	Proposed flow message-processing receipt, not Node-RED Admin API output. No flow was deployed, message sent, or external system triggered.

Development assessment

Factory notification flow

Development concept · integration not tested

Provider capabilities above are based on official documentation or repositories. The proposed product, inputs, deliverable and acceptance criteria below are our development assessment.

Small prototype

Test one documented operation with a small real sample after access is confirmed. This is a development judgment, not a delivery estimate.

Proposed inputs: A sample event, authorized systems and one defined workflow transition.
Proposed deliverable: A visible job state and audit trail for a single workflow.
Acceptance criterion: A retried event must not create duplicate work; an unavailable upstream must remain visibly pending or failed.
Dependencies: Runtime access, workflow permissions and a reviewed notification or write destination.

Development sequence

Confirm access to Node-RED APIs, license and the exact supported version.
Prepare the sample above and implement one documented operation for “Factory notification flow”.
Normalize the result with source, time and explicit error state; keep the provider response for review.
Run the acceptance criterion before estimating rollout effort or committing a customer deliverable.

How to validate demand

Record product views, documentation clicks, specification downloads and contextual hub clicks. These are event counts, not unique people or completed integrations.

This feasibility assessment uses implementation conditions. No traffic-based rank or delivery-time promise is assigned.

Node-RED APIs

Choose an interface. Define a verifiable result.

Company / project overview

Top 10 technical entry points

Reference analysis

API reference

Expected results before implementation

Message transformed

Intentional filtering

Asynchronous pending

Invalid message

Map the expected result to your application

Factory notification flow

Development sequence

How to validate demand

Related products