If your blinds move on a schedule from a vendor app, that schedule probably runs on a server you do not control. It stops the day the vendor changes its API or your internet drops. The best smart blinds for Home Assistant skip that dependency, because the motor talks to a radio in your house and Home Assistant turns it into a cover entity that keeps the morning open and sunset close running offline. The real decision is the second device each blind needs: a coordinator, a border router, a Bluetooth adapter or a relay.
We picked six motors and relays across Matter over Thread, Zigbee, Bluetooth, Z-Wave and Wi-Fi. No motor was hung on a window for this guide, so hardware claims come from maker spec pages, device databases, Home Assistant docs and live Amazon US listings. Everything in the lab section was built on Home Assistant 2026.10.4 in October 2026 on an Ubuntu 26.04 VM with demo covers and two simulated Zigbee2MQTT blinds, so the states, errors and logs below are real.
Best smart blinds for Home Assistant at a glance
Read the radio column before the price, because it tells you what else has to be in the house. Prices are Amazon US bands from late October 2026 and they move often, so check the live listing before you order.
| Job | Pick | Radio to Home Assistant | Power | Price band |
|---|---|---|---|---|
| Retrofit a roller blind, Matter | Eve MotionBlinds Upgrade Kit | Matter over Thread | built-in battery, USB-C | about $170 (small tube) to $220 (large tube) |
| Curtains on a track, Zigbee | Aqara Curtain Driver E1 | Zigbee 3.0 | 6000 mAh battery, USB-C | about $90 (track) to $100 (rod) |
| Horizontal slat blinds | SwitchBot Blind Tilt | Bluetooth, or Matter via SwitchBot hub | 2000 mAh plus solar panel | about $60 |
| Curtains, no hub | SwitchBot Curtain 3 | Bluetooth, or Matter via SwitchBot hub | battery, USB-C | about $90 |
| Wired shade motor, Z-Wave | Shelly Wave Shutter | Z-Wave 800 | 120 V AC mains | about $41 |
| Wired shade motor, Wi-Fi | Shelly 2PM Gen4 | Wi-Fi (Shelly integration), Matter or Zigbee | 110-240 V AC or 24 V DC | about $39 |
Two patterns jump out of that table. The battery motors (Eve, Aqara, SwitchBot) retrofit a blind or curtain you already own, so the cost is one motor per window plus one radio for the house. The two Shelly relays are for a different reader entirely: someone whose shades already have a mains motor with separate up and down wires, where the cheapest path to local control is a $40 relay behind the switch plate.
How smart blinds reach Home Assistant
Every pick above lands in Home Assistant as a cover entity, but each one takes a different road to get there, and the road decides your extra hardware. Thread motors need a Thread border router feeding the Matter Server. On Home Assistant OS that server is an app you install in one click. On a Container install like our lab, the Matter docs call a standalone server unsupported. You run it anyway and point the integration at its URL. Zigbee motors pair with a Zigbee coordinator running ZHA or Zigbee2MQTT. Bluetooth motors need an adapter or an ESPHome Bluetooth proxy within range of the window, and wired relays join either a Z-Wave mesh or your Wi-Fi.

