OpenNeato Home Assistant Integration

Sun, 31 May 2026 00:00:00 +0000

When Neato’s parent company Vorwerk shut down the cloud, perfectly good Botvac robot vacuums lost their app, their scheduling, and even parts of their error handling. OpenNeato (the upstream project) brings them back with a small ESP32 wired to the robot’s debug serial port, serving a local web UI over WiFi with no cloud, no app, and no account.

My contribution is the Home Assistant side. I run a fork whose reason for existing is a HACS-installable custom integration: it discovers the bridge on the LAN and exposes the robot as a first-class Home Assistant device, with no YAML.

The integration polls the bridge’s local HTTP API every 5 seconds and gives you:

A vacuum entity (start/stop/pause/dock/locate/spot, battery, status, fan-speed presets, errors).
A camera entity that renders the LIDAR cleaning map.
Sensors for battery diagnostics (cycle count, voltage, temperature), brush and vacuum motor speeds, WiFi, and cleaning stats.
Switches and buttons for motors and manual controls.

The ESP32 bridge firmware, web UI, and flash tool are the upstream project’s work; the firmware changes in my fork are minor endpoints to feed the integration. The result: my own Neato D6 now works at least as well as it did on the cloud, with more telemetry than the original app ever exposed.

Full write-up: Bringing a bricked Neato back to life. Both projects are open source under the MIT license.

Bringing a Bricked Neato Back to Life: OpenNeato and a Home Assistant Integration

Sun, 31 May 2026 00:00:00 +0000

My actual Neato D6 with the top shell off: the round LIDAR turret at the top, the mainboard and its ribbon cables on the left, the brush bay with its ’neato genuine’ label in the middle. This is where the ESP32 goes. The cloud is gone. The robot is not.

I was a Neato fan from early on. Back when robot vacuums mostly bumped around at random, Neato shipped models with a LIDAR turret on top, which gave them genuinely smarter navigation than the Roombas of the day: they mapped the room and cleaned it in deliberate lines instead of pinballing. I owned several over the years and happily recommended them to friends. The one I still run is a Neato Botvac D6, and I have used it as my daily vacuum for years.

It was never completely trouble-free. Now and then it gets stuck or eats a cable, and it has far fewer tricks than the new camera-based robots that analyse a whole room. But it is a good machine, and I kept it going: new brushes a few times, a fresh battery. Mechanically, it still works.

The day it became a brick

A few months ago, the servers were switched off. Neato had been wound down by its parent company Vorwerk back in 2023, and the cloud that the app depended on was shut off for good. Overnight, the app became useless. Worse, the robot leaned on the cloud for more than scheduling: even some of its error handling round-tripped through the server. So a perfectly functional, recently re-batteried vacuum turned into an expensive brick. It would still do a single manual clean if you pressed the button, but everything that made it smart was gone.

This is the part of the connected-hardware bargain nobody signs up for: the mechanics outlast the company, and the company takes the brains with it when it leaves.

The community fix: talk to the robot directly

It turns out these robots have a debug serial port on the mainboard, and the cleaning behaviour is driven by simple serial commands. So the community fix is delightfully direct: wire a small ESP32 onto that port and drive the robot yourself, with no cloud in the loop at all.

A few projects grew out of that idea. The one that worked best for me is OpenNeato, an open-source replacement for Neato’s dead cloud and app. The ESP32 talks to the Botvac (D3 to D7) over UART and serves a local web UI over WiFi. No cloud, no app, no account. It does scheduling, manual driving, a live LIDAR map, cleaning history, and push notifications through ntfy. All of it runs on a board that costs a few dollars and lives inside the robot.

The hardware side is conceptually simple: open the robot, find the serial header, pick up power and the serial TX/RX with a handful of wires to the ESP32, and route them back out. In practice, opening a Botvac is the fiddly part. I did not have a screwdriver fine enough for the screws, so I gently drilled out a bit of the plastic to reach them. Not elegant, but it worked, and the robot went back together cleanly in the end. That is my actual D6 opened up in the photo at the top of this post, LIDAR turret and all. Once it is buttoned up, the only outward sign is a small bundle of wires near the seam.

