The Standard for IoT Messaging

Comparison: MQTT vs HTTP

While HTTP is the web standard, it is heavy and document-centric. MQTT is data-centric.

The Broker

The heart of the system. It receives all messages, filters them, decides who is interested in them based on subscriptions, and then publishes the message to all subscribed clients. Popular brokers include Mosquitto, HiveMQ, and EMQX.

Publisher

A client that sends data (messages) to the broker on a specific topic. For example, a temperature sensor publishing data to home/livingroom/temp. Publishers do not need to know who subscribers are.

Subscriber

A client that registers interest in a specific topic. When the broker receives a message on that topic, it forwards it to the subscriber. A client can be both a publisher and subscriber.

QoS 0

At most once

Also known as "Fire and forget". The message is sent once. No confirmation is expected. If the connection drops or the server is busy, the message is lost forever.

Use case: Periodic temperature sensor data where missing one reading out of a hundred isn't critical.

QoS 1

At least once

Guarantees that a message will be delivered at least once to the receiver. The sender stores the message until it gets a PUBACK packet. Duplicates may occur if the ack is lost.

Use case: Turning on a light switch. You definitely want it to turn on, and doing it twice is acceptable.

QoS 2

Exactly once

The safest and slowest level. Guarantees that the message is received exactly once by using a four-step handshake. This prevents duplicates.

Use case: Banking transactions, billing systems, or critical alarms where duplicates cause errors.

Python (Paho-MQTT)

The standard library for Python IoT apps.

import paho.mqtt.client as mqtt

# Callback when connected
def on_connect(client, userdata, flags, rc):
    print(f"Connected with result code {rc}")
    # Subscribing in on_connect ensures 
    # we resubscribe if we lose connection
    client.subscribe("home/sensors/#")

# Callback when message received
def on_message(client, userdata, msg):
    print(f"{msg.topic}: {msg.payload.decode()}")

client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message

client.connect("broker.hivemq.com", 1883, 60)
client.loop_forever()

JavaScript (Node.js)

Using the MQTT.js library for async operations.

const mqtt = require('mqtt')
// Connect to a public test broker
const client  = mqtt.connect('mqtt://test.mosquitto.org')

client.on('connect', function () {
  console.log("Connected!")
  
  // Subscribe to presence topic
  client.subscribe('presence', function (err) {
    if (!err) {
      // Publish a message
      client.publish('presence', 'Hello mqtt')
    }
  })
})

client.on('message', function (topic, message) {
  // message is a Buffer
  console.log(message.toString())
  client.end() // Close connection
})