The Binse Data Flow user guide.

Version 0.1.0. Copyright 2026 Binse Analytics. All rights reserved.

Data Flow is the workspace of Binse for preparing, joining and summarising data without code. (It was called Data Analytics until September 2026; only the name changed.) You build a flow on a canvas from tools such as Data Source, Filter, Join and Group & Aggregate, connect them left to right, press Run, and click any tool to see its data. Existing workflow files (.yxmd, .yxmc, .yxwz) can be imported, with their tools, formulas and connections.

Under the hood every tool runs on a fast columnar engine (Polars), so files of many millions of rows are fine on an ordinary laptop. All data stays on your machine: the only thing the app sends is its licence check (see Licensing), which never includes your data.

Contents

• Getting started
• The screen
• Working with flows
• Running and results
• Databases and APIs
• File formats
• Tidying a large flow
• Macros
• Parameters
• Sending results to Dashboards
• Tools reference
• Formula language
• Function reference
• Importing workflows
• Licensing
• Keyboard shortcuts
• Troubleshooting
• Glossary

Getting started

1. Open Binse (or Binse Enterprise) from the desktop shortcut and choose Data Flow on the home page (or press 1 there). The first time, it asks for a licence: paste the licence key from your receipt email into the Licence key box and press Activate. See Licensing. To keep it on the taskbar, right-click its taskbar button and choose Pin to taskbar.
2. Drag Data Source from the palette on the left onto the canvas. In the panel on the right, click Browse and choose a CSV or Excel file. The tool's node shows the number of rows it will read once the flow has run.
3. Drag a Filter onto the canvas. Drag from the circle on the right of Data Source to the square on the left of Filter to connect them. Pick a field and a condition.
4. Press Run (or F5). Row counts appear under every tool. Click a tool to see its data in the results panel at the bottom; the Filter has two outputs, True and False, shown as tabs.
5. Drag a Write Data tool, connect it to Filter's T output, choose where to write the file, and Run again.
6. Save (Ctrl+S) stores the flow as a small JSON file you can reopen, copy, or email. Turn on Autosave beside it and the file is kept up to date from then on.

The screen

Palette (left). Every tool, grouped by category. Drag a tool onto the canvas, or double-click it to add it. The search box filters by name or description.

Canvas (centre). Your flow. Tools are boxes with input ports (squares) on the left and output ports (circles) on the right. Drag from an output port to an input port to connect them. Drag empty space to pan, use the mouse wheel to zoom, and the buttons in the bottom-left corner to zoom to fit. Right-click a tool for Run to here, Duplicate and Delete. Under each tool you see its state: the row count after a run, the number of fields before a run, or a red error message.

Configuration (right). The options for the selected tool. Field pickers show the fields that arrive at that tool, updated live as you change upstream tools. Problems are shown in red at the top of the panel before you run anything. The Annotation box gives a tool a label of your own, shown on the canvas.

Results (bottom). One tab per output of the selected tool, with a data grid:

• Click a column header to sort; click again to reverse; a third time clears the sort.
• Drag the edge of a header to resize a column.
• Find in data filters rows to those containing the text in any field.
• Profile opens a column summary: type, nulls, unique values, min, max, average, and the most common values when you click a column.
• Export writes the data shown to a CSV, Excel or Parquet file.
• The Messages tab lists timings, warnings and errors for every tool after a run.

Footer. The right-hand end shows the licence holder and the engine's memory: what the engine is using and what the machine has free, turning amber when less than a fifth is free and red below a tenth. The engine keeps memory it has freed for reuse, so the figure stays high after a big run; Restart relaunches the engine in a couple of seconds and hands the memory back to Windows. Your unsaved work stays in the window and results are re-read from the cache.

Tabs (under the toolbar). Every open flow is a tab. New opens a fresh tab; Open opens a flow in a new tab (or switches to it if it is already open). A dot on a tab means unsaved changes.

Working with flows

Ports. Most tools have one input and one output. Filter has True and False outputs; Remove Duplicates has Unique and Duplicates; Join has Left (L), Join (J) and Right (R) inputs and outputs; Wait Until Done has three outputs. Stack Rows accepts any number of inputs on its single port.

Connecting. Drag from an output circle to an input square. An input port normally takes one connection; connecting a second replaces the first. Loops are not allowed. Delete a connection by clicking it and pressing Delete.

Selecting and editing. Click a tool to select it. Delete removes the selection. Ctrl+Z and Ctrl+Y undo and redo every change to the flow, including configuration edits.

Saving. Ctrl+S saves; the first time it asks where. Save as… in the Save menu writes a copy anywhere. Flows are JSON text files: small, diffable, safe to email. File paths inside a flow can be relative to the flow's own folder, which keeps flows portable.

Autosave. The switch beside Save keeps the flow's own file up to date: a couple of seconds after you stop making changes, it is written. It shows the time of the last write, so you can see it happening. A flow that has never been saved has no file to write to, so turning autosave on asks you where to keep it first. Until there is a file the switch stays in the off position and says so: a switch that sits in the on position is a promise that your work is being written, and it should never be making that promise idly. If a write ever fails, because the file is read-only or the drive it lives on has gone, autosave switches itself off, says why, and leaves your changes unsaved so you know to deal with it. It never keeps trying quietly. The switch is yours, not the flow's: it stays as you left it for every flow you open.

Choosing a file. Browse opens the file picker. Above the folder it shows the files you have opened lately, ten of them, newest first, so yesterday's file is one click rather than six folders away. The list is checked before it is offered: a file that has been moved or deleted is greyed out and struck through, and clicking it takes it off the list rather than pretending to open it. The list is kept in this browser, not in the flow, and each picker shows only the files it would accept.

Explain this flow. Explain in the top bar writes out what the open flow does in plain English: what it reads, what it does to the rows in order, what it writes, what it asks for before it runs, and anything worth knowing - tools that are switched off, tools connected to nothing, the notes on the canvas. Copy as text puts the same words on the clipboard for a handover note. The words are worked out from the flow itself, from the tools' own names and what each one is set to. Nothing is sent anywhere, and the same flow always explains itself the same way.

Notes. The Note tool is a sticky note on the canvas with no data. Use it to explain sections of a flow to the next person.

Running and results

Run (F5) runs the whole flow. Run to here (Shift+F5, or right-click a tool) runs only the tools the selected tool depends on, which is the quickest way to check a change part-way through a large flow.

Caching. Every tool's output is stored after a run. When you run again, tools whose settings and inputs have not changed are served from that store instantly and marked "cached" in Messages; only what changed is recomputed. Editing a tool half-way down a flow therefore reruns only that tool and the ones after it. Input files are checked by size and modification time, so a changed file is always re-read. Clear cached results in the Save menu empties the store.

Memory. CSV and Parquet files stream through the engine, so their size hardly matters. Excel workbooks have to be read whole, so each one is read on its own, parked in the cache as Parquet and released before the next: a folder of workbooks costs the memory of one workbook, not all of them, and workbooks that have not changed are not read again on later runs. Dropping an Excel input on the canvas reads only a sample to find the fields. The footer shows the engine's memory at all times (see The screen).

Errors. A tool with a problem shows red on the canvas and explains the problem in the configuration panel and in Messages. Tools downstream of an error are skipped and show "An upstream tool has an error".

Types. Each field has a type: String, Int64, Float64, Boolean, Date, DateTime. Data Source guesses types from the data; use Read all fields as text on messy files, then convert with Choose Fields or Detect Types. Comparisons and functions convert sensibly (a String field compared with a number is compared numerically), and the Formula tool shows the type each expression produces.

Databases and APIs

Data Source reads more than files. Set Read to Database or API and it runs a query instead.

Connections are shared with Dashboards. A connection you set up in either workspace is immediately available in the other, because both read the same list. You can manage that list from the home page (Connections to databases and APIs), or make one without leaving the canvas using the + button beside the connection picker.

Setting one up

1. Choose the kind of source. SQLite and REST/JSON work on any installation; SQL Server, Azure SQL, PostgreSQL, MySQL, Oracle, Redshift, Trino, Snowflake, BigQuery, Databricks and anything with an ODBC driver work through drivers that ship with the app. If one is unavailable the list says so and says what is missing.
2. Give it a name and a connection string. The placeholder text shows the shape each kind expects.
3. Never put a password in the connection string. Write ${BINSE_DB_PASSWORD} where the password goes and either set that as a Windows environment variable, or type the password when you connect. A typed password is held in memory for that session only and is never written to disk. Saving a connection string with a plain password in it is refused.

Writing the query

Type SQL that returns the rows you want. For a REST source, leave the query blank to use the profile's URL, or put a full URL in it.

Maximum rows caps what comes back, and the cap is applied at the source where the database supports it - so a limit of 1,000 against a billion-row table transfers a thousand rows, not a billion. Leave it at 0 to read everything the query returns.

While you are designing

The canvas needs to know a query's fields to show them in the tools after it, so it reads a small sample - a couple of hundred rows, limited at the source. That sample is reused for a minute, so editing the query does not send a request on every keystroke. Saving or changing a connection clears it immediately.

A run always asks the database again. A file input can be cached on the file's own timestamp, but a query cannot, so every Run re-reads the source. A flow will not quietly report last week's numbers.

Writing back

Write to Database writes the incoming rows to a table. Choose whether to add to the table, replace everything in it, or stop with an error if it already exists. Only SQL databases can be written to; a REST source cannot.

File formats

A note from this site, not from the guide. One read-only format, .yxdb, is missing from the table below, because its row names another vendor’s product.

Data Source reads, and Write Data and the results pane's Export write, the types below. The table is generated from the engine itself, so it is exactly what this version does.

Text. CSV, tab (.tsv, .tab) and pipe (.psv) separated files stream through the engine and are never held in memory whole. Delimiter can also be Fixed width - give the widths as 10, 5, 8 or as character ranges 1-10, 11-15, 16-23 - or None, which reads each whole line into one field (named from the first line, or Field_1). Encoding converts Windows-1252, DOS, Shift-JIS or GBK text; a UTF-16 file is recognised by its byte-order mark whatever the setting. An .asc file whose first line starts with ncols is an ESRI ASCII grid and is read as one; any other .asc is text. A .tab file that starts with !table is a MapInfo table; otherwise it is tab separated text.

XML. One row per repeating element. Leave Repeating element blank and the shallowest element that repeats is used; or name it (Order, or Orders/Order). Attributes become fields, child elements become fields named by their tag, and nested elements are joined with an underscore (Address_Town). Numbers and ISO dates are recognised unless Read all fields as text is ticked; codes with leading zeros stay text. Writing produces <Rows><Row><Field>... with the names you choose; a null value is left out of its row.

HTML. Each <table> on the page is listed; the first row becomes the field names.

Spreadsheets. Every sheet of .xlsx, .xlsm, .xlsb, .xls and .ods is listed. Writing .xls is limited by the format to 65,535 rows and 256 fields. Macro (.xlsm) and binary (.xlsb) workbooks are read only - write .xlsx instead.

Databases. Pick a table (or view), or write a SQL query that runs inside the file. Paths with the table after ||| also work: C:\data\shop.accdb|||Orders or ...|||select * from Orders. Writing creates the file if needed; If the table exists replaces it or adds the rows. Access files are read through Microsoft's Access ODBC driver when it is installed and, when it is not, tables are still read by a built-in reader; SQL queries and writing need the driver, which comes with 64-bit Office or as the free Microsoft Access Database Engine 2016 Redistributable (64-bit). An ESRI personal geodatabase is an Access .mdb: its feature classes are listed and their shapes are read as geometry. dBase files are written as dBase III: field names up to 10 characters, text up to 254.

Statistical. SAS datasets (.sas7bdat) are read only; SAS transport (.xpt), SPSS (.sav, .zsav) and Stata (.dta) are read and written. Use value labels instead of codes reads the labels (Male/Female) instead of the stored codes (1/2). These formats have no missing text value, so an empty text field reads back as empty rather than null; true/false is stored as 1/0.

QlikView QVX and YXDB. QVX files are read and written, including the dual values Qlik itself writes. .yxdb files are read, spatial objects included; how to write them is not published, so they are read only. Written QVX stores true/false as 1/0.

Spatial files. Shapes are read as WKT text - POINT (-6.26 53.35), POLYGON ((...)) - in a field called SpatialObj (the name imported workflows expect; change it with Geometry field name). By default coordinates are converted to WGS 84 longitude/latitude, which is what the Spatial tools expect; untick Convert coordinates to WGS 84 to keep the file's own system, and tick Add a field with the coordinate system to see which one it was. Height (Z) values are dropped. For writing, choose the field that holds WKT and the Coordinate system its coordinates are in (EPSG:4326 for longitude/latitude, EPSG:27700 for British National Grid). A shapefile, file geodatabase or MapInfo layer holds one kind of shape: mixing points and polygons is refused with a message, while GeoPackage and GeoJSON accept any mix. A file geodatabase is a folder ending in .gdb; the file browser lets you pick it like a file. Grids (.grd, .grc, .asc, .tif) are read as one row per cell with data: X, Y, Value, plus Class for a classified Vertical Mapper grid.

