Connect Home Assistant MQTT to a Victron GX: Configure the N/R MQTT Bridge

Updated 26 September 2026 (Clevr Victron 2.1.0-dev7): earlier versions of this guide said that the Clevr integration sends the Victron keepalive automatically. It does not. The integration only listens. You now need exactly one periodic sender per GX that requests a full republish about every 30 seconds — see step 8. If you set up Clevr 2.1.0-dev5 with Home Assistant-managed keepalive, add this sender before upgrading.

The Clevr Victron integration for Home Assistant reads Victron and Fronius information through MQTT.

It does not create a separate MQTT connection to your Cerbo GX or other Victron GX device. Instead, it uses the MQTT integration already configured in Home Assistant.

For this to work correctly, Home Assistant's MQTT broker must be able to do two things:

receive the Victron N/ notification tree from the GX device, and pass R/ keepalive or read requests back to the GX device, so that one periodic sender can keep the GX republishing its data.

The Clevr integration itself only listens. It sends no R/ requests and no W/ write commands, and therefore does not use MQTT to change settings on your Victron system.

This guide shows how to configure that connection.

How the MQTT Connection Works

A typical Clevr installation looks like this:

             Victron GX
          Cerbo GX / Venus OS
                  │
                  │  N/<portal-id>/...
                  │  Victron measurements
                  ▼
       ┌─────────────────────┐
       │ Home Assistant      │
       │ Mosquitto Broker    │
       │                     │
       │ victron/N/...       │
       │ victron/R/...       │
       └─────────────────────┘
                  │
                  │ Home Assistant MQTT integration
                  ▼
       ┌─────────────────────┐
       │ Clevr Victron       │
       │ Integration         │
       └─────────────────────┘
                  │
                  ▼
        Home Assistant sensors

There is also traffic in the opposite direction:

Periodic sender (one per GX, e.g. a Home Assistant automation)
     │
     │ victron/R/<portal-id>/keepalive
     ▼
Mosquitto Bridge
     │
     │ R/<portal-id>/keepalive
     ▼
Victron GX

The victron/ part in this example is a local bridge prefix. The actual topics on the GX device still start directly with N/ and R/.

Victron's current MQTT implementation uses N/ for notifications, R/ for read requests and W/ for requests that can change D-Bus values.

For the Clevr integration we need only:

MQTT namespace	Direction	Purpose
`N/`	GX → Home Assistant	Measurements and device information
`R/`	Home Assistant → GX	Reads and keepalive requests
`W/`	Not bridged	Victron setting changes — not required by Clevr

This separation is deliberate.

Why Use an MQTT Bridge?

Many Home Assistant installations already use MQTT for other equipment: ESPHome devices, Zigbee gateways, power meters, sensors or other automation systems.

In this situation, Home Assistant should continue using its normal MQTT broker.

Instead of changing Home Assistant to use the GX device as its MQTT broker, we connect the two brokers with a Mosquitto bridge.

The result is simple:

GX topic:

N/abcdef123456/system/0/Ac/Grid/L1/Power

becomes in Home Assistant:

victron/N/abcdef123456/system/0/Ac/Grid/L1/Power

In the other direction:

Home Assistant publishes:

victron/R/abcdef123456/keepalive

GX receives:

R/abcdef123456/keepalive

Mosquitto supports exactly this type of topic remapping using local and remote prefixes.

Step-by-Step Installation

Enable MQTT access on the Victron GX device.
Your GX device must allow MQTT connections from the local network.

Modern Venus OS uses FlashMQ for its local MQTT service. Victron documents the GX MQTT broker as being available on TCP port 1883 and/or 8883, depending on the device's network security configuration.

Check the MQTT and local network access settings on your Cerbo GX or other GX device.

Also note the GX device's IP address. We strongly recommend giving the GX device a DHCP reservation or static IP so that its address does not unexpectedly change.

You will also need the VRM Portal ID of the GX device.

Victron identifies every MQTT installation using this Portal ID, for example:
```
N/abcdef123456/system/0/Ac/Grid/L1/Power
```
In this example:
```
abcdef123456
```
is the Portal ID.

Victron documents the Portal ID as being available from the GX device's VRM settings.
Install the Mosquitto broker in Home Assistant.
If you already use MQTT in Home Assistant, you can normally skip this part.

For Home Assistant OS, open:

Settings → Apps → Install app

and install:

Mosquitto broker

Start the Mosquitto app after installation.

Home Assistant recommends its official Mosquitto broker as the simplest local MQTT setup. The MQTT integration will normally discover the broker automatically.

Then check:

Settings → Devices & services → MQTT

The MQTT integration should show as connected.

If you use a separate MQTT server instead of Home Assistant's Mosquitto app, that is also supported. The important requirement is that this is the same broker used by Home Assistant's MQTT integration.
Enable custom Mosquitto configuration files.
Open the Mosquitto broker app configuration.

Enable custom configuration:
```
customize:
  active: true
  folder: mosquitto
```
Home Assistant's official Mosquitto app will then read additional .conf files from:
```
/share/mosquitto/
```
This custom configuration mechanism is provided by the official Mosquitto app.

