Eufy Gets a Major Home Assistant Upgrade

If you have Eufy cameras, doorbells, HomeBase devices or other Eufy hardware connected to Home Assistant, there is a new project that is worth paying attention to.

The new eufy-sdk project from mega-yfue brings a completely new approach to integrating Eufy devices with Home Assistant. It consists of several components working together, including a new bridge, an SDK and a HACS integration.

I have been testing it myself, and considering that the project was only released on September 11, 2026, my first impression is surprisingly good. Most of what I use works, the integration feels stable so far, and it looks like a very promising replacement for the old Eufy Security integration.

There is one important caveat: this is still a very new project. I have not been running it for months, so this is definitely an early impression rather than a long-term reliability report.

What happened to the old Eufy integration?

For years, the main way of bringing Eufy Security devices into Home Assistant was the excellent community project by fuatakgun, simply known as Eufy Security.

That project provided support for cameras, doorbells, HomeBase stations, motion sensors and other Eufy devices. It also became quite feature-rich over time.

However, that integration is now EOL, which means it is time to look for an alternative if you still depend on it.

The new project takes a different approach rather than simply continuing the existing integration.

And that is where things get interesting.

A new architecture

The new solution is actually made up of several pieces.

At the bottom is eufy-sdk, which is the underlying software library. It is not something you install directly into Home Assistant. Instead, it provides a common interface for Eufy devices, realtime events and live media. The project describes it as a building block for other integrations rather than an end-user application.

Then there is ha-eufy-sdk-bridge.

The bridge is the part that actually logs into your Eufy account and communicates with the Eufy ecosystem. It exposes device information, events, snapshots and video to other applications. It also bundles go2rtc, so live camera streams can be provided without installing a separate go2rtc server.

Finally, we have ha-eufy-sdk, the HACS integration.

This is the part Home Assistant actually talks to. It connects to the bridge over WebSocket and turns the devices reported by the bridge into normal Home Assistant entities.

The architecture therefore looks roughly like this:

                 Eufy
                  │
                  ▼
             eufy-sdk
                  │
                  ▼
        ha-eufy-sdk-bridge
          │              │
          │              └── go2rtc
          │                    │
          ▼                    ▼
     Device data          Live video
          │                    │
          └─────────┬──────────┘
                    ▼
             ha-eufy-sdk
                (HACS)
                    │
                    ▼
             Home Assistant

It may sound slightly more complicated than the old integration, but the separation actually makes a lot of sense.

What does it support?

This is where the new integration gets interesting.

The HACS integration creates entities based on the capabilities reported by each device. That means you don’t necessarily get the same entities for every Eufy device, but the integration can expose quite a lot of functionality where the hardware supports it.

For cameras and doorbells, this includes things such as:

• Live video
• WebRTC/HLS streaming
• Snapshots
• Last-event images
• Motion events
• Person detection
• Pet detection
• Package detection
• Doorbell presses

Other supported device types can expose:

• Battery and signal sensors
• Device status
• Lights
• Brightness and RGB control
• Switches
• Select entities
• Number entities
• Privacy settings
• Night vision
• Recording and video quality
• Supported locks
• Robot vacuums
• Lawn mowers

The project is also designed to add support based on device capabilities rather than requiring a separate piece of integration code for every individual device.

That should make the integration easier to expand as more devices are tested.

Installing it in Home Assistant

There are two parts to the installation, and this is important.

You need to install the bridge first.

1. Install the Eufy SDK Bridge

The ha-eufy-sdk-bridge project is available as a Docker container and there is also a Home Assistant add-on wrapper.

For Home Assistant OS users, the app is likely the easiest option. To do so, just add https://github.com/mega-yfue/ha-eufy-sdk-bridge as a new repository under Apps (settings -> apps -> install app -> “three dots” -> repositories -> add)

The bridge handles the Eufy login and communication with your devices. It also provides the go2rtc functionality used for live video.

The project supports the normal Eufy login flow, including 2FA and CAPTCHA handling where required.

If you are running Home Assistant Container rather than HAOS, the bridge can instead be run as a Docker container alongside Home Assistant.

The important point is simply:

