Home Assistant Glossary, Every Term You'll Actually Encounter

This post may contain affiliate links. As an Amazon Associate we earn from qualifying purchases. Disclosure.

Home Assistant runs on over 300,000 active installations worldwide, according to the project's own analytics dashboard, and a huge portion of new users bail in the first week, not because the platform is bad, but because the terminology is impenetrable. What's a helper? Why does my entity have a different name than my device? What even is MQTT? This glossary answers all of it in plain language, term by term.

Home Assistant setup guides

Core Concepts: What Are Entities, Devices, and Integrations?

These three terms are the foundation. Get them wrong and nothing else makes sense. An entity is a single data point or control exposed to Home Assistant, a temperature reading, a light switch state, a door sensor status. A device is the physical hardware that produces one or more entities. An integration is the software connector that links a device (or an online service) to Home Assistant.

Entities

An entity is the smallest unit Home Assistant works with. Every sensor reading, every switch toggle, every light brightness value, that's an entity. A Philips Hue bulb might expose four entities: on/off state, brightness level (0-255), color temperature (in Kelvin), and a signal strength sensor. You reference entities by their entity_id, which looks like light.living_room_lamp or sensor.outdoor_temperature.

Entity IDs follow a strict format: domain.name. The domain tells Home Assistant what kind of entity it is, light, switch, sensor, binary_sensor, climate, cover, and so on. The name part is auto-generated from the device name but you can rename it in Settings > Entities.

Devices

A device groups all the entities from one piece of hardware into a single record. When you pair a ZigBee door sensor, Home Assistant creates one device entry and then attaches two entities under it: a binary_sensor for open/closed state and a sensor for battery level. Devices show up in the Devices & Services panel. You don't control devices directly, you target their entities in automations.

Integrations

An integration is a plugin that teaches Home Assistant how to talk to a specific brand, protocol, or service. Home Assistant ships with over 3,400 built-in integrations as of version 2026.5. You'll find them under Settings > Devices & Services > Add Integration. Some integrations auto-discover devices on your network (Philips Hue, TP-Link Kasa). Others need a host address, API key, or account login.

Integration deep-dives

What Are Automations, Scripts, and Scenes?

Three tools for making your home act on its own, and they're not interchangeable. Automations run on triggers. Scripts are reusable action sequences you call manually or from other automations. Scenes snapshot a set of entity states and restore them on demand.

Automations

An automation has three parts: a trigger (what starts it), optional conditions (rules that must be true for it to run), and actions (what happens). Triggers can be time-based, state-based (entity changes state), event-based, or numeric (a sensor crosses a threshold). You build automations in the visual editor or write them in YAML in automations.yaml. I tested the UI editor extensively, it covers 90% of real-world use cases without touching a single line of YAML.

Scripts

Scripts are sequences of actions without a trigger. You run them manually from the dashboard, call them from an automation's action block, or trigger them via voice command. They're useful for shared action sequences, for example, a "movie mode" script that dims lights, closes blinds, and sets the TV input. Store them in scripts.yaml or create them through the UI.

Scenes

A scene is a snapshot. You configure which entities should be at what state, living room lights at 40% brightness, 2700K color temperature, TV on, and Home Assistant restores that exact configuration when you activate the scene. Scenes don't monitor state continuously; they're a one-time apply. Create them under Settings > Automations & Scenes.

What Are Helpers?

Helpers are virtual entities you create manually, they don't come from a physical device. They hold state that your automations can read and write. The most common ones are input_boolean (an on/off toggle), input_number (a numeric value), input_select (a dropdown list), input_text (a text string), and counter (an integer that increments/decrements). In my setup, I use an input_boolean as a "guest mode" flag, when it's on, motion-based automations don't trigger bedroom lights after 10 PM.

Helpers live under Settings > Devices & Services > Helpers. They're also accessible in YAML as regular entities. A timer helper (timer) is particularly handy, it counts down and fires an event when it expires, which you can use as an automation trigger.

Wireless Protocols: ZigBee, Z-Wave, and Thread

Home Assistant supports all three major local wireless protocols. Choosing the wrong one for your hardware is a common mistake.

ZigBee

ZigBee is a mesh wireless protocol running at 2.4 GHz. Devices route signals through each other, so range extends as you add more devices. Home Assistant uses ZHA (ZigBee Home Automation) or Zigbee2MQTT to manage ZigBee devices, both require a USB ZigBee coordinator like the SONOFF Zigbee 3.0 USB Dongle Plus (about $20). ZigBee is the most widely supported protocol in the Home Assistant ecosystem, with thousands of compatible sensors, bulbs, and switches.

Z-Wave

Z-Wave runs at 908 MHz in North America (868 MHz in Europe), which means it doesn't compete with your Wi-Fi or ZigBee network. It also has stricter certification requirements, so Z-Wave devices tend to be more reliable and consistent than ZigBee equivalents. You need a Z-Wave USB stick (the Zooz ZAC93 is a solid $40 option) and the Z-Wave JS integration. Z-Wave is the better choice for locks and security-critical devices where reliability matters more than price.

