Skip to content
ThingFace

Limits and measured numbers

The limits the protocol and the cloud impose, and what the SDK costs on a board, measured. Each number carries its base: a limit comes from the devui.1 specification or from the cloud; a measured number says when and on what.

Messages

LimitDefaultWho sets it
Frame received by the board1,024 B, header includedthe board (MAX_RX_FRAME)
Message received by the board4,096 Bthe board (MAX_RX_MSG)
Window per session (what the cloud leaves in flight for one tab)4,096 Bthe board (SESSION_WINDOW)
Frame sent by the board4,096 B, header includedthe cloud
Message sent by the boardthe size of the SDK's queue (up to 64 KB with PSRAM)the board
WebSocket message at the gateway16 KiBthe cloud
Message reassembled by the lib, from the board64 KBthe lib

A message larger than the frame goes in pieces, reassembled only at the ends. Above the receiver's limit: refusal 4413. A message that waits more than 10 s in the relay's queue, or that the board reads more than 10 s old, is dropped without being carried out (4408; see The confirmation levels).

The business events (devui_audit, since 26/10) have a text of up to 128 B and the quota the cloud gives in the HELLO_ACK: by default, 10 at once and 360 an hour per device; above it, DEVUI_ERR_OVER_QUOTA on the board (and 4429 from the cloud, which does not write the event).

On the ESP8266, the "8266" profile lowers these limits: messages of up to 1 KB both ways, up to 4 tabs and no signed trust orders (The SDK on the ESP8266, in Portuguese).

The interface and the data

  • Bundle: the interface comes from the firmware or from the product's publication. The firmware's (the packed web/ folder) goes up from the board to the cloud, up to 512 KB, and the packer warns when it does not fit the target's partition; in a product with its interface in the cloud, the cloud refuses it, and the tabs get the publication only. The CLI's publication goes up to 512 KiB unsigned; signed, up to the ceiling of the account's plan (CLI reference).
  • Uploads per day: a new bundle counts up to 3 per device in the UTC day (it turns at 00:00 UTC); a resumption, HAVE and WAIT do not count, and the account's up to 2 development devices have no ceiling. Above it the cloud answers REJECT, and the board says so on the serial.
  • What the interface keeps in the browser (dev.storage): 64 KiB per user and device in the Free plan, 256 KiB in the paid ones; keys of up to 256 characters. It goes at the logout, when someone else signs in on the browser, and after 90 days without use.

The database

The board's requests to the database (Database):

LimitDefaultWho sets it
Writes per board60 a minute, with a burst of 10the cloud (DEVUI_DB_LIMIT, with the wait)
Reads per board120 a minute, with a burst of 20the cloud (DEVUI_DB_LIMIT, with the wait)
Requests waiting for their answer at once4the board (the fifth returns DEVUI_ERR_DB_LIMIT with nothing on the wire) and the cloud
Request, in JSON4,083 B (1,011 B on the ESP8266); an insert of the queue, 4,055 B (983 B), as it gets the op_idthe board (the SDK's send queue; ESP_ERR_INVALID_SIZE)
Record2 KB and 32 fieldsthe cloud (DEVUI_DB_TOO_LARGE)
Wait for the answer10 sthe board (DEVUI_DB_UNAVAILABLE)
Queue of inserts in the NVS2,048 B (DEVUI_DB_QUEUE_FLASH_MAX); on the ESP8266, the queue in the RAM onlythe board
Tables of a product64, of 1 to 32 fieldsthe cloud and the CLI

Opening the connection

On the board, the TLS handshake and the WebSocket upgrade wait for the network up to 15 s (on ESP-IDF and on Arduino for ESP32, the WebSocket client's network_timeout_ms, for each read or write; the ESP8266 and the POSIX port have the same deadline). The cloud gives each stage of the opening 20 s (the gateway's opening_timeout_ms). The board's is shorter on purpose: when the network stalls, it gives up and tries again before the cloud cuts the connection. On 27/10/2026, on a residential network, the ESP32 took 3 to 16.5 s from the DNS to the HELLO_ACK in 49 openings, and the former 10 s cut one (-0x7280 on the serial). A board gets the new deadline only when it is flashed with an SDK from after that date.

What the SDK costs on a board (measured on 13/10/2026)

Measured with the protocol 1.0 SDK and ESP-IDF 5.5.5, on the LED example; the SDK has grown since, and these numbers are the order of magnitude, not a promise.

WhatESP32 (no PSRAM)C3
Free heap with only the Wi-Fi251,664 B206,392 B
Free heap at steady state, 0 to 4 tabs~228 KB~183 KB
Free heap at the worst moment, 4 tabs at 10 msg/s~203 KB—
SDK flash with the WebSocket client and TLS31.8 to 36.4 KB37.3 to 44.8 KB
P-256 signature of the HELLO273 ms at 160 MHz; 205 ms at 240 MHz141 ms
From the IP to the HELLO_ACK, p50 / p952.59 / 3.54 s at 160 MHz; 1.92 / 2.46 s at 240 MHz1.45 / 2.44 s
Round trip page to board (ack: 'device'), p50~100 ms with WIFI_PS_MIN_MODEM; 34 ms with no power saving~100 ms; 22 ms with no power saving
Stack headroom: SDK task / WebSocket task (6 KB each)3.8 to 4.2 KB / 2.6 to 3.5 KB (both chips together)

The product's target is to leave at least 100 KB of free heap on an ESP32 with no PSRAM. The Wi-Fi's default power saving adds ~70 ms to the median round trip; the p95 of the ESP32's opening at 160 MHz misses the 3 s target, and at 240 MHz it fits.

On the Arduino core 3.3 as it ships, the SDK costs twice as much: the core's precompiled mbedTLS uses fixed TLS buffers, and the SDK's idle session takes ~40 KB instead of ~4 KB (measured on 11/11/2026 on the ESP32 without PSRAM: ~82 KB of 8-bit RAM with the SDK online, against ~45 KB with dynamic buffers). The recipe for Arduino on the ESP32 without PSRAM, with the measurements, is in ESP32 without PSRAM on Arduino.

The whole rule is in the protocol's specification, devui.1.