Get the bridge running and connected to your Eufy account before installing the HACS integration.

2. Install the HACS integration

Once the bridge is working, install ha-eufy-sdk through HACS.

If the repository isn’t already available in the normal HACS search, add it as a custom repository:

https://github.com/mega-yfue/ha-eufy-sdk

Select Integration as the repository type and install it.

Restart Home Assistant when HACS asks you to.

Then go to:

Settings → Devices & services → Add Integration

Search for:

eufy-sdk

The integration asks for the bridge address and port, although it can also auto-discover the Home Assistant add-on when running under Supervisor. Once connected, the devices reported by the bridge should appear automatically.

One nice touch is that the configuration flow can also handle Eufy’s 2FA or CAPTCHA requirements during the initial login process.

A simple Home Assistant automation

Once the devices are available as normal Home Assistant entities, the interesting part begins.

For example, one useful automation is to turn on a light when the Eufy doorbell detects a person after dark.

The exact entity names will depend on your devices, but the automation could look something like this:

alias: Eufy Doorbell - Front Door Light
description: Turn on the front door light when a person is detected after dark
triggers:
  - trigger: state
    entity_id: binary_sensor.eufy_doorbell_person
    to: "on"

conditions:
  - condition: sun
    after: sunset
    before: sunrise

actions:
  - action: light.turn_on
    target:
      entity_id: light.front_door
    data:
      brightness_pct: 80
      transition: 2

  - delay:
      minutes: 3

  - action: light.turn_off
    target:
      entity_id: light.front_door

mode: restart

The nice thing here isn’t really the light itself. It’s the fact that an event generated by the Eufy ecosystem becomes another normal Home Assistant trigger.

That means you can combine it with presence, time, lighting, notifications, alarms and practically anything else in your smart home.

For example, a package detection could notify you, a person detection could illuminate the driveway, and a doorbell press could trigger a notification containing a snapshot from the camera.

What about video?

Video is one of the areas where the new architecture is particularly interesting.

The bridge includes go2rtc, and the HACS integration can use the bridge’s video functionality to provide camera streams to Home Assistant. The integration documentation describes the path as the camera’s stream source going through go2rtc and then to WebRTC.

This means there is no requirement to install a separate go2rtc instance just to get the Eufy cameras working.

That is a significant improvement over some older Eufy setups, where getting reliable video into Home Assistant could involve several different components.

My first impressions

So far, I am impressed.

I have only been testing the new integration since its release on September 11, so it would be wrong to claim that it has been proven reliable over months or years.

But during my testing, most of the Eufy functionality I use has worked as expected, and the integration has felt stable.

There is currently one issue I have noticed that is worth mentioning.

With my HomeBase 3, the arming state is exposed as a switch rather than an alarm_control_panel entity. This is already tracked as GitHub issue #23, opened on September 11. The issue specifically notes that the previous integration exposed the HomeBase 3 arming state as an alarm control panel, while the new integration currently exposes it as a switch.

For me, this isn’t a showstopper, but it is a good example of the fact that this is a brand-new project.

There are also devices and features that aren’t supported yet. For example, the current documentation notes that the eufyMake 3D printer is not supported, while Anker Solix support is currently limited to the development/beta bridge image.

Worth trying?

Absolutely.

If you are still using the old Eufy Security integration, this is a project I would definitely keep an eye on.

The architecture is clean, the feature set is already impressive, and the fact that cameras, events, snapshots and other Eufy devices can all become native Home Assistant entities makes this much more than just another camera integration.

My recommendation at this point would be to test it rather than immediately rebuilding your entire Eufy setup around it.

The project is only days old, and there will undoubtedly be bugs, missing features and changes as more people start using it.

But based on my initial testing, this looks like the Eufy integration Home Assistant users have been waiting for.

And if development continues at the current pace, I suspect the list of supported Eufy devices and features is going to grow quickly.

For now, though, I’m keeping it installed and watching the project closely.

Links:

• eufy-sdk documentation
• ha-eufy-sdk – HACS integration
• ha-eufy-sdk-bridge
• HomeBase 3 issue #23
• Old Eufy Security integration