Dreame Robot Vacuum + Home Assistant: My Automations (2026)

My Dreame vacuum hasn’t been manually started in months. I tested and built a set of Home Assistant automations that handle everything: it cleans when the house is empty, avoids rooms where people are sitting, does a kitchen run after dinner, and empties its dock at night when nobody’s awake to hear it. Here’s the exact setup.

Why Automate a Robot Vacuum?

A robot vacuum that you have to manually start is barely better than a regular vacuum. The whole point is hands-free cleaning, and that means proper automation. Pressing “clean” in an app every day isn’t automation, it’s just a remote control.

With Home Assistant, your vacuum becomes genuinely smart. It knows when you leave, which rooms are occupied, what time it is, and whether the dustbin is full. That context turns a dumb cleaning robot into something that actually fits your life without any daily input from you.

If you haven’t picked a robot vacuum yet, check our best robot vacuum 2026 roundup or our Dreame vs Roborock comparison.

My Hardware

• Dreame L20 Ultra (auto-empty dock, mop washing, hot air drying)
• Home Assistant on a mini PC (Intel N100)
• Aqara FP2 presence sensors (2x, living room and office)
• Phone-based presence detection for away/home status

The Dreame L20 Ultra was about €900 when I bought it. Not cheap, but the auto-empty and self-cleaning mop mean it truly runs itself. The FP2 sensors cost €60 each and detect room occupancy with mmWave radar (not just motion, actual presence).

Connecting Dreame to Home Assistant

The Dreame integration for Home Assistant is official and works well. Here’s how to set it up:

1. Install the Dreame Vacuum integration from HACS (Home Assistant Community Store)
2. Log in with your Dreame/Xiaomi account credentials
3. Select your vacuum from the device list

Once connected, you get:

• Vacuum state (cleaning, idle, docked, error)
• Battery level
• Current room being cleaned
• Map with room segments
• Brush/filter life remaining
• Controls (start, stop, pause, return to dock)
• Room-specific cleaning commands

The integration exposes room segments by ID, so you can tell the vacuum to clean only specific rooms. This is critical for the automations below.

For more on making the most of HA integrations, see our best Home Assistant integrations guide.

My 5 Automations (With YAML)

Automation 1: Clean When Everyone Leaves

This is the foundation. When the last person leaves the house, start a full clean. When someone arrives home, send the vacuum back to the dock.

How it works: I use the Home Assistant companion app on both my phone and my partner’s phone for presence detection. HA tracks our zones (home, work, etc.) and has a “group.family” entity that shows “not_home” when everyone is away.

automation:
  - alias: "Vacuum - Start when everyone leaves"
    trigger:
      - platform: state
        entity_id: group.family
        to: "not_home"
        for: "00:05:00"
    condition:
      - condition: state
        entity_id: vacuum.dreame_l20_ultra
        state: "docked"
      - condition: numeric_state
        entity_id: vacuum.dreame_l20_ultra
        attribute: battery_level
        above: 50
    action:
      - service: vacuum.start
        target:
          entity_id: vacuum.dreame_l20_ultra

The 5-minute delay prevents false triggers (stepping outside to grab a package shouldn’t start a cleaning cycle). The battery check ensures it won’t start with insufficient charge for a full run.

Reliability: 9/10. Works every time. The only failures are when presence detection glitches (maybe once a month someone’s phone drops off WiFi briefly). The 5-minute buffer catches most of those.

Automation 2: Avoid Occupied Rooms

When someone is in a room, skip that room. This uses the Aqara FP2 sensors for occupancy detection. The vacuum still cleans the rest of the house, it just avoids rooms where people are present.

automation:
  - alias: "Vacuum - Skip occupied rooms"
    trigger:
      - platform: state
        entity_id: vacuum.dreame_l20_ultra
        attribute: status
        to: "cleaning"
    action:
      - service: dreame_vacuum.vacuum_clean_segment
        data:
          entity_id: vacuum.dreame_l20_ultra
          segments: >
            {% set occupied = [] %}
            {% if is_state('binary_sensor.fp2_living_room_presence', 'on') %}
              {% set occupied = occupied + [3] %}
            {% endif %}
            {% if is_state('binary_sensor.fp2_office_presence', 'on') %}
              {% set occupied = occupied + [5] %}
            {% endif %}
            {% set all_rooms = [1,2,3,4,5,6] %}
            {{ all_rooms | reject('in', occupied) | list }}

