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
Incoming messages sample data

    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.

    1. Create a project

      Group devices the way your work is organised: one site, one machine line, one customer.

    2. Add a device

      Each device gets its own ID and password, shown once. Nobody else can use its login.

    3. Flash your firmware

      Paste the login into the ESP32, Arduino or Python example and connect over MQTT with TLS.

    4. 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
    See all examples in the docs
    // 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    = "iot.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/telemetry
    • subscribe devices/dev_coldroom01/cmd
    • subscribe devices/dev_pump_03/cmd
    • subscribe 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.

    Create free account