Home Assistant tags every integration with an IoT class, and that tag is the quickest way to tell a local blind from a cloud one. We read it from the manifest.json files inside the Home Assistant 2026.10.4 container in our lab, for the integrations a blind or shade can arrive through:
zwave_js local_push
matter local_push
zha local_polling
mqtt local_push
switchbot local_push
hunterdouglas_powerview local_polling
lutron_caseta local_push
motion_blinds local_push
overkiz local_polling
somfy_mylink assumed_state
shelly local_push
tuya cloud_push
smartthings cloud_push
soma local_polling
Anything marked local_push or local_polling keeps working on the LAN. The two cloud_push lines are the trap. A cheap Tuya Wi-Fi roller motor added through the tuya integration depends on Tuya’s servers, even though it sits a metre from your router. With assumed_state on somfy_mylink, Home Assistant never hears back from the shade. It guesses the position from the last command. IKEA’s own integration is tradfri, which polls the TRÅDFRI gateway locally; without that gateway, IKEA blinds pair to ZHA or Zigbee2MQTT like any other Zigbee device.
We’d choose the path in this order, based on what already runs in the house:
- A Thread border router is already on the LAN: a Matter over Thread motor such as the Eve kit drops in with no new radio.
- A Zigbee coordinator already runs your sensors: buy Zigbee motors, because a few battery motors add little load to an existing mesh.
- Neither, and only one or two windows: Bluetooth is the cheapest start, as long as a Bluetooth proxy can sit near the window.
- The shades already have mains motors: skip battery motors entirely and put a relay behind the wall switch.
Mixing paths is fine, but each extra radio is one more thing to update and back up, so most houses end up standardising on one for blinds.
How we picked and what we tested
Each pick had to clear three checks before it earned a place:
- Maker spec page: radio, power, limits and hub needs read from the manufacturer, not from a listing.
- Live Amazon US listing: the exact variant, in stock, with price and review count captured in late October 2026.
- Independent source: a Zigbee2MQTT or Z-Wave JS device file, or the Home Assistant integration page.
Products that failed one check moved to the made-to-measure section with the reason stated. That is why IKEA, SmartWings and iBlinds are not award picks, even though Home Assistant users run all three. The Eve kit is the thinnest on the third check: we found no device-database entry for it, so beyond Eve’s own page its support rests on Home Assistant’s Matter integration and the Amazon listing.
The lab side ran on a 2-vCPU Ubuntu 26.04.1 VM with Docker 29.9.2, the ghcr.io/home-assistant/home-assistant:stable image (2026.10.4) and a Mosquitto broker. The demo integration supplied five covers with different feature sets, and two MQTT discovery entities stood in for Zigbee2MQTT roller blinds, one of them with an inverted motor. That is enough to show how Home Assistant treats position, tilt and stop, what it refuses to do, and how automations drive covers. It is not a test of motor torque, battery life or radio range, and we don’t claim any of those numbers beyond what the makers publish.
Eve MotionBlinds Upgrade Kit for Matter over Thread
The Eve kit is the pick for anyone who wants Matter on an existing roller blind, because the motor slides into the blind’s existing roller tube and replaces the chain mechanism rather than hanging off the chain. It’s a Thread device with a built-in rechargeable battery charged over USB-C, it runs without an Eve cloud account, and in Home Assistant it arrives through the Matter integration as a cover with position control.