Create the Victron bridge.

Create:

/share/mosquitto/victron.conf

A recommended configuration is:

connection victron-gx
address 192.168.1.50:1883

start_type automatic
try_private false
notifications false
cleansession true

topic N/YOUR_PORTAL_ID/# in 0 victron/ ""
topic R/YOUR_PORTAL_ID/# out 0 victron/ ""

Replace:

192.168.1.50

with the IP address of your GX device.

Replace:

YOUR_PORTAL_ID

with the actual Portal ID of the GX installation.

For example:

connection victron-gx
address 192.168.1.50:1883

start_type automatic
try_private false
notifications false
cleansession true

topic N/abcdef123456/# in 0 victron/ ""
topic R/abcdef123456/# out 0 victron/ ""

The two topic rules are the important part.

This rule:

topic N/abcdef123456/# in 0 victron/ ""

subscribes to this tree on the GX:

N/abcdef123456/#

and places it in the Home Assistant broker under:

victron/N/abcdef123456/#

The second rule:

topic R/abcdef123456/# out 0 victron/ ""

does the opposite for read requests.

A message published locally to:

victron/R/abcdef123456/keepalive

is sent to the GX as:

R/abcdef123456/keepalive

Notice that there is deliberately no W/ bridge rule.

Restart the Mosquitto broker.
Restart the Mosquitto app after creating or modifying victron.conf.

Check its log after startup.

You should not see repeated connection errors for the victron-gx bridge.

If the GX device does not accept connections on port 1883, check its local network security configuration. Current Venus OS installations can expose MQTT on port 8883 using SSL/TLS instead, depending on the selected security profile.

Do not reduce the security of an installation merely to make the example configuration work. If your GX is configured for secure MQTT only, configure the bridge for its TLS connection instead.
Test the N/ direction.
In Home Assistant open:

Settings → Devices & services → MQTT → Configure

Find Listen to a topic.

Enter:
```
victron/N/YOUR_PORTAL_ID/#
```
and start listening.

You may initially see very little or nothing.

This is normal.

Modern Venus OS no longer publishes the complete MQTT tree as retained messages. A client that connects must request a refresh using a Victron keepalive.
Test the R/ direction with a keepalive.
Keep the topic listener running.

In the MQTT configuration page, publish an MQTT packet to:
```
victron/R/YOUR_PORTAL_ID/keepalive
```
with an empty payload.

The bridge removes the victron/ prefix and the GX receives:
```
R/YOUR_PORTAL_ID/keepalive
```
The GX should then publish its current MQTT data.

Within Home Assistant you should start seeing messages such as:
```
victron/N/YOUR_PORTAL_ID/system/0/...
```
```
victron/N/YOUR_PORTAL_ID/solarcharger/...
```
```
victron/N/YOUR_PORTAL_ID/pvinverter/...
```
and other devices installed on your system.

At the end of a complete refresh, recent Venus OS versions also publish:
```
N/YOUR_PORTAL_ID/full_publish_completed
```
Victron specifically recommends the R/<portal-id>/keepalive mechanism to request the current MQTT tree.
Set up exactly one periodic full-republish sender.
The GX only republishes its complete MQTT tree when it is asked to. The Clevr integration and the Clevr panel never ask: something else on your site must do it.

Configure exactly one sender per GX that publishes one of these requests about every 30 seconds:
```
victron/R/YOUR_PORTAL_ID/keepalive            (empty payload)
```
or a read request:
```
victron/R/YOUR_PORTAL_ID/system/0/Serial     (empty payload)
```
Both make the GX publish its full tree, ending with N/YOUR_PORTAL_ID/full_publish_completed.

Check first whether your site already has one. Node-RED flows, other Victron integrations or an existing Home Assistant automation often already send a keepalive. Listen to victron/R/YOUR_PORTAL_ID/# for a minute: if requests arrive regularly, keep that sender and do not add another. A second sender makes the GX republish its whole tree twice as often, for no benefit.

If there is none, a Home Assistant automation is the simplest sender. Create a new automation, switch to Edit in YAML and paste (with your own Portal ID and prefix):
```
alias: Victron GX full republish
description: The only periodic sender for this GX. Do not add a second one.
triggers:
  - trigger: time_pattern
    seconds: "/30"
actions:
  - action: mqtt.publish
    data:
      topic: victron/R/abcdef123456/keepalive
      payload: ""
mode: single
```
Do not use the suppress-republish keepalive option (a keepalive payload such as {"keepalive-options": ["suppress-republish"]}). It stops the GX sending full_publish_completed, which the Clevr setup needs, and panel values that do not change can go stale after 65 seconds.

Why 30 seconds: the GX accepts a keepalive interval of up to 60 seconds, but 30 seconds lets the setup scan see two complete publications within its 130-second limit and keeps panel values well inside their 65-second freshness limit.

Check the result: listen to victron/N/YOUR_PORTAL_ID/full_publish_completed. A new message should arrive about every 30 seconds.
Configure the Clevr Victron integration.
Once the bridge is working, install or configure the Clevr Victron Panel integration.

