Introdução

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

Visão geral

In this tutorial, you will build Price Watch: a Maestro Flow that fetches a live currency exchange rate from an external API, compares it against a threshold you set, and returns either an alert or a no-action result based on the threshold. The flow is six nodes long, so the focus stays on how Flow wires data between nodes rather than on the domain logic.

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.

O que você está criando

We are going to build the rest of the Price Watch Flow, which takes three inputs on its manual trigger and returns one object. 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"

The node IDs in that diagram are the ones we will build, and every expression in this tutorial uses their IDs as shown. Keep them as they are, or update every expression that references them.

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

Component	Detalhes
Entrada: baseCurrency	string, default USD; the currency to price from
Entrada: quoteCurrency	string, default EUR; the currency to price into
Entrada: alertThreshold	number, default 0.9; alert when the rate falls below this value
Saída: 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

The API you will call

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 suits a first tutorial.

A live response for the USD to EUR rate is a JSON array with one entry per quoted currency:

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

That 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.

Pré-requisitos

• 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.

Dica:

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

Scaffold the solution and the flow project. A Flow project always lives inside a solution, which is the deployable unit the platform packages and publishes, so the solution comes first. Both build paths start here.

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

   # Create the solution
   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
   

   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 writes a resources/ tree at the solution root, which is generated state that packaging regenerates; leave it alone.

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

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

5. Open PriceWatch/PriceWatch.flow in VS Code.

   With the UiPath Maestro extension installed, the file opens on the visual canvas instead of as raw text, so you watch nodes and edges appear as they are written.

   

Estimated time: 30 minutes.

---

We are now ready to build our Flow.