Analysis Runtimes

The runtime decides which language your Analysis is written in, how it gets its dependencies, and what it can reach while it runs. You pick one in the Runtime field when you create the Analysis. Admin lists each option by language and runtime code, such as Deno - deno-rt2025, and the code is what the API stores.

Available runtimes

Runtime	Code	Language	Dependencies	Runs on
Bun	bun-rt2026	TypeScript, JavaScript	Resolved automatically from package-name imports	TagoIO or External
Deno	deno-rt2025	TypeScript, JavaScript	Resolved automatically from npm: and URL imports	TagoIO or External
Node.js	node-rt2025	JavaScript	One bundled file carrying every dependency	TagoIO or External
Python	python-rt2025	Python	Resolved automatically with uv	TagoIO or External
Luau	luau-rt2026	Luau	None	TagoIO only
Other	other	Any	Yours to install and manage	External only

tip

Choose Bun (bun-rt2026) or Deno (deno-rt2025) to edit scripts directly in TagoIO and resolve dependencies from imports. Bun imports packages by name, as in a Node.js project; Deno needs the npm: prefix. Choose Node.js (node-rt2025) when your workflow builds and tests a bundled script locally before upload.

Bun (bun-rt2026)

Bun runs TypeScript and JavaScript directly, and you do not compile or bundle anything yourself. Import packages by name, the way you would in a Node.js project, and Bun installs them. Add a version to the import when the script needs a specific release.

import { Analysis, Device } from "@tago-io/sdk";
import dayjs from "dayjs";
import isOdd from "is-odd@3.0.1";

When you save a new version, TagoIO builds the script and its packages into one file, so each run starts without installing anything. If the build fails, the Console shows the reason. A syntax error or a package that does not exist also stops the Analysis when it runs, so fix it and save again. For any other build failure, such as a build larger than 10 MB, the version still runs as uploaded and installs its packages on every run, so each run takes longer and uses more of your Analysis Service time. To get under the 10 MB limit, remove a heavy package or move part of the work into a separate Analysis, then save again.

npm: and jsr: imports do not work on Bun. Use the plain package name instead.

Choose Bun when you want to write TypeScript in the TagoIO editor and import packages the same way you would locally.

Deno (deno-rt2025)

Deno runs TypeScript and JavaScript with built-in TypeScript support, so there is no compilation step. Dependencies resolve automatically: you import packages directly from npm: specifiers or URLs, with no bundling and no upload.

import { Analysis, Device } from "npm:@tago-io/sdk";
import { DateTime } from "npm:luxon";

Write the whole Analysis in the TagoIO editor, add imports as you need them, and run. The editor includes linting and formatting. Dependencies are fetched and cached on first run, so early executions take a little longer.

Choose Deno when you want to maintain the script in the TagoIO editor without a local bundling step.

Node.js (node-rt2025)

When hosted on TagoIO, Node.js runs JavaScript from a single bundled file containing the script's dependencies. Build the bundle locally with the TagoIO Analysis Builder, then upload it. The hosted runtime does not resolve npm packages from imports at execution time.

npm install -g @tago-io/builder
analysis-builder my_script.js
# Upload the generated .tago-io.js file to the Analysis

The full walkthrough, including the local project setup, is in Running Analysis as External using Node.js, under the Analysis-Builder section.

Choose Node.js when you want to develop and test the script locally, then upload a bundle containing its dependencies. You can organize the source across files and modules before building. Changes require rebuilding and uploading the bundle.

Python (python-rt2025)

Python resolves dependencies automatically with uv. Declare them in the script header and imports that are not part of the standard library are installed when the Analysis runs.

# /// script
# dependencies = [
#   "tagoio-sdk",
#   "pandas",
#   "requests<3",
# ]
# ///

from tagoio_sdk import Analysis, Device
import pandas as pd
import requests
from datetime import datetime, timedelta

Resolution is standard Python packaging, so you import from PyPI the same way you would locally. Pick Python for data work that needs pandas, numpy, or scipy. First runs are slower while packages install; later runs use the cached environment.

Luau (luau-rt2026)

Luau is the low-cost option for reading and writing device and entity data. It can work with devices and entities, list Analyses, and start other Analyses. It cannot do anything else: no libraries, no internet access, no Secrets, and no Analysis Token.

Use it for the small jobs that run frequently: converting a reading and saving it back, averaging recent data, flagging a threshold, or tidying up device names and tags. It also picks up where a Payload Parser stops, since a parser can only rework the payload that just arrived while Luau can read earlier data and change the device.

Choose Bun, Deno, Node.js, or Python instead when the script calls an outside service, needs a library, or works with resources other than devices, entities, and Analyses.

Luau runs on TagoIO only, so the External option is not available for it. See Luau Runtime for what it can do, how to write one, and its limits.

Other (other)

other covers any language or runtime TagoIO does not host. An Analysis on other runs externally only: your code runs on your own machine or server and connects back to TagoIO. Nothing is uploaded and nothing runs on TagoIO.

Deprecated runtimes

node-legacy and python-legacy still appear for Analyses created before the current runtimes existed. Both ship outdated packages. Move those Analyses to node-rt2025 or python-rt2025.

Choosing

• bun-rt2026 to write TypeScript or JavaScript in the TagoIO editor, importing packages by name.
• node-rt2025 for a local development, testing, and bundling workflow.
• deno-rt2025 to maintain the script in the TagoIO editor, with dependencies resolved from imports.
• python-rt2025 for data processing that leans on the scientific libraries.
• luau-rt2026 for small device jobs that run often and stay inside TagoIO.
• other when the code runs on your own infrastructure in a language TagoIO does not host.

Bun, Deno, and Node.js use the JavaScript SDK; Python uses the Python SDK. Use the documentation for your SDK's method signatures and data types.

Luau uses its own built-in functions and is not source-compatible with these SDKs.