When it asks for:

MQTT bridge prefix

enter:
```
victron/
```
When it asks for:

GX Portal ID

enter your actual Portal ID:
```
abcdef123456
```
Clevr will therefore look under:
```
victron/N/abcdef123456/
```
It does not send anything to victron/R/abcdef123456/: the requests there come from your periodic sender.

The setup scan waits up to 130 seconds for two complete GX publications, so the periodic sender from step 8 must already be running when you add the integration.

Understanding the MQTT Prefix

The prefix entered in the Clevr configuration must match what exists on the Home Assistant MQTT broker, not necessarily what exists on the GX itself.

For example:

Topics visible in Home Assistant	Clevr MQTT prefix
`victron/N/<portal>/...`	`victron/`
`gx/N/<portal>/...`	`gx/`
`energy/victron/N/<portal>/...`	`energy/victron/`
`N/<portal>/...`	leave prefix empty

For the bridge configuration shown in this article, use:

victron/

If Home Assistant connects directly to the GX MQTT broker and sees topics beginning directly with:

N/<portal-id>/

then the Clevr prefix should be left empty.

Why the Keepalive Is Important

Victron's current MQTT implementation does not rely on retained messages for the complete device tree.

Instead, applications subscribe to the N/ tree and then request the current data using:

R/<portal-id>/keepalive

The GX responds by publishing its available data again. Victron documents a 60-second keepalive timeout and recommends periodically refreshing it while an MQTT application is active.

The Clevr integration does not send keepalives. It only listens to the data your GX publishes. Since 2.1.0-dev7 it sends no R/ requests at all, during setup or at runtime.

You therefore need exactly one periodic sender per GX, about every 30 seconds, as described in step 8. With none, the setup scan finds no complete publication and the panel's values go stale. With two or more, the GX republishes its whole tree more often than needed.

Clevr Does Not Write Settings to the GX

This distinction is important.

Victron MQTT uses:

N/

for notifications,

R/

for reads,

and:

W/

for write requests. Victron's documentation shows that W/ requests can modify D-Bus values and therefore change operating settings.

The Clevr Victron integration does not need the W/ namespace.

Our recommended Mosquitto configuration consequently contains:

topic N/YOUR_PORTAL_ID/# in 0 victron/ ""
topic R/YOUR_PORTAL_ID/# out 0 victron/ ""

but deliberately does not contain:

topic W/# out

This provides an additional layer of protection at the MQTT bridge itself.

Even if another client accidentally publishes:

victron/W/...

to the Home Assistant broker, the bridge configuration shown here has no rule allowing that message to reach the GX device.

For the Clevr integration, the Victron connection is therefore designed around monitoring and read requests, not control of GX settings.

Troubleshooting

Problem	What to check
MQTT integration is unavailable	Check that the Home Assistant Mosquitto broker is running
Bridge will not connect	Verify GX IP address, MQTT access and the port permitted by the GX security profile
No `victron/N/...` topics appear	Send an `R/<portal>/keepalive`; modern GX MQTT data is not simply retained forever
`N/` data arrives but Clevr reports “No fresh GX data”	Check the Clevr Portal ID and MQTT prefix
Keepalive produces no response	Check that the `R/` bridge rule is present and points from Home Assistant to the GX
Topics begin with `N/...` rather than `victron/N/...`	The connection has no local prefix; leave the Clevr MQTT prefix empty
Topics appear under a different prefix	Enter that complete prefix in the Clevr setup
Port 1883 is refused	Check the GX local network security profile; the installation may require secure MQTT on port 8883
Data appears briefly and then stops	No periodic sender is running, or the `R/` bridge rule does not pass its requests to the GX
Clevr setup reports “No fresh GX data” or finds only part of the system	Check that one sender publishes a keepalive about every 30 seconds and that `full_publish_completed` arrives; do not use `suppress-republish`
Full publishes arrive more often than every 30 seconds	Two or more senders are active (for example Node-RED and a Home Assistant automation); keep only one

The Final Result

Once this configuration is complete, Home Assistant should have a bidirectional read-only MQTT path to the Victron GX:

Victron GX
   │
   │ N/ notifications
   ▼
Mosquitto bridge
   │
   │ victron/N/...
   ▼
Home Assistant
(one periodic sender, ~30 s)
   │
   │ victron/R/... keepalive
   ▼
Mosquitto bridge
   │
   │ R/... keepalive
   ▼
Victron GX

There is intentionally no corresponding path for:

W/

With this MQTT layer working, you can proceed to install the Clevr Victron Panel integration for Home Assistant. The integration will use Home Assistant's existing MQTT connection to discover your Victron system, MPPT solar chargers, grid and battery devices, and supported AC PV inverters such as Fronius.

No additional MQTT credentials need to be entered into the Clevr Home Assistant integration.

Next step: install the integration itself — see Connect Victron GX and Fronius to Home Assistant with the Clevr Victron Integration. Then configure your Clevr GX Panel.