Archives. A .zip, .gz, .bz2, .xz, .tar, .tgz / .tar.gz (and .tar.bz2, .tar.xz) is unpacked into the cache once per version of the archive, and the file inside is read exactly as if it were on its own, with its own options. File in the archive picks one, or a pattern such as *.csv reads every match and stacks them with an ArchiveMember field saying where each row came from. A shapefile or file geodatabase inside a zip is unpacked with all its parts. Archives are checked before anything is unpacked: one holding a path that would escape its folder (../, a drive letter, a link) is refused, and unpacking stops with a message beyond 64 GB or when a file expands more than 1,000 times its packed size.

Components. Spatial files need the GDAL component, statistical files the ReadStat component and .xls writing the xlwt component. They are part of the standard install; if one is missing or Windows refuses to load it, only its own formats are affected and they say which component they need.

Tidying a large flow

Past about thirty tools a flow needs organising, and a container is how you do it. Select several tools - drag a box round them, or hold Ctrl and click each one - and press Group at the bottom of the canvas.

A container is a box drawn behind the tools it holds. It is not a tool: it has no inputs or outputs, it does not appear in the results panel, and it changes nothing about how the flow runs.

• Rename it by double-clicking its title.
• Collapse it with the chevron, to get a large flow onto one screen.
• Drag it to move everything inside it together.
• Ungroup removes the box and leaves every tool exactly where it was. It never deletes anything.
• Switch it off with the power button.

Switching a container off is the useful part. The tools inside it are skipped, and so is everything downstream of them - shown greyed out rather than red, because a branch you deliberately turned off is not a failure. The rest of the flow runs normally. It is the quickest way to try a flow without its slow step, or to keep a branch you are not using without deleting it.

Switching one tool off

A single tool can be switched off too - right-click it and choose Switch off, press Ctrl+/, or use the power button at the top of its settings. Select several tools first and they switch together. The tool stays on the canvas, greyed out with a power badge, keeps its settings, and is neither run nor checked - so a half-configured tool can be switched off to get the rest of the flow running.

What the tools after it see depends on its shape. A tool with one input hands its rows on unchanged, down its first output: switch a Filter off and the True side carries every row, which is the quickest way to see what a filter was hiding. A Formula, Sort or Choose Fields switched off is simply not there. Anything else - a Data Source, a Join, an Output, a Stack Rows with several connections - has nothing it could sensibly pass on, so it and the tools after it are skipped, not failed. The settings panel says which of the two applies to the tool you switched off. This is the tool-level cousin of switching a container off: a container always cuts its branch.

Macros

A macro is a piece of a flow saved so it can be used in other flows as a single tool. If you clean addresses the same way in nine workflows, do it once.

Making one

1. Start a new flow and build the steps you want to reuse.
2. Instead of a Data Source tool at the front, use Macro Input. That is where data will arrive from whatever flow uses the macro. Give the port a name - Rows, say - because that is the label the macro's node will show.
3. Instead of Write Data at the end, use Macro Output, named the same way.
4. Save it in your Workflows folder like any other flow.

A macro is an ordinary flow. You can open it, run it and look at its data exactly as you would anything else - which is the point, because a piece of a workflow you cannot inspect is a piece you cannot trust. While you are designing it, Macro Input produces the example rows you type into it, so the tools after it have fields to work with.

Using one

Drag a Macro tool onto a flow and choose the macro from the list. Its ports appear on the node with the names you gave them, and you connect it like any other tool.

Macros can use other macros. A macro that uses itself is refused, with a message naming the loop.

What actually happens

When you press Run, each macro node is replaced by the macro's own tools before anything executes. The engine never sees a macro - it sees one flat flow. That is why row counts, error messages, partial runs and Cancel all behave normally, and why an error inside a macro appears on the macro's node rather than vanishing.

Parameters

A parameter turns a flow into a small form. Someone who has never opened the canvas can run it, answer two questions and get their report.

1. Drag a Parameter tool anywhere on the canvas. It has no connections; it is a declaration, not a step.
2. Give it a Name - Month, say - and a prompt such as Which month?
3. Choose what kind of value it is: text, a number, a date, one of a list, yes or no, a file, or a folder. A list also takes the choices, comma separated.
4. Use it as $Month anywhere a tool's setting is text: Data Source C:\exports\$Month\sales.csv Filter [Region] = "$Region" Write Data C:\reports\Sales $Month.xlsx

Press Run and the flow asks for its values first. Parameters marked Must be filled in stop Run until they have one.

Use ${Month} with braces where the name would otherwise run into what follows - ${Month}_final.csv. A $Something that is not one of your parameters is left exactly as it is, so Windows environment variables, currency symbols and regular expressions are all safe.

While you are designing, each parameter uses its own default, so the canvas shows sensible fields before anyone has been asked anything.

Sending results to Dashboards

If you have Dashboards installed alongside this workspace, a Write Data tool can register what it writes as a dashboard table.

Tick Also make this a table in Dashboards on the Write Data tool and give it a name. When the run finishes, the file it wrote appears in Dashboards as a table, ready to build on.

Running the flow again refreshes that table, rather than adding a second one - and a dashboard somebody has open at the time updates on its own within a few seconds. So a flow becomes the thing that keeps a dashboard current: run it when the new month's data arrives, and every dashboard built on it is up to date.

The table is also watched afterwards, so if anything else rewrites the same file - a colleague, a scheduled task - it refreshes then too.

Tools reference

Tools by category. Ports are listed as they appear on the canvas.

Data Source

In. Read a file - text, Excel, database, statistical, spatial or archive, over 50 types - every matching file in a folder, a file at a web address or in cloud storage (S3, Azure, SharePoint, Google Drive), or a query against a database or JSON API.

Inputs: none. Outputs: out Output.

Reads one file, or every file in a folder that matches a pattern.

One file. Choose the file. For Excel, pick the sheet; the first sheet is used if none is chosen. For CSV, the delimiter is detected automatically (comma, tab, semicolon or pipe).

All files in a folder. Choose the folder and a pattern such as *.xlsx or *.csv;*.txt. Every matching file is read with the same settings and the rows are stacked. Files with extra or missing columns are aligned by column name. When the folder holds Excel workbooks, Sheet (Excel files) lists the sheets of the first workbook the pattern matches, and tells you how many workbooks matched; every workbook is read with the chosen sheet name (First sheet if none). The field is hidden when no workbook matches, for example a CSV-only folder. Tick Read every sheet of each workbook to read all sheets of every Excel file instead. Adding or changing a file in the folder is noticed on the next run, and only that file is read again.

First row contains field names. Untick for files without a header; fields are then named column_1, column_2, ... and you can rename them with Choose Fields or Rename Fields.

Skip rows at top. For reports with a title block above the real header. With a header, the header is taken from the first row after the skipped ones.

Read all fields as text. Turns off type guessing. Recommended for files where a column mixes numbers and text, or where leading zeros matter (postcodes, references). Convert later.

Treat as null. Values to read as missing, for example NA, N/A, -.

Add a field with the file name. Adds a field holding the file's path, useful in folder mode to know which file each row came from.

Over fifty file types are read: text (delimited, fixed width, whole lines), JSON, XML, HTML, Excel and OpenDocument, Parquet, Avro, Arrow, .yxdb, QlikView .qvx, SQLite, DuckDB, Access, dBase, SAS, SPSS, Stata, shapefiles, MapInfo, KML, GeoJSON, GeoPackage, file geodatabases, grids, and any of these inside a zip, gzip or tar archive. The options shown change with the type of file chosen: Sheet, table or layer for anything that holds more than one, File in the archive for archives, Or a SQL query for databases, geometry and coordinate options for spatial files. See File formats for the full list and what each option does.

Options:

• Read (choice): One file, All files in a folder, A web address, Cloud storage, Database or API
• Web address (text). Any file type the tool reads from disk. May use $Name to read a Parameter.. Example: https://example.com/data/sales.csv
• Headers (table of settings). Values may use $Name to read a Parameter, so a key need not be saved in the flow. Each row has:
  • Name (text)
  • Value (text)
