There is a light in your ceiling that turns on when you press a switch. No app opens. No hub decides. No cloud round-trip happens. The wire does it, and it has worked for a hundred years.
Matter Binding is the attempt to keep that property in a wireless world.
What Binding actually is
Binding is a cluster — 0x001E in the Matter data model — and it behaves like an address book living on the device that sends commands.
The device that presses (a switch, a dimmer, a sensor, a doorbell) holds a binding table. Each entry says: when this endpoint sends a command, deliver it to that node and that endpoint — or to that group.
The device that receives the command rarely knows anything about the sender. It only checks its Access Control List (ACL): is this node allowed to invoke this cluster on this endpoint?
Two devices, two pieces of configuration
This is the part that trips people up, so it is worth stating plainly:
- The initiator holds the binding table — where commands go.
- The target holds the ACL — who is allowed to send them.
Both must line up. A correct binding table with a missing ACL entry produces a command that is sent and rejected. A correct ACL with an empty binding table produces nothing at all, because nothing is ever sent. The failure looks identical from the sofa: the light does not come on.
Unicast and group
A binding entry can be one of two shapes.
Unicast — node plus endpoint. The initiator opens a CASE session to that specific device and invokes the cluster. One sender, one receiver, encrypted session, confirmed delivery.
Group — a group ID instead. The initiator sends a multicast message encrypted with a group key, and every member of the group acts on it. No CASE session, no per-device handshake, and it scales to a room full of lights.
Group binding needs more setup on both sides: a group key set and group key map on the initiator, the same key on every target, group membership on the target endpoint, and an ACL entry with group auth mode.
What Binding is not
Binding is not an automation. An automation is a rule that something else evaluates — a hub, a controller, an app. When that something else is offline, the rule stops.
Binding is not a scene. A scene is a stored set of attribute values. It says what state to set, not who is allowed to command whom.
Binding is a direct relationship between two devices, stored on the devices themselves. It keeps working when the hub is unplugged, when the internet is down, and when the vendor's cloud has a bad afternoon.
Why it is worth caring about
Latency. A bound command does not travel to a server and back. On a Thread network it is a local hop.
Resilience. No dependency on a controller being awake.
Predictability. The relationship is static. It does not silently re-evaluate because someone edited a rule at 2am.
The trade-off is equally clear: a binding is configuration, not logic. Change the device, and you rewrite the table. You cannot add a condition like "only after sunset" — that is what automations are for.
Where you meet it in practice
- A wall switch controlling a ceiling light
- A dimmer or scene panel driving a group of fixtures
- A doorbell triggering a chime
- A sensor commanding a light directly, without a hub in the path
What comes next in this series
Part 2 compares binding, automation and scenes — when each one is the right tool, and how each one fails.
Part 3 is a walkthrough of binding setup in our own app, screen by screen.
Part 4 is a troubleshooting guide: the eight failure modes we see most often, and what each one actually means.
Written by ReZ-TI. We build Matter over Thread lighting and controls, and we write about the parts of the standard that change how a house behaves.