An MQTT broker is a river of messages, most of them meaningless without a map. The topic name hints, the payload carries a number, and nothing in the protocol itself tells you which of the two hundred topics streaming past is the air-quality sensor you actually care about — or what units that number claims to be in. Turning topics into explicit building data points is the work that makes the river usable.
This guide covers MQTT integration in BAaaS — the managed gateway platform from Hexomation: the broker and TLS prerequisites, how restricted topic learning works, why a silent topic is not an absent one, what SUB/PUB and QoS metadata do and don’t govern, and how to validate a payload before trusting it. Every topic and value here is invented.
Where BAaaS fits
BAaaS is Hexomation’s managed gateway platform: an edge gateway on site picks up a device identity and speaks BACnet/IP and MS/TP via supported routers, Modbus, LonWorks over IP-852, and MQTT — then feeds monitoring, groups, trends, alarms, schedules, dashboards and analytics above it. It can also act as a BACnet/SC node or a site’s primary-only edge hub; the separate managed-hub product is HUBaaS, on a separate tenant.
MQTT here means point data: learned or explicitly mapped topics become monitored points alongside the other protocols’ inventory. This article is about inbound data — a read-only pilot — not publishing commands to equipment, which is its own authorized path and not this guide.
The scenario throughout is a synthetic indoor-air-quality deployment: a few IAQ topics on one broker, a read-only integration account, and one value to prove. It stays deliberately small — the point is the workflow, not the scale.
Broker and trust prerequisites
Before topics, the connection: a broker the gateway can reach, TLS configured correctly, and authentication provisioned. Broker credentials are secrets — they live in the configuration, never in documentation, exports or screenshots; nothing in this article contains or needs real credentials, and a leak in the wrong place is a whole different incident.
Least privilege starts at the broker. The account the gateway uses should be scoped to the topics it needs — a broker-enforced ACL, not a courtesy. A read-only pilot needs subscribe rights and nothing more; if your integration account can publish to command topics, the credential is the risk, not the article.
Do the reachability check before any topic work: a gateway that can’t establish the authenticated TLS session has nothing to learn, and every downstream symptom will look like a topic problem when it’s a connection problem.
Learning is a window, not an inventory
Topic learning runs against filters you scope, for a bounded window — the gateway learns what it observes during that period. That gives you a list of active topics, which is not the same as an inventory of existing topics: a topic that publishes once an hour, on an event, or only when a condition changes will simply not appear in a five-minute learn window.
Silent topics aren’t lost — they can be added manually as concrete, non-wildcard topic names when you know what should exist — the concrete name, spelled fully, because wildcards in a point definition invite more data than you meant to map. The distinction matters for troubleshooting, with its own caveat: an empty result only means no observable matches after a successful authenticated, subscribed learn — connection errors, broker ACL restrictions and your own filters can all hide data from the window. Check that the learn itself ran cleanly, then check publisher-side activity, before concluding a topic doesn’t exist.
Scope the learn filters deliberately too: a filter narrow enough to find your pilot topics without drowning the result in every health-check and heartbeat topic on the broker. The window is a tool for finding specific data, not a trawl for everything.
SUB, PUB and QoS are metadata — not ACLs
Points carry direction metadata — SUB, PUB, BOTH — and a QoS level from 0 to 2. Both are easy to over-read. A SUB point does not enforce read-only: the broker ACL enforces what the connection can actually do; the metadata describes intent. Similarly, QoS describes delivery behavior on the transport — at-most, at-least or exactly-once delivery between client and broker — not that your building point was updated exactly once physically.

The safe pilot shape follows directly: subscribe-only topics on a least-privilege account, wildcard filters scoped narrowly during learning — never the all-topics # as a standing recommendation — and no publish examples anywhere near operational command topics.
QoS levels deserve the same sobriety in commissioning: a higher QoS on the subscription changes delivery guarantees between client and broker, not sensor quality, payload correctness or whether the point’s value means anything. Choose it against what the data is for — not as a general “more is better” reflex.
Payloads: extraction, not interpretation
When a subscribed message arrives, the platform reads UTF-8 payloads and extracts a scalar value if the payload is a JSON object — otherwise the payload is preserved as opaque input rather than dropped or mangled. There is no arbitrary nested-JSON transformation, no automatic units correctness, no universal schema inference and no Sparkplug certification claim. A simple invented example: a topic like site/ahq/iaq/temp carrying {"value":21.5} extracts 21.5 — the unit is what your documentation says it is, not something the protocol told you.
Two freshness cautions ride along. A retained message delivers the last-known payload on subscribe — receipt is not evidence of a fresh measurement. And a timestamp in a payload is whatever the publisher wrote, on the publisher’s clock; compare it against receipt time before treating data as current.
And the scalar-only extraction shapes what you can map: a payload that’s a plain number or a flat {"value": ...} object integrates cleanly; a deeply nested envelope or an array needs publisher-side shaping or a different tool — don’t plan on the platform flattening it for you.
Accept the point against a known reference
Validation is the same shape as the other protocols in this series, with MQTT’s own twist. Observe the payload in the window, confirm the extraction produced the scalar you expected, check the unit against the publisher’s documented semantics — and where possible, compare one value against an independent reading.

A value that arrives is not a value that’s right — retained payloads especially can show a healthy-looking number for a sensor that stopped publishing yesterday. A point that reports something and a point that reports now are different things; treat silence as unknown, not as healthy-zero.
Record what you verified — topic, expected unit, extraction result, and how freshness was checked — because “the MQTT point” six months later is only as trustworthy as the note that defined it.
The fair alternative and the limits
Where this integration earns its place: topics join the same monitored inventory as BACnet objects and Modbus registers — alarms, trends and dashboards in one view instead of a separate MQTT viewer you check manually. Where a dedicated IoT platform still wins is complex payload work: arbitrary schema transformation, Sparkplug semantics, or a broker estate large enough to need its own operations tooling.
The stated limits hold throughout: learning is observed-only, metadata is not access control, extraction is a limited scalar-`value` read (other UTF-8 payloads are preserved as opaque input, not rejected), retained delivery is not freshness, and QoS is transport behavior — none of it substitutes for knowing what your publisher actually emits and when.
Judge the fit honestly: if your goal is making existing topics visible and alarmable alongside the rest of the plant, this is the short path; if the data needs heavy transformation upstream, shape it at the source or use the platform built for that job.
Topics into points, deliberately
The sequence that works: verify broker TLS and a least-privilege subscribe account, run a scoped learn window for long enough to catch slow publishers, separate observed topics from silent ones, add known-silent topics concretely, validate payload extraction and units — then let monitoring do its job on points you actually verified.
What you end up with is a building data point like any other in the inventory — named, directional, monitored — not a mystery topic somebody once found interesting in a viewer and forgot to document.
To trial a read-only broker integration, review the capability overview at BAaaS.io/features. Collection strategy — what monitoring does with these points next — has its own upcoming piece, and the inventory walkthrough carries the matching identity discipline.