Explainer
MQTT broker support is not Sparkplug support
Short answer
No. A compliant MQTT broker carries Sparkplug traffic without knowing it exists: to the broker the payload is opaque bytes, and the topic namespace, payload encoding and birth/death state conventions are implemented entirely by the publishing and subscribing clients. Verify Sparkplug support at both endpoints, never in the broker.
On this page
No. An MQTT broker does not need Sparkplug support, and a compliant broker never speaks the specification. Sparkplug is a client-side convention — a defined topic namespace, a Protocol Buffer payload encoding and a birth/death state model — carried over ordinary MQTT. The broker forwards those messages as a topic string plus opaque bytes, exactly as it forwards any other publish. When a platform gains a broker app and its vendor calls Sparkplug support possible once demand appears, only the transport question has been answered. The components that must support Sparkplug are the publishing client and every subscribing client, so that is where verification belongs.
What the broker does with a Sparkplug publish #
An MQTT broker authenticates clients, routes each publish by topic to current subscribers, honors the QoS of every message, holds retained messages, stores messages for offline persistent-session subscribers, and delivers a registered Last Will when a client dies without disconnecting. It never parses the payload. To the broker, a Sparkplug metric and a plain text string are indistinguishable bytes.
Sparkplug leans on three of those generic duties. The publishing client registers its Last Will so that the broker itself emits the node's death certificate when that client disappears. Host application state travels as retained messages, which the broker stores and serves to late subscribers. Reliability across short outages rests on the broker's rules for queueing undelivered messages, which is the territory of offline message delivery versus standard QoS.
Because the payload stays unread, the broker also keeps no queryable history of it; storing history is a subscribing client's job, not the router's, and whether an MQTT broker stores historic data you can query answers the same way.
What Sparkplug adds on top of MQTT #
MQTT supplies the transport: topics, publish/subscribe, QoS levels, retained messages, wills. Sparkplug B, an open specification maintained under the Eclipse Foundation's TAHU project, defines everything MQTT deliberately leaves open. It fixes a standardized topic namespace, encodes payloads as Protocol Buffers, and specifies the message lifecycle: birth certificates when a node or device comes online, data messages while it runs, death certificates when it goes away, and host state management so consumers know which edge nodes are alive. In its own summary, the specification "defines how to use MQTT in a mission-critical, real-time environment."
Every one of those rules is implemented by software at the ends of the wire. The publisher builds the topics, encodes the payloads and registers the will; each subscriber decodes the payloads and tracks the state machine. A consumer built for plain, application-defined MQTT topics will receive Sparkplug messages and render nothing usable, because no broker translates between the two conventions.
The question to ask instead #
Ask of every endpoint: does this client implement the Sparkplug specification, at a documented version, for the message types this path uses? For the broker, any working MQTT broker settles its part. Two nuances exist, and neither moves the requirement.
Some enterprise broker editions offer optional Sparkplug-aware tooling, such as decoding payloads for an operations dashboard. That is a convenience for the people watching the system, not a protocol dependency, and it removes nothing from the endpoint requirement.
Broker configuration can still break the traffic while the broker remains perfectly MQTT-compliant. Access rules must permit the whole topic namespace, the discipline behind writing MQTT Distributor ACL topic filters for Sparkplug B. Retained messages and wills must be delivered rather than filtered, or the broker rejects exactly the messages Sparkplug depends on, as in why a broker rejects a Sparkplug client over its STATE will.
Auditing a path with one publisher, one broker and two subscribers #
The inputs, with the source of each:
- One publishing client: the controller application whose Sparkplug support the vendor describes only as possible — the situation that prompts this question.
- One broker: confirmed installable on the platform as an app, which proves transport and nothing else.
- Two subscribing clients: a SCADA driver and a historian gateway, the usual consumers on a plant edge path.
The rule in words: a component must implement Sparkplug if it publishes or consumes Sparkplug messages; a component that only routes them must simply be a working MQTT broker. Required Sparkplug-aware components equal the publishers plus the subscribers.
The arithmetic:
- 1 publisher + 2 subscribers = 3 clients that must be Sparkplug-capable.
- 3 clients + 1 broker = 4 components on the path, and 3 of the 4 carry the Sparkplug requirement.
- Confirmed Sparkplug-capable components today = 0, because the broker is never one of them and neither client documents support.
- 3 required - 0 confirmed = 3 clients left to verify.
- 2 checks per client — decode the payload, track the state machine — so 3 x 2 = 6 verification checks.
Decision: below 3 of 3 clients with documented Sparkplug support, this design is blocked no matter which broker is installed, and the confirmed broker contributes zero toward the requirement. Verify or replace each missing client; only at 3 of 3 does the broker become the easy part of the project.
How to verify a client before you trust it #
- Documentation first. The vendor must state Sparkplug support for the exact application and release you deploy, with the specification version and the message types it handles. A conditional statement is intent, not capability: score it as unsupported.
- Exercise the state machine. Connect the publisher (birth), request a rebirth, then kill its connection without a clean disconnect so the will fires (death). The subscriber must reflect all three transitions.
- Exercise the payload. Confirm the subscriber presents named metrics with correct values, not raw bytes or silently dropped messages.
A successful broker connection proves none of this. A subscriber that connects but shows nothing usable points at client capability or payload mismatch, not at the broker. Because the specification targets mission-critical, real-time data flow, qualify the design on documented features only. Rerun the three tests after any broker change: capable clients have still shown rebirth failures following a broker switch, the subject of why rebirth fails after switching Sparkplug MQTT brokers.
Why a broker app answers a different question #
A broker arriving in a controller platform's app store is a transport offer. Since the broker carries no Sparkplug obligation, its placement is free — on the controller, on a cabinet PC, on a virtual machine — the trade-off in running the MQTT broker on the PLC or on a separate device. What stays scarce is Sparkplug-capable client software, and no broker app adds any. Pick the clients for their documented Sparkplug support first, then let the broker follow.
Questions asked
If the broker never decodes payloads, why do some brokers advertise Sparkplug features?
Some enterprise broker editions add optional Sparkplug-aware tooling, such as decoding payloads for a management dashboard or counting namespace traffic. Those are operator conveniences. The specification places no requirement on the broker, and every publish and subscribe still needs Sparkplug-capable clients, so choose such a broker for its tooling, never as a substitute for endpoint compatibility.
Which broker settings can break Sparkplug even though support is not required?
The usual culprits are access rules that block part of the topic namespace, retained-message support being disabled, and a maximum packet size smaller than a large birth certificate. All three are valid MQTT configurations that starve Sparkplug of messages it needs. None of this is broker Sparkplug support; it is configuration that must permit the traffic.
Can a successful connection to the broker prove Sparkplug works?
No. Connection and even message delivery prove transport only. Capability is proven when a subscriber decodes payloads into named metrics and correctly reflects node state across a birth, a requested rebirth and an unexpected disconnect. Test all three events, because connection-level tests pass even when payload interpretation fails.
We are replacing our broker. Must we requalify the Sparkplug path?
Not for broker capability, which was never the dependency, but retest anyway. Session handling, retained-message behavior and access-rule defaults differ between brokers, and rebirth problems have been traced to broker changes with unchanged clients. Run the birth, rebirth and disconnect tests against the new broker before cutover.
Our platform vendor says Sparkplug is possible if demand justifies it. Can we design around that?
No. A conditional statement is not a capability, so the publishing or consuming client on that platform counts as unsupported today. Build the path with clients that document Sparkplug support now — a documented gateway client in front of the controller is the usual route — and revisit the native client when the vendor ships and documents it.