• Treat as (choice): By address, CSV (comma separated) (.csv), Tab separated text (.tsv), Pipe separated text (.psv), Text (delimited, fixed width or whole lines) (.txt), ASC text, or ESRI ASCII grid (.asc), JSON (.json), JSON lines (NDJSON) (.ndjson), XML (.xml), HTML table (.html), Excel workbook (.xlsx), Excel macro workbook (.xlsm), Excel binary workbook (.xlsb), Excel 97-2003 workbook (.xls), OpenDocument spreadsheet (.ods), Parquet (.parquet), Avro (.avro), Arrow IPC (.arrow), Feather (.feather), YXDB database (.yxdb), QlikView data exchange (QVX) (.qvx), SQLite database (.sqlite), DuckDB database (.duckdb), Access database (.accdb), Access 2000-2003 database / ESRI personal geodatabase (.mdb), dBase table (.dbf), SAS dataset (.sas7bdat), SAS transport (XPORT) (.xpt), SPSS data (.sav), SPSS compressed data (.zsav), SPSS portable (.por), Stata data (.dta), ESRI shapefile (.shp), MapInfo table (.tab), MapInfo interchange (.mif), KML (.kml), KMZ (zipped KML) (.kmz), GeoJSON (.geojson), GeoPackage (.gpkg), ESRI file geodatabase (.gdb), FlatGeobuf (.fgb), GML (.gml), GPS exchange (GPX) (.gpx), AutoCAD DXF (.dxf), Grid (Vertical Mapper / Northwood, Surfer) (.grd), Classified grid (Vertical Mapper / Northwood) (.grc), GeoTIFF grid (.tif), Zip archive (.zip), Gzip (.gz), Bzip2 (.bz2), XZ (.xz), Tar archive (.tar). By address works the type out from the file name in the address, or failing that from what the server says it is sending. Pick a type when the address has no file extension.
• File in the archive (text). Example: blank = the first readable file
• Sheet, table or layer (text). Example: blank = the first one
• Give up after (seconds) (number)
• Maximum size (MB) (number). The download stops, with an error, past this size. A guard against a mistyped address pulling something enormous onto this computer.
• Provider (choice): Amazon S3, or S3-compatible (MinIO, Cloudflare R2, Backblaze B2), Azure Blob Storage, SharePoint (Microsoft 365), Google Drive
• Bucket, container or library (text). Example: my-bucket (SharePoint: blank = the default library)
• Drive or folder ID (text). A shared drive's or a folder's ID (or its address from the browser), shared with the service account.. Example: blank = the service account's own My Drive
• Service account key file (file or folder path). The service account's .json key. May use $Name to read the path from a Parameter. Blank uses GOOGLE_APPLICATION_CREDENTIALS. Needs the google-auth library.
• SharePoint site URL (text). Example: https://contoso.sharepoint.com/sites/Data
• Tenant (directory) ID (text). Example: the directory (tenant) ID of the app registration
• Client ID (text). Example: the app registration's application (client) ID
• Client secret (text). Use $Name to read a Parameter, so the secret is not saved in the flow. The app registration needs the Sites.ReadWrite.All application permission with admin consent.. Example: $Name reads a Parameter
• Endpoint URL (text). Only for an S3-compatible service. Leave blank for Amazon itself.. Example: blank = Amazon S3 (e.g. https://<account>.r2.cloudflarestorage.com)
• Region (text). Example: blank = the AWS CLI's default
• Storage account (text). Blank uses AZURE_STORAGE_ACCOUNT, or the account in a connection string.. Example: mystorage or https://mystorage.blob.core.windows.net
• Access key ID (text). Example: blank = the AWS CLI's or the environment's credentials
• Secret access key (text). Use $Name to read a Parameter, so the secret is not saved in the flow. Blank with a blank key ID uses AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY, then the AWS CLI's own sign-in.. Example: $Name reads a Parameter
• Session token (text). Example: only for temporary credentials
• Account key, SAS token or connection string (text). Use $Name to read a Parameter, so the secret is not saved in the flow. Blank uses AZURE_STORAGE_CONNECTION_STRING, then AZURE_STORAGE_KEY or AZURE_STORAGE_SAS_TOKEN, then an Azure CLI sign-in (needs the azure-identity library).. Example: $Name reads a Parameter
• Public bucket or container: connect without credentials (tick box)
• Read (choice): One object, Every object under a prefix
• Object key (text). The object's full path inside the bucket or container. May use $Name to read a Parameter.. Example: exports/2026/sales.csv
• Prefix (text). Example: exports/2026/ (blank = the whole bucket)
• Name pattern (text). Example: *.csv (several: *.csv;*.parquet)
• Treat as (choice): By address, CSV (comma separated) (.csv), Tab separated text (.tsv), Pipe separated text (.psv), Text (delimited, fixed width or whole lines) (.txt), ASC text, or ESRI ASCII grid (.asc), JSON (.json), JSON lines (NDJSON) (.ndjson), XML (.xml), HTML table (.html), Excel workbook (.xlsx), Excel macro workbook (.xlsm), Excel binary workbook (.xlsb), Excel 97-2003 workbook (.xls), OpenDocument spreadsheet (.ods), Parquet (.parquet), Avro (.avro), Arrow IPC (.arrow), Feather (.feather), YXDB database (.yxdb), QlikView data exchange (QVX) (.qvx), SQLite database (.sqlite), DuckDB database (.duckdb), Access database (.accdb), Access 2000-2003 database / ESRI personal geodatabase (.mdb), dBase table (.dbf), SAS dataset (.sas7bdat), SAS transport (XPORT) (.xpt), SPSS data (.sav), SPSS compressed data (.zsav), SPSS portable (.por), Stata data (.dta), ESRI shapefile (.shp), MapInfo table (.tab), MapInfo interchange (.mif), KML (.kml), KMZ (zipped KML) (.kmz), GeoJSON (.geojson), GeoPackage (.gpkg), ESRI file geodatabase (.gdb), FlatGeobuf (.fgb), GML (.gml), GPS exchange (GPX) (.gpx), AutoCAD DXF (.dxf), Grid (Vertical Mapper / Northwood, Surfer) (.grd), Classified grid (Vertical Mapper / Northwood) (.grc), GeoTIFF grid (.tif), Zip archive (.zip), Gzip (.gz), Bzip2 (.bz2), XZ (.xz), Tar archive (.tar). By key works the type out from the key's file extension, or failing that from the object's content type. Pick a type when the key has no extension.
• File in the archive (text). Example: blank = the first readable file
• Sheet, table or layer (text). Example: blank = the first one
• Maximum size (MB) (number). An object bigger than this is refused rather than downloaded. A guard against a mistyped key pulling something enormous onto this computer, at a price.
• Connection (connection). Connections are shared with the Dashboards workspace: set one up in either and it is here too.
• Query (text). SQL for a database. For a REST source, leave blank to use the profile's URL, or put a full URL here.
• Maximum rows (number). 0 reads everything the query returns. A limit is applied by the database where it can be.
• Read only rows added since the last run (tick box). Turns a nightly full scan into a nightly catch-up. The flow remembers the highest value it saw and asks only for rows above it next time.
• Column that only goes up (text). A modified date or an ever-increasing id. If a row can change without this moving, that change will be missed.. Example: modified_at
• Start from (text). Used only on the first run, or after Forget where this got to.. Example: blank = read everything the first time
• File (file or folder path)
• File in the archive (sheet name). Several files can be read and stacked with a pattern such as *.csv.
• Sheet, table or layer (sheet name)
• Or a SQL query (text). Runs inside the file instead of reading one table.
• Repeating element (text). The tag that holds one record; its attributes and child elements become fields.. Example: blank = detect (e.g. Order, or Orders/Order)
• Folder (file or folder path)
• File pattern (text). Example: *.xlsx (several: *.xlsx;*.csv)
• Include subfolders (tick box)
• Sheet (Excel files) (sheet name). Listed from the first workbook the pattern matches; every workbook in the folder is read with this sheet name.
• Read every sheet of each workbook (tick box)
• First row contains field names (tick box)
• Delimiter (choice): Auto detect, Comma, Tab, Semicolon, Pipe, Fixed width, None: each line is one field
• Field widths (text). Example: 10, 5, 8 or 1-10, 11-15, 16-23
• Skip rows at top (number)
• Read all fields as text (tick box). Safer for messy files; convert later with Choose Fields or Detect Types.
• Rows used to guess types (number)
• Encoding (choice): UTF-8, Latin-1 / Windows-1252, UTF-16, DOS (code page 850), Japanese (Shift-JIS), Chinese (GBK)
• Geometry field name (text). Shapes are read as WKT text into this field, the name imported workflows expect.. Example: SpatialObj
• Convert coordinates to WGS 84 longitude/latitude (tick box). What the Spatial tools expect. Untick to keep the file's own coordinate system.
• Add a field with the coordinate system (tick box)
• Band (number)
• Use value labels instead of codes (tick box)
• Treat as null (comma separated) (text). Example: NA, N/A, -
• Add a field with the file name (text). Example: blank = none
• If a file fails (choice): Stop with an error, Skip it with a warning

Enter Data

In. Type a small table by hand.

Inputs: none. Outputs: out Output.

A small table you type by hand: lookup lists, test data, parameters. Add rows and columns with the buttons, rename a column by editing its header. You can paste a block copied from Excel into a cell (the grid grows to fit), or paste onto the header cell to replace the whole table including column names. Numbers, dates (2026-01-31) and true/false are detected automatically.

Options:

• Table (table)

List Files

In. List the files in a folder: one row per file with path, name, size and modified time.

Inputs: in Folders (optional). Outputs: out Output.

Lists the files in a folder as data: FullPath, Directory, FileName, ShortFileName, Extension, Size, ModifiedTime, CreationTime. Optionally recurses into subfolders and matches a pattern. Connect an input and choose take folders from this input field to list several folders. Feed the result into Read Files from List, or filter it by name or date first.

Options:

• Folder (file or folder path)
• Or take folders from this input field (one field from the input)
• File pattern (text). Example: *.*
• Include subfolders (tick box)

Macro Input

In. Where data comes into this macro. Only meaningful in a flow saved as a macro.

Inputs: none. Outputs: out Output.

Options:

• Port name (text). How this input is labelled on the macro's node when it is used in another flow.. Example: Input
• Can be left unconnected (tick box)
• Example data (table). Used only while designing the macro, so the tools after it have fields to work with. It is replaced by the real data whenever the macro runs inside another flow.

Parameter

In. Ask for a value when the flow runs, and use it as $Name in any tool's settings.

Inputs: none. Outputs: none.

Options:

• Name (text). Use it as $Month in a file path, a filter, a formula - anywhere a setting is text.. Example: Month
• Prompt (text). Example: Which month?
• Kind (choice): Text, Number, Date, One of a list, Yes or no, A file, A folder
• Choices (comma separated) (text). Example: EMEA, APAC, AMER
• Default value (text)
• Must be filled in (tick box)
• Note shown under the prompt (text)

Read Events

In. Read a batch of messages from a Kafka topic - up to a limit, or until the topic goes quiet - and remember where it got to, so a scheduled flow carries on from there next time. JSON messages become columns; anything else arrives as text or bytes. Avro and Protobuf through a schema registry are not supported.

Inputs: none. Outputs: out Output.

Options:

• Bootstrap servers (text). Example: broker1:9092,broker2:9092
• Topic (text). Example: orders
• Consumer group (text). Example: binse-data-flow
• Sign in with (choice): No sign-in, SASL PLAIN, SASL SCRAM-SHA-256, SASL SCRAM-SHA-512
• Username (text)
• Password (text). Use $Name to read a Parameter, so the password is typed at run time rather than saved in the flow.. Example: $Name reads a Parameter
• Encrypt the connection (TLS) (tick box)
• On the first run, start from (choice): The oldest message the broker still has, Only messages that arrive after the first run. Only the first run looks at this. Every run after it carries on from where the last successful run stopped.
• Read at most this many messages (number)
• Stop after this long with nothing new (seconds) (number)
• Message format (choice): JSON: one column per top-level field, Text: the whole message in one field, Bytes: the raw message in one field
• If a message is not valid JSON (choice): Keep it, as text in a Message field, Leave it out, with a warning, Stop the flow
• Add the message key (tick box)
• Add the partition (tick box)
• Add the offset (tick box)
• Add the message time (tick box)

Read Files from List

In. Read every file listed in a field (usually from List Files) and stack the rows.

Inputs: in File list. Outputs: out Output.

Reads every file whose path is in a field of the incoming data (usually from List Files) with the same settings, and stacks the rows. Files that fail can be skipped with a warning. Options match Data Source. Read every sheet of each workbook expands each Excel file to all its sheets.

For most cases the folder mode of Data Source is simpler; use Read Files from List when you need to filter or manipulate the file list first.

Options:

• Field holding the file path (one field from the input)
• Add a field with the file name (text). Example: FileName (blank = none)
• That field contains (choice): File name only, Full path as listed
• Read every sheet of each workbook (tick box)
• Sheet, table or layer (text). Example: First sheet
• First row contains field names (tick box)
• Delimiter (CSV) (choice): Auto detect, Comma, Tab, Semicolon, Pipe
• Skip rows at top (number)
• Read all fields as text (tick box)
• If a file fails (choice): Stop with an error, Skip it with a warning

Macro Output

Out. Where data leaves this macro. Only meaningful in a flow saved as a macro.

Inputs: in Input. Outputs: out Preview.

Options:

• Port name (text). How this output is labelled on the macro's node when it is used in another flow.. Example: Output

Run SQL Script

Out. Run a statement that returns no rows - TRUNCATE, DELETE, MERGE, CREATE - against a saved connection, in its place in the flow's order.

Inputs: in Input. Outputs: out Output.

Options:

• Connection (connection). Only SQL databases. A REST source has no SQL to run, and an ODBC connection cannot be told to run one here.
• SQL (text). Runs exactly as written, with your database permissions. $Name reads a Parameter.
• Run it (choice): Before the rows pass through, After every incoming row has been read
• If it fails (choice): Stop the flow, Carry on with a warning

Run Stored Procedure

Out. Call a stored procedure with parameters, and take the rows it returns if it returns any.

Inputs: in Input. Outputs: out Output.

Options:

• Connection (connection). Only SQL databases. A REST source has no procedures, and an ODBC connection cannot be told to run one here.
• Procedure (text). Letters, digits, _ and $, with dots between database, schema and name. Anything else is refused before it reaches the database.. Example: dbo.usp_refresh_sales
• Parameters (table of settings). Passed in this order. Values may use $Name to read a Parameter. A blank is sent as NULL, except for Text, which is sent as empty text. Each row has:
  • Name (text)
  • Value (text)
  • Type (choice): Text, Whole number, Decimal, Yes/No, Date, Date and time
• The procedure returns rows (tick box). Ticked, the output is what the procedure returns instead of the incoming rows. Its fields are only known once it has run: the canvas shows an empty table until then.
• If it fails (choice): Stop the flow, Carry on with a warning

Send to Diagrams

Out. End the flow in a diagram: refresh one whose shapes are linked to this data, or make a new flowchart, org chart or network from the rows.

Inputs: in Input. Outputs: none.

Options:

• What to send (choice): Refresh a diagram that is linked to this data, Make a diagram from these rows
• Diagram (file or folder path). A diagram whose shapes are already linked to a table. Link them in Diagrams once; after that every run of this flow puts fresh rows behind them.
• Data source in the diagram (text). Example: the one this file feeds
• Point that data source at the file below (tick box). Leave this on and the diagram reads this flow's file from now on, refreshing itself whenever it is opened. Turn it off to leave the diagram file untouched and only write the rows.
• Diagram to make (choice): Flowchart: a step per row, joined by what each one leads to, Org chart: a card per row, under whoever it reports to, Network: a device per row, joined by what it links to
• Diagram name (text). Example: the file name
• Row id (one field from the input)
• Label (one field from the input)
• Links to (one field from the input)
• Words on the line (one field from the input)
• Shape (one field from the input)
• Group (one field from the input)
• Reports to (one field from the input)
• Job title (one field from the input)
• Department (one field from the input)
• Table file (file or folder path). Where the rows are written. This file is what the diagram reads, so keep it somewhere that stays put: beside the diagram is the usual answer.
• File type (choice): Comma separated (.csv), Excel workbook (.xlsx), JSON (.json), Parquet (.parquet)
• Key field (one field from the input). The field whose value picks out a row for a shape. Each value should appear once.

Write Data

Out. Write the data to a file on this computer or in cloud storage (S3, Azure, SharePoint, Google Drive): text, Excel, database, statistical or spatial, 35 types.

Inputs: in Input. Outputs: none.

Writes the incoming data to a file. File type chooses the format, grouped as Text, Spreadsheet, Data files, Database, Statistical and Geospatial, or By file extension to follow whatever the file name ends with. Choosing a type rewrites the file name's extension to match, and picking or typing a name with a known extension sets the type. In the Browse dialog, Save as type does the same thing and always saves with the matching extension. The folder is created if needed and an existing file is overwritten.

Only the options for the chosen type are shown: a sheet name for spreadsheets (columns are auto-fitted in .xlsx), a delimiter for CSV and Text (including fixed width), a table name and If the table exists (replace or add rows) for databases and GeoPackage, the geometry field and coordinate system for spatial files, element names for XML, and Compression (gzip or zip) for single-file formats. A zipped shapefile holds all its parts. A file name ending .gz is gzipped whatever the setting. See File formats for what each type can hold.

Write Data only writes during a real Run, never while you are just configuring.

Options:

• Write to (choice): A file on this computer, Cloud storage
• File type (choice): By file extension, CSV (comma separated) (.csv), Tab separated text (.tsv), Pipe separated text (.psv), Text (delimited, fixed width or whole lines) (.txt), JSON (.json), JSON lines (NDJSON) (.ndjson), XML (.xml), HTML table (.html), Excel workbook (.xlsx), Excel 97-2003 workbook (.xls), OpenDocument spreadsheet (.ods), Parquet (.parquet), Avro (.avro), Arrow IPC (.arrow), Feather (.feather), QlikView data exchange (QVX) (.qvx), SQLite database (.sqlite), DuckDB database (.duckdb), Access database (.accdb), Access 2000-2003 database / ESRI personal geodatabase (.mdb), dBase table (.dbf), SAS transport (XPORT) (.xpt), SPSS data (.sav), SPSS compressed data (.zsav), Stata data (.dta), ESRI shapefile (.shp), MapInfo table (.tab), MapInfo interchange (.mif), KML (.kml), KMZ (zipped KML) (.kmz), GeoJSON (.geojson), GeoPackage (.gpkg), ESRI file geodatabase (.gdb), FlatGeobuf (.fgb), GML (.gml). Choosing a type sets the file name's extension; picking a file with a known extension sets the type.
• File (file or folder path)
• Provider (choice): Amazon S3, or S3-compatible (MinIO, Cloudflare R2, Backblaze B2), Azure Blob Storage, SharePoint (Microsoft 365), Google Drive
• Bucket, container or library (text). Example: my-bucket (SharePoint: blank = the default library)
• Drive or folder ID (text). A shared drive's or a folder's ID (or its address from the browser), shared with the service account.. Example: blank = the service account's own My Drive
• Service account key file (file or folder path). The service account's .json key. May use $Name to read the path from a Parameter. Blank uses GOOGLE_APPLICATION_CREDENTIALS. Needs the google-auth library.
• SharePoint site URL (text). Example: https://contoso.sharepoint.com/sites/Data
• Tenant (directory) ID (text). Example: the directory (tenant) ID of the app registration
• Client ID (text). Example: the app registration's application (client) ID
• Client secret (text). Use $Name to read a Parameter, so the secret is not saved in the flow. The app registration needs the Sites.ReadWrite.All application permission with admin consent.. Example: $Name reads a Parameter
• Endpoint URL (text). Only for an S3-compatible service. Leave blank for Amazon itself.. Example: blank = Amazon S3 (e.g. https://<account>.r2.cloudflarestorage.com)
• Region (text). Example: blank = the AWS CLI's default
• Storage account (text). Blank uses AZURE_STORAGE_ACCOUNT, or the account in a connection string.. Example: mystorage or https://mystorage.blob.core.windows.net
• Access key ID (text). Example: blank = the AWS CLI's or the environment's credentials
• Secret access key (text). Use $Name to read a Parameter, so the secret is not saved in the flow. Blank with a blank key ID uses AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY, then the AWS CLI's own sign-in.. Example: $Name reads a Parameter
• Session token (text). Example: only for temporary credentials
• Account key, SAS token or connection string (text). Use $Name to read a Parameter, so the secret is not saved in the flow. Blank uses AZURE_STORAGE_CONNECTION_STRING, then AZURE_STORAGE_KEY or AZURE_STORAGE_SAS_TOKEN, then an Azure CLI sign-in (needs the azure-identity library).. Example: $Name reads a Parameter
• Public bucket or container: connect without credentials (tick box)
• Object key (text). The object's full path inside the bucket or container; an existing object is replaced. May use $Name to read a Parameter.. Example: exports/sales.csv
• Delimiter (choice): Comma, Tab, Semicolon, Pipe, Fixed width (padded columns)
• Sheet name (text)
• Table or layer name (text). Example: the file name
• If the table exists (choice): Replace it, Add the rows to it
• Geometry field (WKT) (one field from the input)
• Coordinate system (text). What the geometry's coordinates are in: EPSG:4326 for longitude/latitude, EPSG:27700 for British National Grid, and so on.. Example: EPSG:4326
• Root element (text). Example: Rows
• Row element (text). Example: Row
• Compression (choice): None, Gzip (adds .gz), Zip (writes .zip)
• Take the file name from a field (tick box). Writes one file per distinct value: a file per region, per month, per customer. The field itself is left out of what is written.
• Field (one field from the input)
• Keep that field in the files (tick box)
• The value is (choice): Added to the file name above, The whole file name, in that folder, A full path of its own
• Also make this a table in Dashboards (tick box). The file is registered as a dashboard table when the run finishes, and running the flow again refreshes it. Available when both workspaces are installed together.
• Table name (text). Example: the file name

Write to Database

Out. Write the data to a table in a SQL database.

Inputs: in Input. Outputs: none.

Options:

• Connection (connection). Only SQL databases can be written to. A REST source or an ODBC connection cannot.
• Table (text). Example: orders_clean
• If the table exists (choice): Add the rows to it, Replace everything in it, Stop with an error. Replace drops the table and writes it again. There is no undo, so it asks for the table by name rather than offering a list.

Batch Macro

Workflow. Run a macro once for every value - every customer, every month, every file - with a setting inside it changing each time. Results are stacked together.

Inputs: in Control. Outputs: out Output.

Options:

• Macro (macro)
• Batch Parameter name (text). The $Name inside the macro that changes on each pass. Leave empty to use the first one.. Example: Month
• Take its values from (one field from the input)
• Run once per (choice): Different value in that field, Record
• Send the macro (choice): Only the records for that value, Every record, every pass, No records - it reads its own data
• Add the control value as a field on the output (tick box)
• Name for that field (text). Example: Control
• Stop after this many passes (number)
• If one pass fails (choice): Stop the flow, Skip it and carry on

Data Check

Workflow. Stop the run if something is not true: an empty table, a duplicate key, a total that has moved.

Inputs: in Input. Outputs: out Output.

Options:

• Checks (table of settings) Each row has:
  • Check (choice): The table has rows, The table has no rows, Row count equals, Row count is at least, This field has no duplicates, This field has no nulls, This is true for every row
  • Field (one field from the input)
  • Value (text)
  • Expression (formula)
  • Message (text). Example: auto
• When a check fails (choice): Stop the run with an error, Carry on with a warning

Inspect

Workflow. Look at the data at this point in the workflow.

Inputs: in Input. Outputs: out Output.

Shows the data at that point in the flow. Every tool already shows its output when selected, so Inspect is mainly a labelled viewpoint you want to come back to, and it keeps imported flows intact.

Log Message

Workflow. Write a note into the run's messages: a row count, a total, whatever you need in the log.

Inputs: in Input. Outputs: out Output.

Options:

• Message (text). {rows} is replaced with the row count. Anything in square brackets is read as a field and shows the first row's value.. Example: Loaded {rows} rows

Loop Macro

Workflow. Run a macro over and over, feeding its answer back in, until nothing is left or a limit is reached - for hierarchies, explosions and allocations.

Inputs: in Input. Outputs: out Output.

Options:

• Macro (macro)
• Name of the output that feeds back (text). A macro with two outputs sends one back round and one to the result. With a single output, that output does both.. Example: Loop
• Stop when (choice): The feedback output has no records, A set number of times has run, Nothing changed since the pass before
• Number of times (number)
• Never run more than (number)
• Return (choice): Every pass, stacked together, Only the last pass
• Pass number available as (text). Write $Iteration in any setting inside the macro to get 1, 2, 3 .... Example: Iteration
• Add the pass number as a field on the output (tick box)

Macro

Workflow. Run another flow as a single tool. Choose the macro and its ports appear here.

Inputs: in Input. Outputs: out Output.

Options:

• Macro (macro)

Note

Workflow. A note on the canvas. Has no data.

Inputs: none. Outputs: none.

A note on the canvas with no data ports. Explain what a section of the flow does, who owns it, or what to check.

Options:

• Text (text)

Unsupported Step

Workflow. Placeholder for a step in an imported workflow that has no equivalent yet. Replace it with other tools.

Inputs: in Input. Outputs: out Output.

A placeholder created by the workflow importer for a tool that has no equivalent. It keeps the connections so you can see where it sat, and always reports an error. Replace it with the tools that do the same job, then delete it.

Options:

• Original tool (text)
• Notes (text)

Choose Fields

Preparation. Choose, rename, reorder and change the type of fields.

Inputs: in Input. Outputs: out Output.

Choose which fields continue, rename them, change their type and set their order.

• Untick a field to drop it. Select all / Deselect all help with wide files.
• Type a new name in Rename.
• Change Type to convert: text to Int64, Float64, Date or DateTime, numbers to text, and so on. Values that cannot be converted become null rather than stopping the run.
• The arrows reorder fields.
• Keep fields not listed (Unknown) controls what happens to fields that appear later, for example when the input file gains a column. Ticked, they pass through at the end; unticked, only the listed fields pass.

Fields that are in the list but no longer arrive are shown in amber; use the × to forget them.

Options:

• Fields (field list)
• Keep fields not listed (Unknown) (tick box)

Clean Data

Preparation. Trim, fix case, remove punctuation, replace nulls, drop empty rows and columns.

Inputs: in Input. Outputs: out Output.

Tidies text and nulls in one step, on the fields you choose (all fields if none chosen):

• remove rows where every field is null, and columns where every value is null;
• replace null text with blank and null numbers with 0;
• trim leading and trailing whitespace, collapse repeated whitespace;
• remove punctuation, letters or digits;
• change case to upper, lower or Title.

Only text fields are affected by the text options.

Options:

• Fields to cleanse (empty = all) (one or more fields)
• Remove rows where every field is null (tick box)
• Remove columns where every value is null (tick box)
• Replace null text with blank (tick box)
• Replace null numbers with 0 (tick box)
• Trim leading and trailing whitespace (tick box)
• Collapse repeated whitespace (tick box)
• Remove punctuation (tick box)
• Remove letters (tick box)
• Remove numbers (tick box)
• Change case (choice): No change, UPPER, lower, Title

Detect Types

Preparation. Detect the best type for text fields (numbers, dates, booleans).

Inputs: in Input. Outputs: out Output.

Looks at the values in text fields and converts each to the best type: whole numbers to Int64, decimals to Float64, YYYY-MM-DD values to Date, true/false to Boolean. A field is only converted when every non-empty value fits. Use it after reading a file as all text.

Options:

• Fields to check (empty = all text fields) (one or more fields)

Fill Missing Values

Preparation. Fill in missing values, or values you nominate, rather than removing the field.

Inputs: in Input. Outputs: out Output.

Options:

• Fields (one or more fields)
• Replace (choice): Nulls, Nulls and a value I choose
• That value (text). Number fields match by value, so 0 also matches 0.0; other fields match as text.. Example: 0
• Replace it with (choice): A fixed value, The field's average, The field's median, The field's smallest value, The field's largest value, The previous row's value, The next row's value, Remove the row
• Value (text). Example: 0

Filter

Preparation. Split rows into True and False by a condition.

Inputs: in Input. Outputs: T True, F False.

Splits rows into a True output (rows matching the condition) and a False output (the rest). Rows where the condition cannot be evaluated, for example because a field is null, go to False.

Basic mode: pick a field, a condition (equals, greater than, contains, is null, is in list, ...) and a value. For "is in list", separate values with commas.

Custom expression mode: any formula that produces true or false, using the formula language, for example [Amount] > 100 AND [Country] IN ("IE", "GB") or IsNull([Tracking]).

Both outputs carry all fields; the tool never changes data, it only routes rows.

Options:

• Filter type (choice): Basic, Custom expression
• Field (one field from the input)
• Condition (choice): equals, does not equal, is greater than, is greater than or equal to, is less than, is less than or equal to, contains, does not contain, starts with, ends with, is in list (comma separated), is null, is not null, is empty or null
• Value (text)
• Expression (formula). Example: [Amount] > 100 AND [Country] = "IE"

Formula

Preparation. Create or update fields with expressions.

Inputs: in Input. Outputs: out Output.

Creates new fields or updates existing ones with expressions. Each row of the tool is one formula: an output field name, the expression, and an optional type.

• Formulas run in order, so a later formula can use a field created by an earlier one.
• Naming an existing field updates it in place.
• Type is normally Auto (the expression's own type). Set it to force a conversion, for example Int64 for a whole-number result.
• The editor highlights syntax, suggests fields when you type [ and functions as you type, and checks the expression as you type. Help under the editor lists every field and function; click one to insert it.

Examples:

[Amount] * 1.23
[First Name] + " " + [Surname]
IIF([WeightKg] < 1, "Light", "Heavy")
IF [Status] = "Delivered" THEN 1 ELSEIF [Status] = "Returned" THEN -1 ELSE 0 ENDIF
Round([Net] / [Qty], 0.01)
DateTimeFormat(ToDate([OrderDate]), "%Y-%m")

See the Formula language and Function reference.

Options:

• Formulas (table of settings) Each row has:
  • Output field (field name (new or existing))
  • Expression (formula)
  • Type (choice): Auto, String, Int64, Float64, Boolean, Date, DateTime

Formula Across Fields

Preparation. Apply one expression to several fields at once. [_CurrentField_] is the field being changed.

Inputs: in Input. Outputs: out Output.

Options:

• Fields (one or more fields)
• Expression (formula). Write it once. [_CurrentField_] stands for each selected field in turn.. Example: Trim([_CurrentField_])
• Change the type to (choice): Auto, String, Int64, Float64, Boolean, Date, DateTime
• Add as new fields instead of changing them (tick box)
• New field prefix (text). Example: New_

Formula Across Rows

Preparation. Expressions that can refer to other rows, e.g. [Row-1:Field]. Sort first.

Inputs: in Input. Outputs: out Output.

Like Formula, but the expression can refer to other rows with [Row-1:Field] (the previous row) or [Row+1:Field] (the next row). Sort the data first so "previous" means what you expect.

Group by restarts at each group: [Row-1:Amount] at the first row of a group is null.

Typical uses: differences between consecutive rows ([Amount] - [Row-1:Amount]), flags for changes ([Customer] != [Row-1:Customer]), and numbering within groups (RowNumber()).

Limitation: an expression cannot refer to the field it is creating ([Row-1:NewField]), except the running-count pattern, which the workflow importer rewrites to RowNumber().

Options:

• Output field (field name (new or existing))
• Type (choice): Auto, String, Int64, Float64, Boolean, Date, DateTime
• Group by (one or more fields)
• Expression (formula). Example: [Amount] - [Row-1:Amount]

Group into Bands

Preparation. Put each row in a numbered band: equal counts, equal ranges, or cut points you choose.

Inputs: in Input. Outputs: out Output.

Options:

• Bands by (choice): Equal count (deciles, quartiles), Equal range, Cut points I choose, One band per distinct value
• Field (one field from the input)
• How many bands (number)
• Cut points (comma separated) (text). Example: 100, 500, 1000
• Band within each group of (one or more fields). Leave empty to band the whole table at once.
• Band number field (text). Example: Tile_Num
• Band label field (text). Example: Tile_Name

Remove Duplicates

Preparation. Split first occurrences (Unique) from repeats (Duplicates).

Inputs: in Input. Outputs: U Unique, D Duplicates.

Splits rows into the first occurrence of each value combination (Unique) and the repeats (Duplicates). Choose the fields that define a duplicate; with none chosen, whole rows are compared. Rows keep their order, and it is always the first occurrence that goes to Unique, so sort first if you care which one survives.

Options:

• Fields that make a row unique (one or more fields)

Rename Fields

Preparation. Rename fields from the first row of data, from a lookup table, or with a prefix or suffix.

Inputs: in Input, R Names (optional). Outputs: out Output.

Renames fields from data rather than by hand: take names from the first row (for reports whose real header is not on line 1), look names up from a table on the R input (old name, new name), or add / remove a prefix or suffix on the chosen fields.

Options:

• Rename mode (choice): Take field names from the first row, Look up names from the R input, Add a prefix, Add a suffix, Remove a prefix, Remove a suffix
• Fields to rename (empty = all) (one or more fields)
• Prefix / suffix text (text)
• R field with current names (one field from the input)
• R field with new names (one field from the input)

Replace by Rule

Preparation. Apply a lookup table of corrections across many fields at once, instead of one Lookup Replace per field.

Inputs: in Input, R Replacements. Outputs: out Output.

Options:

• Fields to correct (empty = every text field) (one or more fields)
• Replacements field holding the value to find (one field from the input)
• Replacements field holding the new value (one field from the input)
• Replace when the value (choice): Is exactly the value to find, Contains the value to find
• Ignore capitals (tick box)

Row Number

Preparation. Add a sequential row number.

Inputs: in Input. Outputs: out Output.

Adds a sequential number to every row, starting at the value you choose, at the start or end of the fields. Restart numbering for each restarts the count within each group, for example per file when reading a folder.

Options:

• Field name (text)
• Start at (number)
• Position (choice): First column, Last column
• Restart numbering for each (one or more fields)

Row Ranges

Preparation. Keep rows by record number ranges, e.g. 1-100, 250, 1000+ or -50 (first 50).

Inputs: in Input. Outputs: out Output.

Keeps rows by position: 1-100 the first hundred, 250 one row, 1000+ from row 1000 on, -50 the first fifty. Separate several ranges with commas. Row numbers are 1-based.

Options:

• Ranges (1-based, comma separated) (text). Example: 1-1000, 2000+

Running Total

Preparation. Cumulative sum of numeric fields, optionally per group. Sort first.

Inputs: in Input. Outputs: out Output.

Adds a cumulative sum of the chosen numeric fields, as new fields named RunTot_<field>. Group by restarts the total for each group. Sort first for a meaningful running order.

Options:

• Fields to total (one or more fields)
• Group by (one or more fields)

Sample Rows

Preparation. Take the first N rows, skip rows, every N-th row or a random sample.

Inputs: in Input. Outputs: out Output.

Takes part of the data: the first N rows, the last N, everything after the first N, one row in every N, N random rows or N percent at random. Group by applies first/last/skip within each group, for example the latest 3 orders per customer after a Sort.

Options:

• Mode (choice): First N rows, Last N rows, Skip first N rows, 1 of every N rows, Random N rows, Random N percent
• N (number)
• Group by (first/last/skip per group) (one or more fields)

Select Fields by Rule

Preparation. Keep or drop fields by what type they are, or by a rule about their name - so the flow still works when next month's file has different columns.

Inputs: in Input. Outputs: out Output.

Options:

• Choose fields by (choice): Their type, Their name, A formula
• Then (choice): Keep only those fields, Remove those fields
• String (tick box)
• Whole number (tick box)
• Decimal (tick box)
• Yes/No (tick box)
• Date (tick box)
• Date and time (tick box)
• Name matches (text). Use * for any run of characters and ? for one. Tick the box below to use a regular expression instead.. Example: *_amount or Total*
• The pattern is a regular expression (tick box)
• Ignore capitals (tick box)
• Formula (formula). Written against [Name], [Type] and [Position] - one row per field. For example: StartsWith([Name], "Sales") AND [Type] = "Float64"

Sort

Preparation. Sort rows by one or more fields.

Inputs: in Input. Outputs: out Output.

Orders rows by one or more fields, ascending or descending. Nulls go last. Sorting is stable: rows that tie keep their previous order, so you can sort by a second field first and a first field second to get a two-level order, or simply add both fields in one Sort.

Options:

• Sort by (table of settings) Each row has:
  • Field (one field from the input)
  • Order (choice): Ascending, Descending

Split into Samples

Preparation. Split the rows at random into estimation, validation and holdout sets.

Inputs: in Input. Outputs: E Estimation, V Validation, H Holdout.

Options:

• Estimation % (number)
• Validation % (number). Whatever is left over goes to the holdout output.
• Random seed (number). The same seed gives the same split every run. 0 picks a new one each time.
• Keep these together (one or more fields). Rows sharing these values land in the same set - a customer's whole history, say, rather than half of it in estimation and half in validation.

Wait Until Done

Preparation. Pass the data through three outputs. Kept so imported workflows stay intact; ordering is automatic here.

Inputs: in Input. Outputs: 1 Output 1, 2 Output 2, 3 Output 3.

Passes the data through three identical outputs. The order in which outputs are written is automatic here, so it exists to keep imported flows intact.

Add to Every Row

Join. Append every Source row to every Target row (cartesian product).

Inputs: T Target, S Source. Outputs: out Output.

Attaches every Source row to every Target row (a cartesian product). Meant for adding a one-row table of parameters or totals to every row; with larger Source tables the output grows very quickly. Source fields whose names clash are prefixed Source_.

Fuzzy Match

Join. Find records that are nearly the same: Smith and Smyth, ACME Ltd and Acme Limited.

Inputs: in Input, ref Reference (optional). Outputs: out Matches.

Options:

• Look for (choice): Duplicates within one input, Matches between two inputs
• Field (one field from the input)
• Reference field (one field from the input)
• Match if at least % alike (number)
• Record id (one field from the input). Carried through so a match can be joined back. Leave empty to use the row number.
• Reference record id (one field from the input). Goes in the Right field of each match. Leave empty to use the Reference row number.
• Include each record matching itself (tick box)

Join

Join. Match rows from two inputs. J = matched, L/R = unmatched from each side.

Inputs: L Left, R Right. Outputs: L Left unmatched, J Joined, R Right unmatched.

Matches rows from the Left and Right inputs on one or more pairs of fields:

• J rows that matched, with all fields from both sides. Right-side fields whose names clash with a left-side field are prefixed Right_.
• L left rows with no match on the right.
• R right rows with no match on the left.

For a "left outer join" (all left rows, matched or not) feed J and L into a Stack Rows tool.

If the two key fields have different types, they are compared as text and a warning is shown. Trim and change case first if keys are typed inconsistently.

Options:

• Join fields (table of settings) Each row has:
  • Left (one field from the input)
  • Right (one field from the input)

Join Many

Join. Join three or more inputs on the same key fields in one tool, instead of a chain of Joins.

Inputs: in Inputs (several connections). Outputs: out Output.

Options:

• Join on (one or more fields). Fields that every input has. Inputs are joined in the order they were connected.
• Keep (choice): Only records every input has, Every record from the first input, Every record from every input
• Number fields that clash, rather than dropping them (tick box). When two inputs both have a Value field, the second becomes Value_2.

Link Groups

Join. Turn pairs of matched records into groups: if A matches B and B matches C, all three are one group. The tool that finishes what Fuzzy Match starts.

Inputs: in Pairs. Outputs: out Groups.

Options:

• First of the pair (one field from the input)
• Second of the pair (one field from the input)
• Name for the record field (text). Example: Id
• Name for the group field (text). Example: Group
• Add how many records are in each group (tick box)

Lookup Replace

Join. Look values up in a table (R): replace text, or append fields from the matching row.

Inputs: F Find in, R Lookup. Outputs: out Output.

Looks up values from a second table (R) in a field of the main data (F):

• Whole field equals lookup value is a fast exact match.
• Lookup value anywhere in the field / starts with find partial matches (lookup tables up to a few thousand rows).

Then either replace the found text with a value from R, or append chosen fields from the matching R row (like a VLOOKUP).

Options:

• Field to search (F) (one field from the input)
• Match (choice): Whole field equals lookup value, Lookup value anywhere in the field, Field starts with lookup value
• Case insensitive (tick box)
• Lookup field (R) (one field from the input)
• Then (choice): Replace the found text with a value from R, Append fields from R
• Replacement value field (R) (one field from the input)
• Fields to append (R) (one or more fields)

Reference Row Filter

Join. Keep or drop the rows of the first input that appear in the second. No columns are added.

Inputs: in Input, ref Reference. Outputs: out Matched, miss Not matched.

Options:

• Match on (table of settings) Each row has:
  • Input (one field from the input)
  • Reference (one field from the input)
• Ignore case (tick box)

Stack Rows

Join. Stack rows from several inputs.

Inputs: in Inputs (several connections). Outputs: out Output.

Stacks the rows of every connected input into one table. By name lines fields up by name and fills fields missing from an input with null. By position lines them up by column order and uses the names from the first input. Connect as many inputs as you like to the single port.

Options:

• Match fields (choice): By name, By position

Count Rows

Transform. Output a single row with the number of records.

Inputs: in Input. Outputs: out Output.

Outputs a single row with one field, Count, holding the number of input rows. Handy for a reconciliation flow: count each side and join the counts.

Create Rows

Transform. Create rows that are not in the data: a row per day, a number sequence, a range expanded out.

Inputs: in Input (optional). Outputs: out Output.

Options:

• New field (text). Example: RowCount
• Type (choice): Int64, Float64, Date, DateTime
• Starting value (formula). Example: 1
• Carry on while (formula). Example: [RowCount] <= 10
• Next value (formula). Example: [RowCount] + 1
• Stop after this many rows per input row (number). A safety net. A condition that never becomes false would otherwise run until the machine gives up.

Describe Fields

Transform. Turn the table's own shape into data: one row per field, with type, nulls and distinct counts.

Inputs: in Input. Outputs: out Output.

Options:

• Include counts and ranges (tick box). Off, this reads only the schema and costs nothing. On, it reads the data to count nulls and distinct values.

Group & Aggregate

Transform. Group rows and aggregate: sum, count, min, max, average, concatenate...

Inputs: in Input. Outputs: out Output.

Groups rows and calculates aggregates, one action per row of the tool:

• Group by fields define the groups (none means one grand total row).
• Sum, Min, Max, Average, Median, Std deviation on numbers (text is converted where possible).
• Count counts rows; Count distinct counts different values; Count non-null and Count null as named.
• First and Last take the first or last value in the group.
• Concatenate joins values as text with the separator you set.

Output names default to the action and the field (Sum_Amount, Count_OrderID); type your own in Output name.

Options:

• Actions (table of settings) Each row has:
  • Field (one field from the input)
  • Action (choice): Group by, Sum, Count, Count distinct, Count non-null, Count null, Min, Max, Average, Median, Std deviation, Weighted average, First, Last, Concatenate
  • Weight (one field from the input)
  • Output name (text). Example: auto
• Concatenate separator (text)

Pivot

Transform. Pivot values of one field into column headers.

Inputs: in Input. Outputs: out Output.

Pivots values of one field into column headers. Choose the fields that identify a row (Group data by), the field whose values become the new columns (Change column headers), the field whose values fill the cells, and how to combine several values in a cell (Sum, Count, First, ...). Header values are cleaned so they are valid field names. The output fields are only known after a run, because they depend on the data.

Options:

• Group data by these values (one or more fields)
• Change column headers (one field from the input)
• Values for new columns (one field from the input)
• Method (choice): Sum, Count, First, Last, Min, Max, Average, Concatenate

Rearrange Fields

Transform. Turn each record into a labelled block of rows - the shape a report wants, rather than the shape a database wants.

Inputs: in Input. Outputs: out Output.

Options:

• Repeat these fields on every row (one or more fields)
• One output row per line (table of settings) Each row has:
  • Label (text)
  • Field (one field from the input)
• Name for the label field (text). Example: Description
• Name for the value field (text). Example: Value
• Leave out rows whose value is empty (tick box)

Unpivot

Transform. Turn columns into rows (Name / Value pairs).

Inputs: in Input. Outputs: out Output.

Turns columns into rows. The Key fields are repeated on every output row; each Data field becomes one row with two new fields, Name (the field's name) and Value. Data fields of different types are converted to text.

Options:

• Key fields (kept as is) (one or more fields)
• Data fields (empty = all others) (one or more fields)

Weighted Average

Transform. Average a field with each record counting for more or less - price weighted by quantity, a rate weighted by exposure.

Inputs: in Input. Outputs: out Output.

Options:

• Average this field (one field from the input)
• Weighted by (one field from the input)
• Group by (empty = one answer for everything) (one or more fields)
• Name for the result (text). Example: blank = Weighted_ and the field name
• Also show the total weight (tick box)

Convert Dates

Parse. Convert text to dates or dates to text with a format.

Inputs: in Input. Outputs: out Output.

Converts text to a Date/DateTime using a format, or a date to text. Formats use codes: %Y year, %m month, %d day, %H:%M:%S time, %b Jan, %B January, %y two-digit year. For example %d/%m/%Y reads 31/01/2026. Formats written as dd/MM/yyyy in an imported workflow are converted automatically.

Options:

• Field (one field from the input)
• Direction (choice): Text to date/time, Date/time to text
• Format (text). %Y year, %m month, %d day, %H:%M:%S time, %b Jan, %B January. Example: %d/%m/%Y
• Output field (text). Example: DateTime_Out

Parse JSON

Parse. Turn JSON held in a field into columns. For a whole JSON file, use Data Source instead.

Inputs: in Input. Outputs: out Output.

Options:

• Field (one field from the input)
• Path to the records (text). A dotted path into the payload, such as data.results, for an API that wraps its rows.. Example: blank = the whole value
• Produce (choice): A column per key, A row per item in a list
• Prefix new fields with (text). Example: blank = none
• Keep the original field (tick box)
• If a value will not parse (choice): Leave the new fields empty, Stop with an error

Parse XML

Parse. Turn XML held in a field into columns: child elements and attributes become fields.

Inputs: in Input. Outputs: out Output.

Options:

• Field (one field from the input)
• Element to read (text). A slash path such as Order/Lines/Line, starting at the outermost tag (Lines/Line works too). Several matches become several rows.. Example: blank = the root element
• Include attributes (tick box)
• Prefix new fields with (text). Example: blank = none
• Keep the original field (tick box)
• If a value will not parse (choice): Leave the new fields empty, Stop with an error

Split Text

Parse. Split a text field on a delimiter into new columns or rows.

Inputs: in Input. Outputs: out Output.

Splits a text field on a delimiter into new columns (Field1, Field2, ... using the prefix you set) or into new rows, one per piece. With Split on any of these characters ticked, a multi-character delimiter means "any of these"; unticked, the whole string is the delimiter.

Options:

• Field to split (one field from the input)
• Delimiter (text). Example: ,
• Split on any of these characters (tick box)
• Split to (choice): Columns, Rows
• Number of columns (number)
• Output prefix (text)

Text Pattern

Parse. Parse groups out of a text field, replace matches, or flag matches.

Inputs: in Input. Outputs: out Output.

Regular expressions on a text field:

• Parse groups: each capture group ( ) in the pattern becomes a new field.
• Tokenize: every match becomes a field (or a row), for example \d+ to pull all numbers.
• Replace: replace matches with text; $1 refers to the first group.
• Match: adds a True/False field.

Patterns use standard regex syntax (\d digit, \w word character, . any, * and + repeats, ^ and $ anchors, [A-Z] classes).

Options:

• Field (one field from the input)
• Regular expression (text). Example: (\d+)-(\w+)
• Output method (choice): Parse groups, Tokenize, Replace, Match
• Number of columns (number)
• Split matches to rows instead (tick box)
• Replacement ($1 for groups) (text)
• Case insensitive (tick box)
• Output prefix (text)

Base64 Encode

Developer. Encode or decode text as Base64 - the format an API asks for when it wants a file, a token or a signature inside JSON.

Inputs: in Input. Outputs: out Output.

Options:

• Fields (one or more fields)
• Do (choice): Encode, Decode
• Use the web-safe alphabet (- and _ instead of + and /) (tick box)
• Add this to the new field names (text). Example: blank = replace them

Convert Binary

Developer. Turn a file field into text and back - so a PDF can be sent to an API, or an image stored in a database column.

Inputs: in Input. Outputs: out Output.

Options:

• Field (one field from the input)
• Convert (choice): File to text, Text to file
• As (choice): Base64, Hexadecimal, Plain text (UTF-8)
• Name for the new field (text). Example: blank = replace the field

Delete Files

Developer. Delete the files named in a field - housekeeping once an archive or export step has finished with them.

Inputs: in Input. Outputs: out Output, err Failed.

Options:

• Field holding the file path (one field from the input)
• If a file is not there (choice): Treat it as already gone, Send that record to the Failed output, Stop the flow
• I understand this permanently deletes every file listed in that field. They do not go to the Recycle Bin and cannot be recovered. (tick box)

Post to Chat

Developer. Post a message to a Microsoft Teams or Slack channel when the flow runs - to say it finished, what it found, or that something needs looking at.

Inputs: in Input. Outputs: out Output.

Options:

• Post to (choice): Microsoft Teams, Slack
• Webhook address (text). The channel's incoming webhook. Use $Name to read a Parameter, so the address is supplied at run time rather than saved in the flow.. Example: https://...
• Send (choice): One message for the whole run, One message per record
• Message (text). Anything in [square brackets] is replaced with that field's value - from each record, or from the first record when sending one message.
• Add the number of records to the message (tick box)
• If a post fails (choice): Stop the flow, Warn and carry on

Python Script

Developer. Write a few lines of Python against the records, for the thing no tool does. The input arrives as a DataFrame called df.

Inputs: in Input (optional). Outputs: out Output.

Options:

• Code (text)
• Give up after (seconds) (number)

R Script

Developer. Run an R script against the records. Needs R installed on this computer.

Inputs: in Input (optional). Outputs: out Output.

Options:

• Script (text)
• Rscript program (text). Leave as Rscript if R is on the PATH, or give the full path to Rscript.exe.. Example: Rscript
• Give up after (seconds) (number)

Rate Limit

Developer. Slow the flow down on purpose, to stay inside what a website or a licence will put up with.

Inputs: in Input. Outputs: out Output.

Options:

• Records a minute (number)
• Never wait longer than (seconds) (number)

Read Binary Files

Developer. Read whole files - PDFs, images, anything - into a field, so they can travel through the flow alongside the records that describe them.

Inputs: in Paths (optional). Outputs: out Output.

Options:

• Read (choice): The files named in a field, Every file in a folder
• Field holding the file path (one field from the input)
• Folder (file or folder path)
• Matching (text). Example: *.pdf
• Include folders inside it (tick box)
• Name for the file field (text). Example: Blob
• If a file cannot be read (choice): Leave it empty and carry on, Stop the flow

Run Command

Developer. Run a program on this computer as part of the flow - a script, a converter, anything with a command line.

Inputs: in Input (optional). Outputs: out Output.

Options:

• Program (text). Example: python or C:\Tools\convert.exe
• Arguments (text). $Input and $Output stand for the two files below, wherever they appear.
• Run in folder (file or folder path)
• Write the input records to a CSV first (tick box). The file is temporary. Put $Input in the arguments to tell the program where it is.
• Read a CSV back in when it finishes (tick box). Put $Output in the arguments. Without this the input records pass straight through.
• Give up after (seconds) (number)
• Treat a non-zero exit code as an error (tick box)

Send Email

Developer. Send an email for each record, optionally attaching a file the flow produced.

Inputs: in Input. Outputs: out Output.

Options:

• Mail server (text). Example: smtp.office365.com
• Port (number)
• Security (choice): STARTTLS (usually port 587), SSL/TLS (usually port 465), None
• Sign in as (text). Example: blank = no sign-in
• Password (text). Use $Name to read a Parameter so the password is typed at run time rather than saved in the flow.
• From (text)
• Field holding the To address (one field from the input)
• Subject (text). Anything in [square brackets] is replaced with that field's value for the record.. Example: Statement for [Account]
• Message (text). Field names in [square brackets] are replaced here too.
• Field holding a file to attach (optional) (one field from the input)
• Do not actually send - just report what would be sent (tick box). Leave this ticked while building the flow.

Web Request

Developer. Call a web address once per record and bring the answer back as a field - so a flow can enrich, look up, or post to any API.

Inputs: in Input. Outputs: out Output, err Failed.

Options:

• Address (choice): From a field, The same every time
• Field holding the address (one field from the input)
• Address (text). Example: https://api.example.com/v1/rates
• Method (choice): GET, POST, PUT, PATCH, DELETE, HEAD
• Headers (table of settings). Values may use $Name to read a Parameter, so a key need not be saved in the flow. Each row has:
  • Name (text)
  • Value (text)
• Send a body (choice): No body, From a field, The same every time
• Field holding the body (one field from the input)
• Body (text)
• Content type (text). Example: application/json
• Give up after (seconds) (number)
• Requests at a time (number). More is faster, up to whatever the far end tolerates. The order of the records never changes.
• At most this many a minute (0 = no limit) (number)
• Retry a failed request this many times (number)
• Name for the response field (text). Example: DownloadData
• Also bring back the response headers (tick box)
• If a request fails (choice): Send that record to the Failed output, Leave the response empty and carry on, Stop the flow

Write Binary Files

Developer. Write a file field back out as real files, one per record.

Inputs: in Input. Outputs: out Output.

Options:

• Field holding the file (one field from the input)
• Write into folder (file or folder path)
• Name each file (choice): From a field, By counting up
• Field holding the name (one field from the input)
• Name starts with (text). Example: file_
• Extension (text). Example: .pdf
• Replace files that are already there (tick box)

Apply Setting

Interface. Change one setting on another tool when the flow runs - for the settings that are not text and so cannot hold a $Name.

Inputs: none. Outputs: none.

Options:

• Tool to change (text). Example: The tool's id, shown beside its name
• Setting (text). The name of the setting inside that tool. Hover a setting to see it.. Example: path
• Change it to (text). Example: $SourceFile
• Treat the value as (choice): Text, A number, Yes or no

Batch Parameter

Interface. The value a Batch Macro changes on every pass. Put one in a macro, then use $Name anywhere in that macro's settings.

Inputs: none. Outputs: none.

Options:

• Name (text). Write $Month in any setting inside this macro and it becomes the value for that pass.. Example: Month
• Shown as (text). Used in the Batch Macro's messages about each pass, e.g. Pass for Sales month 2026-01.. Example: blank = the name
• Example value (text). Used only while designing, so the tools in this macro have something to work with. The real value replaces it on every pass.

Branch

Interface. Send the records down one of two paths, decided by a setting rather than by the data - usually a $Name from a Checkbox.

Inputs: in Input. Outputs: left Left, right Right.

Options:

• Take the right-hand path when this is (text). Anything that reads as yes - true, yes, y, 1, on - takes the right-hand path. Everything else takes the left.. Example: $IncludeDrafts
• Leave the other path empty rather than switching it off (tick box). Off, the unused branch is skipped and everything after it stays grey, up to a Branch End. On, it gets an empty table, so anything after it still runs and produces nothing.

Branch End

Interface. Bring the two paths of a Branch back together.

Inputs: in Paths (several connections). Outputs: out Output.

Checkbox

Interface. Ask a yes or no question, and choose what $Name becomes for each answer.

Inputs: none. Outputs: none.

Options:

• Name (text). Use it as $IncludeDrafts in any tool's settings - a path, a filter, a formula.. Example: IncludeDrafts
• Prompt (text)
• Must be answered (tick box)
• Note shown under the prompt (text)
• When ticked, $Name is (text). Example: true
• When not ticked, $Name is (text). Example: false
• Ticked to begin with (text). Example: true or false

Date Picker

Interface. Ask for a date, defaulting to something that moves - today, or the end of last month - rather than to whenever the flow was written.

Inputs: none. Outputs: none.

Options:

• Name (text). Use it as $AsAt in any tool's settings - a path, a filter, a formula.. Example: AsAt
• Prompt (text)
• Must be answered (tick box)
• Note shown under the prompt (text)
• Default to (choice): Use the fixed default below, Today, Yesterday, Tomorrow, The first of this month, The first of last month, The last day of last month, The first of January, The last day of last year
• Fixed default (text). Example: 2026-01-31

Dropdown

Interface. Ask for one value from a list - typed here, or read from a lookup file so the choices are the real ones.

Inputs: none. Outputs: none.

Options:

• Name (text). Use it as $Region in any tool's settings - a path, a filter, a formula.. Example: Region
• Prompt (text)
• Must be answered (tick box)
• Note shown under the prompt (text)
• Choices come from (choice): A list typed here, A field in a file
• Choices (comma separated) (text). Example: EMEA, APAC, AMER
• Lookup file (file or folder path)
• Field in that file (text). Read when the form is built, so the list is whatever the file says today.. Example: CostCentre
• Default value (text)

File Picker

Interface. Ask for a file or a folder, offering only the kinds of file that will work.

Inputs: none. Outputs: none.

Options:

• Name (text). Use it as $SourceFile in any tool's settings - a path, a filter, a formula.. Example: SourceFile
• Prompt (text)
• Must be answered (tick box)
• Note shown under the prompt (text)
• Ask for (choice): A file, A folder
• Only offer these types (text). Example: .csv, .xlsx
• Refuse to run if it is not there (tick box)
• Default (text)

If Condition

Interface. Send everything one way or the other depending on what the data turns out to be - how many records arrived, or whether a total is over a threshold.

Inputs: in Input. Outputs: yes Yes, no No.

Options:

• Take the Yes path when (choice): There is at least one record, There are no records, There are more records than, There are fewer records than, This is true of at least one record, This is true of every record
• Records (number)
• Condition (formula). Example: [Amount] > 1000000

Multi-Choice List

Interface. Ask for several values at once. $Name becomes all of them, ready to drop into a filter.

Inputs: none. Outputs: none.

Options:

• Name (text). Use it as $Regions in any tool's settings - a path, a filter, a formula.. Example: Regions
• Prompt (text)
• Must be answered (tick box)
• Note shown under the prompt (text)
• Choices come from (choice): A list typed here, A field in a file
• Choices (comma separated) (text). Example: EMEA, APAC, AMER
• Lookup file (file or folder path)
• Field in that file (text)
• Substitute as (choice): Quoted list - "A", "B" - for a filter, Plain list - A, B. With the quoted form, [Region] IN ($Regions) is a working filter.
• Chosen to begin with (comma separated) (text)

Stop with Error

Interface. Stop the flow with a message of your own when the data is not what it should be - the check that keeps bad numbers out of a report.

Inputs: in Input. Outputs: out Output.

Options:

• Stop when (choice): Any record matches the condition, No records arrived at all, More records arrived than, Fewer records arrived than
• Records (number)
• Condition (formula). Example: IsNull([Account]) OR [Amount] < 0
• Message (text)
• And (choice): Stop the flow, Carry on, but say so
• Add how many records matched (tick box)

Switch

Interface. Send each record out of one of several ports by the value of a field or an expression - up to five cases, each with its own port, and Otherwise for the rest. First case to match wins.

Inputs: in Input. Outputs: 1 Case 1, 2 Case 2, 3 Case 3, 4 Case 4, 5 Case 5, otherwise Otherwise.

Options:

• Switch on (choice): A field's value, An expression
• Field (one field from the input)
• Expression (formula). Example: Left([Account], 2)
• A case matches when the value (choice): Is exactly the case, Is the case, ignoring capitals, Starts with the case
• Cases (table of settings). The first case leaves by port 1, the second by port 2, and so on up to 5. Anything that matches none of them leaves by Otherwise. Each row has:
  • Value (text). Example: EMEA

Association Measures

Investigation. Which fields are related to each other, whatever their type - numbers, categories or a mix of the two.

Inputs: in Input. Outputs: out Output.

Options:

• Fields (empty = all of them) (one or more fields)
• Compare everything against (optional) (one field from the input). Leave empty to compare every field with every other one.
• Only show pairs at least this strong (number)

Contingency Table

Investigation. Count every combination of two fields as a grid, and say whether the pattern is more than chance.

Inputs: in Input. Outputs: out Table, stats Test.

Options:

• Down the side (one field from the input)
• Across the top (one field from the input)
• Show (choice): Counts, Percent of each row, Percent of each column, Percent of everything
• Add a totals row and column (tick box)

Correlation

Investigation. How strongly each pair of number fields moves together, from -1 to 1.

Inputs: in Input. Outputs: out Pairs, matrix Grid.

Options:

• Fields (empty = every number field) (one or more fields)
• Measure (choice): Pearson - straight-line relationships, Spearman - any relationship that only goes one way
• Only show pairs at least this strong (number)
• Include each field against itself (tick box)

Distribution Fit

Investigation. The shape of a number field: percentiles, how lopsided it is, and where the outliers start.

Inputs: in Input. Outputs: out Summary, bins Histogram.

Options:

• Number fields (empty = all of them) (one or more fields)
• Separately for each (one or more fields)
• Histogram bars (number)

Frequency Table

Investigation. How often each value turns up in a field, as a count and a percentage, most common first.

Inputs: in Input. Outputs: out Output.

Options:

• Fields (one or more fields). Choosing more than one counts each combination of their values.
• Show only the top (number). 0 shows every value. Anything left out is gathered into one Other row.
• Count empty values as a value of their own (tick box)
• Add a running percentage (tick box)

Profile Fields

Investigation. One row per field saying what is in it: type, how much is missing, how many different values, and the range. The first thing to run on a file you have never seen.

Inputs: in Input. Outputs: out Summary.

Options:

• Fields (empty = all of them) (one or more fields)
• Include a few example values (tick box)
• Include the quartiles for number fields (tick box)

ARIMA

Time Series. Fit an ARIMA model to a series - the standard choice when the value depends on where it has just been.

Inputs: in Input. Outputs: out Model, fit How it fits.

Options:

• Date field (one field from the input)
• Value to model (one field from the input)
• One record per (choice): Day, Week, Month, Quarter, Year
• Choose the terms automatically (tick box). Tries a small range of models and keeps the one that fits best for its complexity.
• Past values used (p) (number)
• Times to difference (d) (number)
• Past errors used (q) (number)
• Include a seasonal pattern (tick box)
• Name this model (text). Example: Sales model

Compare Forecasts

Time Series. Score a forecast against what actually happened, so two models can be compared on the same footing.

Inputs: in Forecast, actual Actuals. Outputs: out Scores, detail Record by record.

Options:

• Date on the forecast (one field from the input)
• Forecast value (one field from the input)
• Date on the actuals (one field from the input)
• Actual value (one field from the input)
• Score each of these separately (one or more fields)
• Call this forecast (text). So several models' scores can be stacked and compared.. Example: Model A

ETS

Time Series. Fit an exponential smoothing model - trend and season, with recent history counting for more. Usually the better first try.

Inputs: in Input. Outputs: out Model, fit How it fits.

Options:

• Date field (one field from the input)
• Value to model (one field from the input)
• One record per (choice): Day, Week, Month, Quarter, Year
• Trend (choice): A steady rise or fall, A percentage rise or fall, None
• Season (choice): None, The same amount each cycle, The same percentage each cycle
• Let the trend level off (tick box). Stops a rising trend being projected upwards for ever.
• Name this model (text). Example: Sales model

Fill Time Gaps

Time Series. Put the missing dates back. A week with no sales should be a zero, not a gap - otherwise every average after it is wrong.

Inputs: in Input. Outputs: out Output.

Options:

• Date field (one field from the input)
• One record per (choice): Day, Week, Month, Quarter, Year
• Separately for each (one or more fields). Every group gets a complete calendar of its own.
• Cover (choice): Each group's own first and last date, The same span for every group
• New records get (choice): Empty values, Zero, for number fields, The value before them
• Mark which records were added (tick box)

Forecast

Time Series. Use a fitted model to say what the next few periods look like, with a range around each one.

Inputs: model Model. Outputs: out Forecast.

Options:

• Periods ahead (number)
• Range covers this much (%) (number)
• Name for the date field (text). Example: Date
• Name for the forecast field (text). Example: Forecast

Build Shapes

Spatial. Join a list of points into a shape or a line - a boundary from its corners, a route from its stops.

Inputs: in Input. Outputs: out Output.

Options:

• Point (one field from the input)
• One shape per (one or more fields). Leave empty to build a single shape from every record.
• In the order given by (one field from the input). Leave empty to use the order the records arrive in.
• Build (choice): A shape (closed), A line (open)
• Name for the shape field (text). Example: Shape
• Add how many points went into each (tick box)

Catchment Area

Spatial. Draw a catchment around each point - everything within five miles of a store, or three rings at five, ten and twenty.

Inputs: in Input. Outputs: out Output.

Options:

• Around this point (one field from the input)
• Distances (text). One catchment per record for each distance given.. Example: 5, 10, 20
• Measured in (choice): Kilometres, Miles, Metres, Nautical miles
• Cut each ring out of the next one (tick box). On, the 10 mile shape is a doughnut with the 5 mile circle removed, so the catchments do not overlap. Off, each is a full circle.
• Name for the shape field (text). Example: Area
• Name for the distance field (text). Example: Radius

Grid Cells

Spatial. Cover an area with square cells, for counting things by area instead of by region boundary.

Inputs: in Input (optional). Outputs: out Grid.

Options:

• Cover (choice): Everything in the input, A box I give
• Points (one field from the input)
• West edge (number)
• South edge (number)
• East edge (number)
• North edge (number)
• Cell size (number)
• Measured in (choice): Kilometres, Miles, Metres, Nautical miles
• Extend the box by this many cells (number)

Make Points

Spatial. Turn a longitude and a latitude into a point, so the rest of the spatial tools can work with it.

Inputs: in Input. Outputs: out Output.

Options:

• Longitude (east-west) (one field from the input)
• Latitude (north-south) (one field from the input)
• Name for the point field (text). Example: Point
• If a record has no usable coordinates (choice): Leave the point empty, Leave the record out, Stop the flow

Measure Distance

Spatial. How far apart two points are, and which way round - as the crow flies.

Inputs: in Input, to Destinations (optional). Outputs: out Output.

Options:

• From (one field from the input)
• To (choice): Another point field on the same record, A single point from the second input
• To (one field from the input)
• Point field on the second input (one field from the input)
• In (choice): Kilometres, Miles, Metres, Nautical miles
• Name for the distance field (text). Example: Distance
• Also give the compass direction (tick box)

Nearest Match

Spatial. For every record, the closest few from another list - the nearest depot, the three nearest branches, whatever is within ten miles.

Inputs: in Input, ref Look in. Outputs: out Matched, miss Nothing near enough.

Options:

• Point on the input (one field from the input)
• Point to look for (one field from the input)
• How many to find (number)
• No further away than (0 = no limit) (number)
• Measured in (choice): Kilometres, Miles, Metres, Nautical miles
• Name for the distance field (text). Example: Distance
• Number them 1, 2, 3 by how close they are (tick box)

Spatial Join

Spatial. Work out which area each point falls inside - which region, which sales territory, which catchment.

Inputs: in Points, areas Areas. Outputs: out Matched, miss Outside every area.

Options:

• Point (one field from the input)
• Area (one field from the input)
• When a point is inside more than one area (choice): Give a record for each, Keep only the first

Apply Model

Predictive. Apply a fitted model to new records and add its prediction as a field.

Inputs: in Input, model Model. Outputs: out Output.

Options:

• Name for the prediction field (text). Example: Prediction
• Also add the chance of each answer (tick box). Only for models that predict a category.
• If a record is missing something the model needs (choice): Leave the prediction empty, Leave the record out, Stop the flow

Assign Cluster

Predictive. Put each record into one of the groups a cluster model found.

Inputs: in Input, model Model. Outputs: out Output.

Options:

• Name for the group field (text). Example: Group
• Also add how far the record is from its group's centre (tick box). A large distance means the record does not really belong to any group.

Balance Classes

Predictive. Rebalance the records so a rare answer is no longer rare - the usual first step before modelling fraud, churn or any other needle in a haystack.

Inputs: in Input. Outputs: out Output.

Options:

• Field holding the answer (one field from the input)
• The rare value (text)
• Make it this much of the result (%) (number)
• By (choice): Leaving out common records, Repeating rare records
• Random seed (number). The same seed gives the same sample every run.

Cluster Analysis

Predictive. Find groups in the data that nobody labelled - customers who behave alike, sites that look alike.

Inputs: in Input. Outputs: out Model, fit How it fits, centres Group centres.

Options:

• Group on these fields (one or more fields)
• How many groups (number)
• Put every field on the same scale (tick box). Almost always wanted: without it the field with the biggest numbers decides everything.
• Name this model (text). Example: Segments

Compare Models

Predictive. Score several models on the same held-back records and put their results side by side.

Inputs: in Test records, models Models (several connections). Outputs: out Comparison.

Options:

• The right answer is in (one field from the input)
• Best model is the one with (choice): The best score for its kind, No particular order

Cross Validation

Predictive. Fit and test a model several times over different slices of the data, to find out how well it really does on records it has not seen.

Inputs: in Input. Outputs: out Summary, folds Each round.

Options:

• Predict this field (one field from the input)
• Using these fields (one or more fields)
• Model (choice): Linear regression, Logistic regression, Decision tree, Random forest
• Rounds (number)
• Shuffle before splitting (tick box). Leave off when the records are in time order and the question is about the future.
• Name this model (text). Example: My model

Decision Tree

Predictive. Learn a set of yes/no rules that predict a field - the model you can read and explain to somebody.

Inputs: in Input. Outputs: out Model, fit How it fits, importance What matters.

Options:

• Predict this field (one field from the input)
• Using these fields (one or more fields)
• Longest chain of questions (number)
• Fewest records in an answer (number)
• Name this model (text). Example: My model

Linear Regression

Predictive. Fit a straight-line relationship between a number you want to predict and the fields that might explain it.

Inputs: in Input. Outputs: out Model, fit How it fits, coef Coefficients.

Options:

• Predict this field (one field from the input)
• Using these fields (one or more fields)
• Include a constant term (tick box)
• Name this model (text). Example: My model

Logistic Regression

Predictive. Predict a yes or no - will they churn, will it be late - and get the odds rather than only the verdict.

Inputs: in Input. Outputs: out Model, fit How it fits, coef Coefficients.

Options:

• Predict this field (one field from the input)
• Using these fields (one or more fields)
• Count this value as yes (text). Example: blank = the less common one
• Give the rarer answer extra weight (tick box). Worth having when one answer is much rarer than the other, which is usually the interesting one.
• Name this model (text). Example: My model

Random Forest

Predictive. Many trees, averaged. Slower and far harder to explain than one tree, and usually the most accurate thing here.

Inputs: in Input. Outputs: out Model, fit How it fits, importance What matters.

Options:

• Predict this field (one field from the input)
• Using these fields (one or more fields)
• How many trees (number)
• Longest chain of questions (0 = no limit) (number)
• Fewest records in an answer (number)
• Name this model (text). Example: My model

Simulate Values

Optimize. Run a what-if thousands of times with the uncertain numbers drawn at random, to see the range of outcomes rather than one guess.

Inputs: in Input. Outputs: out Draws, summary Summary.

Options:

• Name of each uncertain number (one field from the input)
• Its shape (one field from the input). One of "normal", "uniform", "triangular", "lognormal" or "fixed".
• First number (one field from the input). Average for normal; lowest for uniform and triangular; the value for fixed. For lognormal, the average of the value's logarithm: for values around 100, use 4.6.
• Second number (one field from the input). Spread for normal; highest for uniform and triangular. For lognormal, the spread of the value's logarithm, e.g. 0.25.
• Third number (triangular only) (one field from the input). The most likely value.
• How many runs (number)
• Random seed (number)

Solver

Optimize. Find the cheapest or most profitable combination that still obeys every rule - how much of each thing to buy, make, ship or assign.

Inputs: in Choices, limits Limits. Outputs: out Answer, summary Summary.

Options:

• Name of each choice (one field from the input)
• Value of one unit (one field from the input)
• Aim to (choice): Make this as large as possible, Make this as small as possible
• Least of each (optional) (one field from the input)
• Most of each (optional) (one field from the input)
• Answers must be whole numbers (tick box). Needed when the thing being chosen cannot be halved - lorries, staff, machines.
• Name of each limit (one field from the input)
• Field holding at most / at least / exactly (one field from the input). Values may be "<=", ">=" or "=".
• The limit itself (one field from the input)
• How much of each limit one unit uses (one or more fields). One field per limit, in the same order the limits are listed.

Formula language

Used by Formula, Formula Across Rows and Filter (custom mode). Expressions in imported workflows work unchanged.

Building blocks

Field and function names are not case sensitive. Line breaks and extra spaces are fine.

Operators

Multiplication binds tighter than addition, comparisons tighter than AND, and AND tighter than OR; use brackets to be explicit.

Conditions

IIF([Amount] > 100, "Big", "Small")

IF [Status] = "Delivered" THEN 1
ELSEIF [Status] = "Returned" THEN -1
ELSE 0
ENDIF

Switch([Code], "Other", "IE", "Ireland", "GB", "Britain")

Types and nulls

Every expression has a type: number, text, true/false, date or datetime. Mixing types converts sensibly: text plus a number joins them as text, a number compared with text is compared as a number. Null (missing) propagates: [Amount] + 1 is null when Amount is null, and a comparison involving null is neither true nor false, so Filter sends such rows to False. Use IsNull, IsEmpty and Coalesce to handle missing values deliberately.

Dates

Dates are real Date or DateTime values, not text. Turn text into a date with ToDate, DateParse or DateTimeParse, and a date into text with DateTimeFormat. Format codes: %Y four-digit year, %y two-digit, %m month number, %b/%B month name, %d day, %H hour, %M minute, %S second, %A weekday name. Date arithmetic uses DateTimeAdd and DateTimeDiff; subtracting two dates directly gives the difference in days.

Function reference

76 functions, by category. Names are not case sensitive.

Conditional · Conversion · DateTime · Math · Regex · String · Test · Window

Functions: Conditional

Functions: Conversion

Functions: DateTime

Functions: Math

Functions: Regex

Functions: String

Functions: Test

Functions: Window

Importing workflows

Open > Import workflow (.yxmd, .yxmc, .yxwz)… and choose a .yxmd file (also .yxwz and .yxmc).

• Every tool with an equivalent is translated with its settings, connections, annotations and canvas positions. Formula expressions carry over as they are; date formats are converted.
• The Join tool's built-in field selection becomes a Choose Fields tool after the J output.
• Macros (.yxmc) are expanded into their tools when the file can be found next to the workflow, in a macros subfolder, or in the macros folder of your Workflows folder. Batch macros that read one file per control record become a Read Files from List tool; per-file Row Numbers are kept.
• Tools with no equivalent, such as database connectors or macros that cannot be found, become red Unsupported Step placeholders that keep the wiring.
• An import report lists what was translated, what was left as a placeholder, and settings that were mapped approximately (for example the Cleanse macro's tick boxes). Check those tools.
• File paths are kept exactly as they were, so paths that pointed at another machine or a network drive need re-pointing before the flow runs.

The imported flow is saved to the workflows folder and opened in a new tab.

Licensing

Binse is licensed per computer, one licence for every workspace. On first start the app shows its licence screen with one box, Licence key. Paste the key from your receipt email and press Activate; the copy licenses itself in a few seconds and the footer then shows who it is licensed to and, if set, when the licence ends. There is nothing to send to anyone. Two kinds of key are accepted, and the app tells them apart by their shape:

What is sent, and where. Only the licence details, never your data, file names or flows:

• Lemon Squeezy key: the key and this computer's device id (a code such as BIN-2754-FU47-WH35) go to api.lemonsqueezy.com when you activate. Later checks and Release this computer send the key and the activation id Lemon Squeezy gave back.
• BINSE- key: the key, the device id, the product name and the app version go to activate.binse.app. Release sends the key and the device id the licence was issued to.
• Every request also carries the app version in its user-agent header.

Staying licensed. The app confirms the licence quietly in the background about every 7 days; it never interrupts your work to do so. If the computer is offline:

• a Lemon Squeezy key keeps working for up to 30 days after its last successful check. After a week without a check the footer warns you; after 30 days the licence screen says Confirm your licence: connect to the internet and press Check now. A network failure alone never locks the app; only a clear answer that the key has expired, been disabled or been released does.
• a BINSE- key is held as a 35-day lease that renews itself once it is a week old. Offline, it keeps working until the lease ends, then asks for a connection in the same way.

Moving to a new computer. Press Release this computer (on the licence screen or in the app footer) on the old one, then enter the same key on the new one. Renaming the PC or signing in with a different Windows account does not count as a new computer: the device id comes from the Windows installation's machine id only. Reinstalling Windows does, so release first if you can.

Licence files issued by hand. For evaluations and support, a signed licence.key file still works. Click Have a licence file, or need one issued by hand? under the key box: it shows this computer's computer code, which is what a hand-issued licence is made out to. Load the file you receive with Load licence file…, or paste its contents. Licences issued before the change to the device id keep working.

The software is proprietary; see LICENSE.txt in the application folder for the terms.

Keyboard shortcuts

Troubleshooting

"Cannot reach the engine" banner. The background engine has stopped. Click Start the engine on the banner (allow it if Windows asks; tick "always allow" to skip the question next time). The engine restarts and the page reconnects by itself within a few seconds. If that does not work, open the app again from the desktop shortcut. Unsaved work in the window is kept either way, so save once the engine is back.

The taskbar shows an Edge icon. Unpin that button, open the app from the desktop shortcut, then right-click the running app's taskbar button and choose Pin to taskbar.

Memory stays high after a run. Normal: the engine keeps memory for reuse. Press Restart in the footer to hand it back. If a folder read is exhausting memory, check for a stray very large workbook in the folder; each workbook is read one at a time, so the biggest one sets the peak.

Nothing happens when I open the app. Look in %LOCALAPPDATA%\Binse Data Analytics & Dashboards\logs\log.txt; errors are also shown in a dialog. If it still will not start, run the installer again over the top: it repairs the program files and keeps your licence, flows and settings.

"File not found" on an imported flow. The path came from another machine. Select the Data Source tool and choose the file or folder on this machine.

A field is missing from a picker. Pickers show the fields that arrive at the tool; check the tools upstream, and make sure the tool's input is connected. Pivot and Detect Types only know their output fields after a run.

Numbers came in as text. Untick Read all fields as text on Data Source, or add a Detect Types or Choose Fields tool to convert.

Excel says "sheet not found". The named sheet is missing from that workbook; the first sheet was used instead and a warning is shown in Messages.

Slow first run on a large file. The first run reads and caches everything; later runs only recompute what changed. Put a Choose Fields tool early in the flow to drop fields you do not need.

Zipping the app folder for someone else. Double-click Make user kit.cmd in the application folder: it builds a clean zip next to the folder without your logs, cached results, licence file or workflows.

"Confirm your licence" on start. The licence has not been confirmed online for too long (30 days for a Lemon Squeezy key, the end of its lease for a BINSE- key). Connect to the internet and press Check now. Nothing is lost; flows and results are untouched.

"This licence key is already in use on as many computers as it allows." Release the old computer from its licence screen or footer (or, for a Lemon Squeezy key, from your Lemon Squeezy customer portal), then activate again.

Uninstalling. Double-click uninstall.cmd in the application folder.

Glossary

• Data Flow: this workspace, the flow canvas. Called Data Analytics before September 2026.
• Flow / workflow: a set of connected tools saved as one JSON file.
• Tool / node: one step in a flow (Data Source, Filter, Join, ...).
• Port: an input (square) or output (circle) on a tool. Letters mark ports when a tool has several: T/F, L/J/R, U/D.
• Field / column: a named column of data with a type.
• Null: a missing value, shown as [Null] in the grid.
• Cache: stored outputs of every tool from the last run; unchanged tools are not recomputed.
• Licence key: the key from your receipt email that licenses a copy: a Lemon Squeezy key or a BINSE-XXXX-XXXX-XXXX key. Pasted once into the licence screen; nothing else is needed.
• Device id / computer code: this computer's identifier, such as BIN-2754-FU47-WH35, taken from the Windows machine id (so it survives a PC rename or a change of Windows account). Sent with a key when activating; only needed by hand for a licence file issued by hand. Older guides called it the machine code.