The catch is fitment, and Eve sells two motors for it. Measure the outside diameter of your roller tube before you order:
- Small-tube kit (B0GLXKLYYX): 25 to 30 mm tubes, blinds at least 22 in wide, 0.5 Nm of torque. Eve says this one may fit IKEA tubes.
- Large-tube kit (B0D54KR9W7): 38 to 51 mm tubes, blinds at least 26.75 in wide, 1.1 Nm. Eve says it does not fit IKEA or Hunter Douglas tubes.
- Both: need a Thread border router on the LAN; Home Assistant’s Matter integration does the rest.
Eve does not publish a battery-life figure on its product page, so we won’t invent one. Who it’s for: an owner of a plain roller blind who already has, or wants, a Thread network. Skip it if your blind is a cellular or slat type, or if you’d rather not take the blind down to fit a motor into the tube. The small-tube listing had only 10 Amazon reviews when we checked, and Eve’s own store showed the kit out of stock while Amazon had it. Expect about $170 for the small kit and about $220 for the large one, and check the live price.
Aqara Curtain Driver E1 on Zigbee
The Aqara Curtain Driver E1 is the Zigbee pick for curtains, and it pairs straight to Zigbee2MQTT (model ZNCLBL01LM) or ZHA without an Aqara hub. It clips onto the first glider of an existing track, pulls the curtain along, and reports position back, which is what makes a sunset close or a 30% heat-mode position possible in Home Assistant.
Aqara rates it for curtains up to 12 kg and quotes up to a year from the 6000 mAh battery, a figure that drops with heavy curtains, long tracks and friction. It charges over USB-C, can run from constant power, and carries a light sensor you can use as an extra trigger. The track version fits U-rail and I-rail tracks, and the rod version adds round rods; neither handles extendable rods or grommet-style curtains.
One detail on Aqara’s own page is easy to misread. Matter support for the E1 arrives as an update to an Aqara Zigbee hub, which then bridges the motor to Matter; the motor itself stays a Zigbee device. For Home Assistant that is irrelevant if you pair it directly to your coordinator. That is the route we would take, because it keeps the Aqara hub and app out of the control path.
The Amazon titles say an Aqara hub is required and other brands’ hubs are not supported. That wording describes the Aqara app route, not Zigbee2MQTT or ZHA. ZHA ships a quirk for the E1, and the Zigbee2MQTT device page lists a minimum coordinator firmware, so update an older CC2652 or ConBee II stick first. If you have not settled on a stack yet, our ZHA vs Zigbee2MQTT comparison covers the trade-off. Skip it if your curtains hang from grommets. Expect about $90 for the track version and about $100 for the rod version.
SwitchBot Blind Tilt for horizontal slat blinds
For venetian and faux-wood slat blinds, the SwitchBot Blind Tilt is the cheapest local option we found that works with Home Assistant. It clamps onto the tilt wand, turns the slats rather than raising the blind, and talks Bluetooth to Home Assistant’s SwitchBot integration, which is local push and needs no SwitchBot hub.
SwitchBot puts a 2000 mAh battery and a solar panel in the box and claims about two-degree tilt precision, plus a light sensor. The limit is Bluetooth range. Home Assistant needs a Bluetooth adapter on the server or an ESPHome Bluetooth proxy near the window, and a proxy is the usual answer once the server sits in a cupboard two rooms away. Bluetooth is the hub-free path. SwitchBot says a Hub 2 adds Matter support, so the hub can also bridge it to Home Assistant’s Matter integration, though Home Assistant’s SwitchBot Matter page does not list it as certified.
One quirk to plan for: Home Assistant maps the Blind Tilt’s tilt so that 50% is open and both 0% and 100% are closed, slats down and slats up. A routine that sets 30% therefore partly closes the slats downward, and the SwitchBot integration page gives a template cover workaround if you want a conventional scale.
Who it’s for: renters and anyone with slat blinds who wants privacy and glare control without changing the blind. Skip it if you need the blind to go up and down, because it only tilts. With 1,460 Amazon reviews it is also the most proven listing in this guide. Expect about $60, or a little more for the bundle with a remote.
SwitchBot Curtain 3 for curtains without a hub
The SwitchBot Curtain 3 covers the same job as the Aqara E1 but over Bluetooth, which makes it the better buy when you have no Zigbee coordinator and don’t want one. Home Assistant lists it as certified for its SwitchBot Bluetooth integration, and it also reaches Matter if you own a SwitchBot Hub 2 or Hub 3.
SwitchBot rates the rod version for curtains up to 15 kg and has a QuietDrift mode it puts under 25 dB. Center-opening curtains need two units, and the solar panel is sold separately. There are several near-identical listings, so match the style to your hardware: the U-rail version for tracks and the 2025 rod version for rods, both about $90.
Like the Blind Tilt, it depends on a Bluetooth adapter or proxy within range, and Home Assistant’s docs say calibration and pairing of two motors happen in the SwitchBot app before Home Assistant sees the device. Skip it if the window is far from any Bluetooth radio you control and you don’t want to add a proxy.
Shelly Wave Shutter for wired Z-Wave shades
If your shades or shutters already have a mains motor with separate up and down wires, a relay behind the switch is far cheaper than any battery motor. The Shelly Wave Shutter is the Z-Wave 800 option: a 120 V in-wall module that joins the mesh through a Z-Wave stick and Z-Wave JS, repeats for other nodes and meters power.
Shelly rates it at 7 A per channel and 1/3 hp, and the Z-Wave JS device file exposes a shutter endpoint and a slat-tilt endpoint. Parameter 71 picks the mode: shutter with positioning, venetian blind with slat positioning, or manual time set for motors without end switches. Parameter 78 runs calibration, which you must do before position reporting means anything. It needs a neutral wire and an AC motor; low-voltage and battery motors are out, and Shelly’s knowledge base recommends an RC snubber across the motor, which your electrician should see before the install. The long-range variant is a separate SKU and does not repeat in Long Range mode, so the standard one is the right buy for a mesh.
The listing is thin on social proof, with 6 reviews and low stock when we checked, so treat it as the specialist pick it is. Expect about $41.
Shelly 2PM Gen4 for wired motors on Wi-Fi
The Shelly 2PM Gen4 does the same wiring job as the Wave Shutter over Wi-Fi, and it’s the relay we’d pick for most houses without a Z-Wave mesh. Home Assistant’s Shelly integration is local push, and once you set the device profile to Cover and run calibration, you get position, stop and, on venetian blinds, slat control.
Shelly rates it at 10 A per channel and 16 A total on 110-240 V AC or 24 V DC, with metering per channel. The radio story needs reading carefully. The relay has Wi-Fi 6, Bluetooth 5.0 and a Zigbee radio, but it runs Matter over Wi-Fi by default. Five presses of the button switch it to the Zigbee profile instead, so it is Matter or Zigbee, never both. For blinds we would ignore both and use the native Shelly integration, because that is where calibration and metering live.
Check the listing before you buy. The single B0DZJ1W814 title does not say UL, while the UL-certified 2-pack does, and that matters if an electrician has to sign off the install. Skip it if your Wi-Fi is already struggling at the window wall. Expect about $39 for the single and about $78 for the UL 2-pack.
Made-to-measure shades and premium systems
Several popular options fell out of the award list for one stated reason each, and they’re still worth knowing about if you’re buying new shades rather than motorising old ones:
- SmartWings: made-to-order roller shades with a choice of Zigbee or Matter over Thread motor, sized from 16 to 110 in wide on Amazon. The Matter listing had 4 reviews and a third-party seller, and smartwings.com blocked our checks, so we could not confirm its Matter certification independently.
- IKEA KADRILJ, PRAKTLYSING, TREDANSEN: Zigbee blinds that Zigbee2MQTT supports as covers, paired through the TRÅDFRI repeater IKEA puts in the box. IKEA does not sell on Amazon and its US site blocked us, so current US range and prices are unverified.
- iBlinds V3.1: a Z-Wave Plus tilt motor that fits inside the headrail of 2 to 2.5 in corded slat blinds. It sells only on the maker’s site, it was sold out on 29 October 2026, and the charger costs extra.
- Lutron Serena: dealer or direct only; Home Assistant’s
lutron_casetaintegration is local push, handles Lutron shades as covers and lists the standard Caseta Smart Hub among its supported bridges. - Hunter Douglas PowerView: dealer only; the integration polls the hub locally, and Gen 3 shades report position while Gen 1 and Gen 2 Pebble remotes don’t.
- Somfy:
overkizhas a local API on TaHoma Switch and similar gateways, but RTS motors are one-way, so Home Assistant never knows their real position.
The pattern across that list is position feedback. A shade that reports where it is behaves like the demo covers below. A one-way RTS or myLink shade forces Home Assistant to guess, so automations that set a percentage drift out of step the first time someone uses the wall remote.
Cover entities in the Home Assistant lab
Home Assistant does not know a Zigbee blind from a Z-Wave relay once it’s a cover; it knows a set of features, and those features decide which actions an automation may call. The integration reports them as the supported_features bitmask, and the values in the 2026.10.4 container are:
| Feature | Value | Feature | Value |
|---|---|---|---|
| OPEN | 1 | OPEN_TILT | 16 |
| CLOSE | 2 | CLOSE_TILT | 32 |
| SET_POSITION | 4 | STOP_TILT | 64 |
| STOP | 8 | SET_TILT_POSITION | 128 |
| SPEED | 256 |
Here are the seven cover entities in the lab, read from the REST API, with the feature number decoded. A battery roller blind on Zigbee2MQTT or Matter usually looks like the two MQTT rows; a tilt-only device like the Blind Tilt looks like the pergola roof:
| Entity | State | Position | Tilt | Features | What it can do |
|---|---|---|---|---|---|
| cover.office_roller_blind (MQTT) | open | 40 | none | 15 | open, close, set position, stop |
| cover.bedroom_roller_blind, inverted (MQTT) | open | 70 | none | 15 | open, close, set position, stop |
| cover.hall_window | open | 10 | none | 15 | open, close, set position, stop |
| cover.living_room_window | open | 70 | 50 | 511 | everything, including tilt and speed |
| cover.kitchen_window | closed | none | none | 11 | open, close, stop, no position |
| cover.pergola_roof | closed | none | 60 | 240 | tilt only |
| cover.garage_door | closed | none | none | 3 | open and close only |
Calling an action the cover doesn’t support fails loudly, which is useful because it tells you at test time rather than at sunset. Asking the garage door and the tilt-only pergola for a position or tilt they lack returned HTTP 400 with these messages:
{"message":"Entity cover.garage_door does not support action cover.set_cover_tilt_position"}
{"message":"Entity cover.garage_door does not support action cover.set_cover_position"}
{"message":"Entity cover.pergola_roof does not support action cover.set_cover_position"}
The same thing happens inside an automation, except nobody is watching. Our first heat-mode automation targeted the kitchen window, whose feature number 11 has no SET_POSITION, and the trigger fired but the cover never moved. The only trace was this line in the Home Assistant log:
Error while executing automation automation.kitchen_window_cover_to_30_percent_in_heat_mode: Entity cover.kitchen_window does not support action cover.set_cover_position
So before you buy, check that the motor reports position, not only open and close. A blind that exposes features 11 or 3 can’t do the half-drop or 30% routines most people buy smart blinds for. Stop works on any cover with feature 8: in the lab a cover sent to 100% from 50% was at 80% after three seconds, and after cover.stop_cover it stayed at 80% six seconds later.
The inverted motor problem
Some roller motors report 0 for open and 100 for closed, the opposite of Home Assistant’s convention, and the blind then shows open when it’s down. The MQTT cover has position_open and position_closed options for this (see the MQTT cover docs), and we set them to 0 and 100 on the bedroom blind. When the simulated motor published a raw position of 30, Home Assistant showed the blind open at 70%:

