Inputs left, outputs right
A node takes what it needs on one side and offers its results on the other. What connects to what is visible on the canvas rather than implied by the order of lines in a file.
Node LibraryA journey is assembled,
A journey is assembled,
not written.
Every step of a flow is a node: a single operation with typed inputs on one side and typed outputs on the other. Over 100 of them across 17 categories — and the list is not fixed, because the library is meant to be extended.
What a node is
A flow is a graph, not a script. Each operation is a node, and directional links define both the execution path and the data travelling along it.
Outputs are typed
Success, warning and error are distinct exits, not one return value you have to inspect. The branch for the case that went wrong is drawn, which means somebody had to decide what it does.
Front end or back end
A node either runs in the browser, where the person can see it, or on the server, where they cannot. Each node says which it is, so a journey never hides where the work is happening.
Categories
What is in the palette
Nodes are grouped by what they are for. The proportions are informative on their own: the largest category is the general-purpose one, because most of a journey is deciding and transforming rather than calling.
Flow Nodes
6Where a flow starts and ends, how one flow calls another, and how a result is handed back to whoever asked.
User Management
12The user record itself: create it, read it, search for it, change it, move it through its lifecycle.
User Groups Management
4Group objects and the membership that attaches a person to them.
User Applications Management
1The link between a person and an application they are entitled to reach.
User Roles Management
3Assigning and removing roles as the journey decides they apply.
User Session Management
6Opening a session, inspecting what is in it, and closing it before it outlives its reasons.
Federated Identity Providers
1Handing authentication to an external provider and picking the journey back up afterwards.
OpenID Providers
2The steps specific to OpenID Connect providers.
LDAP and Active Directory
8Directory-native operations, for the systems where identity has lived the longest.
User Agent components
8Everything that happens in the browser: prompts, redirects, forms, what the person actually sees.
One Time Password
4Generating a one-time code and checking the one that comes back.
Fido and Passkeys
2Registering a public-key credential and verifying an assertion against it.
Encryption and signing
8Tokens, hashes and signatures, for the moments a flow has to prove something rather than assert it.
Server side components
7Server-side logic and calls out to the systems that hold the answer.
Utility components
24The general-purpose toolkit — variables, conditions, transformation, control. The largest category, which is what you would expect.
Custom Session
4Session data you define yourself, for the state a standard session was never meant to carry.
Application consent management
3Asking for consent, recording it, and letting it be taken back.
Where nodes appear
Not everything belongs everywhere
A node declares which kinds of flow it is available in. It is why the palette stays readable: designing a consent journey does not put every directory operation in front of you.
Authentication
The journeys that end with somebody signed in.
Self Service
What a person does for themselves: recovery, profile, credentials.
Admin
What an administrator does on somebody else's behalf.
API
Flows invoked by a system rather than walked by a person.
Consent
Capturing and revoking permission.
Library
Reusable sub-flows, called by the others instead of copied into them.
Custom
Journeys that do not fit the shapes above.
User Defined
Categories you create yourself.
Extending it
A library, not a fixed set
The nodes that ship with the platform are a starting point. What you add sits beside them, with the same shape and the same rules.
Your own categories
Alongside the categories that ship with the platform you can define your own, with their own name, colour, icon and position in the list. The library is organised the way your team thinks about it.
Your own node types
A node type is a metadata definition: bundle, name, category, and the flow categories it should appear in. Define one and it takes its place in the palette next to the built-in nodes.
Your own inputs and outputs
A custom node declares the inputs it expects and the outputs it can take, each with a level — success, warning, error — so the branches downstream can tell the difference.
Localisation and lifecycle
Display name and description can be set per language. Node types that have been superseded can be marked deprecated rather than deleted, so existing flows keep working while new ones move on.
Categories and counts reflect the current product documentation and move with each release. What a specific node does, what it expects and what it returns is documented per node — this page is the map, not the reference.
Bring us a journey and we'll show you the nodes
The quickest way to judge a node library is to watch somebody build your flow with it.
Talk to an expert