Introduction

Build a workflow to fetch a live currency exchange rate and send an alert if it is below a certain threshold.

Overview

In this tutorial, we will build the Price Watch workflow: a Maestro Flow that fetches a live currency exchange rate from an external API, compares it against a threshold we set, and returns either an alert or a no-action result based on the threshold. This showcases how a workflow can have branching logic based on values it retrieves. The flow is six nodes long, so the focus stays on how Flow wires data between nodes rather than on a more complex workflow with multiple logic branches.

Estimated time: 30 minutes.

What is Maestro

Maestro is a cloud-native orchestration platform that unifies automation, AI agents, and human interactions into streamlined, end-to-end business processes. It is one engine with three modeling surfaces:

• Maestro Flow (.flow) for developer-authored orchestration.
• Maestro BPMN (.bpmn) for Business Process Model and Notation diagrams that business stakeholders review.
• Maestro Case Management (caseplan.json) for exception-heavy human work.

Flow is a different modeler built on the same runtime as Maestro BPMN, designed for developers who prefer a visual, node-based experience over BPMN notation. If you have built Robotic Process Automation (RPA) workflows or read a BPMN diagram before, the concepts transfer directly; what changes is the ergonomics. For guidance on picking a surface, see Choosing a Maestro modeler.

What you are building

We are going to build the rest of the Price Watch Flow, which takes three inputs on its manual trigger and returns one object with the result based on our logic. Every node in the Flow has a single job, and the Flow connects them to create the full workflow.

Below is a text diagram of the different nodes, how they are connected, and shows details about each one's purpose:

     start              fetchRate1           reshapeRate1        belowThreshold1
┌──────────────┐      ┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│ Manual       │─────▶│ HTTP Request │────▶│ Script       │────▶│ Decision     │
│ trigger      │      │              │     │              │     │              │
└──────────────┘      └──────────────┘     └──────────────┘     └──────┬───────┘
 baseCurrency          GET /v2/rates        reads .body          rate below
 quoteCurrency         ?base&quotes         returns pair,        threshold?
 alertThreshold                             rate, asOf,                │
                                            belowThreshold             │
                                                                ┌──────┴──────┐
                                                           true │             │ false
                                                                ▼             ▼
                                                           endAlert1     endNoAction1
                                                          ┌──────────┐  ┌──────────┐
                                                          │ End      │  │ End      │
                                                          └──────────┘  └──────────┘
                                                           "alert"       "no action"

Tip:

We will use the node ID values shown above by updating them for readability from the generated ones - the instructions will show you how to update each of them.

The following is the list of all the components that will make up the Flow:

Component	Details
Input: baseCurrency	string, default USD; the currency to price from
Input: quoteCurrency	string, default EUR; the currency to price into
Input: alertThreshold	number, default 0.9; alert when the rate falls below this value
Output: watchResult	object with pair, rate, asOf, and belowThreshold
Node (Manual trigger): start	Starts the run on demand and carries the three inputs into the flow
Node (HTTP Request): fetchRate1	Sends a GET request to the Frankfurter exchange-rate API
Node (Script): reshapeRate1	Reads the response body and returns pair, rate, asOf, and belowThreshold
Node (Decision): belowThreshold1	Evaluates belowThreshold and takes either the true or the false path
Node (End): endAlert1	Returns watchResult as an object with the values pair, rate, asOf and belowThreshold from the reshapeRate1 node
Node (End): endNoAction1	Returns watchResult as an object with the values pair, rate, asOf and belowThreshold from the reshapeRate1 node

Currency Exchange API

To get real exchange rate values, we will use Frankfurter, a free, open-source currency data API that tracks daily exchange rates from institutional sources. It needs no API key, no account, and no authentication header, which is why it is a good fit for building your first Flow.

An example response for the USD to EUR rate from the API contains a JSON array with one entry per quoted currency:

[
  {
    "date": "2026-09-01",
    "base": "USD",
    "quote": "EUR",
    "rate": 0.86111
  }
]

Note:

The array shape matters for the Script node you build later: the rate is not at a fixed path, so the script looks up the entry whose quote matches your quoteCurrency input rather than reading a known key.

Prerequisites

• Node.js and npm on your PATH - the UiPath command-line interface (CLI) (uip) installs with npm. Check with node --version and npm --version, and install from nodejs.org if either is missing.
• A UiPath account - sign up or log in to UiPath Automation Cloud before starting.
• A tenant with Maestro Flow enabled - debug runs and deployment both route through your selected tenant.
• Network access to your UiPath environment - CLI sign-in uses an OAuth browser flow with a callback on localhost port 8104.
• VS Code 1.110.0 or higher with the UiPath Maestro extension - required to build on the canvas, and useful on either path for watching the flow take shape. Check your version in Code > About Visual Studio Code, or run code --version.

No prior UiPath experience is required, and you do not need Studio Web open at any point in this tutorial.

Tip:

Working in a remote workspace? In Windows Subsystem for Linux (WSL), Secure Shell (SSH), Codespaces, and dev container workspaces, the extension runs on the remote host, so the UiPath CLI must be installed there rather than on your local machine.

If you have not installed the prerequisites before, follow the steps to set up your environment for UiPath tutorials. Use uip --version and uip login status to verify that the CLI is installed, and you have authenticated it.

Step 1 - Scaffold the Price Watch flow

A solution is the deployable unit that contains one or more projects that we will be using to package and deploy our Flow. Let's start by creating the solution first, and then the Flow project inside it:

1. Create the solution - it creates a directory with the name you specify via uip solution init <solution name>.

   uip solution init tutorial-maestro-flow-price-watch
   

2. Change into the newly created solution directory.

   cd tutorial-maestro-flow-price-watch
   

3. Create the Flow project inside the solution.

   uip maestro flow init PriceWatch
   

   Note:

   The flow init command creates the PriceWatch/ directory containing PriceWatch.flow (the only file you edit), project.uiproj, and operate.json. When flow init is run from inside a solution directory, it also registers the project with the parent solution and reports "Status": "Registered". It also creates a folder resources/ at the solution root that contains the generated state that packaging regenerates each time we deploy, but you won't need to edit these files for this tutorial.

4. Confirm that the Flow was scaffolded with a single trigger node:

   uip maestro flow node list PriceWatch/PriceWatch.flow --output table
   

   You should only see a single line for trigger in the output - your X and Y coordinates may differ as these change as you move nodes in the visual Canvas:

   Id              | Type                | Label           | Position                         
   ----------------|---------------------|-----------------|----------------------------------
   start           | core.trigger.manual | Manual trigger  | {"X":-192,"Y":0}
   

5. Open the PriceWatch/PriceWatch.flow file in VS Code. With the UiPath Maestro extension installed, the file opens on the visual canvas instead of as raw text, allowing you to see the visual representation of your workflow.

   

---

Next Step

We are now ready to build our Flow.