Nivalo
Get started free

IoT operations for small hardware teams

Operate connected devices from prototype to fleet.

Nivalo is the operational layer around real hardware — device identity, per-device MQTT credentials, live telemetry, tracked commands, and over-the-air firmware — so one bench prototype can grow into a managed fleet.

Get started free Log in

Free plan · 1 device · 1,000 posts a month

iot.nivalo.io/devices/greenhouse-node-01
Nivalo
Overview Telemetry Events Commands Functions Firmware Devices3 Credentials Settings
makerlab PRO
Connecting…
Status
Connecting…
Last seen
—
Firmware
v1.4.2
Uptime
—
Signal
-58 dBm
Memory
146 KB free
Telemetry streaming · last 96 s
waiting for device…
Temperature °C— Humidity %— Battery V—
Recent commands queued → published → accepted → running → done
Event stream live
Last payload 
{
  "schema": "nivalo.iot.v1",
  "messageId": "msg_8f3c2a1e",
  "deviceId": "dev_9m4k2p",
  "sentAt": "2026-07-01T12:41:07Z",
  "payload": {
    "name": "temperature",
    "value": 23.4,
    "unit": "C"
  }
}
The Nivalo Console · simulated device data

The workflow

Connect it. See it. Operate it. Update it.

The whole loop from a bare board to firmware in the field — one console, one protocol, no glue code.

01

Register the device

Give it a name, MAC, serial, and type, and assign it to a product. It exists in your fleet before it ever powers on.

name=greenhouse-node-01 · mac=A4:CF:12:8B:3E:5A · type=esp32
02

Bring it online with its own credentials

Each device gets scoped MQTT credentials — shown once, rotatable anytime. Flash them into the firmware and watch the device appear in the console in real time.

mqtt.nivalo.io:1883 · user dev_9m4k2p · password shown once
03

Stream telemetry, inspect everything

Telemetry lands in live charts; events arrive with severity. Every message is a versioned envelope you can read parsed or raw.

nivalo/v1/devices/dev_9m4k2p/telemetry
04

Send commands you can trust

Call product-defined functions, read variables, send commands. Every one is tracked through its full lifecycle — including the failures.

queued → published → accepted → running → succeeded
05

Rotate credentials without fear

Per-device MQTT credentials and org-scoped API keys rotate in one click, and every action lands in the audit log.

credentials.rotate · old secret revoked immediately
06

Ship firmware to the field

Upload an artifact, pick a channel, and queue firmware.flash. SHA-256 verified, delivered over a signed expiring URL, progress ACKed from 0 to 100%.

firmware.flash · stable @ v1.5.0 · sha-256 ✓ · progress 0–100%

The platform

Everything around the device, so you don't build it

The console at iot.nivalo.io, backed by an API, an MQTT broker, a device gateway, and embedded libraries — one operational layer instead of six side projects.

Device onboarding

Register devices with name, MAC, serial, and type. Assign them to products and bring them online with per-device MQTT credentials — shown once, rotatable anytime.

Live device operations

Status, last seen, firmware, uptime, signal, and memory at a glance. Live telemetry charts, an event stream with severity, and payload inspection — parsed or raw.

Commands & functions

Send commands, call product-defined functions, read variables. Every command is tracked from queued to published, accepted, running — and succeeded, failed, or timed out.

Firmware over the air

Upload artifacts for ESP32, STM32 coprocessor, or gateway targets. SHA-256-verified downloads over signed expiring URLs, firmware channels per product, and flash progress ACKed 0–100%.

Illustration of an over-the-air update: a stream of hexagonal packets arcs down and fills a glowing hexagon

Secure access

Per-device scoped MQTT credentials, rotatable organization API keys, WorkOS-backed sign-in, and an audit log of who did what, when.

Product definitions

Products define reusable variables, functions, firmware channels, and device profiles — so your telemetry is structured, not a stream of random names.

For embedded engineers

Real protocol. Real libraries. No mystery.

Underneath the console it's plain MQTT with versioned envelopes — nothing you can't inspect with a packet capture.

  • ESP32 — Arduino / PlatformIO library. Connect, publish telemetry and events, receive commands, report OTA progress. A few lines in setup() and loop().

  • STM32-class MCUs — portable C bridge. Secondary MCUs speak NivaloLink over SPI to the network-side chip, so your control loop stays where it belongs.

  • Plain MQTT underneath. Per-device credentials against mqtt.nivalo.io:1883; every message is a nivalo.iot.v1 envelope.

#include <Nivalo.h>

NivaloClient nivalo;

void setup() {
  nivalo.begin(NIVALO_DEVICE_ID,      // dev_9m4k2p
               NIVALO_MQTT_USERNAME,  // per-device credential
               NIVALO_MQTT_PASSWORD); // rotatable in console

  nivalo.onFunction("pump.start", startPump);
  nivalo.variable("soil_moisture", &soilMoisture);
}

void loop() {
  nivalo.telemetry("temperature", readTempC(), "C");
  nivalo.loop();  // keepalive + command dispatch + OTA
  delay(5000);
}
NivaloLink: the same commands, variables, and OTA flow reach STM32-class secondary MCUs over SPI.

Pricing

Start with one device. Grow into a fleet.

Every feature on both plans. Upgrade via Stripe checkout from the console when you outgrow Free.

A row of wall-mounted connected devices, each with a lit blue status LED

Free

for the bench prototype
$0/ month
  • 1 device
  • 1,000 posts / month
  • Full console: telemetry, events, commands, OTA
  • Per-device MQTT credentials
Start free

Pro

for the pilot fleet
$9.99/ month
  • 25 devices
  • 250,000 posts / month
  • Everything in Free
  • Upgrade in one click — Stripe checkout from the console
Get started free

Need more than 25 devices? Talk to us.

Bring your first device online

Register it, grab its credentials, flash the library — then watch it show up in the console.

Get started free hello@nivalo.io