Intelligence in every solution
Connect your devices. Watch every reading live.
AIOTA IoT Cloud is an MQTT platform for ESP32, Arduino and Linux devices. Organise them into projects, see their data the moment it's sent and control them from your browser.
- MQTT 3.1.1 and 5 over TLS
- Works with any MQTT library
- REST API and live WebSocket
From unboxed board to live chart in four steps
No servers to set up on your side. If your device can reach the internet, it can report to AIOTA.
Create a project
Group devices the way your work is organised: one site, one machine line, one customer.
Add a device
Each device gets its own ID and password, shown once. Nobody else can use its login.
Flash your firmware
Paste the login into the ESP32, Arduino or Python example and connect over MQTT with TLS.
Watch and control
Readings appear live on the dashboard. Send commands like relay_on back with one click.
What you get
The parts every connected product needs, already built and working together.
Live dashboard
Charts update the moment a message arrives, with history for the last 15 minutes to 7 days.
Projects
Keep devices for each site or customer apart, and see at a glance how many are online.
Two-way commands
Switch relays, change reporting intervals or reboot a device from the browser.
Online status
Devices set an MQTT Last Will, so you know within seconds when one drops off the network.
Admin console
See every registered user and their devices. Deny an account and its devices are cut off.
Plain JSON over MQTT
No SDK to install. Any MQTT library that can publish JSON works, on any hardware.
A few lines of code on the device
Publish JSON to your device's topic and subscribe to its command topic. That's the whole contract.
- Send readings
devices/<id>/telemetry- Report status
devices/<id>/status- Receive commands
devices/<id>/cmd
// Arduino IDE / PlatformIO. Libraries: PubSubClient, ArduinoJson
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>
const char* DEVICE_ID = "dev_xxxxxxxxxxxx"; // from the dashboard
const char* PASSWORD = "your-device-password";
const char* BROKER = "mqtt.aiota.tech";
WiFiClientSecure net;
PubSubClient mqtt(net);
String base = String("devices/") + DEVICE_ID;
void onCommand(char* topic, byte* payload, unsigned int len) {
JsonDocument doc;
if (deserializeJson(doc, payload, len)) return;
const char* cmd = doc["command"] | "";
if (strcmp(cmd, "relay_on") == 0) digitalWrite(2, HIGH);
if (strcmp(cmd, "relay_off") == 0) digitalWrite(2, LOW);
}
void connectMqtt() {
while (!mqtt.connected()) {
String status = base + "/status";
// Last Will: the broker publishes "offline" if the device drops
if (mqtt.connect(DEVICE_ID, DEVICE_ID, PASSWORD, status.c_str(), 1, true, "offline")) {
mqtt.publish(status.c_str(), "online", true);
mqtt.subscribe((base + "/cmd").c_str(), 1);
} else delay(5000);
}
}
void setup() {
pinMode(2, OUTPUT);
WiFi.begin("wifi-name", "wifi-password");
while (WiFi.status() != WL_CONNECTED) delay(500);
net.setInsecure(); // for production use net.setCACert(rootCA)
mqtt.setServer(BROKER, 8883);
mqtt.setCallback(onCommand);
}
void loop() {
if (!mqtt.connected()) connectMqtt();
mqtt.loop();
static unsigned long last = 0;
if (millis() - last > 5000) {
last = millis();
JsonDocument doc;
doc["temperature"] = temperatureRead();
doc["rssi"] = WiFi.RSSI();
char buf[200];
size_t n = serializeJson(doc, buf);
mqtt.publish((base + "/telemetry").c_str(), (uint8_t*)buf, n, false);
}
}Each device has its own key, and its own lane
The broker checks every connection and every topic against the platform. A device can only talk on its own topics, so a leaked password can't be used to read anyone else's data.
- TLS encryption between device and cloud
- Per-device passwords, stored only as bcrypt hashes and replaceable any time
- Admins can deny an account and its devices instantly
Signed in as dev_coldroom01
publish devices/dev_coldroom01/telemetrysubscribe devices/dev_coldroom01/cmdsubscribe devices/dev_pump_03/cmdsubscribe devices/#
Built for real deployments
Use a project for each site, customer or product line.
Cold chain
Freezer and cold room temperatures, recorded around the clock.
Smart farming
Soil moisture, pump control and tank levels across fields.
Factory machines
Vibration, current and run hours from motors and compressors.
Energy metering
Power and energy readings from meters, inverters and DG sets.
Buildings
Occupancy, air quality and lighting control for offices and campuses.
Questions people ask
Something else? The developer docs cover topics, payloads and the API in detail.
Which devices can connect to AIOTA?
Anything that speaks MQTT: ESP32, ESP8266, Arduino with Wi-Fi or Ethernet, Raspberry Pi, Raspberry Pi Pico W, industrial gateways and PLCs with MQTT support. The docs include ready-to-run code for ESP32, Python, Node.js and MicroPython.
What data format do devices send?
A JSON object on the topic devices/<device-id>/telemetry, for example {"temperature": 24.5}. Every number in it can be charted on the dashboard. No schema needs to be set up first.
Is the connection secure?
Devices connect with MQTT over TLS on port 8883. Each device has its own password, stored only as a hash, and can only publish and subscribe on its own topics.
Can I send commands to my devices?
Yes. Commands are published to devices/<device-id>/cmd as JSON, for example {"command": "relay_on", "params": {}}. You can send them from the device page or through the REST API.
What happens if an admin denies a user's access?
The user is signed out and can't sign in, and the broker refuses their devices. Their projects and data are kept, so access can be restored later.
Can I use the platform from my own software?
Yes. Everything on the dashboard is available through a REST API with token authentication, plus a WebSocket for live updates. See the developer docs.

Put your first device online today
Create an account, add a device and run the simulator. You'll see live data within a few minutes.