The room segment IDs (1-6) map to rooms in the Dreame app. You’ll need to check your own mapping since these are specific to your floorplan.

Reliability: 8/10. The FP2 sensors are excellent at detecting presence (even someone sitting still reading). Occasional issues when the vacuum starts between room transitions, like if someone walks from the living room to the kitchen during the decision moment.

Automation 3: Kitchen-Only Clean After Dinner

Every evening, if the kitchen was occupied between 7-8 PM (dinner time) and then becomes unoccupied, run a kitchen-only clean. This catches crumbs and food debris right after we eat.

automation:
  - alias: "Vacuum - Kitchen after dinner"
    trigger:
      - platform: state
        entity_id: binary_sensor.fp2_kitchen_presence
        to: "off"
        for: "00:10:00"
    condition:
      - condition: time
        after: "19:30:00"
        before: "21:00:00"
      - condition: state
        entity_id: vacuum.dreame_l20_ultra
        state: "docked"
      - condition: state
        entity_id: input_boolean.kitchen_cleaned_today
        state: "off"
    action:
      - service: dreame_vacuum.vacuum_clean_segment
        data:
          entity_id: vacuum.dreame_l20_ultra
          segments: [2]
          suction_level: "turbo"
      - service: input_boolean.turn_on
        target:
          entity_id: input_boolean.kitchen_cleaned_today

I use an input_boolean helper to prevent the kitchen from being cleaned multiple times in one evening (otherwise it’d trigger every time someone leaves and returns to the kitchen). The helper resets at midnight via a separate automation.

The turbo suction level is key here. Kitchen debris (crumbs, rice, small food bits) needs more power than regular dust.

Reliability: 9/10. Very consistent. The 10-minute presence timeout ensures dinner is actually over, not just a bathroom break mid-meal.

Automation 4: Empty Dock at 11 PM

The auto-empty feature on the Dreame L20 Ultra is loud. Like, startlingly loud. By default it empties right after cleaning, which is fine when you’re away but terrible at 9 PM when you’re watching a movie.

My solution: disable auto-empty on the vacuum itself, then trigger it via HA at 11 PM when we’re usually in bed (bedrooms are upstairs, dock is downstairs).

automation:
  - alias: "Vacuum - Empty dock at 11pm"
    trigger:
      - platform: time
        at: "23:00:00"
    condition:
      - condition: state
        entity_id: vacuum.dreame_l20_ultra
        state: "docked"
      - condition: numeric_state
        entity_id: sensor.dreame_l20_ultra_dust_collection
        above: 60
    action:
      - service: dreame_vacuum.vacuum_start_auto_empty
        target:
          entity_id: vacuum.dreame_l20_ultra

The dust collection sensor check (above 60%) prevents unnecessary emptying when the bin isn’t very full. No point running that loud motor for a half-empty dustbin.

Reliability: 10/10. Dead simple time-based trigger. Never fails unless the vacuum isn’t docked (which rarely happens since it returns home after every clean).

Automation 5: Maintenance Alerts

The vacuum tracks brush hours, filter condition, and mop pad wear. I get notifications when anything needs attention.

automation:
  - alias: "Vacuum - Maintenance alerts"
    trigger:
      - platform: numeric_state
        entity_id: sensor.dreame_l20_ultra_main_brush_life
        below: 10
      - platform: numeric_state
        entity_id: sensor.dreame_l20_ultra_side_brush_life
        below: 10
      - platform: numeric_state
        entity_id: sensor.dreame_l20_ultra_filter_life
        below: 10
    action:
      - service: notify.mobile_app_pieter_phone
        data:
          title: "Vacuum Maintenance"
          message: >
            {{ trigger.to_state.name }} is at {{ trigger.to_state.state }}%. 
            Time to replace it.

Reliability: 10/10. Simple sensor threshold. Main brush lasts about 6 months, side brushes 3 months, filter 4 months in my usage.

My Automations Summary Table

Automation	Trigger	Conditions	What It Does	Reliability
Clean when everyone leaves	Group “family” goes to not_home for 5 min	Vacuum docked, battery above 50%	Full house clean	9/10
Avoid occupied rooms	Vacuum starts cleaning	FP2 detects presence in specific rooms	Skips rooms with people	8/10
Kitchen after dinner	Kitchen unoccupied for 10 min	Between 7:30-9 PM, not already cleaned today	Kitchen-only clean on turbo	9/10
Empty dock at night	Time: 11:00 PM	Vacuum docked, dust bin above 60%	Runs auto-empty cycle	10/10
Maintenance alerts	Brush/filter life below 10%	None	Push notification to phone	10/10

