# ConnectMQ

> ConnectMQ is a managed MQTT broker: a private MQTT 3.1.1 and MQTT 5 broker with TLS, WebSockets and per-topic access control — without running servers.

Key facts:
- Managed, private MQTT broker instances; standard MQTT 3.1.1 and MQTT 5 — any MQTT client library works, no proprietary SDK.
- Transports: MQTT over TCP (1883), TLS (8883), WebSocket (8083, path /mqtt) and secure WebSocket (8084, path /mqtt).
- Broker address: broker.connectmq.com.
- Security: TLS, username/password authentication, per-topic access control, isolated instances.
- Platform: live dashboard, ISA-95 topic workspace, topic monitor, threshold rules and alerts, 3D Digital Twin.
- Plans (USD excl. tax): Free free, one-time, no card (10,000 session minutes one-time, 5 concurrent connections, 256 KB messages); Basic $39/month (1,000,000 session minutes/month, 100 concurrent connections, 256 KB messages); Scale $199/month (10,000,000 session minutes/month, 1,000 concurrent connections, 1 MB messages). No overage charges; paid plans can be cancelled anytime and have a 30-day money-back guarantee; payments are processed by Paddle (Merchant of Record).
- Languages: English, Español, Português, Deutsch, Français, Türkçe. English is at the site root; other languages live under /es/, /pt/, /de/, /fr/, /tr/.

## Product