The command direction is where it bit us. Setting both blinds to 25% produced these messages on the broker, the first two being the simulated motor states and the last two what Home Assistant sent back:
zigbee2mqtt/office_blind {"position": 40, "state": "OPEN"}
zigbee2mqtt/bedroom_blind {"position": 30}
zigbee2mqtt/office_blind/set {"position": 25 }
zigbee2mqtt/bedroom_blind/set {"position": 25 }
Our command template used {{ position }}, and it sent 25 to the inverted motor as well, so the inversion applied to the state Home Assistant displays but not to that command. The reason is the template variable: in the MQTT cover code, position is Home Assistant’s own percentage, while value is the number already mapped through position_open and position_closed. Use {{ value }} in the template, or drop the template, or fix the inversion in Zigbee2MQTT instead, then send a single 25% command and look at the window before you build automations on it. One small trap from the same test: a discovery payload with both a device block and an entity name produced doubled entity IDs such as cover.office_roller_blind_office_roller_blind. Home Assistant’s MQTT entity naming rules explain it: set the entity name to null and the entity takes the device name instead.
Automations that drive covers
These are the three automations we ran, exactly as they sat in automations.yaml on the lab VM. On a Docker install, the file lives in the host directory you bind-mounted to /config, which was /opt/ha/config in our lab:
sudo vim /opt/ha/config/automations.yaml
The file holds a sun trigger with an offset, a helper-driven position and a weekday morning open:
- id: close_living_room_at_sunset
alias: Close living room window cover at sunset
description: Close the living room window cover 30 minutes before sunset
triggers:
- trigger: sun
event: sunset
offset: "-00:30:00"
actions:
- action: cover.close_cover
target:
entity_id: cover.living_room_window
- id: hall_cover_heat_mode
alias: Hall window cover to 30 percent in heat mode
triggers:
- trigger: state
entity_id: input_boolean.heat_mode
to: "on"
actions:
- action: cover.set_cover_position
target:
entity_id: cover.hall_window
data:
position: 30
- id: open_blinds_weekday_morning
alias: Open blinds at 07:30 on weekdays
triggers:
- trigger: time
at: "07:30:00"
conditions:
- condition: time
weekday: [mon, tue, wed, thu, fri]
actions:
- action: cover.open_cover
target:
entity_id:
- cover.office_roller_blind_office_roller_blind
- cover.bedroom_roller_blind_bedroom_roller_blind_inverted_motor
The heat_mode helper is an input_boolean. Our lab configuration.yaml was this short:
default_config:
demo:
input_boolean:
heat_mode:
name: Heat mode
automation: !include automations.yaml
Leave out demo: on a real install, since it only adds the sample covers we tested against. Validate the configuration before reloading:
docker exec homeassistant python -m homeassistant --script check_config --config /config
A clean run prints one line and exits 0:
Testing configuration at /config
Then reload automations from Developer tools, YAML, Automations, or call the automation.reload action, so the new rules load without a restart.
Turning heat_mode on through the API fired the hall window automation, and the logbook shows the whole chain in two seconds, from helper to cover at 30%:
2026-10-29T08:34:05.509432+00:00 input_boolean.heat_mode | Heat mode | None | on
2026-10-29T08:34:05.509763+00:00 automation.hall_window_cover_to_30_percent_in_heat_mode | Hall window cover to 30 percent in heat mode | triggered by state of input_boolean.heat_mode |
2026-10-29T08:34:05.510481+00:00 cover.hall_window | Hall Window | None | opening
2026-10-29T08:34:07.512240+00:00 cover.hall_window | Hall Window | None | open
A real motor takes longer than a demo cover, but the shape is the same, and every step ran on the VM without an internet dependency. If you are still choosing the box that runs all this, our mini PC for Home Assistant guide covers the hardware, and the Docker install guide matches the container setup used here.
What to check before you order
Every pick above can go wrong on fitment or radio before the motor ever turns. Work through these before you click buy:
- Position feedback: the motor must report a percentage, or Home Assistant can only open and close it, as the kitchen window above showed.
- Tube, track or rod: measure the roller tube diameter for the Eve kit, and the rail type for curtain motors; grommet curtains and extendable rods rule out the Aqara E1.
- The second device: a Thread border router, a Zigbee coordinator, a Bluetooth proxy near the window, or a Z-Wave stick. Price it in.
- Power: battery motors want a charge every few months to a year by the makers’ own claims; wired relays need a neutral and an AC motor with separate up and down wires.
- The integration’s IoT class:
local_pushorlocal_pollingis what you want; avoid anything that only reaches Home Assistant throughtuyaor another cloud integration. - Calibration: SwitchBot calibrates in its app first, Shelly in its web UI or a Z-Wave parameter, so plan a calibration pass per window before any automation.
If the house already runs a local thermostat or Z-Wave lock, follow the radio you already maintain; one well-placed mesh beats three half-built ones.
The cost of four windows
Per-window prices hide the real cost, which is the radio. The table prices four windows on each path at the late-October 2026 Amazon prices above, before any radio hardware you may already own:
| Path | Four motors or relays | Plus |
|---|---|---|
| Eve MotionBlinds, small tube | about $680 | a Thread border router |
| Aqara Curtain Driver E1, track | about $360 | a Zigbee coordinator |
| SwitchBot Blind Tilt | about $240 | Bluetooth in range of each window |
| SwitchBot Curtain 3 | about $360 | Bluetooth in range of each window |
| Shelly Wave Shutter | about $164 | a Z-Wave stick, existing AC motors |
| Shelly 2PM Gen4, two UL 2-packs | about $157 | Wi-Fi, existing AC motors |
The relays look cheapest because they assume the expensive part, a motorised shade, is already on the wall. Among the retrofits, Bluetooth is cheapest for a room or two and gets dearer once you add proxies across the house, while Zigbee spreads the coordinator cost thinner with every window. We’d put the Eve kit on the one or two roller blinds where Matter matters to you, Aqara or SwitchBot on curtains, and stop there until the house has a radio you’d want to grow.




