- Introduction
- Getting started
- Build on any canvas
- Build with Case
- Reference
- Defining case keys (system vs. external)
- Establishing task I/O and write-back contracts
- Modeling primary and secondary stages
- Triggering a case from Data Fabric
- Implementing stage-level personas and permissions
- Setting SLAs and automated escalation rules
- Configuring a rework loop (re-entry)
- Configuring and testing the Case Manager Agent (preview)
- Build with Flow
- Build with BPMN
- Operating
- Monitoring
- Optimizing
- Reference information
Connector nodes
Connector nodes that integrate third-party services directly on the canvas with pre-built operations.
What they are
Connector nodes let you work with other apps directly from the canvas, without setting up HTTP requests yourself. Each connector provides ready-made nodes for one app, such as GitHub, Salesforce, Slack, or Microsoft 365, with typed inputs and outputs, and a connection that handles sign-in for you.
Connector nodes are in the Connector category of the Add node panel. The category starts with HTTP Request, which calls any web address, followed by the apps, from Act! 365 onward. Each app opens the list of its actions.
Available connectors
The connectors available to you depend on your organization, and the Connector category of the Add node panel lists all of them. They cover apps such as Salesforce, ServiceNow, and Slack. Popular connectors links to the most common ones, and Connectors in the Integration Service guide documents each one, with its setup, sign-in, and operations.
How they work
The Add node panel lists the connectors available in your organization. Each connector node maps to a specific API operation on the target service.
When you add a connector node to the canvas, Maestro Orchestrate fetches its input schema and renders a dynamic configuration form in the properties panel. You fill in the required fields, select a connection for authentication, and the node handles the API call at runtime.
Configuration
Connection
Every connector node needs a connection, which signs UiPath in to the app with your account. You select the connection in the properties panel when you set up the node. The connection field lists the existing connections, grouped by folder, with Add new connection to create one without leaving the canvas, and Open connections to review all of them. Create a connection has the steps.
Connections handle token refresh, OAuth workflows, and credential storage automatically. Auth headers and secrets are not managed directly. Connections are managed by Integration Service. Connections in the Integration Service guide describes how to share and manage them.
Node-specific inputs
Each connector node has its own input fields based on the API operation it wraps. The properties panel renders these dynamically. You'll see different fields for a "Create Issue" node than for a "List Repositories" node, even within the same connector.
All input fields support variable expressions ($vars.<nodeName>.<property>).
Output
Connector node output is available at $vars.<nodeName>.output. The shape of the output depends on the specific node and the API it calls.
// Access the output of a GitHub connector node named "listBranches1"
$vars.listBranches1.output
// Access the output of a GitHub connector node named "listBranches1"
$vars.listBranches1.output
Error handling
Connector nodes support error handles. If the API call fails and an error handle is connected, the run continues on the error path with the standard error object at $vars.<nodeName>.error.
Error handling has the details.
Connector triggers
Some connectors also provide triggers: start events that fire when something happens in the external service (e.g., a new email arrives, a form is submitted). Connector triggers appear in the Triggers section of the node palette.
Trigger inputs are owned by the trigger and accessed as $vars.<triggerName>.output.<inputName>. Triggers has the details.
When to use a connector vs HTTP Request
| Use a connector node when... | Use HTTP Request when... |
|---|---|
| A connector exists for your target service | No connector exists for the service |
| You want typed inputs and outputs with no manual configuration | You need full control over headers, query parameters, and body |
| You want a connection to handle sign-in for you | The API uses a non-standard auth scheme |
| You want a maintainable process that adapts to API changes | You're prototyping against a new or internal API |
Rule of thumb: The node palette is the first place to check for a connector. HTTP Request is the fallback when no connector exists for the target service.
Next steps
- Popular connectors: the most common apps, with a link to each connector
- Create a connection: create a connection from the node
- HTTP Request node: general-purpose API calls when no connector exists
- Triggers: connector-based triggers and other trigger types
- Error handling: handling failures from connector nodes
- Variables and data flow: accessing connector output with
$vars