Thread and Matter

Thread is the newest mesh protocol, running at 2.4 GHz like ZigBee but using the IPv6 networking stack. It's the underlying network for Matter devices. Home Assistant added native Thread border router support in version 2023.4. Matter standardizes the application layer so one device can work with Home Assistant, Apple HomeKit, and Google Home without separate integrations. It's promising but still maturing, I wouldn't buy Thread-only hardware yet if compatibility breadth matters.

Smart lighting protocol comparison

YAML, Jinja2, and the Configuration Files

Home Assistant stores configuration in plain text YAML files. The main one is configuration.yaml in your config directory. For most installations this is /config/configuration.yaml, accessible via the File Editor add-on or SSH. YAML is sensitive to indentation; two spaces per level is the standard. Tabs break parsing completely.

Jinja2 is the template language Home Assistant uses inside automations and dashboards. It lets you compute values dynamically, checking entity states, doing math, formatting strings. A template like {{ states('sensor.outdoor_temperature') | float | round(1) }} reads a sensor value, converts it to a float, and rounds it to one decimal. Templates go inside {{ }} (value output) or {% %} (logic blocks like if/for).

In my experience, the most common YAML error new users hit is mixing tabs and spaces in the same file, the parser throws a cryptic "mapping values not allowed here" error with no line number. Always use a YAML linter before saving.

Add-ons and HACS

Add-ons are containerized applications running alongside Home Assistant OS or Supervised installations. The Mosquitto MQTT broker, the File Editor, ESPHome, and the Terminal & SSH add-on are all add-ons. They live in the Add-on Store (Supervisor > Add-on Store). You can't install add-ons on Home Assistant Container or Core installations, those are bare Python installs without the supervisor layer.

HACS (Home Assistant Community Store) is a separately installed integration that gives you access to thousands of community-made integrations, Lovelace cards, and themes that aren't in the official store. Install it by running a one-line script in the Terminal add-on. HACS doesn't automatically update its plugins, you approve updates manually, which is the right call for stability.

Lovelace and Dashboards

Lovelace is the name for Home Assistant's dashboard system. You build dashboards from cards, visual blocks that display entity state, trigger actions, or show history graphs. The default dashboard auto-generates cards for your devices. Custom dashboards let you arrange exactly what you want. Cards range from simple entity toggles to complex Markdown cards, map cards, and energy monitoring panels.

Smart home hub comparison

The Energy Dashboard (added in Home Assistant 2021.8) tracks electricity consumption, solar production, and grid import/export in one view. It requires energy monitoring entities, either from a smart meter integration or from plug-level power monitoring devices. It's one of the best free energy tracking tools available for home use, and it costs nothing beyond the hardware you're already running.

ESPHome and DIY Sensors

ESPHome is a framework for programming ESP32 and ESP8266 microcontrollers so they publish sensor data directly to Home Assistant over MQTT or the ESPHome native API. If you've ever wanted a custom CO2 sensor, a leak detector under your washing machine, or a soil moisture probe for your plants, ESPHome is how you actually build it without custom firmware from scratch. You flash the board once, then manage it entirely from the Home Assistant UI. The official ESPHome documentation covers every supported component and sensor type.

The terms you'll encounter when reading ESPHome tutorials: node (the physical ESP device), component (a sensor or output type), and substitutions (variables you define once and reuse across the config YAML). Most beginner builds use a DHT22 temperature/humidity sensor or a PIR motion sensor, both cost under $5 and pair with an ESP32 development board for another $4.

Supervisor, Core, OS, and Container: Which Version Are You Running?

Home Assistant ships in four installation types, and the differences matter:

• Home Assistant OS (previously HassOS): Full install including the operating system, recommended for dedicated hardware like a Raspberry Pi or NUC. Gives you access to add-ons and the Supervisor panel.
• Home Assistant Supervised: Runs on an existing Linux OS. Same features as HAOS but you manage the host yourself.
• Home Assistant Container: Docker-only. No Supervisor, no add-on store.
• Home Assistant Core: Bare Python install. Fewest features, most control.

Most tutorials assume HAOS or Supervised. If a guide mentions "go to Supervisor" and you don't see it in your sidebar, you're on Container or Core.

Webhooks and REST API

A webhook is an HTTP endpoint that Home Assistant exposes so external services can trigger automations. If your smart doorbell doesn't have a native integration, it might support webhook notifications: you give it a URL, it POSTs to that URL when someone rings, and your Home Assistant automation fires. Webhooks are one-way (push from external service in), while the REST API is bi-directional.

The Home Assistant REST API lets external scripts read and write entity states using standard HTTP requests. You authenticate with a Long-Lived Access Token generated in your profile settings. This is how custom scripts, Node-RED flows, and third-party dashboards actually talk to Home Assistant outside the UI.

Understanding this vocabulary makes every tutorial, forum post, and documentation page instantly more readable. There are terms you'll actually encounter on day one (entities, automations, YAML), and terms you'll encounter only after you've been running your setup for a few months (webhooks, ESPHome, the REST API). Start with entities and automations, everything else builds on those two concepts.