Glossary

This glossary defines core Matter terminology. It is meant to help developers, testers, and advanced users understand the language behind device behavior, commissioning, and communication in Matter networks.

For a longer tour of the data model, see Concepts.

Node

A Node is a complete participant in a Matter network with a unique identity and address. In everyday terms, you can think of a Node as a logical “device” in the system—including phones, hubs, lights, locks, and similar products.

A single physical product can still be represented by one or more Nodes when the product architecture requires it.

All communication in Matter—reads, writes, commands, and state sync—starts and ends at a Node. When a Node is added to a Fabric, it receives a unique Operational Node ID on that Fabric.

A Node can expose multiple Endpoints, so one physical unit can offer several independent functions (for example, two outlets on one power strip: still one Node, two Endpoints).

More information: The Matter Data Model (Silicon Labs).

Fabric

A Fabric is a secure trust domain in Matter: Nodes inside the same Fabric can identify, authenticate, and communicate with each other using shared trust material. A Fabric is anchored by components such as Fabric ID, Root Node ID, and Root Public Key.

Nodes on the same Fabric share compatible trust information so they can exchange data securely.

A device may belong to multiple Fabrics (multi-admin). Each Fabric assigns its own Operational Node ID to that device.

Communication is scoped to a Fabric. Nodes on different Fabrics do not communicate as part of the same security context without additional commissioning/admin steps.

Learn more: Matter Fabric (Google Home for Developers).

Commissioning

Commissioning is the process of securely adding a new device (Commissionee) to a Fabric. Two roles matter most:

• Commissioner — A Node or application that runs the flow: authenticates the device, exchanges security material, and assigns an Operational Node ID on the Fabric.
• Commissionee — The device being added; it receives credentials and its Node identity for that Fabric.

The Commissioner’s job is to ensure the Commissionee is trusted and can participate securely with other Nodes on that Fabric.

At a high level, commissioning spans multiple stages (discovery, PASE/CASE, attestation, operational credentials, etc.).

*workflow diagram*

*Image/Gif*

Learn more: Commissioning (Google Home for Developers).

Endpoint

In Matter, an Endpoint is an independent functional unit within a Node. Each endpoint hosts clusters that define attributes, commands, and events—so the endpoint is where application behavior is modeled. Together, endpoints describe the full capability surface of the Node.

Example: a multi-sensor product might use:

• Endpoint 1 — Temperature measurement
• Endpoint 2 — Humidity measurement
• Endpoint 3 — Occupancy detection

Each endpoint can be addressed and managed separately so features can operate in parallel.

Matter also distinguishes:

• Leaf endpoints — Standalone; do not depend on sibling endpoints for core behavior.
• Composed endpoints — Integrate or depend on other endpoints to deliver their function.

*Image/Gif: endpoint composition*

A smart thermostat is a common pattern: one endpoint exposes measurement, another exposes heating/cooling control, and the control side uses data from the measurement side.

Endpoints are numbered, starting from 0. Endpoint 0 is special: it carries utility clusters for the whole Node—discovery, addressing, diagnostics, software update paths, and similar cross-cutting concerns.

Other endpoints are numbered sequentially; the same endpoint number on different Nodes can mean different feature sets, because each Node’s model is independent.

Cluster

A Cluster groups related attributes (state/configuration), commands (actions), and events (notifications of change) for one feature on an endpoint. Think of a cluster as the interface for a capability (on/off, level, color, etc.).

An endpoint can host many clusters; the same cluster type can also appear more than once when the product needs multiple parallel instances.

There are two primary interaction patterns:

• Server cluster — Stateful. Holds the authoritative data and executes requested behavior.
• Client cluster — Stateless interaction surface. Used to read/write attributes, subscribe to events, and invoke commands on a server peer.

Depending on its role in a interaction, a cluster instance may act as server or client, and a Node can host both kinds across different endpoints.

*Diagram SVG*

Attributes, Commands & Events

Attributes

Attributes represent state, configuration, or capability exposed by a cluster.

Examples: an On/Off cluster exposes on/off state; a Level cluster exposes current level; a switch might expose position. Attribute types include integers (uint8, etc.), strings, structs, arrays, and more.

Some attributes are fabric-scoped: they are only meaningful (or only accessible) within the same Fabric as the client.

Commands

Commands are named operations defined by a cluster. They are how a client asks a server to do something—the “verb” in the interaction model.

Direction is always explicit:

• Client → server (for example, “turn on this light”).
• Server → client is also possible where the model defines server-initiated exchanges.

A command can have a response path: success, error, or “unsupported” depending on the cluster rules and device capabilities.

Events

Events are timestamped records that something meaningful happened on a device—often richer than a single attribute snapshot for logging and diagnostics.

Events carry priority, a timestamp, and a monotonic counter (per stream) so consumers can order and de-duplicate what happened over time.

Border Router

A Border Router connects a local low-power mesh (commonly Thread) to other IP-based networks such as Wi‑Fi or Ethernet.

It lets Nodes on the mesh reach off-mesh IPv6 destinations—controllers, other Fabrics (where applicable), or broader LAN/internet paths—subject to your network and security configuration.

In Matter deployments, a Border Router is the gateway between mesh-attached accessories and the rest of your IP infrastructure.

For OpenThread’s reference implementation, see OpenThread Border Router.

Radio Co-Processor (RCP)

A Radio Co-Processor (RCP) is a dedicated radio/network coprocessor that handles Thread (and related) stack work off the main application MCU.

It typically owns timing-sensitive RF, MAC, and mesh routing details so the application processor can focus on product logic, UI, and higher-level Matter behavior. RCP-style designs are common for low-power or battery devices that still need reliable Thread mesh participation.