Dashboard Setup

I have a dedicated vacuum card on my HA dashboard showing:

• Live map with vacuum position
• Battery level
• Current status
• Last clean time and duration
• Quick buttons: clean all, clean kitchen, return to dock
• Brush/filter life gauges

The Dreame integration provides a map camera entity that shows the floorplan with the vacuum’s position in real-time. It’s surprisingly satisfying to watch.

What I Learned After Months of Use

Presence detection is everything. Without reliable presence detection, most of these automations fall apart. Phone-based presence (GPS + WiFi) works for home/away. FP2 sensors work for room-level occupancy. Don’t try to do room-level with phone GPS, it’s not accurate enough.

Start simple, then add complexity. My first automation was just “clean when I leave.” I added the room avoidance and kitchen schedule weeks later after the basic setup proved reliable.

The vacuum needs a consistent map. If you rearrange furniture frequently, the room segment IDs might change after a remap. I keep my layout fairly stable and only remap when something major moves.

Suction levels matter for different rooms. Kitchen gets turbo (food debris). Bedrooms get quiet mode (less dust, less noise if someone’s napping). Living room gets standard.

If you’re looking for other budget devices to pair with your vacuum setup, check out our list of best smart home devices under €50.

Common Issues and Fixes

Vacuum doesn’t start when triggered: Check battery level. Below 20% and some models refuse to start. Also verify the vacuum state is “docked” not “idle” (they’re different).

Room segments don’t match: After a firmware update or remap, segment IDs can shift. Go to the Dreame integration entities and check the segment mapping.

Presence detection false triggers: Add a time delay to your away trigger (I use 5 minutes). Also make sure all family members’ phones are in the HA companion app and tracking correctly.

Vacuum gets stuck during automated runs: I added a simple automation that notifies me if the vacuum has been in “error” state for more than 2 minutes. Happens maybe once a month (usually a sock on the floor).

Is This Setup Worth It?

Absolutely. I tested this over many months and the vacuum runs itself completely now. The combination of presence detection and room-awareness means it cleans at the right time, in the right rooms, without disturbing anyone. That’s what automation should be: invisible.

The Dreame L20 Ultra plus two FP2 sensors plus Home Assistant gives you a cleaning system that’s smarter than anything you’d get from any vendor’s own app. The Dreame app can do scheduled cleans, sure. But it can’t know you just left the house, or that your partner is working in the office, or that dinner just ended.

That context is what makes HA automation genuinely useful rather than just a party trick.

For the full guide on getting Home Assistant running, start with our beginner guide. And for choosing the best ecosystem for your whole home, see our smart home ecosystem comparison.

FAQ

Which Dreame vacuums work with Home Assistant?

Most Dreame vacuums from 2023 onwards work with the HACS Dreame integration: the L20 Ultra, L10s Pro, D10 Plus, and newer models. Older models (pre-2022) may need the Xiaomi Miio integration instead. I tested with the L20 Ultra and can confirm full room control, map display, and auto-empty triggers all work.

Do I need presence sensors for vacuum automation?

For basic “clean when I leave” automation, phone-based presence detection is enough. For room-avoidance (skipping occupied rooms), you need room-level presence sensors like the Aqara FP2. Regular motion sensors won’t work because they can’t detect someone sitting still. The FP2 uses mmWave radar for true presence detection.

Can I control which rooms get cleaned from Home Assistant?

Yes. The Dreame integration exposes room segments, so you can send the vacuum to clean specific rooms. You need the room mapping from the Dreame app (do a full clean first so it maps your house), then use the segment IDs in your automations. I clean individual rooms like the kitchen on a separate schedule from the full-house run.

How reliable are these automations day-to-day?

Very reliable. In my experience over several months, the “clean when leaving” automation works about 95% of days without any intervention. The main failure points are presence detection glitches (phone drops WiFi briefly) and physical obstacles (the vacuum gets stuck on a cable or shoe). I get maybe 2-3 false triggers per month, and the vacuum gets stuck about once a month.

Does the Dreame vacuum need internet for Home Assistant control?

The HACS Dreame integration currently uses the Dreame cloud API, so yes, internet is needed for HA communication. This is different from something like Valetudo (which makes vacuums fully local), but Valetudo doesn’t support Dreame models well yet. The cloud dependency is a tradeoff, but in practice the latency is under 2 seconds for commands, which is fine for automation triggers.