Skip to main content

Creating a Home Assistant Integration for the Harman Kardon Aura Speaker

After finally setting up in my apartment in 2024, I wanted to automate my place as much as possible. One of the devices I own is a Harman Kardon Aura Plus speaker, which has great sound but limited smart features.

The Aura Plus is a high-end wireless speaker with 360° sound and ambient lighting. Unfortunately, while it sounds great, it lacks an open API. The official app talks over Bluetooth/Wi-Fi — and that’s where I saw an opportunity..

Harman Kardon Aura Plus Speaker


In this post, I’ll walk you through how I intercepted the speaker’s network traffic, decoded its control protocol, analyzed that communication, and replicated those controls from my own scripts and smart home automations.

Tools Used

Goal

Harman Kardon Remote App

Identify and reproduce the network requests made by the Harman Kardon remote app in order to:

  • Control volume, bass, and EQ settings
  • Power off the speaker
  • Mute/unmute
  • Integrate it with Home Assistant or custom tools

Network Traffic Capture with Ettercap

Both devices were on the same Wi-Fi network, and I assigned them static IPs to make things easier.

The setup looked like this:

+-------------+                +----------------------+                +---------------+
| iPhone      |  <--requests-- | MacBook Pro          |  --forwards--> | Aura Speaker  |
| 172.16.1.69 |  (HTTP/XML)    | (Ettercap MITM)      |  (HTTP/XML)    | 172.16.1.68   |
+-------------+                +----------------------+                +---------------+
        ^                             ^    |
        |                             |    |--[ARP poisoning: intercept & forward]
        |                             |
        `-----------------------------'
                 (man-in-the-middle)
                 (capture traffic)

I started by running Ettercap in MITM mode between my iPhone (172.16.1.69) and the Aura speaker (172.16.1.68):

    sudo ettercap -T -M arp:remote /172.16.1.68// /172.16.1.69// -w speaker.pcap

After launching the Harman Kardon app and toggling various settings, Ettercap successfully intercepted traffic between the devices.

What the App Sends

Captured requests were simple HTTP POSTs with XML payloads to the speaker’s IP:

MitM Traffic Capture

Other examples include:

  • Set Bass Level:
        <name>set_bass_level</name>
    <zone>Main Zone</zone>
    <para>38</para>
  • Set Volume:
        <name>set_system_volume</name>
    <zone>Main Zone</zone>
    <para>50</para>
  • Set EQ Mode:
        <name>set_eq_mode</name>
    <zone>Main Zone</zone>
    <para>Basic</para>
  • Power Off:
        <name>power-off</name>
    <zone>Main Zone</zone>
    <para></para>
  • Mute/Unmute:
        <name>set_mute</name>
    <zone>Main Zone</zone>
    <para>mute-on</para>

        <name>set_mute</name>
    <zone>Main Zone</zone>
    <para>mute-off</para>

The XML structure is consistent, with a root <harman> element and nested tags for commands and parameters. The only values that change are the <name> and <para> fields.

These controls work over plain HTTP without authentication, any device on the same Wi-Fi network can control the speaker.

Sample Python Snippet

Now that the protocol is clear, I can replicate this in Python using requests:

XML Request

Home Assistant Integration

Based on the results of this reverse engineering effort, and the Home Assistant documentation Creating your first integration, I developed a custom Home Assistant integration for the Harman Kardon Aura speaker.

The integration structure is as follows:

├── __init__.py             - Initializes the integration
├── hk_request_template.xml - XML template for sending control commands to the speaker
├── manifest.json           - Basic information about the integration
├── number.py               - Entities for controlling the bass and volume
├── speaker.py              - Main entity representing the speaker
└── switch.py               - Entities for controlling the EQ mode and mute status

At this point, I could control the speaker directly from Home Assistant, without needing the official app..

Harman Kardon Aura Plus HA


But it wasn’t done yet. As I was testing the integration, I realized that each time I adjusted the volume or bass using the UI slider, Home Assistant generated a burst of sequential requests. This flooded the speaker’s control interface, causing it to become unresponsive.

To solve this, I implemented a debounce mechanism in the `number.py` entity logic. This ensures that only the final slider value—after a short idle interval—is sent to the speaker, preventing redundant network calls, reducing load on the device, and improving overall responsiveness.

Harman Kardon Aura Plus HA

At that point, I considered the core features stable enough to tag a v1 release and published the project in a new repository: harman_kardon_aura_HA

Features

  • Control volume, bass, and EQ mode
  • Mute/unmute
  • Designed for local network control
  • XML templates dynamically generated per action

I can now easily automate my speaker with YAML or the UI—like powering it off when closing the turntable, setting the EQ in the morning, or adjusting the bass before movie night.

Conclusion

With a little network analysis and patience, I reverse engineered the Harman Kardon Aura speaker’s local control protocol—and as a result, I was able to develop a custom Home Assistant integration.

This project highlights how many smart devices can be controlled locally, without relying on cloud services or proprietary apps. If you have a device you want to integrate into your smart home, consider capturing its network traffic to see what’s possible.