The one thing it was missing

OpenNeato’s web UI is great, and the ntfy notifications are a nice touch. But I run my whole house through Home Assistant, and that is where I want the vacuum to live: on my dashboards, in my automations, next to every other device. OpenNeato did not have a Home Assistant integration.

The good news was that the firmware already exposed everything over a clean local HTTP API (/api/*). All the data and all the controls were right there. What was missing was the glue: a Home Assistant integration that speaks that API and presents the robot as a proper HA device.

So I built it.

What I built: the Home Assistant integration

I made a fork of OpenNeato whose whole reason for existing is the Home Assistant side. It ships a HACS-installable custom integration that discovers the bridge on your network by IP or hostname and exposes the robot as a single, first-class HA device. No YAML, no extra add-on, no cloud round-trip. The integration polls the local API every 5 seconds over your LAN.

The robot shows up with the full set of entities you would want:

A vacuum entity with start, stop, pause, return-to-dock, locate, and spot-clean, plus battery level, status, fan-speed presets (Eco, Auto, Intense), and error reporting. It works with the standard Home Assistant vacuum cards out of the box.
A camera entity that renders the LIDAR cleaning map, so I can see where the robot has been right on my dashboard.
Sensors for the things the old app never bothered to surface: battery level and detailed battery diagnostics (cycle count, voltage, temperature), brush and vacuum motor speeds, WiFi signal, cleaning stats, and more.
Switches and buttons for the motors, manual error clearing, and the other controls the firmware exposes.

The firmware changes in the fork are deliberately minor (a few extra endpoints to feed the integration, like /api/sensors and some hardening of /api/history). The ESP32 bridge firmware, the web UI, and the flash tool are the work of the upstream project; my contribution is the Home Assistant layer on top.

The OpenNeato web UI, which runs entirely on the ESP32. The Home Assistant integration speaks the same local API this dashboard uses.

A nice detail of the underlying project: the web frontend is gzipped and embedded directly into the firmware binary, so a single over-the-air update ships both the firmware and the UI together. And the LIDAR map you get in the web UI is the same data the Home Assistant camera entity renders.

The LIDAR map from a cleaning session. In Home Assistant this becomes a camera entity you can drop straight onto a vacuum card.

Installing it

For anyone with a stranded Neato and a Home Assistant box, the integration install is the easy part:

In HACS, add the fork as a custom repository: https://github.com/Leicas/OpenNeato (category: Integration).
Search for OpenNeato in HACS and install it, then restart Home Assistant.
Go to Settings, Devices & Services, Add Integration, OpenNeato and enter the bridge hostname or IP (for example neato.local).

It needs firmware 1.0+ on the ESP32; the battery diagnostics need a slightly newer build. Everything is local-polling, so nothing leaves your network.

The result: better than the cloud it replaced

Since I started running this, my vacuum works at least as well as it did before, and honestly better. I get push notifications when a clean finishes or an error happens. I can see the battery state, the brush rotation speeds, the cleaning history, and the map, all inside Home Assistant. That is more information than the original Neato app ever gave me, on a robot the manufacturer had effectively declared dead.

There is something very satisfying about that. The hardware was always fine. What failed was a business decision and a server bill. A few dollars of ESP32, an open-source project, and a bit of integration glue were enough to take the robot back.

Links and credit

Upstream project: renjfk/OpenNeato, the ESP32 bridge firmware, web UI, and flash tool. If you only want the standalone web UI, use this directly.
My Home Assistant fork: Leicas/OpenNeato, with the HACS-installable Home Assistant integration. Use this if you run Home Assistant and want the robot as a first-class device.
Notifications: ntfy.

Both the upstream project and my fork are open source under the MIT license, and both are still early beta, so expect a few rough edges. If your Neato is sitting in a closet because the app stopped working, it does not have to stay there.

Neato | Antoine Weill--Duflos