;
};
Every value in a flow has a type. Each node output is typed, each field expects a type, and the editor uses both to decide what you can connect, what gets converted, and whether a node runs once or once per item.
## How data moves between nodes
A flow is a chain of nodes. Each node does one job and hands its result to the nodes after it. Take the example below where a flow takes a date, rewrites it as `MM-DD-YYYY` and returns it inside an object:
When a node runs, it produces one or more **outputs**, each with a type.\
In the example above the Input receives a **Date Time**, Date Operations then transforms that **Date Time** into **Text**, and Build Structured Object receives that Text and returns a key value **Object** with it.
Depending on the node's input type, its fields can hold the outputs of previous nodes, creating an iterating chain between nodes.
Each time the flow runs, every variable is replaced by the value its node produced.
### Two ways to use a variable
| | Bind the whole field | Insert it into text |
| :- | :- | :- |
| **How** | Click next to a field (or type `/` in an empty one) and pick an output. | In a prompt or text field, type `/` where you want the value and pick an output. |
| **The field gets** | The value itself, with its type: a number stays a number, a list stays a list. | Text: the value is written into the sentence around it. |
| **Example** | The **Date** field of Date Operations above. | A Generate Text prompt such as "Remind the customer of their appointment on" followed by the Formatted Date. |
The variable picker only shows outputs that fit the field, from nodes that run earlier, closest first. Your flow and workspace [variables and secrets](/platform/variables/overview) are listed there too, in a **Variables** group. Hover a variable chip to see where it comes from, its type and its last value.
## Types
The **Input** and **Output** nodes work with every type below. An Input node's **Input type** can be any of them, lists included, and an Output node takes the type of whatever you bind to it.
### Text
Any text: names, messages, prompts, generated answers. It's the most common type and the easiest target, because numbers, booleans, dates and objects all convert to it.
**Comes from:** Generate Text, Combine Text, Text Operations, etc.
**Fits into:** Text and Object fields.
**Good to know:**
* Prompts and long text fields take variables inline. Code fields (JSON bodies, headers, SQL) keep exactly what you type.
* Some single-line fields only bind whole. Text typed around a variable there is stored literally and the variable is never filled in, so build the text in **Combine Text** and bind its output.
### Number
Depending on the input or node, numbers can be **signed**, **integers** and/or **floats**.
**Comes from:** Math Operations, List Operations (Count items), table columns, etc.
**Fits into:** Number, Object and Text fields.
**Good to know:**
* A flow input of type Number turns text like `"5"` into `5`. Text that isn't a number becomes `0`.
**Convert with:** Math Operations to calculate.
### Boolean
**True** or **False**.
**Comes from:** Boolean Operations, Text Operations (Contains, Starts with), etc.
**Fits into:** Boolean, Object and Text fields.
**Good to know:**
* A flow input of type Boolean treats `"true"`, `"1"` and `"yes"` as true, and anything else as false.
**Convert with:** Boolean Operations (AND, OR, NOT and more). A Conditional node can branch on it.
### Date Time
A date, with or without a time, such as `2026-10-12 09:30:00`.
**Comes from:** Date Operations.
**Fits into:** Date Time and Object fields, and Text fields, where it's written as text.
**Convert with:** Date Operations: get the current date, the interval between two dates, extract the year or month, or format it as text such as `DD/MM/YYYY`.
### File
Documents, images, audios or any other type of file that nodes can accept.
**Comes from:** Text to File, File Converter, integrations, etc.
**Fits into:** File fields only, and prompts that send files to the model, such as Generate Text and Agent.
**Good to know:**
* Other text fields don't offer File variables. One already in the text is outlined in amber.
* A File doesn't fit Object fields: it's a record to pass along, not data to read.
**Convert with:** File Converter (format), Base64 Operations (to and from Base64 text), Text to File (text to TXT, PDF or DOCX).
### Object
key value fields, like a JSON object: `{"name": "Ana", "total": 120}`.
**Comes from:** Build Structured Object, Generate Text in Object mode, Extract from Structured, table rows, etc.
**Fits into:** Object fields, and Text fields, where it's written as JSON.
**Good to know:**
* When the source declares its fields, the Outputs tab shows an **N fields** toggle. Otherwise the output is marked **untyped**.
* The picker can't pick one field of an object. Use **Get Object Properties**: add a row per property (dots for nested values, like `customer.email`) and each becomes its own output. A missing property is empty.
**Convert with:** Object Operations (Stringify to JSON, YAML or XML), Extract from Structured (text to object), Build Structured Object (values to object).
### Lists
All of the types above can be a list: **List of Text**, **List of File**, **List of Object** and so on.
When you bind a list, the field decides what happens:
* **A list field** gets the whole list, and the node runs once. List fields only take variables.
* **A single-value field** gets one item at a time, and the node runs once per item. Its output becomes a list of the results.
**Good to know:**
* Two lists going into one node are paired item by item, so they must be the same length or the run stops. A single value, or a one-item list, is reused for every item.
* An empty list runs the node zero times, and nodes that only depend on it are skipped.
* A node runs for at most 100,000 items.
**Convert with:** List Operations (count, pick, sort, join, split), List to Single Value, Single Value to List.
## Skipped values
A node on a branch that wasn't taken, or that depends on a skipped node, doesn't run. Its outputs are **skipped**: shown with a **Skipped** badge in the run, and written as nothing when inserted into text. To bring branches back together, use **Merge Paths**, which runs as long as one of its inputs ran.
## Type errors
When a bound variable stops fitting, for example after you change or delete its source node, the field shows an amber message, the node gets an amber border with the problem listed under it, and hovering **Run** lists every issue under **Resolve the following issues**. Errors block the run; warnings don't.
| Message | Fix |
| :- | :- |
| This field expects Number, but the bound variable is List of Text. | Bind a matching output, or convert the value first. |
| Bound variable points to a node that no longer exists. | Bind the field again. |
| Bound variable isn't produced upstream of this node. | Connect the source so it runs before this node. |
| Variable not found (on a chip) | Remove the chip and insert the variable again with `/`. |
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.
