Integration Node SDK

Build custom nodes for Integration Studio workflows — define the node, its inputs and config, and what it does when it runs.

Integration Studio workflows are built from nodes — each node is one step that runs and passes its output to the next. The platform ships a catalog of common nodes (HTTP request, send email, transform, filter, conditionals, and more). When you need a step that isn't in the catalog, the Integration Node SDK is how you build your own.

Status: early (0.x). The node and manifest formats are still settling, so treat the shapes below as current rather than final.

This page covers writing a node. For building and running workflows in the editor, see Integration Studio.

Install

The SDK package is @revenexx/integrations-node-sdk. It needs Node 20 or newer.

npm
npm install @revenexx/integrations-node-sdk

The SDK is distributed through a private package registry rather than the public npm registry. Configure your .npmrc for the @revenexx scope before installing — your customer console has the registry URL and token.

Define a node

A node is a class that implements the SDK's INode interface. It has a description (what the node is, its inputs and outputs, and its config fields) and an execute method (what it does when the workflow reaches it).

Node
import type {
  INode,
  INodeContext,
  INodeDescription,
  INodeResult,
} from "@revenexx/integrations-node-sdk";

export class GreetNode implements INode {
  readonly description: INodeDescription = {
    slug: "acme:greet",
    name: { en: "Greet", de: "Begrüßen" },
    description: { en: "Builds a greeting string." },
    version: "1.0.0",
    category: "transform",
    inputs: [{ name: "in" }],
    outputs: [{ name: "out" }],
    config: [
      { key: "name", type: "string", label: { en: "Name" }, required: true },
    ],
  };

  async execute(
    _ctx: INodeContext,
    input: { name: string },
  ): Promise<INodeResult> {
    return { outputs: { out: { greeting: `Hello, ${input.name}!` } } };
  }
}

The category is one of trigger, action, transform, control, or io — it tells the editor where the node belongs. Names, descriptions, and labels are keyed by locale so the editor can show them in the user's language.

Register the node

Export your nodes from a NODES array. The package's build step reads it and generates the manifest the platform uses to discover the nodes.

index.ts
import type { INode } from "@revenexx/integrations-node-sdk";
import { GreetNode } from "./nodes/greet/GreetNode.js";

export const NODES: INode[] = [new GreetNode()];

Build the package

The SDK ships a CLI (rvnxx-nodes) that generates the manifest from your NODES array as part of the build.

Build
npm run build

This produces the compiled package plus a manifest.json. You then register the package with your tenant from the customer console; the nodes appear in the Integration Studio editor for your workflows.

Authenticating to external systems

When a node calls an external system, it uses a credential — a typed, named secret your tenant configures once and reuses across nodes. A node references a credential by type; the platform supplies the resolved secret at run time. For example, a node that calls an HTTP API with a bearer token references an HTTP-bearer credential and sends Authorization: Bearer <token> on its request.

A real node to learn from

The platform's own node catalog is the best reference for production-shaped nodes. @revenexx/integrations-nodes-core is the open library of built-in nodes (HTTP request, transforms, file I/O, and more) — each one is an INode implementation built with this SDK, so it shows the full shape of a shipped node.

Where to go next

Was this page helpful?