Zigbee vs. Matter over Thread: Understanding IoT Protocol Performance in Practice

TL;DR

This paper empirically compares Zigbee and Matter over Thread IoT protocols, revealing their distinct strengths in responsiveness versus scalability and robustness in real-world scenarios.

Contribution

It provides the first comprehensive experimental performance comparison of Zigbee and Matter over Thread in realistic IoT network conditions.

Findings

Zigbee has lower baseline overhead and faster route recovery.

Matter over Thread offers better scalability and robustness.

Both protocols exhibit different trade-offs in efficiency and scalability.

Abstract

The widespread adoption of the Internet of Things (IoT) has positioned smart homes as paradigmatic examples of distributed automation systems, where reliability, efficiency, and interoperability depend critically on the underlying communication protocol. Among the low-power wireless technologies available for this scenario, Zigbee and Matter over Thread have emerged as leading contenders. While Zigbee represents a mature, non-IP mesh networking solution, Matter over Thread introduces an IP-based architecture designed to unify device interoperability across different ecosystems. However, despite extensive documentation of their design principles, there is a lack of empirical, comparative performance data under realistic network conditions. This paper presents a comprehensive experimental comparison between the two protocols, conducted on a testbed built from commercially available hardware. The proposed methodology focuses on different key performance dimensions, such as scalability, responsiveness, and fault tolerance. The results reveal that Zigbee achieves a lower baseline overhead and faster route recovery, making it more responsive in static small-scale deployments. Matter over Thread, conversely, exhibits superior scalability and robustness, maintaining stable throughput and predictable latency across multi-hop scenarios. Overall, we highlight that Zigbee and Matter over Thread embody distinct trade-offs between agility, efficiency, and scalability.