- [ConnectMQ — Managed MQTT Broker for IoT](https://connectmq.com/): ConnectMQ is a managed MQTT broker: a private MQTT 3.1.1 and MQTT 5 broker with TLS, WebSockets and per-topic access control — without running servers.
- [Managed MQTT Broker Platform](https://connectmq.com/platform/): Managed MQTT broker with live dashboards, ISA-95 topic workspace, rules, alerts and a 3D digital twin — plus TLS, WebSockets and per-topic access control.
- [MQTT Dashboard & Topic Monitoring](https://connectmq.com/monitoring/): A live MQTT dashboard with broker status and topic cards, an ISA-95 topic workspace and a topic monitor with payload inspector, signal trends and a message dispatcher.
- [MQTT Rules & Alerts](https://connectmq.com/rules-alerts/): Threshold rules on MQTT payload fields with message templates, an alert log with the payload that triggered each alert, and browser notifications.
- [3D Digital Twin with Live MQTT Data](https://connectmq.com/digital-twin/): Place machines in a 3D model of your site and bind each one to its MQTT topic — live telemetry and status appear right on the equipment.
- [MQTT Connectivity: TCP, TLS, WebSockets & MQTT 5](https://connectmq.com/connectivity/): Connect devices, services and browsers to one MQTT broker: MQTT 3.1.1 and MQTT 5 over TCP, TLS, WebSockets and secure WebSockets.
- [MQTT Security: TLS, Authentication & Access Control](https://connectmq.com/security/): How ConnectMQ secures MQTT: TLS and secure WebSockets, username/password authentication, per-topic access control and private, isolated broker instances.
- [Why ConnectMQ: Managed vs Self-Hosted MQTT Brokers](https://connectmq.com/why-connectmq/): Compare running your own MQTT broker, using a free public broker and using ConnectMQ — security, isolation, operations work and time to production.

## Industries & use cases

- [MQTT Broker for Every Industry | Industry Solutions](https://connectmq.com/industries/): How manufacturing, energy, logistics, healthcare, retail, telecom, finance and agriculture teams use a managed MQTT broker — with key use cases.
- [MQTT Use Cases: Predictive Maintenance, Fleets & More](https://connectmq.com/use-cases/): Proven MQTT use cases, step by step: predictive maintenance, fleet management, cold chain, smart metering, agricultural drones and more on ConnectMQ.

## Solutions

- [MQTT Solutions for IoT, Smart Home, Fleet & Energy](https://connectmq.com/solutions/): How teams use a managed MQTT broker for industrial IoT, smart homes, fleet tracking, energy and connected products — with example topic designs for each.
- [MQTT Broker for Industrial IoT & Smart Manufacturing](https://connectmq.com/industrial-iot/): A managed MQTT broker for smart manufacturing: PLC gateways publish machine, OEE and quality data over TLS, with an ISA-95 workspace, alerts and a 3D digital twin.
- [MQTT Broker for Smart Home & Home Assistant](https://connectmq.com/smart-home/): Connect Home Assistant, Zigbee2MQTT and Node-RED to a managed MQTT broker — remote access over TLS and secure WebSockets without opening ports at home.
- [MQTT Broker for Fleet Telematics & Cold Chain](https://connectmq.com/fleet-logistics/): A managed MQTT broker for vehicles, trackers and cold-chain sensors: lightweight messages over cellular, persistent sessions and per-vehicle permissions.
- [MQTT Broker for Smart Energy & EV Charging](https://connectmq.com/energy-utilities/): A managed MQTT broker for smart meters, EV chargers, inverters and batteries — readings to monitoring and billing in parallel, commands on dedicated topics, TLS throughout.
- [MQTT Broker for Connected Products & Smart Hardware](https://connectmq.com/connected-products/): Ship smart hardware without running a broker: standard MQTT for ESP32, nRF, embedded Linux and mobile apps, per-device credentials and secure WebSockets.
- [MQTT Broker for Robot Fleets & Physical AI](https://connectmq.com/robotics/): Connect AMRs, cobots and drones to your fleet manager, WMS and AI data pipeline over MQTT — telemetry, mission commands, Last Will and per-robot ACLs.
- [MQTT for Data Center Power & Cooling Monitoring](https://connectmq.com/data-centers/): Stream PDU, CRAC, UPS and rack sensor data over a managed MQTT broker to your DCIM, NOC alerting and PUE reporting — published on change, TLS and per-site ACLs.
- [MQTT Broker for Smart City Sensors & Streetlights](https://connectmq.com/smart-city/): Connect streetlights, parking, air-quality and waste-bin sensors to one managed MQTT broker — one topic tree for the city, per-department ACLs, retained state.
- [MQTT Broker for Smart Agriculture & Irrigation](https://connectmq.com/smart-agriculture/): Connect soil probes, weather stations and irrigation valves over LTE-M, NB-IoT or LoRaWAN to a managed MQTT broker — small data plans, reliable valve commands.
- [MQTT Broker for Prototyping & Education](https://connectmq.com/prototyping-education/): The quickest way to make things talk: start on the public shared endpoint with code samples for Python, Node.js and ESP32, then move to a private broker.

## Developers

- [Developer Quickstart: Connect to ConnectMQ](https://connectmq.com/developers/): Connect your first MQTT client to ConnectMQ: endpoints and ports, plus code samples for Python, Node.js, browsers, ESP32, Go and the mosquitto CLI.
- [MQTT Code Samples: Python, Node.js, ESP32, Go and More](https://connectmq.com/code-samples/): Copy-paste MQTT client examples for Python, Node.js, ESP32, Go, Java, C#, Rust, Flutter, Swift, Kotlin, Home Assistant and Node-RED, ready for broker.connectmq.com.
- [Free Public MQTT Broker — MQTT 5 Test Server](https://connectmq.com/public-mqtt-broker/): A free public MQTT broker at broker.connectmq.com for learning, prototyping and testing: MQTT 3.1.1 and 5 over TCP, TLS, WebSocket and secure WebSocket.

## Pricing

- [Pricing — Managed MQTT Broker, Free Plan & from $39/month](https://connectmq.com/pricing/): ConnectMQ pricing: a Free plan with no card required, Basic at $39 and Scale at $199 a month. No overage charges, cancel anytime.

## Company

- [About ConnectMQ](https://connectmq.com/about/): ConnectMQ builds a managed MQTT broker and IoT platform in İstanbul, Türkiye, so teams can connect devices without running brokers.
- [Careers at ConnectMQ](https://connectmq.com/careers/): Help build the managed MQTT broker and IoT platform behind connected products. See what we care about and how to get in touch about roles.
- [Support & Contact](https://connectmq.com/support/): Get help with ConnectMQ: send our team a message about your broker, account, billing or plans, or email support@connectmq.com.

## Legal

- [Terms of Service](https://connectmq.com/terms/): The terms that apply when you use ConnectMQ, the managed MQTT broker and platform provided by ConnectMQ, İstanbul, Türkiye.
- [Privacy Notice](https://connectmq.com/privacy/): How ConnectMQ collects, uses and protects personal data on its website and service, and the rights you have under the GDPR and the Turkish KVKK.
- [Refund Policy](https://connectmq.com/refund-policy/): Try ConnectMQ free on the Free plan, and every payment for a paid plan has a 30-day money-back guarantee. How refunds work with Paddle.

## Industries

- [MQTT Broker for Manufacturing | OEE, MES & UNS](https://connectmq.com/industries/manufacturing/): A managed MQTT broker for manufacturing: connect PLCs, edge gateways, MES and SCADA in an ISA-95 unified namespace for live OEE and predictive maintenance.
- [MQTT Broker for Automotive & Connected Vehicles](https://connectmq.com/industries/automotive/): Managed MQTT for automotive: body shop, paint and assembly data, connected car telematics, EV charging and fleets on a private broker with TLS and topic ACLs.
- [MQTT Broker for Oil & Gas | Wells, Pipelines, Tanks](https://connectmq.com/industries/oil-gas/): Managed MQTT for oil and gas: report-by-exception data from wellheads, pipelines and tank farms over cellular or satellite, Sparkplug B-style topics and TLS.
- [MQTT Broker for Utilities | Grid, Water & Smart Meters](https://connectmq.com/industries/utilities/): Managed MQTT for electricity and water utilities: stream substation, smart meter, pumping station and RTU data to SCADA, MDM and GIS with TLS and topic ACLs.
- [MQTT Broker for Renewable Energy, BESS & VPPs](https://connectmq.com/industries/renewable-energy/): Managed MQTT for renewables: inverters, wind turbines, battery storage, EV chargers and VPP dispatch on one private broker with TLS, topic ACLs and live alerts.
- [MQTT Broker for Chemical Plants & Tank Farms](https://connectmq.com/industries/chemicals/): Stream tank levels, process, utility and emissions data from DCS, PLCs and edge gateways to your historian, MES and analytics over a managed MQTT broker.
- [MQTT Broker for Pharma & Life Sciences](https://connectmq.com/industries/pharma-life-sciences/): Move cleanroom, stability chamber, freezer and equipment data from sensors and gateways to your EMS, MES and QMS over a managed MQTT broker with TLS and ACLs.
- [MQTT Broker for Food & Beverage Manufacturing](https://connectmq.com/industries/food-beverage/): Connect filling lines, cold rooms, silos, CIP and refrigeration to a managed MQTT broker — live data for OEE, food-safety records, maintenance and energy.
- [MQTT Broker for Healthcare & Medical Devices](https://connectmq.com/industries/healthcare/): A managed MQTT broker for hospitals, clinics and medical device makers: device telemetry, equipment and environment monitoring and RPM data pipes over TLS.
- [MQTT Broker for Transportation & Logistics](https://connectmq.com/industries/transportation-logistics/): Connect trucks, trailers, reefers, depots and warehouse robots to a managed MQTT broker — live position and condition data for your TMS, WMS and dispatch apps.
- [MQTT Broker for Retail & E-commerce | ConnectMQ](https://connectmq.com/industries/retail-ecommerce/): Connect POS terminals, self-checkouts, ESL, refrigeration and kiosks in every store to one managed MQTT broker — and push live order updates to your apps.
- [MQTT Broker for Telecom Operators & Cell Sites](https://connectmq.com/industries/telecom/): Stream cell site power, battery, genset and cooling data to your NOC over a managed MQTT broker — and run isolated brokers for your enterprise IoT customers.
- [MQTT for Financial Services: ATMs, POS & Market Data](https://connectmq.com/industries/financial-services/): Monitor ATM and POS terminal fleets, stream live market data to trading apps and push real-time alerts over a managed MQTT broker with TLS and per-topic ACLs.
- [MQTT for Agriculture: Greenhouses, Irrigation & Drones](https://connectmq.com/industries/agriculture/): Connect greenhouse sensors, irrigation valves, tank levels and agricultural drones over LTE-M, NB-IoT or LoRaWAN to one managed MQTT broker with retained state.

## Use cases

- [Predictive Maintenance with MQTT | ConnectMQ](https://connectmq.com/use-cases/predictive-maintenance/): Stream vibration, temperature and motor current from sensors and PLCs over MQTT to your condition models and CMMS, and plan repairs before the breakdown.
- [Asset Performance & OEE Tracking with MQTT](https://connectmq.com/use-cases/asset-performance-tracking/): Track OEE, availability and performance of critical assets across sites in real time: machines publish state and counts over MQTT to your dashboards and MES.
- [Industrial Agentic AI on MQTT & Unified Namespace](https://connectmq.com/use-cases/industrial-agentic-ai/): Connect your AI agents to live plant data over MQTT: agents subscribe to the unified namespace and propose actions within per-topic ACLs and human approval.
- [Energy Management & Monitoring with MQTT](https://connectmq.com/use-cases/energy-management/): Collect meter, sub-meter and BMS data over MQTT from every site: kWh per line or building, peak-demand alerts and measured data for your energy reviews.
- [Connected Vehicles & Telematics with MQTT](https://connectmq.com/use-cases/connected-vehicles/): Connect vehicles to your cloud over MQTT: telematics from the TCU, remote commands with QoS 1 and OTA campaign messages to vehicle groups over cellular links.
- [EV Charging Management with MQTT & OCPP](https://connectmq.com/use-cases/ev-charging-management/): Use MQTT alongside OCPP for EV charging: grid meters, batteries and chargers publish live data for load management, operator dashboards and driver apps.
- [Fleet Management & GPS Tracking with MQTT](https://connectmq.com/use-cases/fleet-management/): Real-time fleet tracking over MQTT: trucks and vans publish GPS, CAN and driver data over cellular to your dispatch, TMS and ETA apps, with per-vehicle ACLs.
- [Remote Asset Monitoring with MQTT | SCADA over Cellular](https://connectmq.com/use-cases/remote-asset-monitoring/): Monitor unmanned wellheads, pipelines, pump stations and substations with MQTT: report by exception over cellular or satellite, Last Will alarms, Sparkplug B.
- [Tank Level Monitoring with MQTT | Remote Tank Telemetry](https://connectmq.com/use-cases/tank-level-monitoring/): Remote tank level monitoring with MQTT: radar and ultrasonic sensors publish fuel, chemical and LPG levels over cellular to your VMI, ERP and dispatch systems.
- [Smart Metering with MQTT | AMI Data to MDM & Billing](https://connectmq.com/use-cases/smart-metering/): Move AMI interval reads, meter events and grid sensor data from head-end systems and gateways to MDM, billing and outage tools with MQTT — TLS, ACLs and alerts.
- [Solar & Wind Farm Monitoring with MQTT | Renewable SCADA](https://connectmq.com/use-cases/solar-wind-farm-monitoring/): Monitor solar parks, wind farms and BESS across your portfolio with MQTT: inverter, turbine and battery data to SCADA and asset management, setpoints back out.
- [Cleanroom & GMP Environmental Monitoring with MQTT](https://connectmq.com/use-cases/cleanroom-environmental-monitoring/): Stream particle counts, differential pressure, temperature and humidity from pharma, food and semiconductor cleanrooms into your validated EMS over MQTT.
- [Cold Chain Monitoring with MQTT | Reefer & Cold Room Data](https://connectmq.com/use-cases/cold-chain-monitoring/): Real-time cold chain monitoring with MQTT: temperature, door and GPS data from reefers, cold rooms and pharma shipment loggers, with excursion alerts over TLS.
- [MQTT for Remote Patient Monitoring (RPM) Data](https://connectmq.com/use-cases/remote-patient-monitoring/): Move readings from home devices, hubs and bedside gateways to your RPM platform over MQTT, with TLS, per-device credentials and Last Will. Start for free.
- [Hospital Equipment Tracking & Monitoring with MQTT](https://connectmq.com/use-cases/medical-equipment-tracking/): Stream location and status of infusion pumps, beds and medication fridges from RTLS gateways and sensors to your systems over MQTT. Start for free, no card.
- [Real-Time Notifications with MQTT over WebSockets](https://connectmq.com/use-cases/real-time-notifications/): Push live order status, delivery tracking, alerts and in-app updates to web and mobile apps with MQTT over secure WebSockets — no polling. Start for free.
- [Smart Store Operations with MQTT | Retail IoT](https://connectmq.com/use-cases/smart-store-operations/): Connect refrigeration, HVAC, ESL, digital signage, people counters and self-checkouts in every store to one MQTT broker for live status and alerts. Start for free.
- [ATM & POS Terminal Monitoring with MQTT](https://connectmq.com/use-cases/atm-pos-terminal-monitoring/): Monitor ATM and POS terminal health, cash and receipt paper levels and tamper events over MQTT, and send config changes back securely. Start for free.
- [Telecom Site & Network Equipment Monitoring | MQTT](https://connectmq.com/use-cases/network-equipment-monitoring/): Monitor base station sites, rectifiers, batteries, generators, HVAC and CPE/edge devices over MQTT and feed your NOC, OSS and field service. Start for free.
- [IoT Platform for Operators: Managed MQTT for Telcos](https://connectmq.com/use-cases/iot-platform-for-operators/): Add managed MQTT to your IoT SIM offer: a private ConnectMQ broker for each enterprise customer, with its own endpoint, credentials, topic ACLs and alerts.
- [Real-Time Market Data Streaming over MQTT & WebSockets](https://connectmq.com/use-cases/real-time-market-data/): Fan out live prices and quotes from your feed handler to web and mobile trading apps over MQTT and secure WebSockets, with the last price retained per symbol.
- [MQTT for Agricultural Drones: Spraying & Scouting Fleets](https://connectmq.com/use-cases/agricultural-drones/): Connect spraying and scouting drones to your farm platform over MQTT: telemetry and mission status from every flight, mission plans sent to the field over TLS.
- [Greenhouse IoT Sensors over MQTT: Climate & Substrate](https://connectmq.com/use-cases/greenhouse-iot-sensors/): Stream greenhouse temperature, humidity, CO₂, PAR light and substrate moisture and EC to your climate computer and grower app over MQTT, with alerts per zone.

## Code samples

- [Python MQTT Example: Connect, Publish and Subscribe](https://connectmq.com/code-samples/python/): Python MQTT client example with paho-mqtt 2.x: copy-paste code for the free public broker broker.connectmq.com and a secure TLS connection to ConnectMQ.
- [Node.js MQTT Example: Connect, Publish and Subscribe](https://connectmq.com/code-samples/nodejs/): Node.js MQTT client example with MQTT.js 5: copy-paste code for the free public broker broker.connectmq.com and a secure TLS connection to ConnectMQ.
- [ESP32 MQTT Example: Connect, Publish and Subscribe](https://connectmq.com/code-samples/esp32/): ESP32 MQTT client example with PubSubClient (Arduino): copy-paste code for the free public broker broker.connectmq.com and a secure TLS connection to ConnectMQ.
- [Go MQTT Example: Connect, Publish and Subscribe](https://connectmq.com/code-samples/go/): Go MQTT client example with Eclipse Paho Go: copy-paste code for the free public broker broker.connectmq.com and a secure TLS connection to ConnectMQ.
- [CLI (mosquitto) MQTT Example: Connect, Publish and Subscribe](https://connectmq.com/code-samples/cli/): CLI (mosquitto) MQTT client example with mosquitto_pub / mosquitto_sub: copy-paste code for the free public broker broker.connectmq.com and a secure TLS connection to ConnectMQ.
- [Java MQTT Example: Connect, Publish and Subscribe](https://connectmq.com/code-samples/java/): Java MQTT client example with Eclipse Paho Java Client: copy-paste code for the free public broker broker.connectmq.com and a secure TLS connection to ConnectMQ.
- [C# (.NET) MQTT Example: Connect, Publish and Subscribe](https://connectmq.com/code-samples/csharp/): C# (.NET) MQTT client example with MQTTnet 4: copy-paste code for the free public broker broker.connectmq.com and a secure TLS connection to ConnectMQ.
- [Rust MQTT Example: Connect, Publish and Subscribe](https://connectmq.com/code-samples/rust/): Rust MQTT client example with rumqttc: copy-paste code for the free public broker broker.connectmq.com and a secure TLS connection to ConnectMQ.
- [Dart (Flutter) MQTT Example: Connect, Publish and Subscribe](https://connectmq.com/code-samples/dart-flutter/): Dart (Flutter) MQTT client example with mqtt_client: copy-paste code for the free public broker broker.connectmq.com and a secure TLS connection to ConnectMQ.
- [Swift / Kotlin MQTT Example: Connect, Publish and Subscribe](https://connectmq.com/code-samples/swift-kotlin/): Swift / Kotlin MQTT client example with CocoaMQTT (iOS) · HiveMQ MQTT Client (Android): copy-paste code for the free public broker broker.connectmq.com and a secure TLS connection to ConnectMQ.
- [Home Assistant MQTT Example: Connect, Publish and Subscribe](https://connectmq.com/code-samples/home-assistant/): Home Assistant MQTT client example with MQTT integration: copy-paste code for the free public broker broker.connectmq.com and a secure TLS connection to ConnectMQ.
- [Node-RED MQTT Example: Connect, Publish and Subscribe](https://connectmq.com/code-samples/node-red/): Node-RED MQTT client example with mqtt in / mqtt out nodes: copy-paste code for the free public broker broker.connectmq.com and a secure TLS connection to ConnectMQ.

## Blog

- [Blog: MQTT and IoT Guides](https://connectmq.com/blog/): Guides and tutorials on MQTT, managed MQTT brokers and industrial IoT from the ConnectMQ team.
- [Robot Arm Digital Twin with MQTT: Mirror Joint Angles in 3D and Send Commands Back](https://connectmq.com/blog/robot-arm-digital-twin/): A hands-on guide to a robot arm digital twin: stream joint angles over MQTT, animate a jointed 3D model in the browser, and close the loop with command topics and acknowledgements.
- [Paho MQTT 2.0 Callback API Version: Fixing Migration Errors Step by Step](https://connectmq.com/blog/paho-mqtt-2-0-callback-api-version/): Paho-mqtt 2.0 broke a lot of Python code overnight. Learn what changed, how to fix the callback_api_version error in one line, and how to migrate every callback to the VERSION2 signatures with a working example.
- [How to Calculate OEE: Availability, Performance and Quality with Worked Examples](https://connectmq.com/blog/how-to-calculate-oee/): A clear walkthrough of how to calculate OEE: the three factors, a full worked shift example, the mistakes that inflate the number, and Python that computes OEE from machine-state MQTT messages.
- [Eclipse Tahu: Sparkplug Reference Implementations in Java, Python and C](https://connectmq.com/blog/eclipse-tahu/): Eclipse Tahu is the reference implementation of Sparkplug. This guide tours its Java, Python and C libraries, shows how to build them, and connects a Tahu-based Python edge node to an MQTT broker.
- [BYOC MQTT Broker: Bring Your Own Cloud Explained](https://connectmq.com/blog/byoc-mqtt-broker/): A BYOC MQTT broker runs in your cloud account but is operated by a provider. Learn how the model works, the responsibility split, and how to prepare your account for it.
- [Who Invented MQTT? The History from Oil Pipelines to IoT](https://connectmq.com/blog/who-invented-mqtt/): MQTT was invented in 1999 by Andy Stanford-Clark of IBM and Arlen Nipper of Arcom to monitor oil pipelines over satellite. Follow its path to open source, OASIS, ISO and today's managed cloud brokers.
- [Safe AI Control of IoT Devices: Guardrails for AI-Issued MQTT Commands](https://connectmq.com/blog/safe-ai-control-of-iot-devices/): Letting a language model switch real equipment is a control problem, not a prompt problem. Learn how to put a command gateway with allowlists, limits, confirmations and an audit trail between the AI and your MQTT devices.
- [MQTT Maximum Message Size: Limits and Large Payload Strategies](https://connectmq.com/blog/mqtt-message-size-limit/): MQTT can technically carry a 256 MB packet, but brokers, client libraries and devices impose far lower limits. Learn where the real limits are, what happens when you exceed them, and how to send large payloads.
- [Why Your MQTT Client Keeps Disconnecting (and How to Fix It)](https://connectmq.com/blog/mqtt-client-keeps-disconnecting/): Reconnect loops are one of the most common MQTT problems. Learn the five usual causes, from duplicate client IDs to keep alive timeouts and oversized packets, and follow a diagnosis flow that pinpoints yours.
- [LLM Sensor Data Summaries: Generate Shift Reports and Anomaly Explanations from MQTT](https://connectmq.com/blog/llm-sensor-data-summaries/): Learn how to turn streams of MQTT sensor readings into readable shift reports and anomaly explanations by computing statistics in code and letting an LLM write only the narrative.
- [Industrial DataOps: Contextualizing and Governing Plant Data](https://connectmq.com/blog/industrial-dataops/): What industrial DataOps means in practice: contextualization, normalization, quality checks and governance of OT data, and how to run that layer on top of an MQTT namespace.
- [Go MQTT Client Tutorial with Eclipse Paho autopaho and MQTT 5](https://connectmq.com/blog/go-mqtt-client/): Build a production-style Go MQTT client with paho.golang's autopaho package: MQTT 5 over TLS, automatic reconnects, resubscription, Last Will and graceful shutdown.
- [ESP32 NTP MQTT Timestamp: Add Accurate Time to Every Message](https://connectmq.com/blog/esp32-ntp-mqtt-timestamp/): Sync the ESP32 clock with NTP, format ISO 8601 and epoch-millisecond timestamps, and attach them to MQTT payloads so readings keep their true capture time even when they are published late.
- [ESP-IDF MQTT Example: Build an esp-mqtt Client from Scratch](https://connectmq.com/blog/esp-idf-mqtt-example/): Build an ESP-IDF project from an empty folder with the esp-mqtt component: Wi-Fi station setup, the MQTT event handler, publish and subscribe, MQTT 5 properties and TLS with the certificate bundle.
- [Digital Twin ROI: How to Build a Business Case That Holds Up](https://connectmq.com/blog/digital-twin-roi/): A step-by-step method for estimating digital twin ROI, with the benefit and cost categories that matter, a reusable calculator and advice on proving value with a small pilot first.
- [Zigbee2MQTT Setup Guide: From Coordinator to Dashboard](https://connectmq.com/blog/zigbee2mqtt-setup/): Install Zigbee2MQTT with Docker, configure the coordinator and MQTT connection, pair and rename devices, control them over MQTT and view their states on a dashboard, testing first on a free public broker.
- [Tasmota MQTT Setup: Configure Host, Topic and Full Topic and Control a Smart Plug](https://connectmq.com/blog/tasmota-mqtt/): Set up Tasmota's MQTT host, client, topic and full topic from the web UI or console, then switch a smart plug and read its telemetry through broker.connectmq.com.
- [Raspberry Pi RFID MQTT Access Logging with the RC522 Reader](https://connectmq.com/blog/raspberry-pi-rfid-mqtt/): Wire an RC522 RFID reader to a Raspberry Pi, read tags in Python, check them against a local allowlist and publish every access attempt as an MQTT event that loggers, dashboards and alerting tools can consume.
- [Raspberry Pi Reliability: Running a Pi 24/7 as an IoT Gateway](https://connectmq.com/blog/raspberry-pi-reliability/): A practical guide to keeping a Raspberry Pi MQTT gateway running for months: storage wear, read-only filesystems, power, cooling, hardware and software watchdogs, and remote health monitoring.
- [Pico W vs Pico 2 W for MQTT: RP2040 vs RP2350 Performance, Memory and TLS](https://connectmq.com/blog/pico-w-vs-pico-2-w/): The Pico 2 W keeps the Pico W's footprint and Wi-Fi chip but swaps the RP2040 for the faster RP2350. This comparison looks at what that means for MQTT devices: CPU, memory, TLS, security features, software support, and which board to buy for which project.
- [Node-RED OPC UA Client to MQTT with ISA-95 Topics](https://connectmq.com/blog/node-red-opc-ua/): Use node-red-contrib-opcua to subscribe to OPC UA variables on a PLC or simulation server, map node IDs to ISA-95 style MQTT topics, and publish values with quality and timestamps.
- [Node-RED Dashboard 2.0 with MQTT: Gauges, Charts and Controls](https://connectmq.com/blog/node-red-dashboard-2-0/): A hands-on Node-RED Dashboard 2.0 tutorial: subscribe to live MQTT telemetry, show it on gauges and a line chart, and control a device with a switch that publishes commands and reflects real state.
- [Best MQTT CLI Tools for Testing, Scripting and Debugging](https://connectmq.com/blog/mqtt-cli-tools/): A hands-on comparison of mosquitto_pub/sub, MQTTX CLI, HiveMQ MQTT CLI, the MQTT.js CLI, curl and mqttui, with the same test run against broker.connectmq.com so you can choose the right tool for scripting and debugging.
- [Google Cloud IoT Core Alternative: Options and Migration After the Shutdown](https://connectmq.com/blog/google-cloud-iot-core-alternative/): Google retired Cloud IoT Core in August 2023. This guide compares the realistic alternatives, maps IoT Core concepts to plain MQTT, and shows how to move devices to a managed broker while keeping data flowing into Google Cloud.
- [Using esp-mqtt MQTT 5 Features on ESP32 with ESP-IDF](https://connectmq.com/blog/esp-mqtt-mqtt-5/): A hands-on ESP-IDF project that enables MQTT 5.0 in esp-mqtt and uses user properties, message expiry, topic aliases, session expiry and response topics against a real MQTT 5 broker.
- [Condition Monitoring vs Predictive Maintenance: Differences, Maturity Path and MQTT Data Flows](https://connectmq.com/blog/condition-monitoring-vs-predictive-maintenance/): Condition monitoring tells you a machine is unhealthy now; predictive maintenance estimates when it will fail. Learn the difference, the maturity path between them and how the MQTT data flow changes at each step.
- [AWS IoT TwinMaker Alternatives: Build 3D Digital Twins Without Cloud Lock-In](https://connectmq.com/blog/aws-iot-twinmaker-alternative/): You can build interactive 3D digital twins with open web technology instead of a cloud-specific twin service. Compare the options and bind live MQTT data to a glTF model in the browser.
- [Z-Wave JS UI MQTT Gateway Setup: Publish Z-Wave Device Values to a Broker](https://connectmq.com/blog/zwave-js-ui-mqtt/): Configure Z-Wave JS UI's MQTT gateway to publish device values, write them back with /set topics, and reach a cloud broker securely through a small local bridge.
- [Water Meter MQTT Guide: Read Pulses with an ESP32 and Track Consumption](https://connectmq.com/blog/water-meter-mqtt/): Read your water meter with a reed, inductive or optical sensor and an ESP32, store the meter total safely across reboots, publish litres and flow rate over MQTT, and detect leaks from continuous flow.
- [TensorFlow Lite Micro: Getting Started on a Microcontroller with MQTT Output](https://connectmq.com/blog/tensorflow-lite-micro/): A hands-on introduction to TensorFlow Lite for Microcontrollers: the model, op resolver, tensor arena and interpreter explained, a complete example on an ESP32-S3 board, and a serial-to-MQTT bridge that works for any board.
- [OEE vs TEEP vs OOE: Which Metric Should You Use?](https://connectmq.com/blog/oee-vs-teep/): OEE, OOE and TEEP share the same performance and quality factors but measure against different time bases. This comparison works through one example and lists the MQTT signals each metric needs.
- [Node-RED Email Alert from MQTT Data: Thresholds, Hysteresis and Silence Detection](https://connectmq.com/blog/node-red-email-alert/): Send email alerts when MQTT values cross a limit, without flooding your inbox. This tutorial builds a Node-RED flow with hysteresis, a cooldown, a silent-device watchdog and SMTP setup, and compares it with ConnectMQ's built-in threshold alert rules.
- [MQTT Messages per Second: How to Estimate and Measure Throughput](https://connectmq.com/blog/mqtt-messages-per-second/): Throughput planning for MQTT comes down to a few formulas and one honest measurement. Learn how to estimate inbound and outbound messages per second, account for peaks, and map the result to a broker plan.
- [IoT Anomaly Detection: Methods, Architecture and Where Detectors Should Run](https://connectmq.com/blog/iot-anomaly-detection/): A practical guide to detecting anomalies in sensor streams: which methods fit which signals, whether to run them on the device, the edge or in the cloud, and how MQTT ties detectors and alerts together.
- [Build an Indoor Air Quality Monitor with CO2 and PM2.5 Sensors and MQTT](https://connectmq.com/blog/indoor-air-quality-monitor/): Wire an SCD41 CO2 sensor and a PMS5003 particulate sensor to an ESP32, publish readings as JSON over MQTT, and set ventilation alerts when the air gets stale or dusty.
- [Generative AI in Manufacturing: Practical Use Cases Grounded in Plant Data](https://connectmq.com/blog/generative-ai-manufacturing/): A realistic look at where generative AI helps on the factory floor, from shift summaries to troubleshooting assistants, and how to ground every answer in live machine data streamed over MQTT.
- [ESP32 IoT Tutorial: From First Sketch to Cloud-Connected Sensors](https://connectmq.com/blog/esp32-iot-tutorial/): Go from an unboxed ESP32 to a secure, cloud-connected temperature sensor: Arduino IDE setup, Wi-Fi, a DHT22, MQTT publish and subscribe, remote LED control and TLS on port 8883.
- [AI Digital Twin: Adding Prediction and Optimization to Live Models](https://connectmq.com/blog/ai-digital-twin/): How machine learning adds prediction, anomaly detection and optimization to digital twins fed by MQTT data, with an architecture, a working anomaly detector and practical pitfalls.
- [Sensor Fusion Explained for IoT Developers](https://connectmq.com/blog/sensor-fusion/): What sensor fusion is, how complementary and Kalman filters combine noisy sensors, when to fuse at the edge versus in the cloud, and working ESP32 and Python examples that publish fused values over MQTT.
- [How to Rotate MQTT Credentials Without Downtime](https://connectmq.com/blog/rotate-mqtt-credentials/): A step-by-step dual-credential strategy for rotating MQTT usernames and passwords across a fleet: stage the new credential, switch with fallback, verify and only then revoke the old one.
- [Raspberry Pi BLE to MQTT Bridge with Python and Bleak](https://connectmq.com/blog/raspberry-pi-ble-to-mqtt/): Use the Raspberry Pi's built-in Bluetooth, the bleak library and paho-mqtt to scan BLE sensor advertisements, decode temperature and humidity, and publish throttled readings to MQTT.
- [PubSubClient Arduino Library Tutorial: Setup, Callbacks, Buffers and Keep Alive](https://connectmq.com/blog/pubsubclient/): A practical PubSubClient tutorial for ESP32 and ESP8266: install the library, connect to an MQTT broker, handle callbacks, size the buffer, tune keep alive and move to TLS with real credentials.
- [MQTT vs CoAP: TCP Pub/Sub vs UDP Request/Response](https://connectmq.com/blog/mqtt-vs-coap/): MQTT and CoAP both target constrained IoT devices but take opposite approaches: brokered pub/sub over TCP versus RESTful request/response over UDP. Here is how they compare and when to use each.
- [40 MQTT Interview Questions and Answers for IoT Developers](https://connectmq.com/blog/mqtt-interview-questions/): Forty MQTT interview questions with concise answers covering fundamentals, QoS, sessions, retained messages, Last Will, MQTT 5 and security, plus ways to practice each concept on broker.connectmq.com.
- [MQTT Broker vs Message Queue: What's the Difference?](https://connectmq.com/blog/mqtt-broker-vs-message-queue/): An MQTT broker and a message queue both sit between producers and consumers, but they deliver messages in fundamentally different ways. Learn the semantics of each and when a cloud MQTT broker is the right building block.
- [MQTT Broker Latency by Region: How to Measure and Choose a Location](https://connectmq.com/blog/mqtt-broker-latency-by-region/): Where your broker runs decides a large share of end-to-end MQTT latency. Learn what contributes to delay, how to measure round trips from your own sites, and how to choose a deployment location.
- [MQTT Bandwidth Usage: Calculating Overhead per Message](https://connectmq.com/blog/mqtt-bandwidth-usage/): How many bytes does an MQTT message really cost? Work through connect, keep alive and publish overhead at each QoS level, add TCP and TLS, and build a monthly data estimate for cellular IoT devices.
- [Jetson Nano MQTT: Publish GPU Edge Vision Results Securely](https://connectmq.com/blog/jetson-nano-mqtt/): Build an edge vision pipeline on an NVIDIA Jetson: run GPU-accelerated detection, publish compact JSON results and device health over MQTT with TLS, and run it as a service that survives reboots.
- [IoT Time Series Forecasting with Python and MQTT](https://connectmq.com/blog/iot-time-series-forecasting/): A hands-on tutorial on IoT time series forecasting: capture sensor data from MQTT, resample it, compare a statistical model with a machine learning model, backtest honestly and publish forecasts back to the broker.
- [Install Mosquitto on Raspberry Pi as a Secure Local MQTT Broker](https://connectmq.com/blog/install-mosquitto-raspberry-pi/): Install Mosquitto on a Raspberry Pi, lock it down with passwords and a sensible listener config, test it with mosquitto_pub and mosquitto_sub, and learn when a local broker should bridge to a cloud broker.
- [ESP32 PlatformIO MQTT Project: Clean Structure with Environment-Based Broker Settings](https://connectmq.com/blog/esp32-platformio-mqtt/): Structure an ESP32 PlatformIO MQTT project with separate dev and production environments, broker settings injected at build time, secrets kept out of version control and pinned library versions.
- [ESP32 Modbus RS485 to MQTT Gateway: Poll RTU Devices and Publish Register Values](https://connectmq.com/blog/esp32-modbus-rs485-mqtt/): Turn an ESP32 and a 3.3 V RS485 transceiver into a small Modbus RTU master that polls meters and sensors, scales register values and publishes them as JSON over MQTT.
- [Edge AI vs Cloud AI for IoT: Latency, Privacy, Cost and the Hybrid Pattern](https://connectmq.com/blog/edge-ai-vs-cloud-ai/): A practical comparison of running IoT models on devices versus in the cloud, with a decision checklist and a hybrid architecture where edge results flow over MQTT to cloud models.
- [Remaining Useful Life (RUL) Prediction Explained](https://connectmq.com/blog/remaining-useful-life-prediction/): How remaining useful life prediction works, which model families exist, what data history each needs from MQTT-connected assets, and how to publish RUL estimates with uncertainty.
- [MQTT Broker Hosting Options Compared: VPS, Kubernetes, Serverless, Dedicated and BYOC](https://connectmq.com/blog/mqtt-broker-hosting/): There are five common ways to host an MQTT broker, each with different effort, cost and control. This comparison explains them side by side and shows which fits which project.
- [Industry 5.0 vs Industry 4.0: Human-Centric Manufacturing Explained](https://connectmq.com/blog/industry-5-0-vs-industry-4-0/): Industry 5.0 does not replace Industry 4.0. It adds human-centric, sustainable and resilient goals on top of the same connected technologies. This comparison explains the differences and why live plant data remains the foundation for both.
- [IIoT Edge Gateway: What It Does and How to Choose One](https://connectmq.com/blog/iiot-edge-gateway/): An IIoT edge gateway connects machines that speak Modbus, OPC UA or proprietary protocols to MQTT and the cloud. Learn its core roles, common architectures and how to choose the right one.
- [HVAC Digital Twin for Energy Optimization: AHUs and Chillers over MQTT](https://connectmq.com/blog/hvac-digital-twin/): How to build an HVAC digital twin that mirrors air handling units and chillers in real time, using BACnet-to-MQTT gateways, a cloud MQTT broker and simple Python analytics for energy optimization.
- [12 Digital Twin Examples Across Industries and the Data Behind Them](https://connectmq.com/blog/digital-twin-examples/): Twelve practical digital twin examples from factories, power grids, buildings, cities and hospitals, each broken down into the data sources, update rates and topic structure that make it work.
- [Connected Worker Solutions with MQTT: Real-Time Instructions and Alerts](https://connectmq.com/blog/connected-worker/): Tablets, smartwatches and line displays become far more useful when they receive live events. Learn connected worker use cases, the MQTT topic design and a browser client that receives tasks over secure WebSocket.
- [CODESYS MQTT Client: Publishing PLC Variables to a Broker](https://connectmq.com/blog/codesys-mqtt/): Configure the CODESYS IIoT MQTT Client library to publish PLC variables as JSON, verify them on broker.connectmq.com, then move to a private broker with credentials and TLS.
- [How to Store MQTT Data in InfluxDB with Python](https://connectmq.com/blog/store-mqtt-data-in-influxdb/): Build a Python bridge with paho-mqtt and influxdb-client that subscribes to a broker, turns topic levels into InfluxDB tags, writes numeric JSON values as fields in batches and handles bad payloads and type conflicts.
- [Real-Time Anomaly Detection in Python on MQTT Sensor Streams](https://connectmq.com/blog/real-time-anomaly-detection-python/): A complete tutorial that streams simulated sensor data over MQTT, scores every reading with rolling statistics in Python and publishes debounced anomaly events to an alerts topic.
- [Node-RED Chart History: Keep MQTT Chart Data Across Restarts](https://connectmq.com/blog/node-red-chart-history/): Dashboard charts forget everything when Node-RED restarts. This guide shows two reliable ways to keep Node-RED chart history for MQTT data: file-backed context storage and a small SQLite table, both replayed into Dashboard 2.0 on startup.
- [Fixing "MQTT Connection Refused: Not Authorized" (rc 5 and 0x87)](https://connectmq.com/blog/mqtt-connection-refused-not-authorized/): Getting "Connection Refused: not authorised" or reason code 0x87? Work through this checklist covering credentials, client ID binding, ports and TLS, and per-broker accounts to find the cause quickly.
- [MQTT Broker Free Tier: How to Compare Free Plans Before You Commit](https://connectmq.com/blog/mqtt-broker-free-tier/): Free MQTT broker plans differ far more than their headline connection counts suggest. Here is a practical framework for comparing them, with ConnectMQ's free Serverless plan as a worked example.
- [MQTT 3.1.1 vs 5.0: What Changed and Should You Upgrade?](https://connectmq.com/blog/mqtt-3-1-1-vs-5-0/): A practical MQTT 3.1.1 vs 5.0 comparison covering protocol behavior changes, client library support and a step-by-step migration checklist for upgrading a mixed fleet gradually.
- [MicroPython umqtt on ESP32: Publish and Subscribe with umqtt.simple and umqtt.robust](https://connectmq.com/blog/micropython-umqtt-esp32/): Connect an ESP32 running MicroPython to an MQTT broker with umqtt.simple, add automatic reconnects with umqtt.robust, receive commands without blocking and understand what these minimal clients cannot do.
- [ESP32-CAM Person Detection with On-Device AI and MQTT Alerts](https://connectmq.com/blog/esp32-cam-person-detection/): Run a tiny person detection model directly on an ESP32-CAM, publish a confidence score and debounced alerts over MQTT, and keep images on the device unless you explicitly need them.
- [Digital Twin Architecture: Data, Model and Visualization Layers Explained](https://connectmq.com/blog/digital-twin-architecture/): A layer-by-layer reference digital twin architecture: device and edge, messaging, state, model, analytics and visualization, with topic design, data contracts and the trade-offs at each layer.
- [Vibration Monitoring Sensor: Build an MQTT Vibration Monitor for Predictive Maintenance](https://connectmq.com/blog/vibration-monitoring-sensor/): Build a working vibration monitoring sensor from an ESP32 and an accelerometer, compute RMS, peak and crest factor on the device, publish them over MQTT and raise alerts when a machine drifts from its baseline.
- [Unity Digital Twin Connected to MQTT: Live Telemetry and Commands](https://connectmq.com/blog/unity-digital-twin/): Connect a Unity scene to an MQTT broker with MQTTnet, animate a pump from live telemetry on the main thread, publish start and stop commands back to the device and move to TLS for production.
- [Run a Python MQTT Script on Boot with systemd on Raspberry Pi](https://connectmq.com/blog/run-python-mqtt-script-on-boot/): Turn a Python MQTT client into a proper systemd service on a Raspberry Pi: start after the network and clock are ready, restart automatically, keep credentials in an environment file and shut down cleanly.
- [MQTT to MongoDB: Save Device Messages with Node.js and Time-Series Collections](https://connectmq.com/blog/mqtt-to-mongodb/): Build an MQTT to MongoDB pipeline with Node.js: an MQTT.js subscriber validates device messages and batches them into a MongoDB time-series collection with automatic expiry and aggregation-ready indexes.
- [MQTT Offline Messages: How Brokers Queue Messages for Disconnected Clients](https://connectmq.com/blog/mqtt-offline-messages/): MQTT brokers can hold messages for clients that are temporarily offline, but only under specific conditions. Learn the rules, the limits and a reproducible test you can run in five minutes.
- [MQTT Broker SLA: What Uptime Guarantees Really Mean](https://connectmq.com/blog/mqtt-broker-sla/): Uptime percentages look similar but mean very different amounts of downtime. Learn how to read an MQTT broker SLA, what it covers and excludes, and how to design devices for the downtime it allows.
- [Using a Managed MQTT Broker for Mobile Apps](https://connectmq.com/blog/mqtt-broker-for-mobile-apps/): Mobile apps can talk to IoT devices in real time through an MQTT broker. Learn the connection lifecycle, when to use push notifications instead, and how to protect battery and credentials.
- [Home Assistant External MQTT Broker: Connect to a Cloud Broker over TLS](https://connectmq.com/blog/home-assistant-external-mqtt-broker/): Two proven ways to use a home assistant external MQTT broker: connect the integration straight to a cloud broker over TLS, or bridge the local Mosquitto add-on so devices keep working offline.
- [ESP32 W5500 MQTT: Wired Ethernet for Reliable Industrial Nodes](https://connectmq.com/blog/esp32-w5500-mqtt/): Use a W5500 SPI module or a LAN8720 PHY to put an ESP32 on wired Ethernet, handle cable and link events cleanly, and publish machine data over MQTT without depending on Wi-Fi.
- [Dedicated MQTT Broker: When You Outgrow Serverless](https://connectmq.com/blog/dedicated-mqtt-broker/): A dedicated MQTT broker gives your fleet an isolated cluster with predictable performance. Learn the signs you have outgrown serverless, how to size capacity, and how to migrate safely.
- [Raspberry Pi MQTT Tutorial: Publish, Subscribe and Automate with Python](https://connectmq.com/blog/raspberry-pi-mqtt-tutorial/): A complete Raspberry Pi MQTT tutorial: set up a Python virtual environment, publish CPU and sensor readings, switch an LED over MQTT, run the script as a service and move to TLS with your own credentials.
- [Packaging Line Monitoring: Finding Micro-Stops and Speed Losses with MQTT](https://connectmq.com/blog/packaging-line-monitoring/): Packaging lines lose most of their time in short stops nobody records. This use case shows how to capture every stop and speed change over MQTT and turn them into a micro-stop Pareto.
- [Open-Source Digital Twin Tools Compared: Ditto, BaSyx, Three.js and More](https://connectmq.com/blog/open-source-digital-twin-tools/): A practical comparison of open-source digital twin tools across modeling, data, visualization and history, with notes on how each one connects to an MQTT broker and when to combine them.
- [Node-RED Sparkplug B: Publishing and Consuming Edge Data](https://connectmq.com/blog/node-red-sparkplug-b/): Turn Node-RED into a Sparkplug B edge node with node-red-contrib-mqtt-sparkplug-plus: define metrics, publish NBIRTH, DBIRTH and DDATA, handle DCMD commands, then decode the Protobuf payloads into plain MQTT topics.
- [Run Node-RED in Docker for MQTT Projects](https://connectmq.com/blog/node-red-docker/): A practical Node-RED Docker guide: run the official image, keep flows on a persistent volume, use Docker Compose, install extra nodes, pass secrets through environment variables and connect to an MQTT broker over TLS.
- [MQTT Vehicle Tracking: Topics, Payloads and a Live Fleet Map](https://connectmq.com/blog/mqtt-vehicle-tracking/): Build MQTT vehicle tracking that works on patchy cellular links: topic design, compact GPS payloads, keep alive tuning, offline detection and a live web map.
- [MQTT Last Will and Testament (LWT): Detecting Offline Devices](https://connectmq.com/blog/mqtt-last-will-and-testament/): Last Will and Testament lets the broker announce that a client vanished without saying goodbye. Learn the will fields, the exact trigger rules and how to test LWT by killing a client on a live broker.
- [MQTT Client Libraries: Choosing the Right One for Every Language](https://connectmq.com/blog/mqtt-client-libraries/): A practical comparison of maintained MQTT client libraries for Python, JavaScript, Go, Java, C#, Rust, C, embedded and mobile, with a minimal connect-and-publish snippet for each one, tested against broker.connectmq.com.
- [MES vs ERP vs SCADA: Roles in the Factory Stack and How MQTT Connects Them](https://connectmq.com/blog/mes-vs-erp-vs-scada/): ERP plans, MES executes and SCADA supervises. Learn what each system owns, where they overlap, how they map to ISA-95 levels and how an MQTT broker links them without point-to-point spaghetti.
- [ISA-95 Equipment Hierarchy: Enterprise, Site, Area, Line, Cell](https://connectmq.com/blog/isa-95-equipment-hierarchy/): The ISA-95 equipment hierarchy gives every machine an address: enterprise, site, area, work center and work unit. This guide explains each level with plant examples and shows how to map live devices onto it.
- [IOTstack on Raspberry Pi: Node-RED, InfluxDB and Grafana with a Cloud MQTT Broker](https://connectmq.com/blog/iotstack-raspberry-pi/): Use IOTstack to run Node-RED, InfluxDB and Grafana in Docker on a Raspberry Pi, skip the local Mosquitto container and connect Node-RED to an external cloud MQTT broker instead.
- [Cold Storage Temperature Monitoring with MQTT Sensors and Excursion Alerts](https://connectmq.com/blog/cold-storage-temperature-monitoring/): Monitor freezers and cold rooms with ESP32 sensors publishing over MQTT, detect real temperature excursions without nuisance alarms from door openings, flag offline sensors and keep an excursion log.
- [Sparkplug B Payload Format: Metrics, Datatypes and Protobuf](https://connectmq.com/blog/sparkplug-b-payload/): Sparkplug B payloads are compact Protobuf messages, which is why they look like gibberish in a normal MQTT client. This guide walks through every field, shows a decoded example and explains how to inspect payloads in practice.
- [Public MQTT Broker Limitations You Should Know Before You Build](https://connectmq.com/blog/public-mqtt-broker-limitations/): Public test brokers are fantastic for learning and demos, but they come with real constraints. Understand privacy, reliability, shared topics and rate limits, how to design within them, and the signs it is time for a private broker.
- [MQTT.js Node.js Tutorial: Publish, Subscribe, QoS and TLS](https://connectmq.com/blog/mqtt-js-node-js/): Build a Node.js publisher and subscriber with MQTT.js v5, use the async API, QoS and Last Will, encrypt with TLS on port 8883, and tune reconnect options so your service survives network drops.
- [Isolation Forest for Sensor Data: Train Offline, Score Live MQTT Messages](https://connectmq.com/blog/isolation-forest-sensor-data/): Train an Isolation Forest on historical multivariate sensor data with scikit-learn, then load it in a Python service that scores live MQTT readings and publishes anomaly events.
- [ESP32 FreeRTOS MQTT: Separate Sensor and Publishing Tasks with Queues](https://connectmq.com/blog/esp32-freertos-mqtt/): Split sensor sampling and MQTT publishing into two FreeRTOS tasks on the ESP32, connect them with a queue and keep readings flowing even while Wi-Fi or the broker reconnects.
- [Async MQTT in Python with aiomqtt and asyncio: Tasks, Workers and Reconnects](https://connectmq.com/blog/aiomqtt-asyncio/): Write asynchronous MQTT clients in Python with aiomqtt and asyncio: publish and subscribe without callbacks, run concurrent tasks with TaskGroup, process messages in worker queues and reconnect gracefully.
- [YOLO Object Detection over MQTT: Publish Detections as JSON](https://connectmq.com/blog/yolo-object-detection-mqtt/): Run a YOLO model on a webcam or RTSP stream in Python, turn each frame's detections into compact JSON, and publish counts and alerts over MQTT so any dashboard or automation can react.
- [Telegraf MQTT Consumer: Ingest MQTT Data into InfluxDB](https://connectmq.com/blog/telegraf-mqtt-consumer/): A practical guide to Telegraf's mqtt_consumer input: subscribe to broker topics, parse JSON with timestamps and tags, write to InfluxDB 2, secure the connection with TLS and troubleshoot missing data.
- [Sparkplug Templates and UDTs Explained](https://connectmq.com/blog/sparkplug-templates/): Sparkplug templates bring PLC-style user-defined types to MQTT. This guide explains template definitions and instances, parameters, nesting and versioning, with Python code that builds a pump template and tips for keeping models consistent across edge nodes.
- [Revolution Pi MQTT Gateways: Industrial Raspberry Pi (CM4) in Production](https://connectmq.com/blog/revolution-pi-mqtt/): How industrial Raspberry Pi controllers such as the Revolution Pi and other CM4-based devices bridge digital and analog field signals to MQTT, with architecture, code and production practices.
- [MQTT 5 Subscription Options: No Local, Retain As Published, Retain Handling](https://connectmq.com/blog/mqtt-subscription-options/): What each MQTT 5 subscription option does, when to use it and how to set it in MQTT.js and paho-mqtt, with runnable examples against a public MQTT 5 broker.
- [MQTT Broker Total Cost of Ownership: A Practical TCO Model](https://connectmq.com/blog/mqtt-broker-total-cost-of-ownership/): The licence or subscription is rarely the biggest cost of an MQTT broker. This guide builds a TCO model that includes infrastructure, engineering time, on-call, incidents and risk, so you can compare self-hosting and managed options on equal terms.
- [How to Install Node-RED on Windows, Linux and Raspberry Pi](https://connectmq.com/blog/install-node-red/): A practical guide to install Node-RED on Windows, Linux, Raspberry Pi and Docker, run it automatically at boot, lock down the editor and build a first flow that subscribes to a live MQTT broker.
- [ESP32 SCT-013 Current Sensor Energy Monitor over MQTT](https://connectmq.com/blog/esp32-sct-013-current-sensor/): Clamp an SCT-013 current transformer on a mains cable, measure RMS current with the ESP32 ADC, estimate power and energy, and publish the results to broker.connectmq.com for energy dashboards.
- [ESP32 Battery Powered Sensor Design: Boards, Regulators and MQTT Publish Intervals](https://connectmq.com/blog/esp32-battery-powered-sensor/): A practical design guide for an ESP32 battery powered sensor: board choice, low-quiescent regulators, battery voltage monitoring, fast Wi-Fi reconnects and MQTT publish intervals that stretch battery life.
- [Raspberry Pi Distance Sensor MQTT: HC-SR04 for Tank Levels and Presence Detection](https://connectmq.com/blog/raspberry-pi-distance-sensor-mqtt/): Wire an HC-SR04 ultrasonic sensor to a Raspberry Pi with a safe voltage divider, filter noisy readings in Python and publish tank fill level and presence events over MQTT for dashboards and automations.
- [PLC to Cloud Connectivity: Architectures and Trade-Offs](https://connectmq.com/blog/plc-to-cloud/): A practical comparison of the three main PLC to cloud architectures, native PLC MQTT, edge gateways and SCADA-based forwarding, with security, reliability and data-modeling considerations for each.
- [Office Occupancy Sensor Networks with MQTT: PIR, mmWave and CO2](https://connectmq.com/blog/office-occupancy-sensor/): How to choose between PIR, mmWave and CO2 sensing, design MQTT topics for rooms and desks, and turn occupancy data into utilization reports and HVAC savings.
- [Node-RED Delay Node: Rate Limiting MQTT Messages](https://connectmq.com/blog/node-red-delay-node/): High-frequency sensors can flood a broker, a database or an operator's phone. Learn how the Node-RED delay node delays and rate-limits messages, when to queue or drop, how per-topic mode works and how to stay within broker limits.
- [MQTT Request/Response Pattern with Response Topic and Correlation Data](https://connectmq.com/blog/mqtt-request-response-pattern/): MQTT is publish/subscribe, but devices often need to answer questions. Learn how MQTT 5 response topic and correlation data turn MQTT into a clean request/response channel, with working Python and Node.js code.
- [Home Assistant MQTT Integration: Complete Setup Guide](https://connectmq.com/blog/home-assistant-mqtt/): Configure the Home Assistant MQTT integration, define sensors and switches in YAML, test the whole flow against broker.connectmq.com and then switch to a private, authenticated broker.
- [Vue MQTT Client: Real-Time Data over WebSocket with Vue 3](https://connectmq.com/blog/vue-mqtt/): Write a reusable Vue 3 composable around MQTT.js, connect to a broker over wss, and build a live sensor widget, plus the reactivity and lifecycle pitfalls that trip up most Vue MQTT apps.
- [Types of Digital Twins: Component, Asset, System and Process Twins Explained](https://connectmq.com/blog/types-of-digital-twins/): Component, asset, system and process twins differ in scope, data rate and the questions they answer. See examples of each and the MQTT topic and payload design that fits every level.
- [How to Secure Node-RED: A Practical Checklist](https://connectmq.com/blog/secure-node-red/): An exposed Node-RED editor is remote code execution waiting to happen. This checklist shows how to secure Node-RED with admin authentication, HTTPS, an explicit credential secret, protected HTTP endpoints, network controls and TLS to your MQTT broker.
- [Storing MQTT Credentials Securely on Embedded Devices](https://connectmq.com/blog/secure-mqtt-credentials-on-devices/): A practical comparison of ways to protect MQTT usernames and passwords on ESP32 and Linux devices, from encrypted NVS and flash encryption to secure elements and TPM-backed systemd credentials.
- [MQTT 5 Reason Codes: Complete Reference Table with Causes and Fixes](https://connectmq.com/blog/mqtt-reason-codes/): Every MQTT 5 reason code in one table, grouped by the packets that carry it, with the usual causes and practical fixes. Includes the mapping from MQTT 3.1.1 return codes and Python code to log reason codes properly.
- [MQTT Message Ordering Guarantees Explained](https://connectmq.com/blog/mqtt-message-ordering/): MQTT keeps messages in order, but only within narrow rules. Learn exactly what the spec guarantees, the real-world situations that reorder messages, and how sequence numbers make your consumers robust.
- [MQTT Broker Connection Quotas: Connections, Message Rates and Payload Limits](https://connectmq.com/blog/mqtt-broker-connection-quotas/): Managed MQTT brokers enforce quotas on connections, message rates, payload sizes and subscriptions. Learn how each one works, how brokers signal violations, and how to build clients that respect them.
- [MCP Server MQTT Bridge: Let AI Assistants Read and Control Your Devices](https://connectmq.com/blog/mcp-server-mqtt/): Step-by-step tutorial for a Model Context Protocol server that subscribes to MQTT topics, caches the latest values and exposes read and command tools to AI assistants.
- [ISO 50001 Energy Data: What to Collect and How IoT Meters Provide It](https://connectmq.com/blog/iso-50001-energy-data/): ISO 50001 is a management standard, but it runs on data. This explainer maps the standard's data requirements to meters, relevant variables and an MQTT-based collection architecture you can audit.
- [Energy Load Forecasting with IoT Meter Data and MQTT](https://connectmq.com/blog/energy-load-forecasting/): A practical use case for energy load forecasting: collecting meter data over MQTT, turning energy counters into demand, adding weather and calendar features, and publishing day-ahead forecasts for buildings and plants.
- [Arduino UNO R4 WiFi MQTT Tutorial: Publish Sensor Data with ArduinoMqttClient](https://connectmq.com/blog/arduino-uno-r4-wifi-mqtt/): Connect the Arduino UNO R4 WiFi to an MQTT broker with WiFiS3 and ArduinoMqttClient, publish analog readings, control the LED matrix from your laptop and move to TLS on port 8883.
- [Zigbee2MQTT Cloud Broker Setup: Control Zigbee Devices from Anywhere over TLS](https://connectmq.com/blog/zigbee2mqtt-cloud-broker/): Point Zigbee2MQTT at a TLS-secured cloud MQTT broker so your Zigbee lights, sensors and plugs can be monitored and switched from anywhere, without opening ports on your home router.
- [SSL Certificate Verify Failed MQTT Error: Fixing Python Clients](https://connectmq.com/blog/ssl-certificate-verify-failed-mqtt/): Getting "[SSL: CERTIFICATE_VERIFY_FAILED]" when your Python MQTT client connects on port 8883? Here is how to find the exact cause and fix it properly on every platform, without disabling verification.
- [React Native MQTT: Real-Time Mobile IoT Apps over WebSocket](https://connectmq.com/blog/react-native-mqtt/): Build a React Native MQTT app with MQTT.js over secure WebSocket: a reusable hook, live device data, commands, and correct reconnect handling when the app moves between background and foreground.
- [MQTT Broker RFP Checklist: How to Evaluate Vendors](https://connectmq.com/blog/mqtt-broker-rfp-checklist/): An RFP-ready MQTT broker checklist with the questions that matter, why each one matters, what a good answer looks like and, as a worked example, how ConnectMQ answers them, including the things it does not do.
- [Buffer MQTT Messages Offline in Python with SQLite (Store and Forward)](https://connectmq.com/blog/buffer-mqtt-messages-offline-python/): Build a store-and-forward MQTT publisher in Python that writes every reading to SQLite first, then replays the queue in order with QoS 1 acknowledgements once the connection is back.
- [BACnet vs Modbus: Protocol Comparison for Facilities and Plants](https://connectmq.com/blog/bacnet-vs-modbus/): A practical BACnet vs Modbus comparison covering data models, transports, discovery, security and typical use, with a clear pattern for translating both protocols into MQTT topics for a cloud broker.
- [Sparkplug 3.0 vs 2.2: What Changed in the Specification](https://connectmq.com/blog/sparkplug-3-0/): Sparkplug 3.0 kept the payload and topic namespace but tightened the rules around host state, bdSeq and sessions. This comparison explains each change and gives a practical upgrade checklist for edge nodes and host applications.
- [Raspberry Pi Modbus MQTT Gateway with pymodbus (RTU and TCP)](https://connectmq.com/blog/raspberry-pi-modbus-mqtt/): Poll Modbus RTU devices over RS-485 and Modbus TCP devices over Ethernet from a Raspberry Pi with pymodbus, decode scaled and 32-bit float registers correctly, and publish clean JSON to an MQTT broker.
- [Node-RED Function Node: JavaScript for MQTT Messages](https://connectmq.com/blog/node-red-function-node/): A practical guide to the Node-RED function node for MQTT work: reshaping payloads, filtering noise, routing to several outputs, keeping state and handling errors, with a flow you can import and run against a live broker.
- [MQTT CONNACK Return Codes 0-5 Explained (MQTT 3.1.1)](https://connectmq.com/blog/mqtt-connack-return-codes/): MQTT 3.1.1 brokers answer every CONNECT with a CONNACK return code from 0 to 5. Learn what each one means, how it looks in Mosquitto, Paho and MQTT.js, and the fastest fix for each refusal.
- [MQTT Access Control Lists (ACLs): Concepts and Design](https://connectmq.com/blog/mqtt-acl/): What MQTT access control lists are, how brokers such as Mosquitto express topic-level read and write rules, how denied operations behave and how to design topic namespaces so authorization stays simple.
- [Edge Impulse to MQTT: Publish Model Predictions from ESP32 and Linux](https://connectmq.com/blog/edge-impulse-mqtt/): Take a trained Edge Impulse model off the Studio and into a real system: export it as an Arduino library or a Linux .eim file, run inference on the device and publish every prediction over MQTT.
- [Digital Twin in Manufacturing: Use Cases and Getting Started](https://connectmq.com/blog/digital-twin-in-manufacturing/): A practical guide to the digital twin in manufacturing, covering product, process and production twins, high-value use cases and a step-by-step plan to build the MQTT data foundation.
- [TIG Stack with Docker Compose for MQTT Data](https://connectmq.com/blog/tig-stack-docker-compose/): A complete docker-compose setup for Telegraf, InfluxDB 2 and Grafana that subscribes to an MQTT broker, stores sensor data and opens with a provisioned data source and dashboard, plus the pitfalls that break first runs.
- [Self-Hosted vs Managed MQTT Broker: Cost, Risk and Effort Compared](https://connectmq.com/blog/self-hosted-vs-managed-mqtt-broker/): Running your own MQTT broker looks cheap until you count patching, certificates, monitoring and on-call. This comparison weighs effort, cost and risk and gives you a decision matrix you can apply to your own project.
- [OPC UA PubSub over MQTT Explained: Messages, Encodings and Topics](https://connectmq.com/blog/opc-ua-pubsub-over-mqtt/): OPC UA Part 14 lets OPC UA publishers send data through any standard MQTT broker. Learn the PubSub building blocks, JSON vs UADP encodings, topic and metadata conventions, and how to publish and decode messages yourself.
- [DIY Weather Station MQTT Project: Wind, Rain and Temperature with an ESP32](https://connectmq.com/blog/diy-weather-station-mqtt/): Wire an anemometer, rain gauge and BME280 to an ESP32, publish wind, rain, temperature, humidity and pressure as MQTT JSON, then log and chart the data with a short Python script.
- [How to Delete a Retained Message in MQTT (CLI, Python and Web Client)](https://connectmq.com/blog/delete-retained-message-mqtt/): A stale retained message keeps greeting every new subscriber with old data. Here is how to delete a retained message in MQTT with an empty retained publish, from the command line, Python, JavaScript and a browser client.
- [How to Bind IoT Data to a 3D Model: glTF Meshes, Materials and Animations](https://connectmq.com/blog/bind-iot-data-to-3d-model/): A practical guide to the mapping layer of a digital twin: how to bind IoT data to a 3D model by mapping MQTT topic values to glTF nodes, materials, morph targets and animation clips, with bindings stored in the model itself.
- [Secure a Raspberry Pi IoT Device: A Practical Hardening Checklist](https://connectmq.com/blog/secure-raspberry-pi-iot/): A hands-on hardening checklist for Raspberry Pi IoT devices covering accounts, SSH keys, firewall rules, updates, systemd sandboxing, secrets and TLS-encrypted MQTT connections.
- [MQTT to TimescaleDB: Storing IoT Time Series in PostgreSQL](https://connectmq.com/blog/mqtt-to-timescaledb/): Build an MQTT to TimescaleDB pipeline: a Python subscriber batches device messages into a PostgreSQL hypertable with COPY, then continuous aggregates, compression and retention keep queries fast and storage small.
- [MQTT Threshold Alerts: Get Notified When Values Go Out of Range](https://connectmq.com/blog/mqtt-threshold-alerts/): Learn how to raise alerts when MQTT sensor values leave a safe range: rules in the ConnectMQ portal, a Node-RED flow for notifications, and a Python alerter with hysteresis and debounce to avoid alert storms.
- [Federated Learning for IoT Explained: Training Without Centralizing Data](https://connectmq.com/blog/federated-learning-iot/): Federated learning lets IoT devices improve a shared model while their raw data stays local. This explainer covers how it works, where it fits, its pitfalls, and how an MQTT broker can carry model updates between devices and a coordinator.
- [ESP32 MQTT SSL: Secure MQTT over TLS with WiFiClientSecure](https://connectmq.com/blog/esp32-mqtt-ssl/): Connect an ESP32 to an MQTT broker over TLS on port 8883 with WiFiClientSecure and PubSubClient, verify the server with the right root CA, sync time and keep heap usage under control.
- [Digital Twin Maturity Model: Six Levels from Visualization to Autonomy](https://connectmq.com/blog/digital-twin-maturity-model/): A practical six-level digital twin maturity model, with the capabilities, data infrastructure and MQTT patterns each level requires, plus a self-assessment to plan your next step.
- [Soil Moisture Sensor with MQTT: ESP32 Build with Calibration and Watering Alerts](https://connectmq.com/blog/soil-moisture-sensor-mqtt/): Wire a capacitive soil moisture probe to an ESP32, calibrate dry and wet points, publish percent moisture over MQTT with deep sleep, and raise debounced watering alerts.
- [Real-Time OEE Monitoring with MQTT: Build a Live OEE Service](https://connectmq.com/blog/real-time-oee-monitoring/): A hands-on tutorial for real-time OEE monitoring: machines publish states and counts over MQTT, a Python service calculates availability, performance and quality every minute and publishes live OEE for any dashboard.
- [MQTT for Oil and Gas Remote Monitoring Over Cellular and Satellite](https://connectmq.com/blog/mqtt-oil-and-gas/): How to use MQTT for wellheads, pipelines and tank batteries over cellular and satellite links, with keep alive, session, QoS and report-by-exception settings tuned for expensive, intermittent connections.
- [MQTT Broker Pricing Models Explained: How to Estimate Your Bill](https://connectmq.com/blog/mqtt-broker-pricing/): Managed MQTT services bill on very different units: connections, session minutes, messages, traffic or dedicated capacity. Learn how each model works, which workloads it favours and how to estimate your usage before comparing quotes.
- [Machine Downtime Tracking with IoT Sensors and MQTT](https://connectmq.com/blog/machine-downtime-tracking/): Track downtime on any machine, old or new: an ESP32 with a clamp-on current sensor publishes run and stop states over MQTT, and a Python logger records every stop with its duration and reason.
- [ESP32 WiFiManager MQTT Setup: Configure Wi-Fi and Broker Settings in a Captive Portal](https://connectmq.com/blog/esp32-wifimanager-mqtt/): Stop hard-coding credentials: let users enter Wi-Fi plus MQTT host, port, client ID, username and password in a WiFiManager captive portal, store them with Preferences and connect to broker.connectmq.com by default.
- [ESP32 MQTT Reconnect: Non-Blocking Reconnection Logic That Survives Outages](https://connectmq.com/blog/esp32-mqtt-reconnect/): Replace the blocking reconnect loop from most examples with a non-blocking state machine for Wi-Fi and MQTT, with exponential backoff, jitter, resubscribe and an offline buffer, then prove it by rebooting your router.
- [Building a Digital Andon System with MQTT: Calls, Escalation and Display Boards](https://connectmq.com/blog/digital-andon-system/): A practical blueprint for an MQTT-based andon: how operators raise calls, how call states are modelled with retained messages, how escalation works by time, and how response-time breaches become alerts.
- [MQTT over WebSocket: Connect a Browser to an MQTT Broker with MQTT.js](https://connectmq.com/blog/mqtt-over-websocket/): Browsers cannot open raw TCP sockets, so web apps speak MQTT over WebSocket. Build a working browser client and a Node.js client against broker.connectmq.com and learn how to fix the most common connection errors.
- [React MQTT Tutorial: A Hooks-Based Real-Time Dashboard](https://connectmq.com/blog/react-mqtt/): Create a reusable useMqtt hook around MQTT.js, connect React to a broker over secure WebSocket, and render live sensor values without re-render storms, StrictMode surprises or leaked connections.
- [Raspberry Pi Pico W MQTT with MicroPython: Publish Sensor Data and Receive Commands](https://connectmq.com/blog/raspberry-pi-pico-w-mqtt/): A complete, tested path from a bare Raspberry Pi Pico W to a connected MQTT device. Flash MicroPython, install umqtt.simple, publish the onboard temperature sensor, switch the LED from anywhere and keep the connection alive through Wi-Fi drops.
- [MQTT Will Delay Interval: How to Avoid False Offline Alerts](https://connectmq.com/blog/mqtt-will-delay-interval/): A device that drops Wi-Fi for three seconds should not page your on-call engineer. MQTT 5's will delay interval holds the Last Will message back long enough for a quick reconnect.
- [MQTT to SQLite with Python: Store and Query Sensor Messages](https://connectmq.com/blog/mqtt-to-sqlite-python/): Build a Python subscriber that stores every MQTT message in SQLite with a timestamp, topic, QoS and retain flag, using batched writes and WAL mode, then query history, hourly averages and latest values with plain SQL.
- [Real-Time MQTT Data Analysis with Python and pandas](https://connectmq.com/blog/mqtt-pandas/): Stream MQTT messages from a broker into pandas DataFrames without blocking the network loop, then compute rolling means, per-minute resamples, stale-device checks and simple anomaly flags.
- [Log MQTT Messages to CSV with Python for Quick Analysis](https://connectmq.com/blog/log-mqtt-messages-to-csv/): Build a Python logger that subscribes to MQTT topics, writes every message to CSV, rotates files by day and size, and produces data you can open straight in Excel, pandas or a notebook.
- [Is MQTT TCP or UDP? The MQTT Transport Layer Explained](https://connectmq.com/blog/is-mqtt-tcp-or-udp/): MQTT runs over TCP, either directly, inside TLS, or inside WebSocket. Learn why the protocol depends on an ordered, reliable stream, where MQTT-SN and QUIC fit, and which ports to open for a ConnectMQ broker.
- [ESP32 OTA Update over MQTT: Trigger HTTPS Firmware Updates and Report Status](https://connectmq.com/blog/esp32-ota-update-mqtt/): Trigger ESP32 firmware updates with an MQTT command, download the binary over HTTPS with HTTPUpdate, and publish progress and results to a retained status topic so you always know which version each device runs.
- [ESP32 DS18B20 MQTT: Multiple Temperature Probes on One Bus](https://connectmq.com/blog/esp32-ds18b20-mqtt/): Wire several DS18B20 probes to a single ESP32 GPIO, discover their ROM addresses, read them without blocking and publish each probe to its own topic on broker.connectmq.com.
- [Edge AI Hardware Compared: Jetson, Coral, Hailo, Raspberry Pi and ESP32-S3](https://connectmq.com/blog/edge-ai-hardware/): A practical comparison of edge AI hardware from microcontrollers to GPU modules, with a decision checklist and a benchmark script that publishes your own model's latency over MQTT so you can compare boards fairly.
- [MQTT Security Best Practices: A 12-Point Checklist for IoT Teams](https://connectmq.com/blog/mqtt-security-best-practices/): A hands-on MQTT security checklist covering TLS, credentials, client IDs, topic design, payload validation, rate limits and certificate checks, plus how ConnectMQ handles each point.
- [Water Leak Detection with IoT: ESP32 Sensors, MQTT Alarms and an Automatic Shut-Off Valve](https://connectmq.com/blog/water-leak-detection-iot/): Build ESP32 leak sensors that publish retained MQTT alarms, and a valve controller that shuts off the water supply automatically and stays latched until someone resets it.
- [MQTT-SN Explained: MQTT for Sensor Networks](https://connectmq.com/blog/mqtt-sn/): MQTT-SN adapts MQTT for battery-powered sensors on UDP, Zigbee and other non-TCP networks. Learn topic IDs, sleeping clients and gateways, and how to forward MQTT-SN traffic into a standard MQTT broker.
- [MQTT over Cellular (LTE-M, NB-IoT): Design Tips for Data Budgets, Keep Alive and TLS](https://connectmq.com/blog/mqtt-over-cellular/): Cellular links change the rules for MQTT. Learn how to estimate monthly data usage, choose keep alive values that survive carrier NAT, reduce TLS handshake costs and pick between LTE-M and NB-IoT.
- [MQTT Message Expiry Interval: Stopping Stale Commands](https://connectmq.com/blog/mqtt-message-expiry-interval/): MQTT 5 lets a publisher say how long a message stays valid. Learn how the message expiry interval works with persistent sessions and retained messages, and how to stop late devices from executing stale commands.
- [MQTT Latency Explained: What Affects Round-Trip Time and How to Measure It](https://connectmq.com/blog/mqtt-latency/): Where does MQTT latency come from? This guide breaks down network, TLS, QoS and broker processing delays and gives you a Python script to measure round-trip time against broker.connectmq.com.
- [Modbus TCP to MQTT: Polling Registers and Publishing Data with Python](https://connectmq.com/blog/modbus-tcp-to-mqtt/): Write a Python Modbus TCP to MQTT bridge that polls holding and input registers, decodes 32-bit floats, scales values and publishes only meaningful changes to a cloud MQTT broker.
- [Greenhouse Automation with MQTT and Node-RED: Fans, Heating and Misting](https://connectmq.com/blog/greenhouse-automation/): Automate a greenhouse with MQTT: sensors publish climate data, a Node-RED flow decides when to vent, heat or mist using hysteresis, and relay nodes act with local failsafes.
- [ESP32 Servo MQTT: Control a Servo Remotely with Position Feedback](https://connectmq.com/blog/esp32-servo-mqtt/): Move a servo from MQTT commands with an ESP32 and the ESP32Servo library, ramp it smoothly to the target angle and publish position feedback that dashboards can display.
- [ESP32 GPS Tracker MQTT: NEO-6M Positions on a Live Web Map](https://connectmq.com/blog/esp32-gps-tracker-mqtt/): Read a NEO-6M GPS module with the ESP32, publish position, speed and fix quality over MQTT only when the device moves, and display the track live on a Leaflet map over secure WebSocket.
- [Natural Language Device Control: Turn Plain Requests into Validated MQTT Commands](https://connectmq.com/blog/natural-language-device-control/): A hands-on tutorial that turns requests like "dim the kitchen lights to 30 percent" into validated MQTT commands, using an LLM with function calling, a device registry and a strict validation layer.
- [MQTT mTLS: Mutual TLS with X.509 Client Certificates Explained](https://connectmq.com/blog/mqtt-mtls/): Mutual TLS lets an MQTT broker authenticate devices by X.509 certificate. Learn how it works, how to set it up on Mosquitto, what it costs to operate, and when credentials over TLS are the better fit.
- [MQTT Maximum QoS and Subscription Downgrades](https://connectmq.com/blog/mqtt-maximum-qos/): The QoS you ask for is not always the QoS you get. Learn how effective QoS is calculated, how brokers advertise a maximum QoS and grant lower subscription levels, and how to check what your connection really uses.
- [EV Charger MQTT Integration: OCPP vs MQTT and Solar-Aware Charging at Home](https://connectmq.com/blog/ev-charger-mqtt/): OCPP connects chargers to back-office systems, while MQTT connects them to the rest of your home. Learn how the two fit together, which integration path suits your wallbox, and how to build solar-aware charging on top of MQTT.
- [Allen-Bradley MQTT: Publishing ControlLogix and CompactLogix Tags](https://connectmq.com/blog/allen-bradley-mqtt/): Read ControlLogix and CompactLogix tags over EtherNet/IP with pycomm3, map them to ISA-95 topics and publish them to an MQTT broker with deadbands, Last Will and TLS.
- [TinyML on ESP32: Train, Deploy and Publish Results over MQTT](https://connectmq.com/blog/tinyml-esp32/): A complete TinyML ESP32 walkthrough: train a vibration classifier in Python, convert it to an int8 TensorFlow Lite model, run it on an ESP32 with esp-tflite-micro and publish classification results to an MQTT broker.
- [Raspberry Pi GPIO MQTT: Control Outputs and Publish Inputs with Python](https://connectmq.com/blog/raspberry-pi-gpio-mqtt/): Use gpiozero and paho-mqtt to switch Raspberry Pi outputs from MQTT commands and publish input changes as retained state, with a clean command/state topic design that works on every Pi model.
- [MQTT Production Checklist: 30 Checks Before You Go Live](https://connectmq.com/blog/mqtt-production-checklist/): A pre-launch MQTT production checklist for IoT teams: security, client identity, reconnect behavior, topic design, QoS and sessions, monitoring and operations, with production-ready client code.
- [MQTT Payload Formats: JSON vs Protobuf vs CBOR](https://connectmq.com/blog/mqtt-payload-format/): MQTT does not care what is inside a payload, so the choice is yours. Compare JSON, Protobuf and CBOR on size, schemas, debugging and tooling, using byte counts for the same sensor reading.
- [Edge Computing vs Cloud Computing in IIoT: Latency, Bandwidth, Resilience and a Hybrid Design](https://connectmq.com/blog/edge-computing-vs-cloud-computing-iiot/): Where should industrial data be processed? Compare edge and cloud computing on latency, bandwidth, resilience, security and cost, and see a working hybrid pattern that keeps fast logic local and shares results through a cloud MQTT broker.
- [DTDL Explained: Digital Twin Definition Language and How to Map It to MQTT](https://connectmq.com/blog/dtdl/): A practical introduction to DTDL, the Digital Twin Definition Language: how interfaces, telemetry, properties, commands, components and relationships work, and how to map them to MQTT topics on a broker.
- [Digital Twin vs Simulation: Key Differences and When to Use Each](https://connectmq.com/blog/digital-twin-vs-simulation/): A simulation explores what could happen; a digital twin tracks what is happening. Learn the practical differences, how live MQTT data turns a model into a twin, and how the two work best together.
- [Digital Twin MQTT Guide: Streaming Real-Time State to Your Twin](https://connectmq.com/blog/digital-twin-mqtt/): Why MQTT is the natural transport for digital twins, and how to design topics, retained state, presence and commands so a twin stays in sync with real assets, with runnable Python and JavaScript.
- [How to Deploy ML Models to Edge Devices: Packaging, Versioning and MQTT-Driven Rollouts](https://connectmq.com/blog/deploy-ml-models-to-edge-devices/): A practical guide to shipping machine learning models to fleets of edge devices, using MQTT retained messages to announce new versions and collect rollout status from every device.
- [Sparkplug Birth Death Certificates: NBIRTH, NDEATH, DBIRTH and DDEATH](https://connectmq.com/blog/sparkplug-birth-death-certificates/): Birth and death certificates are how Sparkplug knows what is online and whether data is current. This guide explains NBIRTH, NDEATH, DBIRTH and DDEATH, sequence numbers and bdSeq, with a working Python simulator.
- [Python MQTT JSON: Publishing Sensor Data with Timestamps and Schema Versions](https://connectmq.com/blog/python-mqtt-json/): Turn Python sensor readings into clean JSON MQTT messages: compact encoding, UTC timestamps, sequence numbers, schema versioning, NaN-safe serialization and MQTT 5 content type, plus a validating subscriber.
- [Pico W MQTT TLS: Secure MicroPython Connections on Port 8883 with Certificate Verification](https://connectmq.com/blog/pico-w-mqtt-tls/): Encrypt and authenticate your Raspberry Pi Pico W's MQTT traffic. This guide covers firmware and library versions, loading the right root certificate, setting the clock, verifying the server, measuring handshake time and fixing the common TLS errors.
- [Node-RED JSON Node: Parsing MQTT JSON Payloads](https://connectmq.com/blog/node-red-json-node/): How to handle JSON from MQTT in Node-RED: when to rely on the mqtt in node's parsed output, when to use the JSON node, how to validate with JSON Schema and how to fix the parse errors everyone hits.
- [Type-Safe MQTT TypeScript Client: Typed Topics and Validated Payloads](https://connectmq.com/blog/mqtt-typescript/): Define a single contract file for topics, QoS and payload schemas, wrap MQTT.js in a typed client, and validate every incoming message at runtime so publishers and subscribers can never drift apart.
- [Livestock Monitoring IoT: Tracking Animals, Water Troughs and Barn Climate with LoRaWAN and MQTT](https://connectmq.com/blog/livestock-monitoring-iot/): A practical architecture for livestock monitoring with IoT sensors: LoRaWAN collars, water trough and barn climate sensors, a clean MQTT topic tree and alerts that reach the farmer before a problem becomes a loss.
- [How Many Connections Can an MQTT Broker Handle?](https://connectmq.com/blog/how-many-connections-can-an-mqtt-broker-handle/): There is no single number for MQTT broker connection capacity. Learn what actually limits concurrent clients, how to test it yourself, and how managed providers turn those limits into plan quotas.
- [EMQX Cloud Alternative: Choosing Managed MQTT by the Features You Actually Need](https://connectmq.com/blog/emqx-cloud-alternative/): EMQX is a capable, feature-rich broker. If you are weighing alternatives, start from your own requirements. This guide maps common needs to broker capabilities and shows where a lean, industrial-friendly broker fits.
- [Cloud MQTT Broker: The Complete Guide to Hosted MQTT](https://connectmq.com/blog/cloud-mqtt-broker/): Everything you need to choose and run a cloud MQTT broker: deployment models, security, pricing models, limits, migration and a step-by-step start on ConnectMQ's free Serverless plan.
- [Audio Anomaly Detection for Machines: Listening for Faults at the Edge](https://connectmq.com/blog/audio-anomaly-detection/): Machines often sound wrong before they fail. Learn how acoustic anomaly detection works, which models fit edge hardware, and how to publish compact anomaly scores over MQTT instead of streaming raw audio.
- [Raspberry Pi IoT Gateway: Collect BLE, Modbus and Serial Data and Forward It over MQTT](https://connectmq.com/blog/raspberry-pi-iot-gateway/): A practical guide to turning a Raspberry Pi into an IoT gateway: protocol adapters for BLE, Modbus and serial, a normalised topic and payload model, a store-and-forward buffer, and a secure uplink to a cloud MQTT broker.
- [Purdue Model vs ISA-95: What's the Difference?](https://connectmq.com/blog/purdue-model-vs-isa-95/): The Purdue model and ISA-95 share level numbers but solve different problems. This comparison explains each, how they relate, and how MQTT-based architectures flatten data flow without flattening security.
- [Node-RED MQTT Not Connecting: Troubleshooting Guide](https://connectmq.com/blog/node-red-mqtt-not-connecting/): A step-by-step guide for when the Node-RED MQTT node is stuck on connecting or keeps dropping: how to read the logs, test outside Node-RED and fix ports, TLS, hostnames, duplicate client IDs, credentials, quotas and container networking.
- [MQTT Use Cases by Industry: 15 Real-World Examples](https://connectmq.com/blog/mqtt-use-cases/): Fifteen practical MQTT use cases across manufacturing, energy, automotive, smart buildings, agriculture and logistics, each with a sample topic design, the MQTT features it relies on and the broker plan that fits its scale.
- [MQTT Topic Naming Conventions: 12 Rules for Clean Topic Trees](https://connectmq.com/blog/mqtt-topic-naming-conventions/): Topic names are the API of an MQTT system and are hard to change later. These 12 naming rules, with good and bad examples, keep your topic tree readable, secure and wildcard-friendly.
- [MQTT TLS Handshake Failed: How to Diagnose and Fix It](https://connectmq.com/blog/mqtt-tls-handshake-failed/): A step-by-step troubleshooting guide for MQTT TLS handshake failures, using openssl s_client to pinpoint wrong ports, missing CAs, SNI problems, clock drift, TLS version mismatches and intercepting proxies.
- [MQTT Glossary: 60 Terms Every IoT Developer Should Know](https://connectmq.com/blog/mqtt-glossary/): From ACL to Will Delay Interval, this MQTT glossary defines 60 protocol, broker and Sparkplug B terms in plain English, with examples you can try on broker.connectmq.com.
- [Labeling Time Series Sensor Data for Machine Learning](https://connectmq.com/blog/labeling-time-series-sensor-data/): How to capture machine events and operator labels over MQTT alongside telemetry, define a label schema, convert events into labeled intervals and join them with sensor windows for supervised learning.
- [What to Look for in an Industrial MQTT Broker](https://connectmq.com/blog/industrial-mqtt-broker/): An industrial MQTT broker carries plant state, not just messages. This guide explains the capabilities that matter on the factory floor, from Sparkplug awareness and retained state to security and visibility, with a script to test them yourself.
- [ESP32 vs Raspberry Pi Pico W for IoT: Wi-Fi, MicroPython, Arduino and TLS Compared](https://connectmq.com/blog/esp32-vs-raspberry-pi-pico-w/): A practical comparison of the ESP32 and Raspberry Pi Pico W for connected projects, covering hardware, Wi-Fi and Bluetooth, programming options, TLS performance, low-power modes and MQTT code on both.
- [ESP32 BLE MQTT Gateway: Scan Bluetooth Sensors and Forward Advertisements](https://connectmq.com/blog/esp32-ble-mqtt-gateway/): Use an ESP32 as a Bluetooth Low Energy scanner that collects advertisements from nearby sensors and beacons, filters and deduplicates them, and publishes them to per-device MQTT topics.
- [Smart Lighting MQTT Control: Dimmers, LED Strips, Scenes and Schedules](https://connectmq.com/blog/smart-lighting-mqtt/): Control LED strips and dimmers over MQTT with an ESP32, use JSON commands with smooth transitions, store scenes as retained messages and run schedules from a small Python service.
- [Raspberry Pi Relay MQTT Control: Switch a Multi-Channel Relay Board from Anywhere](https://connectmq.com/blog/raspberry-pi-relay-mqtt/): Wire a 4-channel relay board to a Raspberry Pi, control each channel from MQTT topics with Python and gpiozero, and use retained messages so every relay returns to the right state after a reboot or power cut.
- [RAG for Industrial Data: Combine Equipment Manuals with Live MQTT Telemetry](https://connectmq.com/blog/rag-for-industrial-data/): A practical guide to retrieval-augmented generation for factories: index manuals and procedures, pull current values from MQTT topics and give technicians answers grounded in both, with citations.
- [MQTT Retained Messages: How They Work and When to Use Them](https://connectmq.com/blog/mqtt-retained-messages/): The retain flag lets an MQTT broker hand every new subscriber the last known value on a topic immediately. Learn how it works, where it shines and where it causes stale-data bugs.
- [What Is MQTT Bridging? Connecting Local and Cloud Brokers Across Sites](https://connectmq.com/blog/mqtt-bridging/): MQTT bridging forwards selected topics between brokers so each site keeps a local broker while the cloud sees everything. Learn the patterns, a Mosquitto bridge config and a Node-RED alternative pointing at ConnectMQ.
- [KNX MQTT Integration: Bridge Group Addresses to MQTT Topics](https://connectmq.com/blog/knx-mqtt/): Build a two-way KNX MQTT bridge with xknx and paho-mqtt that decodes KNX telegrams into JSON, publishes them to a broker and turns MQTT commands back into group writes.
- [Grafana MQTT Datasource: Live Streaming Panels from Your Broker](https://connectmq.com/blog/grafana-mqtt-datasource/): Install and configure Grafana's MQTT data source plugin, stream numeric and JSON payloads from broker.connectmq.com into live panels, and decide when a time-series database such as InfluxDB is the better choice.
- [Bearing Temperature Monitoring with Wireless Sensors and MQTT Alerts](https://connectmq.com/blog/bearing-temperature-monitoring/): A practical bearing temperature monitoring setup: battery-powered wireless sensors on bearing housings, ambient-compensated readings over MQTT, rate-of-rise detection and threshold alerts that fire before a bearing overheats.
- [MQTT 5 Features That Matter in Practice: Reason Codes, Shared Subscriptions, Expiry and More](https://connectmq.com/blog/mqtt-5-features/): MQTT 5 is more than a version bump. Learn the features that change how you build IoT systems, from reason codes and expiry to shared subscriptions and request/response, with hands-on examples.
- [Sparkplug Rebirth Requests: When and How to Trigger Them](https://connectmq.com/blog/sparkplug-rebirth/): A Sparkplug rebirth makes an edge node republish its births so a host can rebuild an accurate view. This troubleshooting guide covers NCMD rebirth, sequence gaps, unknown aliases, rebirth storms and a step-by-step diagnostic flow.
- [AI Agent Communication MQTT Patterns: Pub/Sub for Multi-Agent Systems](https://connectmq.com/blog/ai-agent-communication-mqtt/): Why publish/subscribe suits multi-agent AI systems, and the topic conventions, MQTT 5 features and safety rules that let agents discover each other and exchange messages through a broker.
- [How to Choose an IoT MQTT Broker: 12 Criteria and the Questions to Ask Your Vendor](https://connectmq.com/blog/how-to-choose-an-iot-mqtt-broker/): A practical 12-point checklist for choosing an IoT MQTT broker, a table of questions to ask every vendor, and a five-minute hands-on test you can run against broker.connectmq.com.
- [Testing MQTT Clients: Unit, Integration and End-to-End Tests](https://connectmq.com/blog/testing-mqtt-clients/): How to test MQTT client code at every level: pure unit tests with mocks, integration tests against a containerised Mosquitto broker in CI, and end-to-end smoke tests against a real cloud broker.
- [Sparkplug B vs JSON over MQTT: Which Payload Should You Use?](https://connectmq.com/blog/sparkplug-b-vs-json/): Sparkplug B and plain JSON both run on any MQTT broker, but they solve different problems. This comparison covers interoperability, state awareness, bandwidth, tooling and a hybrid pattern that gives you both.
- [Node-RED MQTT Topic Mapping: Remap Flat Device Topics into an ISA-95 Hierarchy](https://connectmq.com/blog/node-red-mqtt-topic-mapping/): Learn how to remap messy, flat device topics into a structured ISA-95 namespace with a Node-RED lookup table, normalise payloads on the way, and republish everything to a ConnectMQ broker without creating loops.
- [ESP32 vs ESP8266 for MQTT Projects: Memory, TLS, Peripherals and Cost](https://connectmq.com/blog/esp32-vs-esp8266/): Choosing between the ESP32 and ESP8266 for an MQTT device? This comparison covers memory, TLS capability, peripherals, power, library support and cost, with clear recommendations by project type.
- [ESP32 Relay MQTT: Switch Mains Loads with Commands and Retained State](https://connectmq.com/blog/esp32-relay-mqtt/): Wire a relay module to an ESP32, switch it from an MQTT command topic and publish retained state so every dashboard and app always knows whether the load is on or off.
- [Building Digital Twin for Facilities Management](https://connectmq.com/blog/building-digital-twin/): How to create a building digital twin that links BIM geometry with live HVAC, occupancy and energy data streamed over MQTT, with topic design, code and a rollout checklist.
- [Free Public MQTT Broker for Testing: Connect to broker.connectmq.com in Minutes](https://connectmq.com/blog/free-public-mqtt-broker/): broker.connectmq.com is a free public MQTT broker for testing and learning. Here are the ports, the anonymous access rules, the limits and copy-paste examples for the CLI, Python, Node.js and the browser.
- [Open Source MQTT Broker Comparison: Mosquitto, EMQX, VerneMQ and NanoMQ](https://connectmq.com/blog/open-source-mqtt-broker-comparison/): A fair, practical open source MQTT broker comparison covering Mosquitto, EMQX, VerneMQ and NanoMQ, with Docker commands to try each one and guidance on when a managed service makes more sense.
- [MQTT $SYS Topics: What Broker System Topics Tell You](https://connectmq.com/blog/mqtt-sys-topics/): A practical guide to the $SYS topic tree: where it comes from, why wildcards skip it, what Mosquitto-style brokers publish there and how to watch client connection state on ConnectMQ.
- [What to Expect from an MQTT Broker Management Console](https://connectmq.com/blog/mqtt-broker-management-console/): A tour of the features that make an MQTT broker management console useful day to day: broker setup, credentials, live topics, a web client, connection status, alerts and industrial views, using the ConnectMQ portal as the example.
- [How to Build a Unified Namespace Step by Step](https://connectmq.com/blog/how-to-build-a-unified-namespace/): A practical walkthrough of how to build a unified namespace, from modelling your plant hierarchy and choosing a broker to publishing retained state from the edge and adding the first consumers.
- [What Is Edge AI? Running Models Next to the Sensors](https://connectmq.com/blog/what-is-edge-ai/): Edge AI means running machine learning inference on or near the device that collects the data. This explainer covers how it works, the hardware tiers, and why edge devices should publish results rather than raw data.
- [Siemens S7 MQTT: Publishing S7-1200 and S7-1500 PLC Data to a Broker](https://connectmq.com/blog/siemens-s7-mqtt/): Two proven ways to get data out of an S7-1200 or S7-1500 over MQTT: the PLC-native LMQTT library and an external Python gateway using python-snap7, with TLS, ISA-95 topics and report-by-exception.
- [Common MQTT Vulnerabilities and How to Mitigate Them](https://connectmq.com/blog/mqtt-vulnerabilities/): A defender's overview of MQTT vulnerability classes in brokers, clients and deployments, with concrete mitigations and a patching strategy that does not depend on luck.
- [MQTT vs DDS: Brokered vs Brokerless Industrial Messaging](https://connectmq.com/blog/mqtt-vs-dds/): MQTT routes through a broker; DDS lets peers discover each other and exchange typed data directly. This comparison covers architecture, real-time guarantees, robotics versus IIoT use and how to bridge the two.
- [Matter vs MQTT: How the Smart Home Standards Differ and Work Together](https://connectmq.com/blog/matter-vs-mqtt/): Matter and MQTT are often compared, but they solve different problems. Learn what each does, where they overlap, and how a Home Assistant setup can use Matter for devices and MQTT for everything that needs to travel.
- [EU Cyber Resilience Act and IoT: What It Means for MQTT Devices](https://connectmq.com/blog/eu-cyber-resilience-act-iot/): The EU Cyber Resilience Act sets cybersecurity requirements for products with digital elements. Learn what it asks of connected devices and how secure MQTT connectivity supports your work.
- [ESPHome MQTT: Using MQTT Instead of the Native API](https://connectmq.com/blog/esphome-mqtt/): Switch an ESPHome device from the native API to MQTT so Node-RED, Python scripts, dashboards and Home Assistant can all read and control it through one broker.
- [CNC Machine Monitoring with MQTT: Spindle Load, Program and Utilization](https://connectmq.com/blog/cnc-machine-monitoring/): Learn how to collect execution state, active program, spindle load and part count from CNC machines, publish them over MQTT and turn them into an honest utilization number.
- [Smart Parking IoT with MQTT: Bay Sensors, Occupancy Counts and a Live Availability Map](https://connectmq.com/blog/smart-parking-iot/): A practical blueprint for smart parking with IoT: choose bay sensors, design MQTT topics, aggregate free spaces per zone and drive a live browser map over secure WebSocket.
- [Publish Raspberry Pi System Stats over MQTT for Fleet Health Monitoring](https://connectmq.com/blog/raspberry-pi-system-stats-mqtt/): A small Python service that publishes CPU temperature, load, memory, disk usage and under-voltage flags from every Raspberry Pi to MQTT, with a last will so you know when a Pi goes offline.
- [PHP MQTT Client Tutorial with php-mqtt/client](https://connectmq.com/blog/php-mqtt-client/): Learn to publish MQTT messages from a PHP web request and run a long-lived PHP subscriber worker with php-mqtt/client, including TLS, reconnects, graceful shutdown and Laravel-friendly patterns.
- [Injection Molding Monitoring with IoT: Catch Defects Shot by Shot](https://connectmq.com/blog/injection-molding-monitoring/): A practical use case for injection molding monitoring: publish one MQTT message per shot with cycle time, cushion, pressure and temperatures, then flag drifting shots before bad parts pile up.
- [CAN Bus to MQTT with Raspberry Pi: Read, Decode and Publish Frames](https://connectmq.com/blog/can-bus-to-mqtt-raspberry-pi/): Turn a Raspberry Pi with a CAN HAT into a gateway that reads frames with python-can, decodes signals from a DBC file and publishes rate-limited JSON to an MQTT broker.
- [Warehouse Digital Twin for Logistics Operations](https://connectmq.com/blog/warehouse-digital-twin/): How to build a warehouse digital twin that tracks inventory movement, AGVs and conveyor states in a live 3D model fed by MQTT topics, with topic design, code and pitfalls.
- [Shop Floor Data Collection: Methods, Tools and a Practical Architecture](https://connectmq.com/blog/shop-floor-data-collection/): Manual sheets, PLC tags, retrofit sensors and edge gateways all collect shop floor data differently. Compare the methods, pick the right one per machine and centralize everything on one MQTT namespace.
- [Shelly MQTT Setup for Gen2 and Gen3 Devices: Topics, RPC and Cloud Broker](https://connectmq.com/blog/shelly-mqtt/): Turn on MQTT in Shelly Gen2 and Gen3 devices, learn exactly which topics they publish and accept, control relays with simple commands or JSON-RPC, and connect them securely to a cloud broker.
- [Raspberry Pi Camera Motion MQTT Alerts with Picamera2](https://connectmq.com/blog/raspberry-pi-camera-motion-mqtt/): Build a motion detector with a Raspberry Pi camera and Picamera2, save a snapshot when something moves, and publish motion events with snapshot links over MQTT so dashboards, phones and automations can react.
- [Ollama MQTT Bridge: Run a Local LLM on Your Gateway and Publish AI Insights](https://connectmq.com/blog/ollama-mqtt/): A practical tutorial for running Ollama on an IoT gateway, subscribing to MQTT telemetry and publishing structured, AI-generated insights back to the broker without sending data to an external AI service.
- [IoT Quality Control in Manufacturing: Real-Time Checks with In-Line Sensors and MQTT](https://connectmq.com/blog/iot-quality-control-manufacturing/): Learn how in-line sensors, gauges and test stations publish measurements over MQTT for real-time quality checks, how to design topics and payloads, and how the same data feeds SPC and traceability.
- [How to Retrofit Legacy Machines for IoT Without Touching the PLC](https://connectmq.com/blog/retrofit-legacy-machines-iot/): Old machines still make most of the parts in many plants. This guide shows how to retrofit legacy machines for IoT with current clamps, add-on sensors and a gateway, and publish machine state over MQTT without touching a line of PLC code.
- [PubSubClient rc=-2 and Other State Codes Explained (With Fixes)](https://connectmq.com/blog/pubsubclient-rc-2/): PubSubClient prints "failed, rc=-2" and nothing else? This guide decodes every state code from -4 to 5 and gives tested fixes for DNS, port, TLS, client ID and credential problems.
- [MQTT TLS 1.3: Handshakes, Cipher Suites and Performance](https://connectmq.com/blog/mqtt-tls-1-3/): How TLS 1.3 changes MQTT connections: fewer round trips, a smaller set of strong cipher suites and different trade-offs for microcontrollers. Includes Python, Node.js, Mosquitto and OpenSSL examples.
- [MQTT Audit Logging: What to Record and Why](https://connectmq.com/blog/mqtt-audit-logging/): A practical guide to MQTT audit logging: which events matter for security and compliance, what fields to capture, where logs come from in a managed setup, and how to build a simple pipeline.
- [Designing ISA-95 Based MQTT Topics](https://connectmq.com/blog/isa-95-mqtt-topics/): How to encode the ISA-95 equipment hierarchy into MQTT topics: level order, leaf design, wildcard planning, payload choices and the common pitfalls, plus how Sparkplug B data can be republished into the same tree.
- [How Does MQTT Work? Brokers, Clients and Messages Explained](https://connectmq.com/blog/how-does-mqtt-work/): A step-by-step explanation of how MQTT works, from opening a TCP connection to CONNECT, SUBSCRIBE, PUBLISH, keep alive and disconnect, with a trace you can reproduce on a public broker.
- [Frigate MQTT Events Explained: Topics, Payloads and Remote Alerts](https://connectmq.com/blog/frigate-mqtt/): Learn what Frigate NVR publishes over MQTT, how to read the frigate/events payload and how to forward only the detections that matter to a cloud broker for remote notifications.
- [ESP32 Stepper Motor MQTT: Position Control with Live Progress Updates](https://connectmq.com/blog/esp32-stepper-motor-mqtt/): Drive a NEMA 17 stepper from MQTT position commands with an ESP32, AccelStepper and an A4988 or DRV8825 driver, and publish live progress so apps know where the motor is.
- [ESP32 ArduinoJson MQTT: Send and Parse JSON Payloads the Right Way](https://connectmq.com/blog/esp32-arduinojson-mqtt/): Serialize sensor readings and parse incoming JSON commands with ArduinoJson 7 on an ESP32, publish them over MQTT with PubSubClient, and avoid the buffer and memory pitfalls that silently drop messages.
- [Digital Twin State Synchronization: Reported, Desired and Conflict Patterns](https://connectmq.com/blog/digital-twin-state-synchronization/): How to keep a digital twin and its physical asset in sync: reported and desired state, version numbers, conflict handling, reconnect recovery and retained MQTT topics, with a working Python device.
- [Wireless Industrial Sensors with MQTT: Wi-Fi, LoRaWAN, WirelessHART and Private 5G](https://connectmq.com/blog/wireless-industrial-sensors/): Wireless industrial sensors make it cheap to measure what was never wired. This guide compares the main radio technologies and shows how data from each one reaches a single MQTT broker, with a working LoRaWAN-to-MQTT bridge.
- [Raspberry Pi Sense HAT MQTT: Publish Environment and IMU Data, Show Messages on the LED Matrix](https://connectmq.com/blog/raspberry-pi-sense-hat-mqtt/): Turn a Raspberry Pi Sense HAT into a two-way MQTT device: publish environment and orientation readings as JSON, and scroll messages sent from any MQTT client across the 8x8 LED matrix.
- [.NET MAUI MQTT App: Monitor and Control Devices on Android, iOS and Windows](https://connectmq.com/blog/net-maui-mqtt/): Build one cross-platform .NET MAUI app with MQTTnet that displays live telemetry and sends commands to devices, handles app lifecycle reconnects and runs against a ConnectMQ broker.
- [MQTT Wildcards: How to Use + and # in Topic Filters](https://connectmq.com/blog/mqtt-wildcards/): The single-level + and multi-level # wildcards let one MQTT subscription cover many topics. Learn the exact matching rules, the edge cases and how to test every filter on a live broker.
- [Digital Twin Retained MQTT Tutorial: Using Retained Messages as Twin State](https://connectmq.com/blog/digital-twin-retained-mqtt/): Build a lightweight digital twin where every property is a retained MQTT topic. Viewers get full twin state the instant they subscribe, with no database. Includes a Python simulator, a Node.js viewer and cleanup commands.
- [AWS IoT Core Alternative: When a Standard MQTT Broker Is Simpler](https://connectmq.com/blog/aws-iot-core-alternative/): AWS IoT Core is a deep, AWS-integrated IoT service. Sometimes you only need a standard MQTT broker. This guide shows what to compare, how the authentication models differ and how to keep devices portable.
- [Async MQTT Client on ESP32: Non-Blocking MQTT with AsyncMqttClient](https://connectmq.com/blog/async-mqtt-client-esp32/): Learn how AsyncMqttClient keeps ESP32 firmware responsive: event-driven callbacks, automatic reconnects with FreeRTOS timers, QoS 1 and 2 publishing and fragmented payload handling.
- [AI and IoT: The Complete Guide to AIoT, from Edge Models to LLM Agents](https://connectmq.com/blog/ai-and-iot/): A practical guide to combining AI and IoT: where models should run, how sensor data reaches them, how to detect anomalies in real time and how to let LLM agents act on devices safely.
- [Real-Time Digital Twin Latency: Budgets for Visualization, Monitoring and Control](https://connectmq.com/blog/real-time-digital-twin-latency/): How fast does a real-time digital twin need to be? Latency budgets for visualization, monitoring and control twins, where the milliseconds go, how MQTT QoS and broker placement affect them, and a script to measure your own.
- [Node-RED HTTP to MQTT: Expose REST Endpoints That Publish to Your Broker](https://connectmq.com/blog/node-red-http-to-mqtt/): Legacy systems, ERP scripts and webhooks speak HTTP, while your devices speak MQTT. This tutorial builds a Node-RED HTTP to MQTT bridge with validation, authentication, read endpoints and an optional wait-for-acknowledgement pattern.
- [MQTT SCADA: Modernizing Telemetry with Report by Exception](https://connectmq.com/blog/mqtt-scada/): How MQTT changes SCADA telemetry: report by exception instead of polling, a broker as the hub between RTUs and SCADA hosts, state awareness with Last Will and Sparkplug B, and a step-by-step migration path.
- [IoT Automation Guide: Automating Homes, Buildings, Farms and Energy with MQTT](https://connectmq.com/blog/iot-automation/): How IoT automation works in homes, buildings, farms and energy systems, with a reusable sensor-broker-rules architecture, working Home Assistant and Python examples, and the pitfalls to avoid.
- [Grafana Alerts for IoT Sensor Data: Thresholds, Stale Sensors and Notifications](https://connectmq.com/blog/grafana-alerts-iot-sensor-data/): Build Grafana alert rules on MQTT sensor data in InfluxDB, with one alert instance per device, sensible pending periods, no-data handling for silent sensors and contact points, then compare them with broker-side threshold rules in ConnectMQ.
- [Exposed MQTT Brokers on the Internet: The Risks of Open Port 1883](https://connectmq.com/blog/exposed-mqtt-brokers/): Internet scans regularly find MQTT brokers that accept anyone on port 1883. Learn what that exposes, how to audit your own broker and how to keep test data and production data apart.
- [Unified Namespace vs Data Lake: Complementary or Competing?](https://connectmq.com/blog/unified-namespace-vs-data-lake/): A unified namespace and a data lake solve different problems. This comparison explains real-time state versus historical analytics, where each belongs, and how a simple subscriber connects the two.
- [The Things Network MQTT Integration: Bridge LoRaWAN Uplinks to Your Broker](https://connectmq.com/blog/the-things-network-mqtt/): Subscribe to The Things Network's MQTT server, decode LoRaWAN uplinks with a payload formatter, and republish clean sensor JSON into your own topic tree with a short Python bridge.
- [Predictive Maintenance with IoT: A Practical Guide from Sensor to Model](https://connectmq.com/blog/predictive-maintenance-iot/): What predictive maintenance with IoT really takes: the sensors that matter, features to compute at the edge, how condition data moves over MQTT to analytics, and the modelling steps from thresholds to anomaly detection.
- [Node-RED Modbus to MQTT: Poll Devices and Publish Values](https://connectmq.com/blog/node-red-modbus/): Build a Node-RED Modbus gateway: poll holding registers and coils with node-red-contrib-modbus, decode scaling and 32-bit floats, publish JSON to MQTT by exception, and accept safe write commands.
- [MQTT to Google Sheets: Send Sensor Data with Python and the Sheets API](https://connectmq.com/blog/mqtt-to-google-sheets/): Use a Python MQTT subscriber, a Google service account and gspread to append batched sensor readings to a shared spreadsheet, without hitting API quotas or losing rows on reconnect.
- [MQTT Ports Explained: 1883, 8883, 8083 and 8084](https://connectmq.com/blog/mqtt-ports/): A practical guide to MQTT ports: plain TCP 1883, TLS 8883, WebSocket 8083 and secure WebSocket 8084, with firewall advice and copy-paste tests against broker.connectmq.com.
- [MQTT Keep Alive Interval: How to Choose the Right Value](https://connectmq.com/blog/mqtt-keep-alive-interval/): The keep alive interval decides how fast a broker notices a dead connection and how much traffic and battery an idle client burns. Here is how it works and how to pick a value.
- [Kepware MQTT Agent: Publishing Tags to a Cloud MQTT Broker over TLS](https://connectmq.com/blog/kepware-mqtt/): Configure the Kepware IoT Gateway MQTT Client agent to publish PLC tags to a cloud MQTT broker over TLS, shape the JSON payload, and fan the data out into a clean ISA-95 topic tree.
- [Calculating IIoT ROI: A Practical Framework for Industrial Projects](https://connectmq.com/blog/iiot-roi/): Most IIoT business cases fail because the benefits are vague and the costs are incomplete. This framework turns downtime, energy and quality gains into numbers you can defend, and shows where messaging and broker costs fit.
- [Qt MQTT Client in C++: Building Desktop and Embedded HMIs](https://connectmq.com/blog/qt-mqtt-client/): Use the Qt MQTT module to build a C++ HMI that connects to a cloud broker over TLS, subscribes to machine topics, shows live values with staleness detection and sends operator commands.
- [Production Counting IoT: Sensors, Edge Counters and MQTT Shift Totals](https://connectmq.com/blog/production-counting-iot/): Count good and rejected parts automatically with photoelectric sensors and a Raspberry Pi, persist counts across restarts and publish retained shift totals over MQTT so every screen shows the right number.
- [Battery-Powered Pico W MQTT Sensor with Lightsleep and Duty Cycling](https://connectmq.com/blog/pico-w-battery-mqtt/): Turn a Raspberry Pi Pico W into a battery-powered MQTT sensor that wakes, measures, publishes and sleeps again. Covers MicroPython lightsleep, Wi-Fi shutdown, battery voltage reading and the pitfalls that drain cells.
- [openHAB MQTT Binding Tutorial: Broker Bridge, Generic Things and Rules](https://connectmq.com/blog/openhab-mqtt/): Connect openHAB to an external MQTT broker, model sensors and switches as generic MQTT things, parse JSON payloads and publish from rules, with a TLS setup ready for production.
- [MQTT Explorer Desktop App Comparison: Visualizing Topic Trees](https://connectmq.com/blog/mqtt-explorer-desktop-app/): Compare desktop MQTT explorers, including MQTT Explorer, MQTTX, MQTT.fx and the ConnectMQ Desktop MQTT explorer, learn what features matter when debugging topic trees, and connect any of them to broker.connectmq.com.
- [How to Migrate Mosquitto to a Cloud MQTT Broker Without Downtime](https://connectmq.com/blog/migrate-mosquitto-to-cloud-mqtt/): A practical runbook to migrate Mosquitto to a cloud MQTT broker: inventory clients and topics, map credentials, bridge the two brokers so both see the same traffic, move clients in waves and decommission safely.
- [ESP32 BME280 MQTT Weather Station with a Remote-Configurable Interval](https://connectmq.com/blog/esp32-bme280-mqtt/): Read temperature, humidity and pressure from a BME280 over I2C, publish JSON to broker.connectmq.com, and change the publish interval at runtime with a retained MQTT command stored in flash.
- [Electrical Sub-Metering IoT: Modbus Energy Meters to MQTT](https://connectmq.com/blog/electrical-sub-metering-iot/): Connect DIN-rail Modbus energy meters on an RS-485 bus to a gateway, decode the registers in Python and publish per-machine kWh to an MQTT broker so every machine gets its own energy figure.
- [Eclipse Ditto MQTT Tutorial: Open-Source Digital Twins on a Managed Broker](https://connectmq.com/blog/eclipse-ditto-mqtt/): A hands-on Eclipse Ditto MQTT tutorial: run Ditto with Docker, create a thing, add an MQTT 5 connection to a broker, map device JSON into features and publish twin change events back to MQTT.
- [ChirpStack MQTT Integration for LoRaWAN: Forward Decoded Uplinks to a Cloud Broker](https://connectmq.com/blog/chirpstack-mqtt/): Use ChirpStack's built-in MQTT integration to publish decoded LoRaWAN uplinks, then forward them to a cloud MQTT broker with either a Mosquitto bridge or a small Node.js forwarder.
- [Azure IoT Hub Alternative: Moving to a Full MQTT 3.1.1/5.0 Broker](https://connectmq.com/blog/azure-iot-hub-alternative/): Azure IoT Hub speaks MQTT in a device-to-cloud shape. If you need publish/subscribe between any clients, a full MQTT broker may fit better. Here is how the models differ and how to migrate in stages.
- [Smart City Digital Twin: Traffic, Lighting and Environment over MQTT](https://connectmq.com/blog/smart-city-digital-twin/): How city digital twins combine a geographic model with live traffic, street lighting and environmental sensor data published over MQTT, including topic design, code and a pilot checklist.
- [rtl_433 MQTT Guide: Capture 433 MHz Weather Sensors and Door Contacts](https://connectmq.com/blog/rtl-433-mqtt/): Turn a cheap SDR dongle into a 433 MHz receiver with rtl_433, publish weather stations and door contacts over MQTT, and relay only your own sensors to a private broker over TLS.
- [PubSubClient Buffer Size: Fixing Large Message Failures](https://connectmq.com/blog/pubsubclient-buffer-size/): Large MQTT messages failing silently on your ESP32 or ESP8266? Learn how the PubSubClient buffer works, how to size it with setBufferSize, and how to stream big JSON payloads without wasting RAM.
- [Node-RED Worldmap: Tracking GPS Devices over MQTT](https://connectmq.com/blog/node-red-worldmap/): Turn MQTT GPS messages into moving markers with node-red-contrib-web-worldmap. Includes a vehicle simulator, the mapping function, staleness handling, tracks and tips for embedding the map in Dashboard 2.0.
- [MQTT Packet Structure: Fixed Header, Variable Header and Payload](https://connectmq.com/blog/mqtt-packet-structure/): A byte-level walkthrough of MQTT packets: how the fixed header encodes type and flags, how remaining length works, and what the variable header and payload contain, using a CONNECT and PUBLISH you can capture with Wireshark.
- [MQTT Client ID Best Practices: Uniqueness, Format and Takeovers](https://connectmq.com/blog/mqtt-client-id/): The client ID is how an MQTT broker knows who you are. Get it wrong and devices kick each other offline or lose their sessions. Here are the rules, formats and debugging steps that work.
- [How to Scale an MQTT Broker: Connections, Throughput and Fan-Out](https://connectmq.com/blog/how-to-scale-an-mqtt-broker/): Scaling MQTT is about three numbers: connections, inbound messages and outbound fan-out. Learn how each grows, which scaling strategies fit, and which client habits matter most.
- [Factory Energy Monitoring with IoT: Meters, MQTT and Dashboards per Line and Shift](https://connectmq.com/blog/factory-energy-monitoring/): A practical blueprint for plant-wide energy monitoring: which meters to install, how to structure MQTT topics, how to store counters and how to report energy per line, per shift and per part.
- [Google Coral Edge TPU with MQTT: Classify Images on a Raspberry Pi and Publish Results](https://connectmq.com/blog/coral-edge-tpu/): A hands-on tutorial that sets up a Google Coral Edge TPU on a Raspberry Pi, runs a quantized MobileNet classifier and publishes every prediction as JSON to an MQTT broker.
- [ASP.NET Core MQTT: A Background Service That Stores and Streams Device Data](https://connectmq.com/blog/asp-net-core-mqtt/): Host an MQTTnet subscriber as an ASP.NET Core BackgroundService, persist device telemetry with EF Core and push every reading to browsers over SignalR, using ConnectMQ as the broker.
- [VS Code MQTT Extension: Publish and Subscribe Without Leaving Your Editor](https://connectmq.com/blog/vs-code-mqtt-extension/): Set up MQTT inside VS Code with the ConnectMQ extension and a few workspace tasks, so you can connect to a broker, watch topics and publish test payloads next to the firmware or backend code you are writing.
- [Raspberry Pi MQTT Display: Build a Touchscreen Control Panel in Python](https://connectmq.com/blog/raspberry-pi-mqtt-display/): Build a full-screen touchscreen control panel on a Raspberry Pi. Buttons publish MQTT commands, the screen reflects the real device state from retained messages, and the panel starts automatically on boot.
- [Raspberry Pi LoRa MQTT Receiver: Forward SX127x Packets to the Cloud](https://connectmq.com/blog/raspberry-pi-lora-mqtt/): Receive point-to-point LoRa packets on a Raspberry Pi with an RFM95 or SX127x HAT, match radio settings with your senders and republish every packet as JSON to an MQTT broker.
- [Node-RED Switch Node and Change Node for MQTT Routing](https://connectmq.com/blog/node-red-switch-node/): Use the Node-RED switch node to split MQTT traffic by topic and value, then shape each branch with the change node before republishing. Includes an importable flow and a test plan on a free broker.
- [MQTT JWT Authentication: Tokens in the Password Field](https://connectmq.com/blog/mqtt-jwt-authentication/): A practical explanation of carrying JSON Web Tokens in MQTT CONNECT, how brokers validate them, how to handle expiry and refresh on devices, and when static per-device credentials are the simpler choice.
- [Is MQTT Secure? Threats, Myths and Real Protections](https://connectmq.com/blog/is-mqtt-secure/): An honest look at MQTT security: what the protocol does and does not protect, the threats that actually hit deployments, common myths, and the layers that make an MQTT system secure in practice.
- [IIoT Architecture Layers: Device, Edge, Broker and Application](https://connectmq.com/blog/iiot-architecture/): A clear IIoT architecture separates devices, edge gateways, the messaging broker and applications so each layer can change without breaking the others. This reference explains each layer's role, the design rules that keep it scalable and a runnable end-to-end example.
- [HVAC Monitoring with IoT Sensors and MQTT Alerts](https://connectmq.com/blog/hvac-monitoring-iot/): Which HVAC signals are worth measuring, how to publish them over MQTT, and how to turn delta-T, filter pressure and runtime into early fault alerts with a cloud broker.
- [ESP8266 MQTT Tutorial: Connect a NodeMCU to a Cloud Broker (Plain and TLS)](https://connectmq.com/blog/esp8266-mqtt/): Connect an ESP8266 NodeMCU to an MQTT broker with PubSubClient, publish JSON telemetry, control the onboard LED, then add TLS with BearSSL while keeping the limited heap under control.
- [Automatic Irrigation System with MQTT Control: Soil, Forecast and Valves](https://connectmq.com/blog/automatic-irrigation-system/): Combine soil moisture readings, a rain forecast and MQTT-controlled valves into an automatic irrigation system that waters only when needed and always shuts off safely.
- [Zigbee vs Wi-Fi Smart Home (and Z-Wave): Choosing Radios for an MQTT Setup](https://connectmq.com/blog/zigbee-vs-wifi-smart-home/): Zigbee, Z-Wave and Wi-Fi each have a place in a smart home. Compare power, range, mesh behaviour and cost, and see exactly how each radio gets its data onto an MQTT broker.
- [Unity MQTT Client: Drive 3D Scenes with Live Sensor Data](https://connectmq.com/blog/unity-mqtt-client/): Add an MQTT client to Unity with MQTTnet, subscribe to sensor topics on broker.connectmq.com and safely animate GameObjects from live data on the main thread, the foundation of a digital twin.
- [Tasmota MQTT Commands Cheat Sheet: cmnd, stat and tele Topics Explained](https://connectmq.com/blog/tasmota-mqtt-commands/): A practical reference to Tasmota's cmnd, stat and tele topics and the commands you will actually use, with ready-to-send examples for any MQTT client or the ConnectMQ web client.
- [Sparkplug Primary Host Application and STATE Messages](https://connectmq.com/blog/sparkplug-primary-host-application/): The primary host application is the Sparkplug consumer edge nodes depend on. This guide explains STATE messages in Sparkplug 3.0, how edge nodes react when the host goes offline, and how to test the flow with Python and mosquitto.
- [Node-RED vs n8n for IoT Workflows: MQTT Support, Deployment and When to Use Each](https://connectmq.com/blog/node-red-vs-n8n/): Node-RED and n8n both draw workflows on a canvas, but one was built for message streams and the other for business automations. This comparison covers MQTT support, execution models, licensing, deployment and a hybrid pattern that uses each where it fits.
- [Multi-Tenant MQTT Broker Architecture: Namespaces, Credentials and Quotas](https://connectmq.com/blog/multi-tenant-mqtt-broker/): A practical look at multi-tenant MQTT broker architecture: how tenants are separated by namespace, identity and resource limits, which trade-offs matter, and how ConnectMQ applies them.
- [MTConnect to MQTT: Streaming CNC Machine Data to Dashboards](https://connectmq.com/blog/mtconnect-to-mqtt/): MTConnect agents expose CNC data over HTTP and XML. Build a bridge that follows the agent's sequence numbers, picks the data items that matter and publishes machine state over MQTT for dashboards and analytics.
- [MQTT 5 User Properties: Adding Metadata Without Touching the Payload](https://connectmq.com/blog/mqtt-user-properties/): MQTT 5 user properties are key/value headers you can attach to a message without changing its payload. Learn how they work, what they are good for, and how to send and read them in Python, Node.js and the CLI.
- [LLM Agent for IoT Devices: Architecture, Tools and Safety Guardrails](https://connectmq.com/blog/llm-agent-for-iot-devices/): How to design an LLM agent that reads device state from MQTT and sends commands safely, using a state cache, schema-constrained tools, a policy layer, human approval and a complete audit trail.
- [Industrial IoT with MQTT: The Complete IIoT Guide](https://connectmq.com/blog/industrial-iot-mqtt/): Why MQTT became the backbone of Industrial IoT, how edge gateways, Sparkplug B and ISA-95 namespaces fit together, and how to build a working machine-to-cloud data flow with runnable code.
- [ESP32 OLED MQTT: Show Live MQTT Messages on an SSD1306 Display](https://connectmq.com/blog/esp32-oled-mqtt/): Turn an ESP32 and a cheap SSD1306 OLED into a live MQTT display that shows sensor values and messages from any device, flags stale readings and shows its own connection status.
- [Build a Web-Based 3D Digital Twin with glTF and Live MQTT Data](https://connectmq.com/blog/web-based-3d-digital-twin/): A step-by-step guide to a production-style web based 3D digital twin: model preparation, a Vite project, configuration-driven MQTT bindings, click-to-inspect details, connection health and static deployment.
- [Raspberry Pi Air Quality Monitor with BME680 and MQTT](https://connectmq.com/blog/raspberry-pi-air-quality-monitor/): Wire a BME680 to a Raspberry Pi, calibrate a gas baseline, compute a simple indoor air quality score and stream everything to an MQTT broker you can watch from anywhere.
- [Production Line Monitoring Dashboard with MQTT, Grafana and Node-RED](https://connectmq.com/blog/production-line-monitoring-dashboard/): A step-by-step build of a production line monitoring dashboard: stations publish status and counts over MQTT, Telegraf stores them, and Grafana or Node-RED turns them into a live line view.
- [Node-RED MQTT Tutorial: Flows, Dashboards and Automation](https://connectmq.com/blog/node-red-mqtt-tutorial/): Learn MQTT in Node-RED end to end: broker configuration, mqtt in and mqtt out nodes, JSON handling, a Dashboard 2.0 view, threshold alerts and a secure TLS connection to a private broker.
- [Node-RED Dynamic MQTT Subscribe: Change Topics at Runtime](https://connectmq.com/blog/node-red-dynamic-mqtt-subscribe/): Learn how the mqtt in node's dynamic subscription mode works, how to subscribe and unsubscribe with msg.action, how to restore subscriptions after a restart and how to drive it from a dashboard or a device list.
- [Home Energy Monitor MQTT Guide: Smart Meter and CT Clamp Data to Dashboards](https://connectmq.com/blog/home-energy-monitor-mqtt/): Measure whole-house consumption with a smart meter P1 reader or CT clamps, publish it as MQTT JSON with a short Python script, and store and chart it with Telegraf, InfluxDB or any dashboard that speaks MQTT.
- [ESP32 Cannot Connect to MQTT Broker: 12 Fixes That Actually Work](https://connectmq.com/blog/esp32-cannot-connect-to-mqtt-broker/): A systematic troubleshooting guide for when your ESP32 cannot connect to an MQTT broker, covering Wi-Fi, DNS, ports, TLS certificates, credentials, client IDs and PubSubClient state codes.
- [Cold Chain Monitoring with IoT: Cellular MQTT Telemetry and Temperature Excursion Alerts](https://connectmq.com/blog/cold-chain-monitoring/): Keep chilled and frozen goods within range from depot to delivery. This guide designs a cold chain monitoring system with cellular MQTT gateways, store-and-forward buffering and duration-based excursion alerts.
- [Babylon.js Digital Twin with Real-Time IoT Data over MQTT](https://connectmq.com/blog/babylon-js-digital-twin/): Build an interactive Babylon.js digital twin of a cooling skid that reads live MQTT telemetry over secure WebSocket, highlights alarms, moves a gauge needle and sends start and stop commands when you click the pump.
- [Arduino Nano 33 IoT MQTT with WiFiNINA: Stream IMU Data over SSL](https://connectmq.com/blog/arduino-nano-33-iot-mqtt/): Publish accelerometer and gyroscope readings from the Arduino Nano 33 IoT to an MQTT broker using WiFiNINA, WiFiSSLClient and ArduinoMqttClient, then harden it with credentials and a Last Will.
- [Real-Time SPC with MQTT: Live Control Charts and Out-of-Control Alerts](https://connectmq.com/blog/real-time-spc/): Stream measurements over MQTT, compute X-bar and R control limits in Python, apply Western Electric rules to every new subgroup and show out-of-control points on a live dashboard within seconds.
- [Node-RED MQTT TLS: Configuring the Broker Node Securely](https://connectmq.com/blog/node-red-mqtt-tls/): Configure Node-RED's mqtt-broker node for an encrypted connection on port 8883, with certificate verification, credentials, MQTT 5 options and an importable flow, plus fixes for the errors you are most likely to see.
- [Node-RED InfluxDB Tutorial: Storing and Querying MQTT Data](https://connectmq.com/blog/node-red-influxdb/): Wire MQTT telemetry into InfluxDB 2 with Node-RED: run InfluxDB in Docker, map JSON payloads to fields and tags, write with node-red-contrib-influxdb and query the results with Flux for a Dashboard 2.0 chart.
- [Mosquitto Cloud Alternative: Moving From Self-Hosted Mosquitto to Managed MQTT](https://connectmq.com/blog/mosquitto-cloud-alternative/): Mosquitto is an excellent broker, but running it on a public server means owning TLS, users, patching and uptime. Here is what changes when you move to a managed broker, and how to migrate gradually with a bridge.
- [Angular MQTT Tutorial with RxJS, MQTT.js and ngx-mqtt](https://connectmq.com/blog/angular-mqtt/): Wire an Angular service to an MQTT broker over secure WebSocket, expose topics as RxJS observables with wildcard matching, render them with the async pipe, and compare the approach with ngx-mqtt.
- [Raspberry Pi vs ESP32 for IoT Projects: Choosing the Right Board for MQTT](https://connectmq.com/blog/raspberry-pi-vs-esp32/): A practical Raspberry Pi vs ESP32 comparison for IoT builders: how a Linux single-board computer and a Wi-Fi microcontroller differ in power, cost, reliability and MQTT tooling, and when to use both together.
- [Paho MQTT Python Tutorial: Publish and Subscribe in 10 Minutes](https://connectmq.com/blog/paho-mqtt-python/): Install paho-mqtt 2.x, build a working publisher and subscriber against broker.connectmq.com, learn the network loop, QoS, retained messages and Last Will, then switch to a private broker with credentials and TLS.
- [MQTT Wireshark Tutorial: Capture and Analyze MQTT Traffic](https://connectmq.com/blog/mqtt-wireshark/): Capture your own MQTT traffic with Wireshark, read every packet field on port 1883, and see exactly what TLS on port 8883 protects, using the free broker.connectmq.com test broker.
- [End-to-End MQTT Payload Encryption with AES-GCM](https://connectmq.com/blog/mqtt-payload-encryption/): TLS protects MQTT messages in transit, but the broker still sees plaintext. Learn how to add end-to-end MQTT payload encryption with AES-GCM in Python, and how to handle keys, nonces and topics safely.
- [MQTT for IoT SaaS: Building a Multi-Customer Platform on a Managed Broker](https://connectmq.com/blog/mqtt-for-iot-saas/): How to build an IoT SaaS product on a managed MQTT broker: choosing a customer isolation model, designing credentials and topic prefixes, onboarding devices and running the backend.
- [IEC 62443 and MQTT: Securing Industrial Messaging with Zones and Conduits](https://connectmq.com/blog/iec-62443-mqtt/): A practical guide to applying IEC 62443 concepts such as zones, conduits, foundational requirements and security levels to an MQTT architecture with edge gateways and a cloud broker.
- [Digital Lean Manufacturing: How Real-Time Data Strengthens Lean Tools](https://connectmq.com/blog/digital-lean-manufacturing/): Lean teaches you to see waste; IoT data lets you see it continuously. Learn how real-time machine events support value stream mapping, kaizen, SMED, andon and TPM without replacing gemba.
- [Connect an ESP32 to a Cloud MQTT Broker over TLS](https://connectmq.com/blog/cloud-mqtt-broker-esp32/): Step-by-step guide to moving an ESP32 project from a local Mosquitto broker to a cloud MQTT broker over TLS with username, password and a validated certificate.
- [BACnet to MQTT: Integrating HVAC Controllers with a Python Gateway](https://connectmq.com/blog/bacnet-to-mqtt/): Read analog and binary objects from BACnet/IP HVAC controllers with BAC0 and publish them to an MQTT broker as clean JSON, with deadbands, retained metadata and safe write-back.
- [AI Visual Inspection in Manufacturing: From Camera to Pass/Fail over MQTT](https://connectmq.com/blog/ai-visual-inspection/): How camera-based defect detection works on a production line, how to design the inspection station, and how to publish pass/fail results over MQTT so PLCs, dashboards and traceability systems all get the same answer.
- [Raspberry Pi Grafana InfluxDB Setup for MQTT Sensor Data](https://connectmq.com/blog/raspberry-pi-grafana-influxdb/): Install InfluxDB 2, Telegraf and Grafana on a 64-bit Raspberry Pi, subscribe Telegraf to an MQTT broker, store sensor readings as time series and chart them in Grafana.
- [Node-RED OEE Dashboard from MQTT Machine Data](https://connectmq.com/blog/node-red-oee-dashboard/): Calculate OEE in Node-RED from two MQTT topics, machine state and part counters, then display availability, performance, quality and OEE on Dashboard 2.0 gauges and republish the KPIs for other systems.
- [MQTT Testing Checklist: 12 Checks to Run Before Go-Live](https://connectmq.com/blog/mqtt-testing-checklist/): A go-live MQTT testing checklist with quick, repeatable tests for reconnects, QoS, retained messages, Last Will, payload validation, limits and load, all runnable against a free public broker.
- [MQTT Tenant Isolation: Keeping Customers' Data Separate](https://connectmq.com/blog/mqtt-tenant-isolation/): Learn the difference between logical and physical MQTT tenant isolation, how noisy-neighbor protection works, and how to pick the right isolation level for your customers.
- [Industry 4.0 Guide: Technologies, Architecture and First Steps](https://connectmq.com/blog/industry-4-0-guide/): A practical Industry 4.0 guide for engineers and plant leaders: what the core technologies are, how connectivity, data platforms and analytics fit together, and how to launch a first pilot on a managed MQTT broker.
- [ESP32 Certificate Pinning and CA Validation for MQTT](https://connectmq.com/blog/esp32-certificate-pinning/): Three ways to validate a broker certificate on an ESP32: embed a root CA, use the ESP-IDF certificate bundle, or pin. Learn the trade-offs and get working MQTT code for each.
- [Batch Process Monitoring with MQTT: Phases, Setpoints and Deviations](https://connectmq.com/blog/batch-process-monitoring/): Build a working batch process monitoring pipeline with MQTT. Publish batch phases and process values, compare them to recipe setpoints and record deviations in real time with Python.
- [UNS Topic Structure Examples for Manufacturers](https://connectmq.com/blog/uns-topic-structure/): Ready-to-use UNS topic structure examples for discrete manufacturing and process plants, with the naming rules, payload conventions and validation that keep a unified namespace usable as it grows.
- [Node-RED MySQL: Logging MQTT Data to MySQL or MariaDB with Parameterized Queries](https://connectmq.com/blog/node-red-mysql/): Store MQTT messages in MySQL or MariaDB from Node-RED the safe way. This tutorial covers the table design, parameterized inserts, batching for higher rates, retention, useful queries and the pitfalls that break most first attempts.
- [MQTT Shared Subscriptions: Load Balancing Message Consumers](https://connectmq.com/blog/mqtt-shared-subscriptions/): Shared subscriptions turn MQTT into a work queue: each message goes to one member of a consumer group. Learn the $share syntax, delivery semantics, scaling patterns and how to test support.
- [Energy Digital Twin: Modeling Consumption in Real Time](https://connectmq.com/blog/digital-twin-energy/): How to model a site's energy flows as a digital twin fed by meters streaming over MQTT, then use it to find waste and test efficiency scenarios before spending money.
- [Paho MQTT C Client Tutorial for Embedded Linux](https://connectmq.com/blog/paho-mqtt-c/): A practical Paho MQTT C tutorial for embedded Linux: build the library with OpenSSL, write a TLS publisher and subscriber, cross-compile for ARM, and run it reliably under systemd.
- [Flutter MQTT Client: Building a Cross-Platform IoT App](https://connectmq.com/blog/flutter-mqtt/): A hands-on Flutter MQTT tutorial using the mqtt_client package to connect Android, iOS, desktop and web builds to a cloud broker over TLS or secure WebSocket, read live sensor data and control a device.
- [Cycle Time Monitoring with IoT: From PLC Signals to Bottleneck Analysis](https://connectmq.com/blog/cycle-time-monitoring/): Measure every single cycle instead of sampling with a stopwatch. Capture cycle signals with an ESP32, publish them over MQTT and compute rolling statistics that reveal the real bottleneck of a line.
- [Beckhoff TwinCAT MQTT: Publishing Structured PLC Data to a Broker](https://connectmq.com/blog/beckhoff-twincat-mqtt/): Use TwinCAT 3 IoT functions to publish structured PLC data as JSON, verify it on a public broker and then connect to a private broker with TLS, credentials and a Last Will.
- [Secure IoT Device Provisioning for MQTT Fleets](https://connectmq.com/blog/secure-iot-device-provisioning/): How to get a unique, protected MQTT identity onto every device: factory provisioning, claim-certificate and bootstrap flows, per-device credentials and the steps to connect provisioned devices to a managed broker.
- [Next.js MQTT: Server and Client Integration Patterns That Actually Work](https://connectmq.com/blog/next-js-mqtt/): Learn the three ways to use MQTT in a Next.js App Router project: client components over secure WebSocket, server route handlers that publish with private credentials, and a Server-Sent Events bridge.
- [MQTT Receive Maximum: Flow Control for Slow Devices in MQTT 5](https://connectmq.com/blog/mqtt-receive-maximum/): Receive Maximum is MQTT 5's built-in flow control. It caps how many unacknowledged QoS 1 and 2 messages can be in flight, so slow devices are not overwhelmed after a reconnect.
- [MQTT Data Residency and Region Selection for IoT Messaging](https://connectmq.com/blog/mqtt-data-residency/): Where do your MQTT messages actually live? This guide explains data residency for IoT messaging, the regulatory questions to ask, and how region choice and BYOC address them.
- [MQTT Broker URL Format: mqtt://, mqtts://, ws:// and wss:// Explained](https://connectmq.com/blog/mqtt-broker-url/): An MQTT broker URL combines a scheme, host, port and sometimes a path. Learn what mqtt://, mqtts://, ws:// and wss:// mean and how each library expects them.
- [Choosing an MQTT Broker for Startups: Start Free, Scale Without Lock-In](https://connectmq.com/blog/mqtt-broker-for-startups/): Early-stage IoT teams need a broker that costs nothing on day one and does not trap them later. This guide covers what to choose, what to avoid and how to plan for growth.
- [Machine Status Monitoring with MQTT: Running, Idle and Down in Real Time](https://connectmq.com/blog/machine-status-monitoring/): Define a clean machine state model, derive running, idle and down from stack lights or PLC signals, and publish retained MQTT messages so every dashboard shows the current state the moment it connects.
- [LLM Function Calling IoT Tutorial: Strict JSON Schemas and Validated MQTT Commands](https://connectmq.com/blog/llm-function-calling-iot/): A tutorial on defining strict JSON schemas for device actions, validating every LLM tool call in code, asking the model to repair invalid calls and publishing only verified commands over MQTT 5.
- [Digital Model vs Digital Shadow vs Digital Twin: The Data Flow Explained](https://connectmq.com/blog/digital-twin-vs-digital-shadow/): The difference between a digital model, a digital shadow and a digital twin comes down to which way data flows. See each level mapped to concrete MQTT telemetry and command topics.
- [What Is a Managed MQTT Broker? Benefits, Costs and How to Choose](https://connectmq.com/blog/managed-mqtt-broker/): A managed MQTT broker lets you run IoT messaging without operating servers, certificates or patches yourself. Compare managed and self-hosted, pick a deployment model and connect your first client in five minutes.
- [Build a Sparkplug B Edge Node Simulator in Python](https://connectmq.com/blog/sparkplug-b-edge-node-simulator/): Testing a Sparkplug host or dashboard should not require a PLC. This tutorial builds a Python Sparkplug B edge node simulator with births, data, deaths and rebirth handling, running against a real MQTT broker.
- [Raspberry Pi DS18B20 MQTT: Publish Multiple 1-Wire Temperature Probes](https://connectmq.com/blog/raspberry-pi-ds18b20-mqtt/): Enable 1-Wire on a Raspberry Pi, connect several DS18B20 temperature probes to one GPIO pin, read them from Python without extra libraries and publish named, validated readings over MQTT.
- [Build an MQTT Device Simulator in Python for Hundreds of Virtual Sensors](https://connectmq.com/blog/mqtt-device-simulator/): A complete Python MQTT device simulator that models hundreds of virtual sensors with drift, noise, faults and dropouts, schedules them under broker rate limits and publishes to broker.connectmq.com.
- [MES MQTT Integration: Event-Driven Orders, Counts and Quality](https://connectmq.com/blog/mes-mqtt-integration/): Replace brittle point-to-point MES interfaces with an event-driven MQTT namespace. Learn the topic layout, payload contracts and a working adapter for orders, counts and quality results.
- [Java MQTT Client Tutorial: Eclipse Paho vs HiveMQ Client with TLS and MQTT 5](https://connectmq.com/blog/java-mqtt-client/): Compare the two main Java MQTT libraries, Eclipse Paho and the HiveMQ MQTT Client, and implement publish/subscribe over TLS with MQTT 5 using each of them.
- [Ignition MQTT: Connecting Transmission and Engine Modules to a Broker](https://connectmq.com/blog/ignition-mqtt/): Configure Ignition's MQTT Transmission and MQTT Engine modules against an external broker, publish tags as Sparkplug B, consume them back as Ignition tags, and verify the decoded payloads in a broker portal.
- [Fixing ESP32 Task Watchdog Resets in MQTT Projects](https://connectmq.com/blog/esp32-task-watchdog-mqtt/): Why ESP32 MQTT sketches trigger task watchdog resets, how to read the task_wdt message, and how to restructure reconnect loops, callbacks and blocking code so the watchdog stays quiet.
- [Designing Downtime Reason Codes That Operators Actually Use](https://connectmq.com/blog/downtime-reason-codes/): How to build a downtime reason code tree that stays short, specific and actionable, plus an operator input flow that publishes reasons over MQTT alongside automatically detected machine states.
- [Decode Sparkplug B Python Tutorial: Read Protobuf Payloads Step by Step](https://connectmq.com/blog/decode-sparkplug-b-python/): A complete Python tutorial for decoding Sparkplug B payloads: generate classes from sparkplug_b.proto, subscribe with paho-mqtt 2.x, resolve metric aliases from birth messages and handle signed integers correctly.
- [ArduinoMqttClient Library Guide: API, Polling, QoS and Will Messages](https://connectmq.com/blog/arduinomqttclient/): A complete guide to the official ArduinoMqttClient library: the connection API, why poll() matters, streaming publish and receive, QoS and retain flags, will messages and every connectError() code.
- [What Is TinyML? Machine Learning on Microcontrollers Explained](https://connectmq.com/blog/what-is-tinyml/): TinyML is machine learning on microcontrollers that run on milliwatts and kilobytes. This explainer covers the constraints, the frameworks, real use cases and why tiny devices publish compact inference results over MQTT.
- [Water Tank Level Sensor with ESP32 and MQTT: Percent Full and Low-Level Alerts](https://connectmq.com/blog/water-tank-level-sensor-esp32/): Measure tank level with a waterproof ultrasonic sensor, convert distance to litres and percent full on an ESP32, and publish retained MQTT readings plus debounced low-level alerts.
- [Sparkplug B Data Types and Metric Properties Reference](https://connectmq.com/blog/sparkplug-b-data-types/): A practical reference to every Sparkplug B data type, the Protobuf field each one travels in, metric properties such as Quality, metric flags and DataSets, with decoded examples and common conversion mistakes.
- [Online MQTT Web Client: Test Any Broker from Your Browser](https://connectmq.com/blog/mqtt-web-client-online/): A practical guide to testing MQTT from a browser: how web clients connect over WebSockets, a step-by-step session with the ConnectMQ portal client, a tiny MQTT.js client of your own and fixes for common connection errors.
- [All 15 MQTT Control Packet Types Explained](https://connectmq.com/blog/mqtt-control-packets/): MQTT has just 15 control packet types. This reference explains each one, from CONNECT to AUTH, with its type number, direction, first byte and what it looks like in debug logs while you troubleshoot.
- [ESP32 PIR Motion Sensor MQTT Alerts with Debounce and Last-Motion Time](https://connectmq.com/blog/esp32-pir-motion-sensor-mqtt/): Detect motion with an HC-SR501 or AM312 PIR on an ESP32, debounce noisy triggers, publish motion events over MQTT and keep a retained last-motion timestamp for dashboards and automations.
- [ESP32 Deep Sleep MQTT: Battery-Powered Sensors That Publish and Sleep](https://connectmq.com/blog/esp32-deep-sleep-mqtt/): Build a battery-friendly ESP32 sensor that wakes on a timer, connects quickly, publishes a retained reading, confirms it reached the broker and goes back to deep sleep.
- [Digital Twin Dashboard: Combining a 3D Scene with Live KPIs](https://connectmq.com/blog/digital-twin-dashboard/): Build a web digital twin dashboard where a Three.js scene, KPI cards, a trend chart and an alarm list share one MQTT connection and one state store, with click-to-focus navigation and stale-data handling.
- [Store and Forward MQTT: Buffering Edge Data During Outages and Replaying It in Order](https://connectmq.com/blog/store-and-forward-mqtt/): Network links fail, but industrial data should not disappear. Learn how store and forward works for MQTT edge devices, how to size the buffer, keep replay ordered and throttled, and build it with Python and SQLite.
- [Solar Inverter Monitoring over MQTT with SunSpec Modbus and Python](https://connectmq.com/blog/solar-inverter-monitoring/): Read live production data from your PV inverter over SunSpec Modbus TCP or a local API, publish power, daily energy and status to MQTT, and make solar data available to every dashboard and automation in the house.
- [Report by Exception (RBE) in MQTT Systems: Deadbands, Heartbeats and a Gateway Example](https://connectmq.com/blog/report-by-exception/): Report by exception publishes a value only when it changes meaningfully. Learn how deadbands, rate limits and heartbeats work together, and run a Python gateway that applies RBE before publishing to MQTT.
- [DIY MQTT Garage Door Opener with ESP32, Relay and Reed Switch](https://connectmq.com/blog/mqtt-garage-door-opener/): Turn your existing garage door motor into a smart one with an ESP32, a relay that presses the wall button for you, and a reed switch that reports the real door state as a retained MQTT message.
- [How to Build a Digital Twin in 7 Practical Steps](https://connectmq.com/blog/how-to-build-a-digital-twin/): A practical seven-step process for building your first digital twin: scope it, model the asset, design MQTT topics, stream live data, secure the broker, visualize it and add history.
- [Food and Beverage IoT: Temperature, CIP, Batch and Line Monitoring with MQTT](https://connectmq.com/blog/food-and-beverage-iot/): Food and beverage plants live on temperature, hygiene and throughput. See the IoT use cases that matter most, how to structure the MQTT data and what to watch out for in wet, regulated environments.
- [Enterprise MQTT Broker Requirements: A Practical Evaluation Guide](https://connectmq.com/blog/enterprise-mqtt-broker/): Enterprises evaluate MQTT brokers on isolation, deployment control, security, operations and support. This guide turns those expectations into a concrete checklist.
- [MQTT vs HTTP for IoT: Which Protocol Should You Use?](https://connectmq.com/blog/mqtt-vs-http/): A practical MQTT vs HTTP comparison for IoT covering message overhead, push versus polling, battery life and connection models, with a small benchmark you can run yourself.
- [MQTT DMZ Design: Placing MQTT in an Industrial DMZ](https://connectmq.com/blog/mqtt-dmz/): An MQTT DMZ lets plant data reach the cloud without opening a single inbound port to the OT network. This guide covers outbound-only patterns, DMZ bridge brokers, firewall rules and the mistakes that weaken the design.
- [MQTT Broker as a Service: What You Get and What You Don't](https://connectmq.com/blog/mqtt-broker-as-a-service/): An MQTT broker as a service removes server work, but not every responsibility. Here is a clear split between what the provider handles and what stays with you, with a practical integration pattern.
- [Mosquitto Bridge Configuration: Forward Local Topics to a Cloud Broker over TLS](https://connectmq.com/blog/mosquitto-bridge-configuration/): Configure a Mosquitto bridge on a Raspberry Pi that forwards selected local topics to a cloud MQTT broker over TLS, receives commands back, queues messages during outages and avoids message loops.
- [IIoT Data Modeling: From Flat Tags to Information Models](https://connectmq.com/blog/iiot-data-modeling/): A practical guide to IIoT data modeling: how to move from flat PLC tags to structured, reusable information models using ISA-95, Sparkplug B templates and OPC UA, published over MQTT.
- [Azure Digital Twins Alternatives: Managed, Open-Source and MQTT-Based Options](https://connectmq.com/blog/azure-digital-twins-alternative/): Azure Digital Twins is not the only way to model connected assets. Compare open-source platforms and lightweight stacks built on standard MQTT, and see how to model a twin graph without platform lock-in.
- [Android MQTT Kotlin Client: Connect, Subscribe and Notify](https://connectmq.com/blog/android-mqtt-kotlin/): Build an Android app in Kotlin that connects to an MQTT broker over TLS, subscribes to alarm topics, raises system notifications and reconnects correctly as the app moves between foreground and background.
- [Sparkplug Topic Namespace: spBv1.0, Group, Message Type, Node and Device](https://connectmq.com/blog/sparkplug-topic-namespace/): Every Sparkplug B message travels on a strictly defined topic. This guide breaks down spBv1.0, group ID, message type, edge node ID and device ID, with naming rules, wildcard patterns and common mistakes.
- [Paho MQTT Reconnect: Robust Backoff, Resubscribe and Offline Buffering in Python](https://connectmq.com/blog/paho-mqtt-reconnect/): Why paho-mqtt clients silently stop receiving or lose messages after a network drop, and a tested Python client that adds backoff with jitter, resubscription, an offline queue and persistent MQTT 5 sessions.
- [Build an MQTT Telegram Bot for Device Alerts and Commands](https://connectmq.com/blog/mqtt-telegram-bot/): Connect a Telegram bot to an MQTT broker with Python so alarms arrive in your chat and commands like /on, /off and /status travel back to devices, with a chat allowlist for safety.
- [Modbus RTU to MQTT Gateway with RS-485: Wiring, Settings and Code](https://connectmq.com/blog/modbus-rtu-to-mqtt/): Connect RS-485 Modbus RTU energy meters and sensors to a gateway that publishes their readings over MQTT. Covers wiring, termination, serial settings, register maps and a complete Python poller.
- [ESP32 MQTT Last Will: Reliable Online/Offline Status for Every Device](https://connectmq.com/blog/esp32-mqtt-last-will/): Configure a retained Last Will and Testament plus a birth message on the ESP32 so every dashboard and script can see device availability instantly, including after crashes, power cuts and Wi-Fi loss.
- [Building Automation System MQTT: How MQTT Fits Next to BACnet and KNX](https://connectmq.com/blog/building-automation-system-mqtt/): MQTT does not replace BACnet or KNX in a building, it sits above them. This guide shows the architecture, topic design and security choices for a multi-site building automation system with MQTT.
- [Telegraf json_v2 Parser and MQTT Topic Parsing Explained](https://connectmq.com/blog/telegraf-json-v2-parser/): How to turn real MQTT payloads into clean InfluxDB metrics with Telegraf: json_v2 fields, tags, renames and types for nested JSON, object parsing for arrays, and topic_parsing to extract site, line and machine from the topic.
- [Spring Boot MQTT Integration: Consume Device Data and Expose It via REST](https://connectmq.com/blog/spring-boot-mqtt/): Use Spring Integration's MQTT 5 adapters in Spring Boot to consume device telemetry over TLS, keep the latest readings in memory, expose them through REST and send commands back to devices.
- [Smart Manufacturing for SMB: A Budget-Friendly Roadmap for Small and Mid-Sized Plants](https://connectmq.com/blog/smart-manufacturing-for-smb/): You do not need an enterprise budget to run a data-driven plant. This roadmap shows small and mid-sized manufacturers how to start with a few sensors, a free managed MQTT broker and open-source tools, then grow in steps.
- [MQTT to REST API Flask Tutorial: Expose Live Device Data over HTTP](https://connectmq.com/blog/mqtt-to-rest-api-flask/): Build a Flask app that subscribes to MQTT topics, caches the latest value per device, serves it through REST endpoints and publishes commands from a POST route, with the deployment pitfalls that break most first attempts.
- [MQTT Penetration Testing: A Practical Methodology for Your Own Brokers](https://connectmq.com/blog/mqtt-penetration-testing/): A structured, defensive approach to MQTT penetration testing: how to scope a test of your own broker, what to check at each layer and how to turn findings into hardening work.
- [MQTT Data Historian: Capturing Industrial Time Series](https://connectmq.com/blog/mqtt-historian/): An MQTT historian subscribes to your plant topics and stores every value as time series. This guide compares InfluxDB, TimescaleDB and commercial historians and shows working Telegraf and Python setups.
- [Asset Administration Shell (AAS) Explained: Submodels, Types and Live MQTT Data](https://connectmq.com/blog/asset-administration-shell/): The Asset Administration Shell is the Industry 4.0 standard for describing industrial assets as digital twins. Learn its structure, the three AAS types, and a practical pattern for feeding live submodel values from MQTT.
- [Sparkplug B and the Unified Namespace: Structuring Industrial IoT Data on MQTT](https://connectmq.com/blog/mqtt-sparkplug-b-unified-namespace/): Sparkplug B gives industrial MQTT a strict session and payload model, while a Unified Namespace gives your plant data a single, readable home. Here is how they fit together, with topic design tips and live examples.
- [WS2812B MQTT: Control an Addressable LED Strip with JSON Commands](https://connectmq.com/blog/ws2812b-mqtt/): Drive a WS2812B addressable LED strip from an ESP32 with JSON MQTT commands for color, brightness and effects, and publish retained state so every dashboard stays in sync.
- [Tool Wear Monitoring with Spindle Power, Vibration and MQTT](https://connectmq.com/blog/tool-wear-monitoring/): Use spindle power and vibration published over MQTT to build a per-tool wear index, compare every cut with the fresh-tool baseline and change tools based on condition instead of a fixed part count.
- [Serverless MQTT Broker: How It Works and When to Use It](https://connectmq.com/blog/serverless-mqtt-broker/): A serverless MQTT broker gives you a ready endpoint on a shared, multi-tenant cluster with no servers to manage. Learn how it works, its limits, and when it is the right fit.
- [MQTTnet C# Tutorial: Build MQTT 5 Clients in .NET with TLS](https://connectmq.com/blog/mqttnet/): Build a .NET console publisher and subscriber with MQTTnet, MQTT 5 properties and TLS on port 8883, then add reconnect logic and move the same code to a private ConnectMQ broker.
- [MQTT vs Kafka: Device Messaging vs Event Streaming](https://connectmq.com/blog/mqtt-vs-kafka/): MQTT and Kafka are not competitors so much as neighbors. This guide explains what each one is built for, compares them side by side and shows how to feed Kafka from an MQTT broker with an external consumer service.
- [MQTT vs AMQP: Differences, Use Cases and Performance](https://connectmq.com/blog/mqtt-vs-amqp/): MQTT and AMQP are both brokered messaging protocols, but they solve different problems. This comparison covers routing, delivery guarantees, footprint and typical architectures so you can pick with confidence.
- [MQTT Broker for Students and Classrooms: Running IoT Labs Without Servers](https://connectmq.com/blog/mqtt-broker-for-students/): A practical guide for teachers and students: use a public broker for live demos, give each team an isolated free broker for graded work, and avoid the classic classroom pitfalls.
- [IoT MLOps: Monitoring Machine Learning Models in the Field over MQTT](https://connectmq.com/blog/iot-mlops/): Models deployed on edge devices degrade quietly. This guide shows how to publish inference metrics over MQTT, measure drift centrally and raise alerts when a field model needs attention.
- [ESP32-CAM MQTT: Capture JPEG Snapshots and Publish Them as Binary Payloads](https://connectmq.com/blog/esp32-cam-mqtt/): Turn an AI-Thinker ESP32-CAM into an MQTT camera that publishes JPEG snapshots on demand or on a timer, stays inside broker message limits and saves every frame with a small Python subscriber.
- [Alarm Management Manufacturing Guide: Floods, Priorities and ISA-18.2 Basics](https://connectmq.com/blog/alarm-management-manufacturing/): Too many alarms are as dangerous as too few. Learn why alarm floods happen, how ISA-18.2 structures alarm management, how to prioritize and how to publish clean alarm events over MQTT.
- [What Is an MQTT Broker? A Beginner's Guide to Publish/Subscribe Messaging](https://connectmq.com/blog/what-is-an-mqtt-broker/): An MQTT broker is the hub that routes every message between IoT devices and apps. Learn publish/subscribe, topics and wildcards, sessions, QoS, retained messages and last will, then try it hands-on in minutes.
- [Smart Manufacturing Guide: From Connected Machines to Data-Driven Plants](https://connectmq.com/blog/smart-manufacturing-guide/): Learn how connected machines, an MQTT data backbone and a clear topic namespace turn a traditional plant into a data-driven one, with a step-by-step roadmap and working Python examples.
- [MQTT Session Expiry Interval and Clean Start in MQTT 5 Explained](https://connectmq.com/blog/mqtt-session-expiry-interval/): MQTT 5 split the old clean session flag into Clean Start and Session Expiry Interval. Here is how the two combine, which values to choose and how to verify them on a live broker.
- [Industrial Time Series Data: Sampling, Compression and Storage](https://connectmq.com/blog/industrial-time-series-data/): How to sample, compress, timestamp and store industrial time series data flowing over MQTT, with deadband code, a Telegraf config and a storage decision table.
- [Conveyor Digital Twin Tutorial: Live Speed and Jam Detection with MQTT](https://connectmq.com/blog/conveyor-digital-twin/): Build a browser-based conveyor digital twin whose rollers and parcels move at the real belt speed from MQTT, highlights jams, counts throughput and sends start, stop and reset commands back to the line.
- [Compressed Air Leak Monitoring with IoT Flow and Pressure Sensors](https://connectmq.com/blog/compressed-air-leak-monitoring/): Leaks run around the clock, even when the plant is idle. Learn how to quantify them with flow and pressure sensors, MQTT telemetry and an off-shift baseline that turns a hidden cost into a tracked number.
- [Streamlit MQTT Dashboard in Pure Python: Live Sensor Charts in 100 Lines](https://connectmq.com/blog/streamlit-mqtt-dashboard/): Build a live Streamlit dashboard fed by a background paho-mqtt subscriber connected to broker.connectmq.com, with a thread-safe buffer, auto-refreshing charts and a simulator to feed it.
- [Raspberry Pi Kiosk Dashboard for Live MQTT Data over WebSocket](https://connectmq.com/blog/raspberry-pi-kiosk-dashboard/): Turn a Raspberry Pi and any HDMI screen into a wall-mounted dashboard. A single HTML page subscribes to MQTT over secure WebSocket, and Chromium starts full screen in kiosk mode on every boot.
- [Raspberry Pi DHT22 MQTT: Reliable Temperature and Humidity Publishing with Python](https://connectmq.com/blog/raspberry-pi-dht22-mqtt/): Wire a DHT22 to a Raspberry Pi, read it with Python, and publish validated temperature and humidity JSON over MQTT with retries, median filtering and error counters that keep bad readings out of your dashboards.
- [Node-RED Context Storage: Flow, Global and Persistent](https://connectmq.com/blog/node-red-context/): Node-RED context lets flows remember things between messages. This explainer covers the three scopes, memory versus file storage, multiple stores, async access and a practical pattern for keeping the latest MQTT value per device.
- [MQTT Topic Hierarchy Examples for Real IoT Projects](https://connectmq.com/blog/mqtt-topic-hierarchy-examples/): Ready-to-copy MQTT topic trees for smart home, fleet tracking, factory and energy monitoring projects, each with the wildcard subscriptions it is designed for and the mistakes to avoid.
- [MQTT Topic Browser: How to Explore and Debug Live Topic Trees](https://connectmq.com/blog/mqtt-topic-browser/): A hands-on guide to MQTT topic browsers: generate a realistic topic tree, explore it in the ConnectMQ live topic explorer, and use what you see to fix naming, retained-message and payload problems.
- [MQTT Load Testing Tools: emqtt-bench, MQTTX Bench and Locust Compared](https://connectmq.com/blog/mqtt-load-testing-tools/): A practical comparison of emqtt-bench, MQTTX Bench and Locust for MQTT load testing, with real commands, a latency and loss probe in Python, the metrics worth collecting and the rules for testing responsibly against a private broker.
- [MQTT Device Online/Offline Status with LWT and Retained Messages](https://connectmq.com/blog/mqtt-device-online-status/): A step-by-step presence pattern for MQTT fleets: retained birth messages, a retained Last Will, graceful shutdown messages and a monitor that tracks every device's state in real time.
- [Factory Digital Twin: Use Cases and Architecture](https://connectmq.com/blog/factory-digital-twin/): A practical guide to factory digital twin use cases and architecture, showing how line-level and plant-level twins are fed by ISA-95 structured MQTT data.
- [ESP32 Digital Twin: A Beginner Project with MQTT and a 3D Browser Model](https://connectmq.com/blog/esp32-digital-twin/): A beginner-friendly ESP32 digital twin: the board publishes a potentiometer, a button and an LED state over MQTT, a Three.js model in the browser mirrors them in real time, and clicking the 3D LED switches the real one.
- [ESP32 MQTT Tutorial: Publish Sensor Data and Control an LED with Arduino IDE](https://connectmq.com/blog/esp32-mqtt-tutorial/): Connect an ESP32 to an MQTT broker with Arduino IDE and PubSubClient, publish JSON temperature readings, control the onboard LED from the command line and upgrade to TLS with portal credentials.
- [Sparkplug Metric Aliases: Saving Bandwidth in DATA Messages](https://connectmq.com/blog/sparkplug-metric-aliases/): Sparkplug metric aliases replace long metric names with small integers in DATA messages. This guide explains how the mapping works, when to use it, and how to debug alias mismatches.
- [10 Raspberry Pi 5 IoT Projects with MQTT (From Sensor Hubs to AI Cameras)](https://connectmq.com/blog/raspberry-pi-5-iot-projects/): Ten practical Raspberry Pi 5 IoT projects that use MQTT for messaging, with the hardware, topic layout and starting code for each, from a home sensor hub to an AI camera and a factory gateway.
- [Python MQTT TLS: Connecting Securely on Port 8883 with paho-mqtt](https://connectmq.com/blog/python-mqtt-tls/): Encrypt your Python MQTT traffic with paho-mqtt and TLS on port 8883: use the system CA store, keep hostname verification on, fix the common certificate errors, and connect over secure WebSocket when only 443-style ports are open.
- [Power Quality Monitoring in Manufacturing: Harmonics, Sags and Power Factor over MQTT](https://connectmq.com/blog/power-quality-monitoring/): Unexplained drive trips, hot transformers and power factor penalties all trace back to power quality. Learn what to measure, how analyzers report it and how to stream summaries and events over MQTT.
- [Node-RED Subflows for Reusable MQTT Logic](https://connectmq.com/blog/node-red-subflows/): Node-RED subflows turn repeated groups of nodes into one reusable node. This explainer shows how to build an MQTT alert subflow with instance properties, status reporting and error handling, and how to reuse it across many topics.
- [Node-RED S7: Read Siemens PLC Variables and Publish to MQTT](https://connectmq.com/blog/node-red-s7/): Connect Node-RED to a Siemens S7 PLC with node-red-contrib-s7: enable PUT/GET in TIA Portal, address data block variables correctly, publish changes to MQTT and handle setpoint writes safely.
- [MQTT OT Security: Protecting Industrial Plants When Sending Data to the Cloud](https://connectmq.com/blog/mqtt-ot-security/): How to move data from PLCs and machines to a cloud MQTT broker without opening the plant network: outbound-only design, DMZ patterns, segmentation, credentials and monitoring.
- [Build a Real-Time MQTT Chat App with JavaScript, Presence and No Local](https://connectmq.com/blog/mqtt-chat-app/): Build a browser chat app on MQTT over secure WebSocket, with rooms, retained presence that survives crashes via Last Will, and the MQTT 5 No Local option, running on broker.connectmq.com.
- [MQTT Broker Monitoring: The Metrics That Matter and How to Watch Them](https://connectmq.com/blog/mqtt-broker-monitoring/): Learn which MQTT broker metrics actually predict trouble, how to alert on them without noise, how to build an end-to-end latency probe, and how to watch your broker in the ConnectMQ portal.
- [Motor Current Monitoring with CT Clamps and MQTT for Early Fault Detection](https://connectmq.com/blog/motor-current-monitoring/): Clip a CT clamp around a motor lead, measure RMS current with an ESP32, publish it over MQTT and use a small Python service to detect overloads, frequent starts and drift away from normal load.
- [mosquitto_pub mosquitto_sub Examples: 25 Practical Commands for MQTT Testing](https://connectmq.com/blog/mosquitto-pub-mosquitto-sub-examples/): A copy-paste reference of 25 mosquitto_pub and mosquitto_sub commands covering QoS, retained messages, Last Will, TLS, output formatting and MQTT 5 properties, all runnable against broker.connectmq.com.
- [IT/OT Convergence Explained: Culture, Architecture and a Shared Data Layer](https://connectmq.com/blog/it-ot-convergence/): IT OT convergence is less about merging networks and more about giving two very different teams the same trustworthy data. This explainer covers the cultural gap, the technical building blocks and a practical shared-namespace pattern built on MQTT.
- [Structuring an ISA-95 Digital Twin with the Equipment Hierarchy](https://connectmq.com/blog/isa-95-digital-twin/): A guide to using the ISA-95 equipment hierarchy to organize digital twin models and MQTT topics, including Sparkplug B republishing, naming rules and a validation script.
- [Industrial AI Copilot for Operators: Grounding Answers in Live ISA-95 Data](https://connectmq.com/blog/industrial-ai-copilot/): An industrial AI copilot is only as good as the data it can see. This guide shows how to ground an operator assistant in live, ISA-95 structured MQTT topics so its answers are current, traceable and safe.
- [Raspberry Pi Zero 2 W MQTT Sensor Node: Compact, Low-Power and Reliable](https://connectmq.com/blog/raspberry-pi-zero-2-w-mqtt/): Build a small, headless Raspberry Pi Zero 2 W sensor node that reads a BME280, publishes environment and health data over MQTT 5, uses less power and survives months of unattended operation.
- [Raspberry Pi Power Monitor with MQTT: Measure Voltage, Current and Energy](https://connectmq.com/blog/raspberry-pi-power-monitor/): Measure voltage, current, power and accumulated energy with a Raspberry Pi and an INA219, publish the readings as JSON over MQTT, and learn when to use a CT clamp HAT for AC mains circuits instead.
- [MQTT vs NATS: Choosing a Messaging System for IoT](https://connectmq.com/blog/mqtt-vs-nats/): MQTT and NATS are both lightweight publish/subscribe systems, but they target different clients. This comparison covers device support, delivery guarantees, persistence and ecosystem so you can place each one correctly.
- [MQTT Username and Password Authentication Explained](https://connectmq.com/blog/mqtt-username-password-authentication/): How usernames and passwords travel in the MQTT CONNECT packet, why they must always be paired with TLS, how brokers reject bad credentials and how to manage per-device credentials on a managed broker.
- [MQTT Rate Limiting and DoS Protection Explained](https://connectmq.com/blog/mqtt-rate-limiting/): How MQTT brokers defend against connection floods, publish storms and oversized payloads, what limits a managed broker applies, and how to write clients that respect them.
- [iOS MQTT Swift Client with CocoaMQTT and SwiftUI](https://connectmq.com/blog/ios-mqtt-swift/): Step-by-step iOS MQTT Swift tutorial: add CocoaMQTT with Swift Package Manager, wrap it in an ObservableObject, show live sensor data in SwiftUI and publish commands over TLS.
- [Homebridge MQTT: Bringing MQTT Devices into Apple Home](https://connectmq.com/blog/homebridge-mqtt/): Expose MQTT sensors, switches and lights as HomeKit accessories with Homebridge and the mqttthing plugin, including JSON payloads, TLS credentials and a sensible topic layout.
- [Home Battery Monitoring with MQTT: State of Charge, Cell Voltages and Low-Battery Alerts](https://connectmq.com/blog/home-battery-monitoring/): Publish BMS data such as state of charge, pack voltage, current, cell voltage spread and temperature to an MQTT broker, then add low-battery and imbalance alerts with hysteresis so you hear about problems before the inverter shuts down.
- [Wind Turbine Digital Twin: Load, Yield and Maintenance with MQTT](https://connectmq.com/blog/wind-turbine-digital-twin/): How wind turbine digital twins use SCADA data published over MQTT to monitor yield against the power curve, estimate loads and plan maintenance, with topic design and code.
- [Predictive Maintenance with Machine Learning: Features, Labels and Models](https://connectmq.com/blog/predictive-maintenance-machine-learning/): A practical guide to predictive maintenance machine learning: which condition data to collect over MQTT, how to engineer features and labels, which models to start with, and how to validate them honestly.
- [Designing IoT Clients to Survive an MQTT Broker Outage](https://connectmq.com/blog/mqtt-broker-outage/): Every broker restarts eventually. Learn the client-side patterns that turn an MQTT broker outage into a non-event: jittered reconnects, offline buffering, Last Will status, session handling and idempotent commands.
- [MQTT Broker High Availability: Concepts, Client Design and Questions to Ask](https://connectmq.com/blog/mqtt-broker-high-availability/): High availability for MQTT is a shared responsibility between broker and clients. Learn the core concepts, the failover behavior to expect, how to design resilient clients, and the questions to ask any provider.
- [Industry 4.0 Technologies: The 9 Pillars Explained](https://connectmq.com/blog/industry-4-0-technologies/): The nine pillars of Industry 4.0 are often presented as separate technologies. This explainer walks through each one in plain terms and shows how a shared MQTT messaging layer is what actually connects them on a real plant floor.
- [Home Assistant MQTT Discovery: Auto-Create Entities for Custom Devices](https://connectmq.com/blog/home-assistant-mqtt-discovery/): Publish discovery config payloads so your own sensors and switches show up in Home Assistant as a complete device, with availability, unique IDs and clean removal, using a Python device simulator.
- [Device Shadow vs Digital Twin: Differences, Use Cases and an MQTT Shadow Pattern](https://connectmq.com/blog/device-shadow-vs-digital-twin/): Device shadows and digital twins are often confused. Learn how they differ in scope, data and purpose, when each one is enough, and how to build a portable device shadow with retained MQTT topics.
- [MQTT QoS Levels Explained: QoS 0, 1 and 2 with Packet Flows and Examples](https://connectmq.com/blog/mqtt-qos-levels-explained/): A practical guide to MQTT QoS: how QoS 0, 1 and 2 work on the wire, why the delivered QoS can be lower than you asked for, how sessions queue messages and which level to choose for each use case.
- [Smart Plug MQTT Energy Monitoring: Collect Power Data and Graph Daily Consumption](https://connectmq.com/blog/smart-plug-mqtt/): Collect power and energy readings from MQTT-capable smart plugs, store them in SQLite with a small Python subscriber, and turn them into daily kWh charts per appliance that survive plug reboots and counter resets.
- [Smart Home MQTT Topic Structure: Best Practices for Rooms, Devices and Commands](https://connectmq.com/blog/smart-home-mqtt-topic-structure/): A clean topic layout makes every smart home automation easier. Learn a room/device/property scheme, how to separate command and state topics, when to retain, and which naming mistakes to avoid.
- [Rust MQTT with rumqttc: Async Publish/Subscribe over TLS with Tokio](https://connectmq.com/blog/rust-mqtt-rumqttc/): Build an async Rust MQTT client with rumqttc and Tokio that connects over TLS with rustls, publishes JSON telemetry, receives commands and recovers from network errors.
- [Ruby MQTT Client Tutorial: Publish, Subscribe and TLS with the mqtt Gem](https://connectmq.com/blog/ruby-mqtt-client/): A practical Ruby MQTT client tutorial using the mqtt gem: publish and subscribe, verified TLS, a reconnecting subscriber loop, and patterns for publishing from Rails and running a worker alongside it.
- [PROFINET to MQTT: Gateway Options for Getting Fieldbus Data to the Cloud](https://connectmq.com/blog/profinet-to-mqtt/): PROFINET IO is cyclic, real-time and controller-centric, so you cannot simply poll it like Modbus. Compare the practical ways to get PROFINET data into MQTT, with a working example that reads a Siemens PLC and publishes to a broker.
- [OPC UA to MQTT Gateway: Bridging PLC Data to the Cloud](https://connectmq.com/blog/opc-ua-to-mqtt-gateway/): Build a small, open-source OPC UA to MQTT gateway that subscribes to PLC tags, maps them to ISA-95 style topics and publishes them to a cloud MQTT broker over TLS.
- [Node-RED Telegram Bot for MQTT Devices: Alerts, Status Queries and Remote Commands](https://connectmq.com/blog/node-red-telegram/): Turn Telegram into a pocket control panel for your MQTT devices. This tutorial builds a Node-RED Telegram bot that forwards alerts, answers /status, switches a relay with /on and /off, and only listens to approved chat IDs.
- [Node-RED Projects with Git Version Control](https://connectmq.com/blog/node-red-projects/): Node-RED projects turn your flows into a git repository. This tutorial shows how to enable projects mode, create and clone projects, commit and push changes, and keep MQTT broker credentials encrypted and out of version control.
- [MTBF and MTTR Calculation: Formulas, Examples and Automatic Tracking with MQTT](https://connectmq.com/blog/mtbf-mttr-calculation/): Learn the MTBF and MTTR formulas, work through a full example, avoid the common definition traps and calculate both metrics automatically from failure and repair events published over MQTT.
- [MQTT Tutorial: The Complete Beginner's Guide to MQTT](https://connectmq.com/blog/mqtt-tutorial/): A hands-on MQTT tutorial for beginners: learn brokers, topics, QoS, retained messages and Last Will, then publish and subscribe for real on the free broker.connectmq.com with the CLI, Python and JavaScript.
- [MQTT Prototype to Production: A Step-by-Step Migration Path](https://connectmq.com/blog/mqtt-prototype-to-production/): A prototype on a public broker proves the idea. This guide takes it through credentials, TLS, topic namespacing, presence tracking and monitoring so it is ready for real users.
- [How to Build a Manufacturing Traceability System with MQTT Events](https://connectmq.com/blog/manufacturing-traceability-system/): Design the events, topics and database for a manufacturing traceability system: serial numbers, component genealogy, process parameters and station results flow over MQTT into a database you can query in minutes.
- [IoT Platform vs MQTT Broker: Do You Need Both?](https://connectmq.com/blog/iot-platform-vs-mqtt-broker/): An MQTT broker moves messages; an IoT platform adds device management, storage, rules and dashboards around it. Learn what each layer does, when you need a full platform, and when a lean broker plus a few open tools is enough.
- [ESP32-C6 MQTT Tutorial: Wi-Fi 6 Board to Cloud Broker in Arduino](https://connectmq.com/blog/esp32-c6-mqtt/): Get an ESP32-C6 publishing to broker.connectmq.com with Arduino core 3.x, control its RGB LED from the command line and understand the differences from the classic dual-core ESP32.
- [Zero Trust IoT: Applying Zero Trust Principles to MQTT Messaging](https://connectmq.com/blog/zero-trust-iot/): Zero trust for IoT means no device or network is trusted by default. Learn how to apply identity, least privilege, encryption and continuous verification to MQTT messaging.
- [SIM7600 MQTT: Publish from an ESP32 over 4G LTE with TinyGSM](https://connectmq.com/blog/sim7600-mqtt/): Connect an ESP32 to an MQTT broker over 4G LTE with a SIM7600 modem, TinyGSM and PubSubClient, recover from network drops and keep cellular data usage and costs under control.
- [MQTT Persistent Session and the Clean Session Flag Explained](https://connectmq.com/blog/mqtt-persistent-session/): A persistent session lets a broker remember a client's subscriptions and queue its QoS 1 and 2 messages while it is offline. Learn what is stored, when to use it and the pitfalls to avoid.
- [Exploring MQTT Data in a Jupyter Notebook: Subscribe, Plot and Save Snapshots](https://connectmq.com/blog/mqtt-jupyter-notebook/): A cell-by-cell guide to exploring MQTT data in Jupyter: connect paho-mqtt in the background, inspect raw payloads, plot live charts, save snapshots and avoid the duplicate-client trap when re-running cells.
- [MQTT in the Browser with JavaScript: A Minimal Client in One HTML Page](https://connectmq.com/blog/mqtt-javascript-browser/): Build a single HTML page that connects to broker.connectmq.com over secure WebSocket, subscribes, publishes and shows live messages using MQTT.js, with no build step and no backend.
- [How to Run an IIoT Proof of Concept in 30 Days](https://connectmq.com/blog/iiot-proof-of-concept/): Most IIoT pilots fail from too much scope, not too little technology. This 30-day IIoT proof of concept plan covers scope, success metrics, a lightweight stack and a week-by-week schedule you can follow on your own plant floor.
- [IIoT Connectivity Checklist for Plant Engineers](https://connectmq.com/blog/iiot-connectivity-checklist/): A practical IIoT connectivity checklist for plant engineers, covering network access, protocols, data modeling, security and broker selection, with real commands to verify each step before the first machine goes live.
- [Smart Agriculture IoT with MQTT: Sensors, Connectivity and Architecture](https://connectmq.com/blog/smart-agriculture-iot/): A practical guide to smart agriculture IoT: which sensors matter, how to connect fields without Wi-Fi, how to structure MQTT topics for a farm, and how to keep the system running through seasons.
- [Sensor Data Outlier Detection with Z-Score, IQR and EWMA](https://connectmq.com/blog/sensor-data-outlier-detection/): Three simple, explainable methods for finding outliers in sensor streams, with Python implementations you can run against a live MQTT temperature feed and guidance on when each one fails.
- [Home Assistant MQTT Automation: Triggers, Templates and Publish Actions](https://connectmq.com/blog/home-assistant-mqtt-automation/): Trigger Home Assistant automations from raw MQTT messages, filter them with templates and wildcards, and publish commands back to devices with the mqtt.publish action.
- [HiveMQ Cloud Alternative: A Fair Framework for Comparing Managed MQTT Brokers](https://connectmq.com/blog/hivemq-cloud-alternative/): A neutral framework for comparing managed MQTT services: what to check for protocol support, limits, industrial features, tooling and portability, plus a test script that runs unchanged against any standards-based broker.
- [Three.js Digital Twin: Live 3D Visualization with MQTT](https://connectmq.com/blog/three-js-digital-twin/): Build a browser-based Three.js digital twin of a tank and a motor that reacts to live MQTT telemetry over secure WebSocket, with a Node.js simulator, smooth interpolation and production tips.
- [Smart City IoT Architecture with MQTT: Lighting, Waste, Air Quality and the Messaging Layer](https://connectmq.com/blog/smart-city-iot/): City-scale sensor networks succeed or fail on their messaging layer. Learn how lighting, waste and air quality systems share one MQTT backbone with clean topics, gateways, security and room to grow.
- [Node-RED vs Home Assistant Automations: Which to Use, and How to Run Both on One MQTT Broker](https://connectmq.com/blog/node-red-vs-home-assistant/): Home Assistant and Node-RED both automate devices, but they think differently. This comparison covers automation style, MQTT integration, debugging and maintenance, and shows a clean way to run both against one shared MQTT broker.
- [MQTT for Water and Wastewater Utilities Telemetry](https://connectmq.com/blog/mqtt-water-utilities/): How water and wastewater utilities use MQTT to bring pump stations, reservoirs and lift stations into one telemetry layer, with topic design, report by exception, threshold alerts and a runnable station simulator.
- [MQTT Vendor Lock-In: How to Keep Your Devices Portable With Standard MQTT](https://connectmq.com/blog/mqtt-vendor-lock-in/): MQTT is an open standard, yet IoT projects still get locked in. The cause is rarely the protocol; it is reserved topics, proprietary auth, vendor SDKs and logic that lives inside one platform. Here is how to stay portable.
- [MQTT TLS Configuration: A Practical Guide to Port 8883](https://connectmq.com/blog/mqtt-tls-configuration/): Learn how MQTT TLS really works, what clients must verify, and how to configure Python, Node.js, ESP32 and mosquitto clients for an encrypted connection on port 8883.
- [The MQTT Publish Subscribe Model: Decoupling Devices and Apps](https://connectmq.com/blog/mqtt-publish-subscribe-model/): The MQTT publish subscribe model lets devices and apps exchange data without knowing about each other. Learn the three kinds of decoupling and try them live with two clients on broker.connectmq.com.
- [Running an MQTT Broker on Kubernetes vs Using a Managed Service](https://connectmq.com/blog/mqtt-broker-kubernetes/): A practical comparison of running an MQTT broker on Kubernetes versus using a managed service, with a working manifest, the operational pitfalls of long-lived connections, and a cost-driver breakdown.
- [EtherNet/IP to MQTT: Reading CIP Devices and Logix Tags with Python](https://connectmq.com/blog/ethernet-ip-to-mqtt/): Use open-source CIP libraries on an edge gateway to read ControlLogix and CompactLogix tags and generic EtherNet/IP device attributes, then publish them as clean MQTT messages.
- [ESP32 DHT22 MQTT: Publish Temperature and Humidity as JSON](https://connectmq.com/blog/esp32-dht22-mqtt/): Wire a DHT22 to an ESP32, read temperature and humidity reliably, publish JSON to broker.connectmq.com and view the live readings in the ConnectMQ topic explorer.
- [Digital Twin Predictive Maintenance: Forecasting Failures with Live Data](https://connectmq.com/blog/digital-twin-predictive-maintenance/): How digital twins combine live condition data streamed over MQTT with physics and data-driven models to forecast failures, with a working Python example and rollout checklist.
- [Tasmota MQTT TLS: Connect an ESP32 Tasmota Device to a Broker on Port 8883](https://connectmq.com/blog/tasmota-mqtt-tls/): Learn which Tasmota builds include TLS, how SetOption103 and SetOption132 work, and how to connect an ESP32 Tasmota device to an encrypted MQTT broker on port 8883.
- [15 Smart Factory KPIs to Track in Real Time (and the Data Behind Each)](https://connectmq.com/blog/smart-factory-kpis/): OEE, MTBF, first pass yield, energy per unit and more: a practical list of 15 smart factory KPIs with formulas, the raw machine data each requires and how to compute them live from MQTT events.
- [Self-Signed Certificate MQTT Setup: When and How to Use One](https://connectmq.com/blog/self-signed-certificate-mqtt/): A hands-on tutorial for building a private certificate authority with OpenSSL, securing a lab Mosquitto broker on port 8883 and connecting clients, plus the operational costs that make public certificates easier in production.
- [Public vs Private MQTT Broker: Which One Fits Your Project?](https://connectmq.com/blog/public-vs-private-mqtt-broker/): Public test brokers are perfect for learning and demos; private brokers are where real devices belong. Learn the practical differences and how to move from one to the other without rewriting your clients.
- [OPC UA vs MQTT: Which Industrial Protocol Should You Use?](https://connectmq.com/blog/opc-ua-vs-mqtt/): OPC UA and MQTT are often framed as rivals, but they solve different problems. Compare information modeling, communication patterns, security and cloud connectivity, and learn the architecture most plants end up with.
- [MQTT vs WebSocket: Protocol or Transport?](https://connectmq.com/blog/mqtt-vs-websocket/): WebSocket and MQTT are often compared, but one is a transport and the other a messaging protocol. Learn what raw WebSocket apps must build themselves and how to run MQTT over secure WebSocket in the browser.
- [MQTT Topic Alias: Saving Bandwidth on Long Topic Names](https://connectmq.com/blog/mqtt-topic-alias/): MQTT 5 topic aliases replace long topic names with a two-byte number after the first publish. Learn how the negotiation works, how many bytes you actually save and how to use aliases safely from MQTT.js.
- [MQTT Email Alerts Python Tutorial: Rate-Limited SMTP Notifications](https://connectmq.com/blog/mqtt-email-alerts-python/): Build a Python service that subscribes to MQTT alarm and telemetry topics, applies thresholds with hysteresis and cooldowns, and sends rate-limited SMTP emails, then see how it complements ConnectMQ's built-in alert rules.
- [Handling Duplicate MQTT Messages with QoS 1](https://connectmq.com/blog/mqtt-duplicate-messages/): QoS 1 means at least once, and sometimes that means twice. Learn why MQTT duplicate messages happen, why the DUP flag alone cannot save you, and how to build idempotent consumers that handle them safely.
- [Digital Twin Technology: The Complete Guide to Concepts, Architecture and Real-Time Data](https://connectmq.com/blog/digital-twin-technology/): A practical guide to digital twin technology: what a twin really is, the main types, a reference architecture, and how to feed a live 3D model with real-time MQTT data.
- [AI HVAC Optimization: Smarter Setpoints and Schedules with MQTT Data](https://connectmq.com/blog/ai-hvac-optimization/): A practical use case for AI HVAC optimization: which building data to collect over MQTT, how to learn a zone's thermal response, how to compute optimal start times and setpoints, and how to apply recommendations safely.

## Español (es)

- [ConnectMQ — Broker MQTT gestionado para IoT](https://connectmq.com/es/)
- [Plataforma de broker MQTT gestionado](https://connectmq.com/es/plataforma/)
- [Panel MQTT y monitorización de topics](https://connectmq.com/es/monitorizacion/)
- [Reglas y alertas MQTT](https://connectmq.com/es/reglas-y-alertas/)
- [Gemelo digital 3D con datos MQTT en vivo](https://connectmq.com/es/gemelo-digital/)
- [Conectividad MQTT: TCP, TLS, WebSockets y MQTT 5](https://connectmq.com/es/conectividad/)
- [Seguridad MQTT: TLS, autenticación y control de acceso](https://connectmq.com/es/seguridad/)
- [Soluciones MQTT para IoT, hogar, flotas y energía](https://connectmq.com/es/soluciones/)
- [Broker MQTT para IoT industrial y fabricación inteligente](https://connectmq.com/es/iot-industrial/)
- [Broker MQTT para hogar inteligente y Home Assistant](https://connectmq.com/es/hogar-inteligente/)
- [Broker MQTT para telemática de flotas y cadena de frío](https://connectmq.com/es/flotas-y-logistica/)
- [Broker MQTT para energía inteligente y recarga de VE](https://connectmq.com/es/energia-y-servicios-publicos/)
- [Broker MQTT para productos conectados y hardware](https://connectmq.com/es/productos-conectados/)
- [Broker MQTT para flotas de robots e IA física](https://connectmq.com/es/robotica/)
- [MQTT para energía y refrigeración en centros de datos](https://connectmq.com/es/centros-de-datos/)
- [Broker MQTT para ciudades inteligentes y alumbrado](https://connectmq.com/es/ciudades-inteligentes/)
- [Broker MQTT para agricultura inteligente y riego](https://connectmq.com/es/agricultura-inteligente/)
- [Broker MQTT para cada industria | Soluciones sectoriales](https://connectmq.com/es/industrias/)
- [Casos de uso de MQTT: mantenimiento predictivo, flotas y más](https://connectmq.com/es/casos-de-uso/)
- [Broker MQTT para prototipado y educación](https://connectmq.com/es/prototipos-y-educacion/)
- [Guía rápida para desarrolladores: conéctate a ConnectMQ](https://connectmq.com/es/desarrolladores/)
- [Ejemplos de código MQTT: Python, Node.js, ESP32, Go y más](https://connectmq.com/es/ejemplos-de-codigo/)
- [Broker MQTT público gratuito — servidor de pruebas MQTT 5](https://connectmq.com/es/broker-mqtt-publico/)
- [Soporte y contacto](https://connectmq.com/es/soporte/)
- [Sobre ConnectMQ](https://connectmq.com/es/sobre-nosotros/)
- [Empleo en ConnectMQ](https://connectmq.com/es/empleo/)
- [Términos del servicio](https://connectmq.com/es/terminos/)
- [Aviso de privacidad](https://connectmq.com/es/privacidad/)
- [Política de reembolso](https://connectmq.com/es/politica-de-reembolso/)
- [Precios: broker MQTT gestionado, plan Free y desde $39/mes](https://connectmq.com/es/precios/)
- [¿Por qué ConnectMQ? Broker MQTT gestionado vs. autoalojado](https://connectmq.com/es/por-que-connectmq/)
- [Ejemplo MQTT con Python: conectar, publicar y suscribirse](https://connectmq.com/es/ejemplos-de-codigo/python/)
- [Ejemplo MQTT con Node.js: conectar, publicar y suscribirse](https://connectmq.com/es/ejemplos-de-codigo/nodejs/)
- [Ejemplo MQTT con ESP32: conectar, publicar y suscribirse](https://connectmq.com/es/ejemplos-de-codigo/esp32/)
- [Ejemplo MQTT con Go: conectar, publicar y suscribirse](https://connectmq.com/es/ejemplos-de-codigo/go/)
- [Ejemplo MQTT con CLI (mosquitto): conectar, publicar y suscribirse](https://connectmq.com/es/ejemplos-de-codigo/cli/)
- [Ejemplo MQTT con Java: conectar, publicar y suscribirse](https://connectmq.com/es/ejemplos-de-codigo/java/)
- [Ejemplo MQTT con C# (.NET): conectar, publicar y suscribirse](https://connectmq.com/es/ejemplos-de-codigo/csharp/)
- [Ejemplo MQTT con Rust: conectar, publicar y suscribirse](https://connectmq.com/es/ejemplos-de-codigo/rust/)
- [Ejemplo MQTT con Dart (Flutter): conectar, publicar y suscribirse](https://connectmq.com/es/ejemplos-de-codigo/dart-flutter/)
- [Ejemplo MQTT con Swift / Kotlin: conectar, publicar y suscribirse](https://connectmq.com/es/ejemplos-de-codigo/swift-kotlin/)
- [Ejemplo MQTT con Home Assistant: conectar, publicar y suscribirse](https://connectmq.com/es/ejemplos-de-codigo/home-assistant/)
- [Ejemplo MQTT con Node-RED: conectar, publicar y suscribirse](https://connectmq.com/es/ejemplos-de-codigo/node-red/)
- [Broker MQTT para manufactura | OEE, MES y UNS](https://connectmq.com/es/industrias/manufactura/)
- [Broker MQTT para automoción y vehículos conectados](https://connectmq.com/es/industrias/automocion/)
- [Broker MQTT para petróleo y gas | Pozos y oleoductos](https://connectmq.com/es/industrias/petroleo-y-gas/)
- [Broker MQTT para utilities | Red eléctrica, agua y AMI](https://connectmq.com/es/industrias/servicios-publicos/)
- [Broker MQTT para energías renovables, BESS y VPP](https://connectmq.com/es/industrias/energias-renovables/)
- [Broker MQTT para la industria química](https://connectmq.com/es/industrias/quimica/)
- [Broker MQTT para la industria farmacéutica](https://connectmq.com/es/industrias/farmaceutica/)
- [Broker MQTT para la industria alimentaria](https://connectmq.com/es/industrias/alimentacion-y-bebidas/)
- [Broker MQTT para salud y dispositivos médicos](https://connectmq.com/es/industrias/salud/)
- [Broker MQTT para transporte y logística](https://connectmq.com/es/industrias/transporte-y-logistica/)
- [Broker MQTT para retail y e-commerce | ConnectMQ](https://connectmq.com/es/industrias/retail-y-ecommerce/)
- [Broker MQTT para operadores de telecomunicaciones](https://connectmq.com/es/industrias/telecomunicaciones/)
- [MQTT para servicios financieros: cajeros, TPV y mercado](https://connectmq.com/es/industrias/servicios-financieros/)
- [MQTT para agricultura: invernaderos, riego y drones](https://connectmq.com/es/industrias/agricultura/)
- [Mantenimiento predictivo con MQTT | ConnectMQ](https://connectmq.com/es/casos-de-uso/mantenimiento-predictivo/)
- [Seguimiento de OEE y rendimiento de activos con MQTT](https://connectmq.com/es/casos-de-uso/seguimiento-del-rendimiento-de-activos/)
- [IA agéntica industrial con MQTT y Unified Namespace](https://connectmq.com/es/casos-de-uso/ia-agentica-industrial/)
- [Gestión y monitorización energética con MQTT](https://connectmq.com/es/casos-de-uso/gestion-energetica/)
- [Vehículos conectados y telemática con MQTT](https://connectmq.com/es/casos-de-uso/vehiculos-conectados/)
- [Gestión de puntos de recarga con MQTT y OCPP](https://connectmq.com/es/casos-de-uso/gestion-de-carga-de-vehiculos-electricos/)
- [Gestión de flotas y localización GPS con MQTT](https://connectmq.com/es/casos-de-uso/gestion-de-flotas/)
- [Monitorización remota de activos con MQTT y SCADA](https://connectmq.com/es/casos-de-uso/monitorizacion-remota-de-activos/)
- [Monitorización de nivel de tanques con MQTT](https://connectmq.com/es/casos-de-uso/monitorizacion-de-nivel-de-tanques/)
- [Medición inteligente con MQTT | Datos AMI a MDM](https://connectmq.com/es/casos-de-uso/medicion-inteligente/)
- [Monitorización de plantas solares y eólicas con MQTT](https://connectmq.com/es/casos-de-uso/monitorizacion-de-plantas-solares-y-eolicas/)
- [Monitorización ambiental de salas limpias con MQTT](https://connectmq.com/es/casos-de-uso/monitorizacion-ambiental-de-salas-limpias/)
- [Monitorización de la cadena de frío con MQTT](https://connectmq.com/es/casos-de-uso/monitorizacion-de-la-cadena-de-frio/)
- [MQTT para monitorización remota de pacientes (RPM)](https://connectmq.com/es/casos-de-uso/monitorizacion-remota-de-pacientes/)
- [Seguimiento de equipos hospitalarios con MQTT](https://connectmq.com/es/casos-de-uso/seguimiento-de-equipos-medicos/)
- [Notificaciones en tiempo real con MQTT y WebSockets](https://connectmq.com/es/casos-de-uso/notificaciones-en-tiempo-real/)
- [Tienda inteligente con MQTT: operaciones en tiempo real](https://connectmq.com/es/casos-de-uso/operaciones-de-tienda-inteligente/)
- [Monitorización de cajeros automáticos y TPV con MQTT](https://connectmq.com/es/casos-de-uso/monitorizacion-de-cajeros-y-tpv/)
- [Monitorización de emplazamientos de telecom con MQTT](https://connectmq.com/es/casos-de-uso/monitorizacion-de-equipos-de-red/)
- [Plataforma IoT para operadores: MQTT gestionado para telcos](https://connectmq.com/es/casos-de-uso/plataforma-iot-para-operadores/)
- [Datos de mercado en tiempo real con MQTT y WebSockets](https://connectmq.com/es/casos-de-uso/datos-de-mercado-en-tiempo-real/)
- [MQTT para drones agrícolas: pulverización y monitoreo](https://connectmq.com/es/casos-de-uso/drones-agricolas/)
- [Sensores IoT para invernaderos con MQTT: clima y sustrato](https://connectmq.com/es/casos-de-uso/sensores-iot-para-invernaderos/)

## Português (pt)

- [ConnectMQ — Broker MQTT gerenciado para IoT](https://connectmq.com/pt/)
- [Plataforma de broker MQTT gerenciado](https://connectmq.com/pt/plataforma/)
- [Dashboard MQTT e monitoramento de tópicos](https://connectmq.com/pt/monitoramento/)
- [Regras e alertas MQTT](https://connectmq.com/pt/regras-e-alertas/)
- [Gêmeo digital 3D com dados MQTT ao vivo](https://connectmq.com/pt/gemeo-digital/)
- [Conectividade MQTT: TCP, TLS, WebSockets e MQTT 5](https://connectmq.com/pt/conectividade/)
- [Segurança MQTT: TLS, autenticação e controle de acesso](https://connectmq.com/pt/seguranca/)
- [Soluções MQTT para IoT, casa inteligente, frotas e energia](https://connectmq.com/pt/solucoes/)
- [Broker MQTT para IoT industrial e manufatura inteligente](https://connectmq.com/pt/iot-industrial/)
- [Broker MQTT para casa inteligente e Home Assistant](https://connectmq.com/pt/casa-inteligente/)
- [Broker MQTT para telemática de frotas e cadeia fria](https://connectmq.com/pt/frotas-e-logistica/)
- [Broker MQTT para energia inteligente e recarga de VEs](https://connectmq.com/pt/energia-e-utilidades/)
- [Broker MQTT para produtos conectados e hardware inteligente](https://connectmq.com/pt/produtos-conectados/)
- [Broker MQTT para frotas de robôs e IA física](https://connectmq.com/pt/robotica/)
- [MQTT para energia e refrigeração em data centers](https://connectmq.com/pt/centros-de-dados/)
- [Broker MQTT para cidades inteligentes e iluminação pública](https://connectmq.com/pt/cidades-inteligentes/)
- [Broker MQTT para agricultura inteligente e irrigação](https://connectmq.com/pt/agricultura-inteligente/)
- [Broker MQTT para todos os setores | Soluções setoriais](https://connectmq.com/pt/setores/)
- [Casos de uso de MQTT: manutenção preditiva, frotas e mais](https://connectmq.com/pt/casos-de-uso/)
- [Broker MQTT para prototipagem e educação](https://connectmq.com/pt/prototipagem-e-educacao/)
- [Guia rápido: conecte-se ao broker MQTT ConnectMQ](https://connectmq.com/pt/desenvolvedores/)
- [Exemplos de código MQTT: Python, Node.js, ESP32, Go e mais](https://connectmq.com/pt/exemplos-de-codigo/)
- [Broker MQTT público gratuito — servidor de testes MQTT 5](https://connectmq.com/pt/broker-mqtt-publico/)
- [Suporte e contato](https://connectmq.com/pt/suporte/)
- [Sobre a ConnectMQ](https://connectmq.com/pt/sobre-nos/)
- [Carreiras na ConnectMQ](https://connectmq.com/pt/carreiras/)
- [Termos de serviço](https://connectmq.com/pt/termos/)
- [Aviso de privacidade](https://connectmq.com/pt/privacidade/)
- [Política de reembolso](https://connectmq.com/pt/politica-de-reembolso/)
- [Preços — broker MQTT gerenciado: plano Free e desde $39/mês](https://connectmq.com/pt/precos/)
- [Por que o ConnectMQ: broker MQTT gerenciado vs. próprio](https://connectmq.com/pt/por-que-connectmq/)
- [Exemplo MQTT em Python: conectar, publicar e assinar](https://connectmq.com/pt/exemplos-de-codigo/python/)
- [Exemplo MQTT em Node.js: conectar, publicar e assinar](https://connectmq.com/pt/exemplos-de-codigo/nodejs/)
- [Exemplo MQTT em ESP32: conectar, publicar e assinar](https://connectmq.com/pt/exemplos-de-codigo/esp32/)
- [Exemplo MQTT em Go: conectar, publicar e assinar](https://connectmq.com/pt/exemplos-de-codigo/go/)
- [Exemplo MQTT em CLI (mosquitto): conectar, publicar e assinar](https://connectmq.com/pt/exemplos-de-codigo/cli/)
- [Exemplo MQTT em Java: conectar, publicar e assinar](https://connectmq.com/pt/exemplos-de-codigo/java/)
- [Exemplo MQTT em C# (.NET): conectar, publicar e assinar](https://connectmq.com/pt/exemplos-de-codigo/csharp/)
- [Exemplo MQTT em Rust: conectar, publicar e assinar](https://connectmq.com/pt/exemplos-de-codigo/rust/)
- [Exemplo MQTT em Dart (Flutter): conectar, publicar e assinar](https://connectmq.com/pt/exemplos-de-codigo/dart-flutter/)
- [Exemplo MQTT em Swift / Kotlin: conectar, publicar e assinar](https://connectmq.com/pt/exemplos-de-codigo/swift-kotlin/)
- [Exemplo MQTT em Home Assistant: conectar, publicar e assinar](https://connectmq.com/pt/exemplos-de-codigo/home-assistant/)
- [Exemplo MQTT em Node-RED: conectar, publicar e assinar](https://connectmq.com/pt/exemplos-de-codigo/node-red/)
- [Broker MQTT para manufatura | OEE, MES e UNS](https://connectmq.com/pt/setores/manufatura/)
- [Broker MQTT para o setor automotivo e carro conectado](https://connectmq.com/pt/setores/automotivo/)
- [Broker MQTT para petróleo e gás | Poços, dutos, tanques](https://connectmq.com/pt/setores/petroleo-e-gas/)
- [Broker MQTT para utilities | Energia, água e medição](https://connectmq.com/pt/setores/servicos-publicos/)
- [Broker MQTT para energia renovável, BESS e VPP](https://connectmq.com/pt/setores/energia-renovavel/)
- [Broker MQTT para a indústria química](https://connectmq.com/pt/setores/quimica/)
- [Broker MQTT para a indústria farmacêutica](https://connectmq.com/pt/setores/farmaceutica/)
- [Broker MQTT para a indústria de alimentos](https://connectmq.com/pt/setores/alimentos-e-bebidas/)
- [Broker MQTT para saúde e dispositivos médicos](https://connectmq.com/pt/setores/saude/)
- [Broker MQTT para transporte e logística](https://connectmq.com/pt/setores/transporte-e-logistica/)
- [Broker MQTT para varejo e e-commerce | ConnectMQ](https://connectmq.com/pt/setores/varejo-e-e-commerce/)
- [Broker MQTT para operadoras de telecomunicações](https://connectmq.com/pt/setores/telecomunicacoes/)
- [MQTT para serviços financeiros: ATMs, POS e cotações](https://connectmq.com/pt/setores/servicos-financeiros/)
- [MQTT para agricultura: estufas, irrigação e drones](https://connectmq.com/pt/setores/agricultura/)
- [Manutenção preditiva com MQTT | ConnectMQ](https://connectmq.com/pt/casos-de-uso/manutencao-preditiva/)
- [Monitoramento de OEE e desempenho de ativos com MQTT](https://connectmq.com/pt/casos-de-uso/monitoramento-de-desempenho-de-ativos/)
- [IA agêntica industrial com MQTT e Unified Namespace](https://connectmq.com/pt/casos-de-uso/ia-agentica-industrial/)
- [Gestão e monitoramento de energia com MQTT](https://connectmq.com/pt/casos-de-uso/gestao-de-energia/)
- [Veículos conectados e telemetria com MQTT](https://connectmq.com/pt/casos-de-uso/veiculos-conectados/)
- [Gestão de recarga de veículos elétricos com MQTT e OCPP](https://connectmq.com/pt/casos-de-uso/gestao-de-recarga-de-veiculos-eletricos/)
- [Gestão de frotas e rastreamento GPS com MQTT](https://connectmq.com/pt/casos-de-uso/gestao-de-frotas/)
- [Monitoramento remoto de ativos com MQTT e SCADA](https://connectmq.com/pt/casos-de-uso/monitoramento-remoto-de-ativos/)
- [Monitoramento de nível de tanques com MQTT](https://connectmq.com/pt/casos-de-uso/monitoramento-de-nivel-de-tanques/)
- [Medição inteligente com MQTT | Dados AMI para MDM](https://connectmq.com/pt/casos-de-uso/medicao-inteligente/)
- [Monitoramento de usinas solares e eólicas com MQTT](https://connectmq.com/pt/casos-de-uso/monitoramento-de-usinas-solares-e-eolicas/)
- [Monitoramento ambiental de salas limpas com MQTT](https://connectmq.com/pt/casos-de-uso/monitoramento-ambiental-de-salas-limpas/)
- [Monitoramento da cadeia do frio com MQTT](https://connectmq.com/pt/casos-de-uso/monitoramento-da-cadeia-do-frio/)
- [MQTT para monitoramento remoto de pacientes (RPM)](https://connectmq.com/pt/casos-de-uso/monitoramento-remoto-de-pacientes/)
- [Rastreamento de equipamentos hospitalares com MQTT](https://connectmq.com/pt/casos-de-uso/rastreamento-de-equipamentos-medicos/)
- [Notificações em tempo real com MQTT e WebSockets](https://connectmq.com/pt/casos-de-uso/notificacoes-em-tempo-real/)
- [Loja inteligente com MQTT: operações em tempo real](https://connectmq.com/pt/casos-de-uso/operacoes-de-loja-inteligente/)
- [Monitoramento de caixas eletrônicos e POS com MQTT](https://connectmq.com/pt/casos-de-uso/monitoramento-de-caixas-eletronicos-e-pos/)
- [Monitoramento de sites de telecom com MQTT](https://connectmq.com/pt/casos-de-uso/monitoramento-de-equipamentos-de-rede/)
- [Plataforma IoT para operadoras: MQTT gerenciado para telecom](https://connectmq.com/pt/casos-de-uso/plataforma-iot-para-operadoras/)
- [Dados de mercado em tempo real com MQTT e WebSockets](https://connectmq.com/pt/casos-de-uso/dados-de-mercado-em-tempo-real/)
- [MQTT para drones agrícolas: pulverização e monitoramento](https://connectmq.com/pt/casos-de-uso/drones-agricolas/)
- [Sensores IoT para estufas com MQTT: clima e substrato](https://connectmq.com/pt/casos-de-uso/sensores-iot-para-estufas/)

## Deutsch (de)

- [ConnectMQ — Managed MQTT-Broker für IoT](https://connectmq.com/de/)
- [Managed MQTT-Broker-Plattform](https://connectmq.com/de/plattform/)
- [MQTT-Dashboard & Topic-Monitoring](https://connectmq.com/de/monitoring/)
- [MQTT-Regeln & Alarme](https://connectmq.com/de/regeln-und-alarme/)
- [Digitaler Zwilling in 3D mit Live-MQTT-Daten](https://connectmq.com/de/digitaler-zwilling/)
- [MQTT-Konnektivität: TCP, TLS, WebSockets & MQTT 5](https://connectmq.com/de/konnektivitaet/)
- [MQTT-Sicherheit: TLS, Authentifizierung & ACLs](https://connectmq.com/de/sicherheit/)
- [MQTT-Lösungen für IoT, Smart Home, Flotte & Energie](https://connectmq.com/de/loesungen/)
- [MQTT-Broker für Industrial IoT & Smart Manufacturing](https://connectmq.com/de/industrielles-iot/)
- [MQTT-Broker für Smart Home & Home Assistant](https://connectmq.com/de/smart-home/)
- [MQTT-Broker für Flottentelematik & Kühlkette](https://connectmq.com/de/flotten-und-logistik/)
- [MQTT-Broker für Smart Energy & Ladeinfrastruktur](https://connectmq.com/de/energie-und-versorgung/)
- [MQTT-Broker für vernetzte Produkte & Smart Hardware](https://connectmq.com/de/vernetzte-produkte/)
- [MQTT-Broker für Roboterflotten & Physical AI](https://connectmq.com/de/robotik/)
- [MQTT für Strom- und Kühlungs-Monitoring im Rechenzentrum](https://connectmq.com/de/rechenzentren/)
- [MQTT-Broker für Smart-City-Sensoren & Straßenbeleuchtung](https://connectmq.com/de/smart-city/)
- [MQTT-Broker für Smart Farming & Bewässerung](https://connectmq.com/de/smart-farming/)
- [MQTT-Broker für jede Branche | Branchenlösungen](https://connectmq.com/de/branchen/)
- [MQTT-Anwendungsfälle: Predictive Maintenance, Flotten & mehr](https://connectmq.com/de/anwendungsfaelle/)
- [MQTT-Broker für Prototyping & Lehre](https://connectmq.com/de/prototyping-und-bildung/)
- [Quickstart für Entwickler: Mit ConnectMQ verbinden](https://connectmq.com/de/entwickler/)
- [MQTT-Codebeispiele: Python, Node.js, ESP32, Go und mehr](https://connectmq.com/de/code-beispiele/)
- [Kostenloser öffentlicher MQTT-Broker — MQTT-Testserver](https://connectmq.com/de/oeffentlicher-mqtt-broker/)
- [Support & Kontakt](https://connectmq.com/de/support/)
- [Über ConnectMQ](https://connectmq.com/de/ueber-uns/)
- [Karriere bei ConnectMQ](https://connectmq.com/de/karriere/)
- [Nutzungsbedingungen](https://connectmq.com/de/nutzungsbedingungen/)
- [Datenschutzhinweis](https://connectmq.com/de/datenschutz/)
- [Rückerstattungsrichtlinie](https://connectmq.com/de/rueckerstattung/)
- [Preise — Managed MQTT-Broker, Free-Plan & ab $39/Monat](https://connectmq.com/de/preise/)
- [Warum ConnectMQ: Managed vs. selbst gehostetes MQTT](https://connectmq.com/de/warum-connectmq/)
- [MQTT-Beispiel für Python: Verbinden, Senden, Abonnieren](https://connectmq.com/de/code-beispiele/python/)
- [MQTT-Beispiel für Node.js: Verbinden, Senden, Abonnieren](https://connectmq.com/de/code-beispiele/nodejs/)
- [MQTT-Beispiel für ESP32: Verbinden, Senden, Abonnieren](https://connectmq.com/de/code-beispiele/esp32/)
- [MQTT-Beispiel für Go: Verbinden, Senden, Abonnieren](https://connectmq.com/de/code-beispiele/go/)
- [MQTT-Beispiel für CLI (mosquitto): Verbinden, Senden, Abonnieren](https://connectmq.com/de/code-beispiele/cli/)
- [MQTT-Beispiel für Java: Verbinden, Senden, Abonnieren](https://connectmq.com/de/code-beispiele/java/)
- [MQTT-Beispiel für C# (.NET): Verbinden, Senden, Abonnieren](https://connectmq.com/de/code-beispiele/csharp/)
- [MQTT-Beispiel für Rust: Verbinden, Senden, Abonnieren](https://connectmq.com/de/code-beispiele/rust/)
- [MQTT-Beispiel für Dart (Flutter): Verbinden, Senden, Abonnieren](https://connectmq.com/de/code-beispiele/dart-flutter/)
- [MQTT-Beispiel für Swift / Kotlin: Verbinden, Senden, Abonnieren](https://connectmq.com/de/code-beispiele/swift-kotlin/)
- [MQTT-Beispiel für Home Assistant: Verbinden, Senden, Abonnieren](https://connectmq.com/de/code-beispiele/home-assistant/)
- [MQTT-Beispiel für Node-RED: Verbinden, Senden, Abonnieren](https://connectmq.com/de/code-beispiele/node-red/)
- [MQTT-Broker für die Fertigung | OEE, MES & UNS](https://connectmq.com/de/branchen/fertigung/)
- [MQTT-Broker für Automotive & vernetzte Fahrzeuge](https://connectmq.com/de/branchen/automobilindustrie/)
- [MQTT-Broker für Öl & Gas | Bohrungen, Pipelines, Tanks](https://connectmq.com/de/branchen/oel-und-gas/)
- [MQTT-Broker für Versorger | Strom, Wasser, Smart Meter](https://connectmq.com/de/branchen/versorgungsunternehmen/)
- [MQTT-Broker für Erneuerbare, Speicher & VPP](https://connectmq.com/de/branchen/erneuerbare-energien/)
- [MQTT-Broker für die Chemieindustrie](https://connectmq.com/de/branchen/chemie/)
- [MQTT-Broker für Pharma & Life Sciences](https://connectmq.com/de/branchen/pharma/)
- [MQTT-Broker für die Lebensmittelindustrie](https://connectmq.com/de/branchen/lebensmittel-und-getraenke/)
- [MQTT-Broker für Gesundheitswesen & Medizintechnik](https://connectmq.com/de/branchen/gesundheitswesen/)
- [MQTT-Broker für Transport & Logistik](https://connectmq.com/de/branchen/transport-und-logistik/)
- [MQTT-Broker für Handel & E-Commerce | ConnectMQ](https://connectmq.com/de/branchen/handel-und-e-commerce/)
- [MQTT-Broker für Netzbetreiber & Funkstandorte](https://connectmq.com/de/branchen/telekommunikation/)
- [MQTT für Finanzdienstleister: Geldautomaten, POS & Kurse](https://connectmq.com/de/branchen/finanzdienstleistungen/)
- [MQTT für Landwirtschaft: Gewächshaus, Bewässerung, Drohnen](https://connectmq.com/de/branchen/landwirtschaft/)
- [Predictive Maintenance mit MQTT | ConnectMQ](https://connectmq.com/de/anwendungsfaelle/vorausschauende-wartung/)
- [OEE & Anlagenperformance in Echtzeit mit MQTT](https://connectmq.com/de/anwendungsfaelle/anlagenperformance-tracking/)
- [Industrielle agentische KI mit MQTT & Unified Namespace](https://connectmq.com/de/anwendungsfaelle/industrielle-agentische-ki/)
- [Energiemanagement & Energiemonitoring mit MQTT](https://connectmq.com/de/anwendungsfaelle/energiemanagement/)
- [Vernetzte Fahrzeuge & Telematik mit MQTT](https://connectmq.com/de/anwendungsfaelle/vernetzte-fahrzeuge/)
- [Ladeinfrastruktur-Management mit MQTT & OCPP](https://connectmq.com/de/anwendungsfaelle/ladeinfrastruktur-management/)
- [Flottenmanagement & GPS-Ortung mit MQTT](https://connectmq.com/de/anwendungsfaelle/flottenmanagement/)
- [Fernüberwachung mit MQTT: SCADA über Mobilfunk](https://connectmq.com/de/anwendungsfaelle/fernueberwachung-von-anlagen/)
- [Tankfüllstand-Überwachung mit MQTT | Tank-Telemetrie](https://connectmq.com/de/anwendungsfaelle/tankfuellstand-ueberwachung/)
- [Smart Metering mit MQTT | Zählerdaten an MDM & Abrechnung](https://connectmq.com/de/anwendungsfaelle/smart-metering/)
- [Solar- und Windpark-Monitoring mit MQTT | Park-SCADA](https://connectmq.com/de/anwendungsfaelle/solar-und-windpark-monitoring/)
- [Reinraum-Monitoring mit MQTT | GMP-Umgebungsmonitoring](https://connectmq.com/de/anwendungsfaelle/reinraum-umgebungsmonitoring/)
- [Kühlkettenüberwachung mit MQTT | Kühlauflieger & Kühlräume](https://connectmq.com/de/anwendungsfaelle/kuehlkettenueberwachung/)
- [MQTT für Patientenfernüberwachung (Telemonitoring)](https://connectmq.com/de/anwendungsfaelle/patientenfernueberwachung/)
- [Medizingeräte-Ortung im Krankenhaus mit MQTT](https://connectmq.com/de/anwendungsfaelle/medizingeraete-tracking/)
- [Echtzeit-Benachrichtigungen mit MQTT über WebSockets](https://connectmq.com/de/anwendungsfaelle/echtzeit-benachrichtigungen/)
- [Smart Store mit MQTT: Filialtechnik live überwachen](https://connectmq.com/de/anwendungsfaelle/smart-store-betrieb/)
- [Geldautomaten- & POS-Terminal-Monitoring mit MQTT](https://connectmq.com/de/anwendungsfaelle/geldautomaten-und-kassen-monitoring/)
- [Funkstandort- & Netzinfrastruktur-Monitoring mit MQTT](https://connectmq.com/de/anwendungsfaelle/netzwerkausruestung-monitoring/)
- [IoT-Plattform für Netzbetreiber: Managed MQTT für Telcos](https://connectmq.com/de/anwendungsfaelle/iot-plattform-fuer-netzbetreiber/)
- [Echtzeit-Marktdaten streamen mit MQTT & WebSockets](https://connectmq.com/de/anwendungsfaelle/echtzeit-marktdaten/)
- [MQTT für Agrardrohnen: Sprüh- und Scouting-Flotten](https://connectmq.com/de/anwendungsfaelle/agrardrohnen/)
- [Gewächshaus-Sensorik mit MQTT: Klima- & Substratdaten](https://connectmq.com/de/anwendungsfaelle/gewaechshaus-sensorik/)

## Français (fr)

- [ConnectMQ — Broker MQTT managé pour l’IoT](https://connectmq.com/fr/)
- [Plateforme de broker MQTT managé](https://connectmq.com/fr/plateforme/)
- [Tableau de bord MQTT et supervision des topics](https://connectmq.com/fr/supervision/)
- [Règles et alertes MQTT](https://connectmq.com/fr/regles-et-alertes/)
- [Jumeau numérique 3D avec données MQTT en direct](https://connectmq.com/fr/jumeau-numerique/)
- [Connectivité MQTT : TCP, TLS, WebSockets et MQTT 5](https://connectmq.com/fr/connectivite/)
- [Sécurité MQTT : TLS, authentification et ACL](https://connectmq.com/fr/securite/)
- [Solutions MQTT : IoT, domotique, flottes et énergie](https://connectmq.com/fr/solutions/)
- [Broker MQTT pour l’IoT industriel et l’usine connectée](https://connectmq.com/fr/iot-industriel/)
- [Broker MQTT pour la domotique et Home Assistant](https://connectmq.com/fr/maison-connectee/)
- [Broker MQTT pour la télématique et la chaîne du froid](https://connectmq.com/fr/flottes-et-logistique/)
- [Broker MQTT pour l’énergie intelligente et la recharge VE](https://connectmq.com/fr/energie-et-services-publics/)
- [Broker MQTT pour produits connectés et matériel intelligent](https://connectmq.com/fr/produits-connectes/)
- [Broker MQTT pour flottes de robots et IA physique](https://connectmq.com/fr/robotique/)
- [MQTT pour superviser énergie et froid en data center](https://connectmq.com/fr/centres-de-donnees/)
- [Broker MQTT pour capteurs urbains et éclairage public](https://connectmq.com/fr/ville-intelligente/)
- [Broker MQTT pour l’agriculture connectée et l’irrigation](https://connectmq.com/fr/agriculture-connectee/)
- [Broker MQTT pour chaque secteur | Solutions sectorielles](https://connectmq.com/fr/secteurs/)
- [Cas d’usage MQTT : maintenance prédictive, flottes et plus](https://connectmq.com/fr/cas-d-usage/)
- [Broker MQTT pour le prototypage et l’enseignement](https://connectmq.com/fr/prototypage-et-education/)
- [Démarrage rapide : se connecter à ConnectMQ](https://connectmq.com/fr/developpeurs/)
- [Exemples de code MQTT : Python, Node.js, ESP32, Go et plus](https://connectmq.com/fr/exemples-de-code/)
- [Broker MQTT public gratuit — serveur MQTT 5 de test](https://connectmq.com/fr/broker-mqtt-public/)
- [Support et contact](https://connectmq.com/fr/support/)
- [À propos de ConnectMQ](https://connectmq.com/fr/a-propos/)
- [Carrières chez ConnectMQ](https://connectmq.com/fr/carrieres/)
- [Conditions d’utilisation](https://connectmq.com/fr/conditions-utilisation/)
- [Politique de confidentialité](https://connectmq.com/fr/confidentialite/)
- [Politique de remboursement](https://connectmq.com/fr/politique-de-remboursement/)
- [Tarifs — Broker MQTT managé, offre Free et dès $39/mois](https://connectmq.com/fr/tarifs/)
- [Pourquoi ConnectMQ : broker MQTT managé ou auto-hébergé](https://connectmq.com/fr/pourquoi-connectmq/)
- [MQTT Python : se connecter, publier et s’abonner](https://connectmq.com/fr/exemples-de-code/python/)
- [MQTT Node.js : se connecter, publier et s’abonner](https://connectmq.com/fr/exemples-de-code/nodejs/)
- [MQTT ESP32 : se connecter, publier et s’abonner](https://connectmq.com/fr/exemples-de-code/esp32/)
- [MQTT Go : se connecter, publier et s’abonner](https://connectmq.com/fr/exemples-de-code/go/)
- [MQTT CLI (mosquitto) : se connecter, publier et s’abonner](https://connectmq.com/fr/exemples-de-code/cli/)
- [MQTT Java : se connecter, publier et s’abonner](https://connectmq.com/fr/exemples-de-code/java/)
- [MQTT C# (.NET) : se connecter, publier et s’abonner](https://connectmq.com/fr/exemples-de-code/csharp/)
- [MQTT Rust : se connecter, publier et s’abonner](https://connectmq.com/fr/exemples-de-code/rust/)
- [MQTT Dart (Flutter) : se connecter, publier et s’abonner](https://connectmq.com/fr/exemples-de-code/dart-flutter/)
- [MQTT Swift / Kotlin : se connecter, publier et s’abonner](https://connectmq.com/fr/exemples-de-code/swift-kotlin/)
- [MQTT Home Assistant : se connecter, publier et s’abonner](https://connectmq.com/fr/exemples-de-code/home-assistant/)
- [MQTT Node-RED : se connecter, publier et s’abonner](https://connectmq.com/fr/exemples-de-code/node-red/)
- [Broker MQTT pour l’industrie | TRS, MES et UNS](https://connectmq.com/fr/secteurs/industrie-manufacturiere/)
- [Broker MQTT pour l’automobile et le véhicule connecté](https://connectmq.com/fr/secteurs/automobile/)
- [Broker MQTT pour le pétrole et gaz | Puits, pipelines](https://connectmq.com/fr/secteurs/petrole-et-gaz/)
- [Broker MQTT pour l’énergie et l’eau | Réseaux, compteurs](https://connectmq.com/fr/secteurs/services-publics/)
- [Broker MQTT pour les énergies renouvelables et BESS](https://connectmq.com/fr/secteurs/energies-renouvelables/)
- [Broker MQTT pour l’industrie chimique](https://connectmq.com/fr/secteurs/chimie/)
- [Broker MQTT pour l’industrie pharmaceutique](https://connectmq.com/fr/secteurs/pharmacie/)
- [Broker MQTT pour l’agroalimentaire](https://connectmq.com/fr/secteurs/agroalimentaire/)
- [Broker MQTT pour la santé et les dispositifs médicaux](https://connectmq.com/fr/secteurs/sante/)
- [Broker MQTT pour le transport et la logistique](https://connectmq.com/fr/secteurs/transport-et-logistique/)
- [Broker MQTT pour le retail et l’e-commerce | ConnectMQ](https://connectmq.com/fr/secteurs/commerce-et-e-commerce/)
- [Broker MQTT pour opérateurs télécoms et sites radio](https://connectmq.com/fr/secteurs/telecoms/)
- [MQTT pour les services financiers : DAB, TPE et cotations](https://connectmq.com/fr/secteurs/services-financiers/)
- [MQTT pour l’agriculture : serres, irrigation et drones](https://connectmq.com/fr/secteurs/agriculture/)
- [Maintenance prédictive avec MQTT | ConnectMQ](https://connectmq.com/fr/cas-d-usage/maintenance-predictive/)
- [Suivi du TRS et de la performance des actifs avec MQTT](https://connectmq.com/fr/cas-d-usage/suivi-de-la-performance-des-actifs/)
- [IA agentique industrielle avec MQTT et Unified Namespace](https://connectmq.com/fr/cas-d-usage/ia-agentique-industrielle/)
- [Gestion et suivi énergétique avec MQTT](https://connectmq.com/fr/cas-d-usage/gestion-energetique/)
- [Véhicules connectés et télématique avec MQTT](https://connectmq.com/fr/cas-d-usage/vehicules-connectes/)
- [Gestion des bornes de recharge avec MQTT et OCPP](https://connectmq.com/fr/cas-d-usage/gestion-de-la-recharge-vehicules-electriques/)
- [Gestion de flotte et géolocalisation GPS avec MQTT](https://connectmq.com/fr/cas-d-usage/gestion-de-flotte/)
- [Surveillance d’actifs à distance avec MQTT et SCADA](https://connectmq.com/fr/cas-d-usage/surveillance-des-actifs-a-distance/)
- [Télémesure de cuves avec MQTT | Jauge connectée](https://connectmq.com/fr/cas-d-usage/surveillance-du-niveau-des-cuves/)
- [Comptage intelligent avec MQTT | Données AMI vers MDM](https://connectmq.com/fr/cas-d-usage/comptage-intelligent/)
- [Supervision de parcs solaires et éoliens avec MQTT](https://connectmq.com/fr/cas-d-usage/supervision-de-parcs-solaires-et-eoliens/)
- [Surveillance des salles propres avec MQTT | BPF](https://connectmq.com/fr/cas-d-usage/surveillance-environnementale-des-salles-propres/)
- [Surveillance de la chaîne du froid avec MQTT](https://connectmq.com/fr/cas-d-usage/surveillance-de-la-chaine-du-froid/)
- [MQTT pour la télésurveillance médicale des patients](https://connectmq.com/fr/cas-d-usage/telesurveillance-des-patients/)
- [Suivi des équipements hospitaliers en MQTT](https://connectmq.com/fr/cas-d-usage/suivi-des-equipements-medicaux/)
- [Notifications en temps réel avec MQTT et WebSockets](https://connectmq.com/fr/cas-d-usage/notifications-en-temps-reel/)
- [Magasin connecté avec MQTT : opérations en temps réel](https://connectmq.com/fr/cas-d-usage/operations-magasin-connecte/)
- [Supervision des GAB et TPE avec MQTT](https://connectmq.com/fr/cas-d-usage/supervision-des-gab-et-tpe/)
- [Supervision des sites et équipements télécom en MQTT](https://connectmq.com/fr/cas-d-usage/supervision-des-equipements-reseau/)
- [Plateforme IoT pour opérateurs : MQTT managé pour telcos](https://connectmq.com/fr/cas-d-usage/plateforme-iot-pour-operateurs/)
- [Données de marché en temps réel avec MQTT et WebSockets](https://connectmq.com/fr/cas-d-usage/donnees-de-marche-en-temps-reel/)
- [MQTT pour drones agricoles : pulvérisation et scouting](https://connectmq.com/fr/cas-d-usage/drones-agricoles/)
- [Capteurs IoT pour serres avec MQTT : climat et substrat](https://connectmq.com/fr/cas-d-usage/capteurs-iot-pour-serres/)

## Türkçe (tr)

- [ConnectMQ — IoT için Yönetilen MQTT Broker](https://connectmq.com/tr/)
- [Yönetilen MQTT Broker Platformu](https://connectmq.com/tr/platform/)
- [MQTT Gösterge Paneli ve Topic İzleme](https://connectmq.com/tr/izleme/)
- [MQTT Kuralları ve Uyarıları](https://connectmq.com/tr/kurallar-ve-alarmlar/)
- [Canlı MQTT Verisiyle 3D Dijital İkiz](https://connectmq.com/tr/dijital-ikiz/)
- [MQTT Bağlantısı: TCP, TLS, WebSocket ve MQTT 5](https://connectmq.com/tr/baglanti/)
- [MQTT Güvenliği: TLS, Kimlik Doğrulama ve Erişim](https://connectmq.com/tr/guvenlik/)
- [IoT, Akıllı Ev, Filo ve Enerji için MQTT Çözümleri](https://connectmq.com/tr/cozumler/)
- [Endüstriyel IoT ve Akıllı Üretim için MQTT Broker](https://connectmq.com/tr/endustriyel-iot/)
- [Akıllı Ev ve Home Assistant için MQTT Broker](https://connectmq.com/tr/akilli-ev/)
- [Filo Telematiği ve Soğuk Zincir için MQTT Broker](https://connectmq.com/tr/filo-ve-lojistik/)
- [Akıllı Enerji ve EV Şarjı için MQTT Broker](https://connectmq.com/tr/enerji-ve-altyapi/)
- [Bağlı Ürünler ve Akıllı Donanım için MQTT Broker](https://connectmq.com/tr/bagli-urunler/)
- [Robot Filoları ve Fiziksel Yapay Zekâ için MQTT Broker](https://connectmq.com/tr/robotik/)
- [Veri Merkezi Güç ve Soğutma İzleme için MQTT](https://connectmq.com/tr/veri-merkezleri/)
- [Akıllı Şehir Sensörleri ve Aydınlatma için MQTT Broker](https://connectmq.com/tr/akilli-sehir/)
- [Akıllı Tarım ve Sulama için MQTT Broker](https://connectmq.com/tr/akilli-tarim/)
- [Her Sektör için MQTT Broker | Sektörel Çözümler](https://connectmq.com/tr/sektorler/)
- [MQTT Kullanım Senaryoları: Kestirimci Bakım, Filo ve Fazlası](https://connectmq.com/tr/kullanim-senaryolari/)
- [Prototipleme ve Eğitim için MQTT Broker](https://connectmq.com/tr/prototipleme-ve-egitim/)
- [Geliştirici Hızlı Başlangıç: ConnectMQ’ya Bağlanın](https://connectmq.com/tr/gelistiriciler/)
- [MQTT Kod Örnekleri: Python, Node.js, ESP32, Go ve Fazlası](https://connectmq.com/tr/kod-ornekleri/)
- [Ücretsiz Herkese Açık MQTT Broker — MQTT Test Sunucusu](https://connectmq.com/tr/herkese-acik-mqtt-broker/)
- [Destek ve İletişim](https://connectmq.com/tr/destek/)
- [ConnectMQ Hakkında](https://connectmq.com/tr/hakkimizda/)
- [ConnectMQ’da Kariyer](https://connectmq.com/tr/kariyer/)
- [Kullanım Koşulları](https://connectmq.com/tr/kullanim-kosullari/)
- [Gizlilik Bildirimi](https://connectmq.com/tr/gizlilik/)
- [İade Politikası](https://connectmq.com/tr/iade-politikasi/)
- [Fiyatlandırma — Free Plan ve Aylık $39’dan MQTT Broker](https://connectmq.com/tr/fiyatlandirma/)
- [Neden ConnectMQ: Yönetilen ve Kendi Sunucunuzda MQTT](https://connectmq.com/tr/neden-connectmq/)
- [Python MQTT Örneği: Bağlanma, Yayınlama ve Abonelik](https://connectmq.com/tr/kod-ornekleri/python/)
- [Node.js MQTT Örneği: Bağlanma, Yayınlama ve Abonelik](https://connectmq.com/tr/kod-ornekleri/nodejs/)
- [ESP32 MQTT Örneği: Bağlanma, Yayınlama ve Abonelik](https://connectmq.com/tr/kod-ornekleri/esp32/)
- [Go MQTT Örneği: Bağlanma, Yayınlama ve Abonelik](https://connectmq.com/tr/kod-ornekleri/go/)
- [CLI (mosquitto) MQTT Örneği: Bağlanma, Yayınlama ve Abonelik](https://connectmq.com/tr/kod-ornekleri/cli/)
- [Java MQTT Örneği: Bağlanma, Yayınlama ve Abonelik](https://connectmq.com/tr/kod-ornekleri/java/)
- [C# (.NET) MQTT Örneği: Bağlanma, Yayınlama ve Abonelik](https://connectmq.com/tr/kod-ornekleri/csharp/)
- [Rust MQTT Örneği: Bağlanma, Yayınlama ve Abonelik](https://connectmq.com/tr/kod-ornekleri/rust/)
- [Dart (Flutter) MQTT Örneği: Bağlanma, Yayınlama ve Abonelik](https://connectmq.com/tr/kod-ornekleri/dart-flutter/)
- [Swift / Kotlin MQTT Örneği: Bağlanma, Yayınlama ve Abonelik](https://connectmq.com/tr/kod-ornekleri/swift-kotlin/)
- [Home Assistant MQTT Örneği: Bağlanma, Yayınlama ve Abonelik](https://connectmq.com/tr/kod-ornekleri/home-assistant/)
- [Node-RED MQTT Örneği: Bağlanma, Yayınlama ve Abonelik](https://connectmq.com/tr/kod-ornekleri/node-red/)
- [İmalat için MQTT Broker | OEE, MES ve UNS](https://connectmq.com/tr/sektorler/imalat/)
- [Otomotiv ve Bağlı Araçlar için MQTT Broker](https://connectmq.com/tr/sektorler/otomotiv/)
- [Petrol ve Gaz için MQTT Broker | Kuyu, Boru Hattı, Tank](https://connectmq.com/tr/sektorler/petrol-ve-gaz/)
- [Elektrik ve Su Şebekeleri için MQTT Broker](https://connectmq.com/tr/sektorler/enerji-ve-su-sebekeleri/)
- [Yenilenebilir Enerji, BESS ve VPP için MQTT Broker](https://connectmq.com/tr/sektorler/yenilenebilir-enerji/)
- [Kimya Tesisleri için MQTT Broker](https://connectmq.com/tr/sektorler/kimya/)
- [İlaç ve Yaşam Bilimleri için MQTT Broker](https://connectmq.com/tr/sektorler/ilac-ve-yasam-bilimleri/)
- [Gıda ve İçecek Üretimi için MQTT Broker](https://connectmq.com/tr/sektorler/gida-ve-icecek/)
- [Sağlık ve Tıbbi Cihazlar için MQTT Broker](https://connectmq.com/tr/sektorler/saglik/)
- [Ulaşım ve Lojistik için MQTT Broker](https://connectmq.com/tr/sektorler/ulasim-ve-lojistik/)
- [Perakende ve E-ticaret için MQTT Broker | ConnectMQ](https://connectmq.com/tr/sektorler/perakende-ve-e-ticaret/)
- [Telekom Operatörleri ve Baz İstasyonları için MQTT](https://connectmq.com/tr/sektorler/telekom/)
- [Finans için MQTT: ATM, POS ve Canlı Piyasa Verisi](https://connectmq.com/tr/sektorler/finans/)
- [Tarım için MQTT: Sera, Sulama ve Tarım Dronları](https://connectmq.com/tr/sektorler/tarim/)
- [MQTT ile Kestirimci Bakım | ConnectMQ](https://connectmq.com/tr/kullanim-senaryolari/kestirimci-bakim/)
- [MQTT ile OEE ve Varlık Performansı Takibi](https://connectmq.com/tr/kullanim-senaryolari/varlik-performansi-takibi/)
- [MQTT ve UNS ile Endüstriyel Yapay Zekâ Ajanları](https://connectmq.com/tr/kullanim-senaryolari/endustriyel-yapay-zeka-ajanlari/)
- [MQTT ile Enerji Yönetimi ve Enerji İzleme](https://connectmq.com/tr/kullanim-senaryolari/enerji-yonetimi/)
- [MQTT ile Bağlı Araçlar ve Araç Telematiği](https://connectmq.com/tr/kullanim-senaryolari/bagli-araclar/)
- [MQTT ve OCPP ile Elektrikli Araç Şarj Yönetimi](https://connectmq.com/tr/kullanim-senaryolari/elektrikli-arac-sarj-yonetimi/)
- [MQTT ile Filo Yönetimi ve GPS Araç Takibi](https://connectmq.com/tr/kullanim-senaryolari/filo-yonetimi/)
- [MQTT ile Uzak Saha İzleme: Hücresel Ağ Üzerinden SCADA](https://connectmq.com/tr/kullanim-senaryolari/uzak-saha-varlik-izleme/)
- [MQTT ile Tank Seviye İzleme ve Uzaktan Tank Takibi](https://connectmq.com/tr/kullanim-senaryolari/tank-seviye-izleme/)
- [MQTT ile Akıllı Sayaç ve OSOS Verisi | MDM ve Faturalama](https://connectmq.com/tr/kullanim-senaryolari/akilli-sayac/)
- [MQTT ile GES ve RES İzleme | Güneş ve Rüzgar Santrali](https://connectmq.com/tr/kullanim-senaryolari/gunes-ve-ruzgar-santrali-izleme/)
- [MQTT ile Temiz Oda İzleme | GMP Ortam İzleme](https://connectmq.com/tr/kullanim-senaryolari/temiz-oda-ortam-izleme/)
- [MQTT ile Soğuk Zincir İzleme | Frigorifik ve Soğuk Oda](https://connectmq.com/tr/kullanim-senaryolari/soguk-zincir-izleme/)
- [Uzaktan Hasta İzleme (RPM) Verisi için MQTT](https://connectmq.com/tr/kullanim-senaryolari/uzaktan-hasta-izleme/)
- [MQTT ile Hastane Ekipman ve Tıbbi Cihaz Takibi](https://connectmq.com/tr/kullanim-senaryolari/tibbi-cihaz-takibi/)
- [MQTT ve WebSocket ile Gerçek Zamanlı Bildirimler](https://connectmq.com/tr/kullanim-senaryolari/gercek-zamanli-bildirimler/)
- [MQTT ile Akıllı Mağaza Operasyonları | Perakende IoT](https://connectmq.com/tr/kullanim-senaryolari/akilli-magaza-operasyonlari/)
- [MQTT ile ATM ve POS Terminal İzleme](https://connectmq.com/tr/kullanim-senaryolari/atm-ve-pos-terminal-izleme/)
- [MQTT ile Baz İstasyonu ve Şebeke Ekipmanı İzleme](https://connectmq.com/tr/kullanim-senaryolari/sebeke-ekipmani-izleme/)
- [Operatörler için IoT Platformu: Yönetilen MQTT Broker](https://connectmq.com/tr/kullanim-senaryolari/operatorler-icin-iot-platformu/)
- [MQTT ve WebSocket ile Gerçek Zamanlı Piyasa Verisi](https://connectmq.com/tr/kullanim-senaryolari/gercek-zamanli-piyasa-verisi/)
- [Tarım Dronları için MQTT: İlaçlama ve Gözlem Filoları](https://connectmq.com/tr/kullanim-senaryolari/tarim-dronlari/)
- [Seracılıkta IoT Sensörleri ve MQTT: İklim ve Substrat](https://connectmq.com/tr/kullanim-senaryolari/seracilikta-iot-sensorleri/)

## Optional

- [Sitemap](https://connectmq.com/sitemap.xml): every page in every language with hreflang alternates.