Neoom Beeam Rest API

Dexhex · June 18, 2024, 12:51pm

Hi HA community,

I am very new to the topic and I am struggling a bit with creating sensors via
configuration.yaml

I just tried to get information from a local device called “Neoom Beeam” wich is a local device for accessing real time data of my PV system via the REST api.

According to the API Documentation “/api/v1/site/state”

I am trying to get all the basic information from the site/state.
Therefore I tried the curl command

curl -k \
-H "Authorization: Bearer skxxxx" \
-H "Content-Type: application/json" \
http://192.168.0.x/api/v1/site/state

this is the result

{"energyFlow":{"states":[
{"dataPointId":"befa18bd-7c07-5871-90a2-29f1c51fa368","key":"SELF_SUFFICIENCY","value":100,"ts":1718621135003},
{"dataPointId":"2339a8b3-db1e-5b63-9a6f-a11787c8f905","key":"POWER_PRODUCTION","value":7206,"ts":1718633200003},
{"dataPointId":"24a8122b-d2cc-5374-b5b4-bf22f51dd511","key":"POWER_CONSUMPTION","value":null,"ts":1718621100003},
{"dataPointId":"371d81cc-a0b6-510f-b02d-819adbed7011","key":"POWER_GRID","value":-5973,"ts":1718633200003},
{"dataPointId":"6e5e9fcc-f81b-59b7-8a40-93916ed199a0","key":"POWER_STORAGE","value":37,"ts":1718633180002},
{"dataPointId":"ad7c9711-e91c-5a56-85b2-7de4c6a7ad10","key":"ENERGY_PRODUCED","value":18006700,"ts":1718633200003},
{"dataPointId":"db4e07e8-657c-51b5-9f45-ea48c5dd0a9e","key":"ENERGY_CONSUMED","value":null,"ts":1718621100003},
{"dataPointId":"3b327d89-825a-59f7-b956-4ccdd89f125a","key":"ENERGY_IMPORTED","value":4932816.486869225,"ts":1718621100003},
{"dataPointId":"bee32e2c-f01a-5cff-8252-d2f09e06c9dc","key":"ENERGY_EXPORTED","value":7452677.600188415,"ts":1718633200003},
{"dataPointId":"d46d9e71-d227-5295-8ca5-6957472fa111","key":"ENERGY_CHARGED","value":4558500,"ts":1718631955003},
{"dataPointId":"e25f2c9a-25e7-528e-bab2-9f85f51ec440","key":"ENERGY_DISCHARGED","value":3385000,"ts":1718632635004},
{"dataPointId":"6b73c34d-f868-5792-b9d5-ef92348d202f","key":"STATE_OF_CHARGE","value":100,"ts":1718632000002},
{"dataPointId":"d5461d1f-1b80-5aac-9e15-e020a26aebf3","key":"POWER_CONSUMPTION_CALC","value":1270,"ts":1718633200003},
{"dataPointId":"60341e65-6c4b-5424-b091-f4286512cb94","key":"POWER_GRID_REMAINING","value":null,"ts":1718621100003},
{"dataPointId":"2869f5fc-7737-57d3-a64e-c15c7e084c97","key":"ENERGY_CONSUMED_CALC","value":14313338.886680812,"ts":1718633200003}]}
}

Next step → just putting some code in the configuration.yaml

sensor:
  - platform: rest
    name: Neoom Beeam Energy State
    resource: http://192.168.0.x/api/v1/site/state
    method: GET
    verify_ssl: false
    headers:
      Authorization: !secret beeam_bearer_token
      Content-Type: application/json
    value_template: >
          {% set state = value_json.energyFlow.states[0] %}
            Key: {{ state.key }}, Value: {{ state.value }}, DataPointId: {{ state.dataPointId }}, Timestamp: {{ state.ts }}
    json_attributes_path: "$.energyFlow.states"
    json_attributes:
      - states
    scan_interval: 10

template:
  - sensor:
      - name: "Neoom Autarkie"
        unit_of_measurement: "%"
        device_class: "power"
        state_class: "measurement"
        state: >
          {% set state_data = state_attr('sensor.neoom_beeam_energy_state', 'states') %}
          {% if state_data %}
            {{ state_data | selectattr('key', 'eq', 'SELF_SUFFICIENCY') | map(attribute='value') | first | default('unavailable') }}
          {% else %}
            unavailable
          {% endif %}

      - name: "Neoom Strom Netz"
        unit_of_measurement: "W"
        device_class: "energy"
        state_class: "measurement"
        state: >
          {% set state_data = state_attr('sensor.neoom_beeam_energy_state', 'states') %}
          {% if state_data %}
            {{ state_data | selectattr('key', 'eq', 'POWER_GRID') | map(attribute='value') | first | default('unavailable') }}
          {% else %}
            unavailable
          {% endif %}

But when I look now in the entity state it shows me “unknown”.

Please can you help me.

Thank you very much

Dexhex · September 3, 2024, 2:55pm

Hi community,

just got it working.

Please give me feedback if it is working for you too?



# Loads default set of integrations. Do not remove.
default_config:

# Load frontend themes from the themes folder
frontend:
  themes: !include_dir_merge_named themes

automation: !include automations.yaml
script: !include scripts.yaml
scene: !include scenes.yaml
knx: !include knx.yaml



rest:
  - resource: http://IP-Adress/api/v1/site/state  # BEAAM API URL
    headers:
      Authorization: "Bearer hereyourtoken" #do not delete Bearer at the start
      Content-Type: "application/json"
    method: GET
    scan_interval: 10  # Intervall für API-Aufrufe in Sekunden
    sensor:
      - name: "neoom_self_sufficiency"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'SELF_SUFFICIENCY') | map(attribute='value') | first }}"
        unit_of_measurement: "%"
        device_class: power
        state_class: measurement

      - name: "neoom_power_production"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_PRODUCTION') | map(attribute='value') | first }}"
        unit_of_measurement: "W"
        device_class: power
        state_class: measurement

      - name: "neoom_power_consumption"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_CONSUMPTION') | map(attribute='value') | first }}"
        unit_of_measurement: "W"
        device_class: power
        state_class: measurement

      - name: "neoom_power_grid"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_GRID') | map(attribute='value') | first }}"
        unit_of_measurement: "W"
        device_class: power
        state_class: measurement

      - name: "neoom_power_storage"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_STORAGE') | map(attribute='value') | first }}"
        unit_of_measurement: "W"
        device_class: power
        state_class: measurement

      - name: "neoom_energy_produced"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_PRODUCED') | map(attribute='value') | first }}"
        unit_of_measurement: "Wh"
        device_class: energy
        state_class: total_increasing

      - name: "neoom_energy_consumed"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_CONSUMED') | map(attribute='value') | first }}"
        unit_of_measurement: "Wh"
        device_class: energy
        state_class: total_increasing

      - name: "neoom_energy_imported"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_IMPORTED') | map(attribute='value') | first }}"
        unit_of_measurement: "Wh"
        device_class: energy
        state_class: total_increasing

      - name: "neoom_energy_exported"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_EXPORTED') | map(attribute='value') | first }}"
        unit_of_measurement: "Wh"
        device_class: energy
        state_class: total_increasing

      - name: "neoom_energy_charged"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_CHARGED') | map(attribute='value') | first }}"
        unit_of_measurement: "Wh"
        device_class: energy
        state_class: total_increasing

      - name: "neoom_energy_discharged"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_DISCHARGED') | map(attribute='value') | first }}"
        unit_of_measurement: "Wh"
        device_class: energy
        state_class: total_increasing

      - name: "neoom_state_of_charge"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'STATE_OF_CHARGE') | map(attribute='value') | first }}"
        unit_of_measurement: "%"
        device_class: battery
        state_class: measurement

      - name: "neoom_power_consumption_calc"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_CONSUMPTION_CALC') | map(attribute='value') | first }}"
        unit_of_measurement: "W"
        device_class: power
        state_class: measurement

      - name: "neoom_energy_consumed_calc"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_CONSUMED_CALC') | map(attribute='value') | first }}"
        unit_of_measurement: "Wh"
        device_class: energy
        state_class: total_increasing

Guenter82 · September 7, 2024, 7:26pm

Hi Dominik,

Thank you very much for posting your Solution! I’m new at Home Assistant and have no idea of programming and i looking for this “integration” since i’ve got my PV. Last Week I found a working Solution with the Neoom Connect Cloud, but i prefer the direct Way. I’ve just testing five sensors and four of them working fine, only “neoom_power_consumption” doesn’t produces me an Entity, but it doesnt matter.

Dexhex · September 10, 2024, 12:10pm

Here is my updated code

rest:
  - resource: http://IP-Adress/api/v1/site/state  # BEAAM API URL
    headers:
      Authorization: "Bearer sk_beaam_xxxxx" #Put your bearer token here, but do not delete Bearer at the beginning
      Content-Type: "application/json"
    method: GET
    scan_interval: 10  # Intervall für API-Aufrufe in Sekunden
    sensor:
      # Stromverbrauch (aktuelle Leistung in Watt)
      - name: "neoom_power_consumption"
        unique_id: "power_consumption"
        #value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_CONSUMPTION') | map(attribute='value') | first }}"
        value_template: "{{ (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_PRODUCTION') | map(attribute='value') | first * -1) if (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_PRODUCTION') | map(attribute='value') | first) < 0 else (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_PRODUCTION') | map(attribute='value') | first) }}"
        unit_of_measurement: "W"
        device_class: power
        state_class: measurement
        icon: "mdi:LightningBoltOutline"

      # Stromnetz (aktueller Netzbezug)
      - name: "neoom_power_grid_input"
        unique_id: "power_grid_input"
        #value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_GRID') | map(attribute='value') | first }}"
        value_template: "{{ (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_GRID') | map(attribute='value') | first) * -1 if (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_GRID') | map(attribute='value') | first) < 0 else (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_GRID') | map(attribute='value') | first) }}"
        unit_of_measurement: "Wh"
        device_class: energy
        state_class: total
        icon: "mdi:TransmissionTower"

      # Stromnetz (aktuelle Einspeisung)
      - name: "neoom_power_grid_output"
        unique_id: "power_grid_output"
        #value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_GRID') | map(attribute='value') | first }}"
        #value_template: "{{ (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_GRID') | map(attribute='value') | first) * -1 if (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_GRID') | map(attribute='value') | first) < 0 else (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_GRID') | map(attribute='value') | first) }}"
        value_template: "{{ (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_GRID') | map(attribute='value') | first * -1) if (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_GRID') | map(attribute='value') | first) < 0 else 0 }}"
        unit_of_measurement: "Wh"
        device_class: energy
        state_class: total
        icon: "mdi:TransmissionTower"

      # Batteriespeicher Output (aktuelle Leistung in Watt)
      - name: "neoom_storage_output"
        unique_id: "storage_output"
        #value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_STORAGE') | map(attribute='value') | first }}"
        value_template: "{{ 0 if (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_STORAGE') | map(attribute='value') | first) < 0 else (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_STORAGE') | map(attribute='value') | first) }}"
        unit_of_measurement: "Wh"
        device_class: energy
        state_class: total
        icon: "mdi:BatteryArrowDownOutline"

        # Energie entladen (Entnahme aus dem Speicher in Wh)
      - name: "neoom_energy_discharged"
        unique_id: "energy_discharged"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_DISCHARGED') | map(attribute='value') | first }}"
        unit_of_measurement: "Wh"
        device_class: energy
        state_class: total_increasing
        icon: "mdi:BatteryArrowDownOutline"

      # Batteriespeicher Input (aktuelle Leistung in Watt)
      - name: "neoom_storage_input"
        unique_id: "storage_input"
        #value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_STORAGE') | map(attribute='value') | first }}"
        #value_template: "{{ (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_STORAGE') | map(attribute='value') | first * -1) if (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_STORAGE') | map(attribute='value') | first) < 0 else (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_STORAGE') | map(attribute='value') | first) }}"
        value_template: "{{ (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_STORAGE') | map(attribute='value') | first * -1) if (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_STORAGE') | map(attribute='value') | first) < 0 else 0 }}"
        unit_of_measurement: "Wh"
        device_class: energy
        state_class: total
        icon: "mdi:BatteryArrowUpOutline"

      # Energie geladen (gespeicherte Energie in Wh)
      - name: "neoom_energy_charged"
        unique_id: "energy_charged"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_CHARGED') | map(attribute='value') | first }}"
        unit_of_measurement: "Wh"
        device_class: energy
        state_class: total_increasing
        icon: "mdi:BatteryArrowUpOutline"

      # Energie produziert (gesamte erzeugte Energie in Wh)
      - name: "neoom_energy_produced"
        unique_id: "energy_produced"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_PRODUCED') | map(attribute='value') | first }}"
        unit_of_measurement: "Wh"
        device_class: energy
        state_class: total_increasing
        icon: "mdi:SolarPowerVariant"

      # Energie verbraucht (gesamter Verbrauch in Wh)
      - name: "neoom_energy_consumed"
        unique_id: "energy_consumed"
        value_template: "{{ (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_CONSUMED') | map(attribute='value') | first * -1) if (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_CONSUMED') | map(attribute='value') | first) < 0 else (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_CONSUMED') | map(attribute='value') | first) }}"
        unit_of_measurement: "Wh"
        device_class: energy
        state_class: total_increasing
        icon: "mdi:HomeLightningBoltOutline"

      # Energie importiert (gesamter Import aus dem Netz in Wh)
      - name: "neoom_energy_imported"
        unique_id: "energy_imported"
        #value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_IMPORTED') | map(attribute='value') | first | round(2) }}"
        value_template: "{{ (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_IMPORTED') | map(attribute='value') | first * -1) if (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_IMPORTED') | map(attribute='value') | first) < 0 else (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_IMPORTED') | map(attribute='value') | first) | round(2) }}"
        unit_of_measurement: "kWh"
        device_class: energy
        state_class: total_increasing
        icon: "mdi:TransmissionTowerImport"

      # Energie exportiert (gesamte Einspeisung ins Netz in Wh)
      - name: "neoom_energy_exported"
        unique_id: "energy_exported"
        #value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_EXPORTED') | map(attribute='value') | first * -1 }}"
        value_template: "{{ (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_EXPORTED') | map(attribute='value') | first * -1) if (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_EXPORTED') | map(attribute='value') | first) < 0 else (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_EXPORTED') | map(attribute='value') | first) }}"
        unit_of_measurement: "Wh"
        device_class: energy
        state_class: total_increasing
        icon: "mdi:TransmissionTowerExport"

      # Ladezustand des Speichers in %
      - name: "neoom_state_of_charge"
        unique_id: "state_of_charge"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'STATE_OF_CHARGE') | map(attribute='value') | first }}"
        unit_of_measurement: "%"
        device_class: battery
        state_class: measurement
        icon: "mdi:BatteryHeartVariant"

      # Selbstversorgung (Selbstversorgungsrate in %)
      - name: "neoom_self_sufficiency"
        unique_id: "self_sufficiency"
        value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'SELF_SUFFICIENCY') | map(attribute='value') | first }}"
        unit_of_measurement: "%"
        device_class: power
        state_class: measurement
        icon: "mdi:LightningBoltCircle"

      # PV Leistung aktuell (Leistung in kWh)
      - name: "neoom_power_production"
        unique_id: "power_production"
        #value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_PRODUCTION') | map(attribute='value') | first }}"
        value_template: "{{ (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_PRODUCTION') | map(attribute='value') | first) if (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_PRODUCTION') | map(attribute='value') | first) > 0 else 0 }}"
        unit_of_measurement: "kWh"
        device_class: energy
        state_class: total
        icon: "mdi:SolarPanel"

      # Errechneter Stromverbrauch (Leistung in kWh)
      - name: "neoom_power_consumption_calc"
        unique_id: "power_consumption_calc"
        value_template: "{{ (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_CONSUMPTION_CALC') | map(attribute='value') | first * -1) if (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_CONSUMPTION_CALC') | map(attribute='value') | first) < 0 else (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_CONSUMPTION_CALC') | map(attribute='value') | first) }}"
        unit_of_measurement: "kWh"
        device_class: energy
        state_class: measurement
        icon: "mdi:SolarPanel"

      # Errechneter Energieverbrauch (gesamter Verbrauch in Wh)
      - name: "neoom_energy_consumed_cal"
        unique_id: "energy_consumed_calc"
        #value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_CONSUMED') | map(attribute='value') | first }}"
        value_template: "{{ (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_CONSUMED_CALC') | map(attribute='value') | first * -1) if (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_CONSUMED_CALC') | map(attribute='value') | first) < 0 else (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'ENERGY_CONSUMED_CALC') | map(attribute='value') | first) }}"
        unit_of_measurement: "Wh"
        device_class: energy
        state_class: measurement
        icon: "mdi:HomeLightningBoltOutline"

Flow2825 · September 27, 2024, 7:29pm

Hi Dominik,

I just started using Home Assistant. I also have a Neeom PV and tried to add it to HA.

Do pay to use the Beaam API?

BR Florian

Leschi · October 1, 2024, 8:39pm

Hello Dominik

first of all 1000 thanks for your efforts here and the code. I’m very, very new to HA and also this “programming”. Basically I’m in the stage of trying to understand what the code says and that does often not go well…

However with copying your code I did get results out of my beam. :)) THANKS !!!

In HA in the overview it is shown more or less correct in most cases. I attach a comparison of HA ( left side) and Ntuity ( right side). May be a little lagging due to the 10 sec interval…
Some numbers make sense, some not at all. In the Energy flow graphic of HA it makes no sense at all, as this somehow shows different values. But that is secondary problem .

Major issue right now for me ( using yr updated code) is the house consumption as HA adds House consumption + Battery charging + heating coil …

In the example ( due to lagging may be a bit diff from the Ntuity values) : due to lagging: 1710 / ACX ELWA / Heating coil) +524 ( charging Bat) +x ( House consumption) = 2946 ( ttl calc energy consumption / neoom_power_consumption_calc) . Thus House consumption alone would be → x = 712 ( shown in Ntuity at 950, but again, I think it is the lagging effect accounting for the diff)

Not testet an taken into consideration is the wallbox ( not active when making the comparison) But I’d assume it would be added to the ttl value)

So it would be nice to read out wall box consumption, too ( ?? POWER_CHARGING_POINTS ??), but first of all I think the current
house consumption needs to be calculated (?) different / correct.

I wanted to kindly ask you if this is working correct for you at your end, or may be other users with a Neoom System do have similar issues or solutions?

May be you did do some updates to your code?

Did you use coding help (readme) from the Neoom developer site ?
( /api/v1/things/{thingId}/states)
… and if so, how does this work?

So just wanted to keep this topic “alive” as it is very interesting and even more super useful.

Happy abt any insights someone would like to give ( and pls keep in mind… I’m new to all this, so stupid
from my side may come fast - sorry for that), as I’m trying my best to get an understanding on the logic behind it and on how to get this running.

Greetings
Sven

Leschi · October 2, 2024, 7:22am

Hi Florian,

I do not pay for it, but I also do not pay for the Ntuity service, as I got my System before they started the “Abo Model”. May be nowadays they ask to oay for for new useres. However, there is a disclaimer, that they may charge for it in the future, when i created my took a week ago or so…

May be tis is help for you?

Dexhex · October 2, 2024, 8:57am

Hi,

me too, I only pay for using more devices in my neeom landscape (integration of wall box).

@Leschi : I will check your questions and your approaches, will come back with an answer.

BR

lakemike · October 13, 2024, 2:44pm

Hi Dominik, all,

Many thanks for the help. I got this to work with copy-paste!
Not sure I can already rationalize all historic values (everything ending in "ed).
But the other values make sense based on other readings from the PV system:

neoom_power_production
neoom_power_consumption
neoom_power_grid_input
neoom_power_grid_output
neoom_self_sufficiency
neoom_state_of_charge
neoom_storage_input
neoom_storage_output

Excellent!

With my system, I got a Neoom software subscription for 5 years. Let’s see what I have to do in the year 2029 to get my HA dashboard fed…

KR Michael

PS: I think some units could be wrong? E.g. neoom_power_production should be measured in Watt.

Dexhex · November 11, 2024, 1:53pm

Hi guys,

I am using “Energy Flow Plus” Dashboard > much better integration and calculation for my setup as listed above. You can find it in the HACS.

Works like a charm.

ArtheaRE · November 15, 2024, 9:12pm

Hi there,
Energy Flow Plus really works like a charm.
However, have you guys figured out why some entities from Neoom API itself, like energy consumed or power consumption, are “null”, while calculated entrys work?

Is there someone who could lend me a hand to tell me exactly which entity i need to use to get my Power Flow working correctly?

Thank you very much!

Here are two pictures from the API
consumed
calc

nutriOn · January 19, 2025, 7:03pm

Hi @Dexhex
I have done a similar setup a month ago
Since three days the Beeam API does not give any response anymore. Do you experience the same?
Best regards
Yves

Leschi · January 20, 2025, 12:57pm

Dear All,

same problem on my side. Just realized that since a few days ( can’t say when exactly)
the sensors of Neoom are all “unbekannt” / “unknown”

I was playing with it all day yesterday, could not fix it. Also generated a new Bearer tooken, but that was no solution and probably only a stupid idea of mine.

I did try today (as per opening comment of this overall post) :

~ curl -k
-H "Authorization: Bearer sk_beaam_xxxxxxxxx
"
-H “Content-Type: application/json”
http://192.168.xxx.xx/api/v1/site/state

and get in return:

{“statusCode”:500,“message”:“Internal server error”}#

That let’s me think that Neoom has changed something on their API or may be even closed it for frequent requests. I took a view on their latest “Abo Model” and that gives me the idea that they changed something and wants now extra money for that. I could not find the definition ( in respect to how often can you pull data) between :

Einfaches Abfragekontingent der historischen Energie- und Messdaten (Excel und API)

and

Unlimitiertes Abfragekontingent (fair use) der historischen Energie- und Messdaten (Excel und API)

to book Mega, just to get some date shown in Homeassiatant ( like Battery level, production and consumption) I find way to expensive.

So I hope the community can find a solution here, in a way I’m glad it seems I’m not the only one with this problem.

Further, I mean you can only read data in the beam, you can not write them.
For example : I do not like that the car gets charged from the house battery. But there is no direct way in the beam setup to prevent that. The only workaround is to set the min charge of the battery at x% (whatever it is when you connect the car), and reset it to the value chosen after charging is complete - which I find very annoying … in a way.

If you could write data via Home Assistant in the beam, you could make an automation:
If charge is “grid” and a “car gets connected”, set the minimum battery level at “actual status”. Once the car is not charing anymore, set it back to previous set levels.
I think at the end that can nit be so difficult. The request is actually with Neoom since 2,5 years… and since I hear it will come, but obviously it does not.

Thinking a bit further:

Neoom is by far not the cheapest one with their system and a such I find it annoying that they do come up with their “Abo Model” (in many cases retrospectively I hear, but need to mention not in my case. At lest not for the 10years. But you only get Mega I think. But as of today ( with my little understanding) it feels like you need GIGA to get your data in HAS (?).

Today I can surely say I would NOT buy Neoom again !

…and I wonder if I could somehow get rid of that Beaam thing, etc and just use the Solax - Can all be integrated ? Housebattery and EV charger, 2.Sungrow WR, AC ELWA Heating coil). Would i.e. AC Thor ( would not mind the investment) solve all that? Any other suggetsion…
Understand you can not have Beaam and Solax could simultaneously)

I do not need the “Energiegeminschaft”, which does not work in Germany anyhow.
And I also do not want to go for Tibber etc and use “Grid” as lately I’m not reading any good ( “cheap energy”) things abt it, at least not in winter time. But that is the only time when I consume energy from the grid.
So, I so not need all these “super features”

Sorry, I think my frustration with this set up my have floated a bit in here, but seriously I really would like to find any solution to somehow get these data in HAS as I need them for certain automations.

Any input or thought from the community is highly appreciated.

thank you

Sven

nutriOn · January 22, 2025, 3:05pm

Hi @Leschi
I just opened a ticket at Neoom to ask if they have changed something. I did not see any note on the developer page.
I am in quite the same position as you are - not really interested in a “energiegemeinschaft” or something liek that. I just wanted to have a reliable system able to connect to HomeAssistant. Hope they will add it again, else i am quite disappointed. Maybe i am missing some technical aspects but i mean i am doing a request on a local device, which will in no matter cost Neoom anything, isn’t it?

I will get the charging station from Neoom by April. The point with the EV charging from the battery is also a bummer to hear. Not sure if i should choose another charger then… Does it get charged from the house-battery even if you set to charge it only by solar?

Best regards
Yves

mbaum · January 26, 2025, 8:50pm

Hi community,

I have been working with Home Assistant for a week and also have a solar system from neoom with a beaam. I used to query the data in a separate application, but it’s much more elegant with Home Assistant .

The query via ‘http://10.10.10.10/api/v1/site/state’ has also not worked for me since January. I suspect this is a bug in the firmware of the beaam, there is probably a problem calculating the values.

I have also opened a ticket, but have not yet received an answer.

But there is another way to get the values of the solar system. You can call up all connected devices (and the corresponding GUIDs) via the following address:

http://10.10.10.10/api/v1/site/configuration

You can then call up the values for each device individually. I have adapted the above script as follows (many thanks for the great template):

# BEAAM Battery
- resource: http://10.10.10.10/api/v1/things/GUID/states
  headers:
    Authorization: "Bearer sk_beaam_xxxxx" #Put your bearer token here, but do not delete Bearer at the beginning
    Content-Type: "application/json"
  method: GET
  scan_interval: 15  # Intervall für API-Aufrufe in Sekunden
    
  sensor:
    # Batterie (aktueller Output in Watt)
    - name: "neoom_storage_output"
      unique_id: "storage_output"
      value_template: "{{ 0 if (value_json['states'] | selectattr('key', 'eq', 'POWER') | map(attribute='value') | first) < 0 else (value_json['states'] | selectattr('key', 'eq', 'POWER') | map(attribute='value') | first) }}"
      unit_of_measurement: "Wh"
      device_class: energy
      state_class: total
      icon: "mdi:BatteryArrowDownOutline"      
      
    # Batterie (aktueller Input in Watt)
    - name: "neoom_storage_input"
      unique_id: "storage_input"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'POWER') | map(attribute='value') | first * -1) if (value_json['states'] | selectattr('key', 'eq', 'POWER') | map(attribute='value') | first) < 0 else 0 }}"
      unit_of_measurement: "Wh"
      device_class: energy
      state_class: total
      icon: "mdi:BatteryArrowUpOutline"
      
    # Batterie (Ladezustand)
    - name: "neoom_state_of_charge"
      unique_id: "state_of_charge"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'STATE_OF_CHARGE') | map(attribute='value') | first) }}"
      unit_of_measurement: "%"
      device_class: battery
      state_class: measurement
      icon: "mdi:BatteryHeartVariant"                  
      
# BEAAM Inverter
- resource: http://10.10.10.10/api/v1/things/GUID/states  
  headers:
    Authorization: "Bearer sk_beaam_xxxxx" #Put your bearer token here, but do not delete Bearer at the beginning
    Content-Type: "application/json"
  method: GET
  scan_interval: 15  # Intervall für API-Aufrufe in Sekunden
    
  sensor:
    # Stromproduktion alle Panel (aktuelle Leistung in Watt)
    - name: "neoom_power_panels"
      unique_id: "power_panels"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'INPUTS_POWER') | map(attribute='value') | first)[0] + (value_json['states'] | selectattr('key', 'eq', 'INPUTS_POWER') | map(attribute='value') | first)[1] }}"
      unit_of_measurement: "Wh"
      device_class: energy
      state_class: total
      icon: "mdi:SolarPanel"
    
    # Stromproduktion Panel West (aktuelle Leistung in Watt)
    - name: "neoom_power_panelwest"
      unique_id: "power_panelwest"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'INPUTS_POWER') | map(attribute='value') | first)[0] }}"
      unit_of_measurement: "Wh"
      device_class: energy
      state_class: total
      icon: "mdi:SolarPanel"
            
    # Stromproduktion Panel Osten (aktuelle Leistung in Watt)
    - name: "neoom_power_paneleast"
      unique_id: "power_paneleast"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'INPUTS_POWER') | map(attribute='value') | first)[1] }}"
      unit_of_measurement: "Wh"
      device_class: energy
      state_class: total
      icon: "mdi:SolarPanel"

# BEAAM AC (Grid)      
- resource: http://10.10.10.10/api/v1/things/GUID/states
  headers:
    Authorization: "Bearer sk_beaam_xxxxx" #Put your bearer token here, but do not delete Bearer at the beginning
    Content-Type: "application/json"
  method: GET
  scan_interval: 15  # Intervall für API-Aufrufe in Sekunden
    
  sensor:
    # Stromnetz (aktueller Bezug in Watt)
    - name: "neoom_power_grid_input"
      unique_id: "power_grid_input"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'ACTIVE_POWER') | map(attribute='value') | first) * -1 if (value_json['states'] | selectattr('key', 'eq', 'ACTIVE_POWER') | map(attribute='value') | first) < 0 else (value_json['states'] | selectattr('key', 'eq', 'ACTIVE_POWER') | map(attribute='value') | first) }}"
      unit_of_measurement: "Wh"
      device_class: energy
      state_class: total
      icon: "mdi:TransmissionTower"
      
    # Stromnetz (aktuelle Einspeisung)
    - name: "neoom_power_grid_output"
      unique_id: "power_grid_output"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'ACTIVE_POWER') | map(attribute='value') | first * -1) if (value_json['states'] | selectattr('key', 'eq', 'ACTIVE_POWER') | map(attribute='value') | first) < 0 else 0 }}"
      unit_of_measurement: "Wh"
      device_class: energy
      state_class: total
      icon: "mdi:TransmissionTower"      
      
# BEAAM Ladestation
- resource: http://10.10.10.10/api/v1/things/GUID/states
  headers:
    Authorization: "Bearer sk_beaam_xxxxx" #Put your bearer token here, but do not delete Bearer at the beginning
    Content-Type: "application/json"
  method: GET
  scan_interval: 15  # Intervall für API-Aufrufe in Sekunden
    
  sensor:
    # Ladestation (aktueller Verbrauch in Watt)
    - name: "neoom_car_charger"
      unique_id: "car_charger"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'ACTIVE_POWER') | map(attribute='value') | first) }}"
      unit_of_measurement: "Wh"
      device_class: energy
      state_class: total
      icon: "mdi:EVStation"      

# BEAAM Boiler - Strom
- resource: http://10.10.10.10/api/v1/things/GUID/states
  headers:
    Authorization: "Bearer sk_beaam_xxxxx" #Put your bearer token here, but do not delete Bearer at the beginning
    Content-Type: "application/json"
  method: GET
  scan_interval: 15  # Intervall für API-Aufrufe in Sekunden
    
  sensor:
    # Boiler (aktueller Verbrauch in Watt)
    - name: "neoom_boiler_power"
      unique_id: "water_boiler_power"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'POWER') | map(attribute='value') | first) }}"
      unit_of_measurement: "Wh"
      device_class: energy
      state_class: total
      icon: "mdi:WaterBoiler"

# BEAAM Boiler - Temperatur
- resource: http://10.10.10.10/api/v1/things/GUID/states
  headers:
    Authorization: "Bearer sk_beaam_xxxxx" #Put your bearer token here, but do not delete Bearer at the beginning
    Content-Type: "application/json"
  method: GET
  scan_interval: 15  # Intervall für API-Aufrufe in Sekunden
    
  sensor:
    # Boiler (Temperatur 1)
    - name: "neoom_boiler_temp01"
      unique_id: "water_boiler_temp01"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'TEMPERATURES') | map(attribute='value') | first)[0] | round(0) }}"
      unit_of_measurement: "°C"
      device_class: temperature
      state_class: measurement
      icon: "mdi:WaterBoiler"

    # Boiler (Temperatur 2)
    - name: "neoom_boiler_temp02"
      unique_id: "water_boiler_temp02"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'TEMPERATURES') | map(attribute='value') | first)[1] | round(0) }}"
      unit_of_measurement: "°C"
      device_class: temperature
      state_class: measurement
      icon: "mdi:WaterBoiler"

For GUID, simply insert the GUID of the corresponding device.

I hope this helps someone.

Best regards
Marcel

Alex20 · January 28, 2025, 4:19pm

Hi @Leschi, @nutriOn,
I had the same problem. Everything worked fine and suddenly I got the information about “unknown” entity state. With the curl command I received the same error as you mentioned.
I opened a ticket by Neoom and didn’t get a response. I called them and they helped me although they said the support is not for private people. After a view attemps I reached the right person. He told me that they did an update. He checked my gateway remotly and said that due to any reason the update was not done on my gateway. He manually started the update and after I was able to receive the data on my command line.

pi@raspberrypi:~ $ curl --request GET \
     --url http://10.x.x.x/api/v1/site/state \
     --header 'accept: application/json' \
     --header 'authorization: Bearer sk_beaam_...............................'
{"energyFlow":{"states":[{"dataPointId":"939ef95d-caf5-59cd-a79e-e043110c5a77","                                                                                        key":"SELF_SUFFICIENCY","value":0,"ts":1738079090003},{"dataPointId":"163f8324-2                                                                                        950-5fed-be6e-d0cb0d870cb9","key":"POWER_PRODUCTION","value":0,"ts":173807909000                                                                                        3},{"dataPointId":"37eede49-a1d7-55a3-966a-a6736dec4b6a","key":"POWER_CONSUMPTIO                                                                                        N","value":null,"ts":1738060945003},{"dataPointId":"c3a11963-ee7b-5f94-becb-4b5c                                                                                        74e2ed57","key":"POWER_GRID","value":1254,"ts":1738079190028},{"dataPointId":"0c                                                                                        ca604e-0b95-5f1b-993f-4cb78a581ab0","key":"POWER_STORAGE","value":0,"ts":1738079                                                                                        120004},

…

He also told me that their is no limitation on the access if you have a “free” license model as I have.

Unfortunately I still have a problem to capture the data in Homeassistant. I still get the unknown entity state information although the curl command works fine.

Below the first part of my configuration in the configuration.yaml file.
#Neoom PV Anlage

rest:
  - resource: http://mydevcieIP/api/v1/site/state  # BEAAM API URL
    headers:
      Authorization: "sk_beaam_................" #Put your bearer token here, but do not delete Bearer at the beginning
      Content-Type: "application/json"
    method: GET
    scan_interval: 10  # Intervall fÃ¼r API-Aufrufe in Sekunden
    sensor:
      # Stromverbrauch (aktuelle Leistung in Watt)
      - name: "neoom_power_consumption"
        unique_id: "power_consumption"
        #value_template: "{{ value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_CONSUMPTION') | map(attribute='value') | first }}"
        value_template: "{{ (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_PRODUCTION') | map(attribute='value') | first * -1) if (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_PRODUCTION') | map(attribute='value') | first) < 0 else (value_json['energyFlow']['states'] | selectattr('key', 'eq', 'POWER_PRODUCTION') | map(attribute='value') | first) }}"
        unit_of_measurement: "W"
        device_class: power
        state_class: measurement
        icon: "mdi:LightningBoltOutline"

Is there any error?

During my trials I also tried to run the curl command in the Homeassistant terminal. Here I receive the following error message: Failed to connect to 10.x.x.x port 80 after 0 ms: Could not connect to server

I don’t know, but perhaps somebody of you know what to do or if this is only as I run the curl in the Homeassistant terminal.

Thanks for any help.

Guenter82 · January 29, 2025, 6:47pm

Hi!
I can confirm that it makes no difference whether you have a “Mega” subscription or not, because I have the Mega subscription and the Beaam API doesn’t work either. I recived the response: “statusCode”: 500, “message”: “Internal server error”

In the “Neoom Wissensdatenbank” you can read that the Problem is fixed with BEAAM SW - V1.68.0 since 17.01.2025, but I’am not sure where I can find my Beaam SW Version. But I know that the problem still exists at the moment for me.

@mbaum: Thanks for the way with the GUIDs. This works fine for me and I can get more information as from the Beaam API.

Best regards
Günter

mbaum · January 30, 2025, 7:55pm

Hi,

I have delved further into Home Assistant and realised that I have set the sensors in my yaml incorrectly.

instead of

      device_class: energy
      state_class: total

it should be

      device_class: power
      state_class: measurement

Here again the correct sensors as yaml:

# BEAAM Battery
- resource: http://10.10.10.10/api/v1/things/GUID/states
  headers:
    Authorization: "Bearer sk_beaam_xxxxx" #Put your bearer token here, but do not delete Bearer at the beginning
    Content-Type: "application/json"
  method: GET
  scan_interval: 15  # Intervall für API-Aufrufe in Sekunden
    
  sensor:
    # Batterie (aktueller Output in Watt)
    - name: "neoom_storage_output"
      unique_id: "storage_output"
      value_template: "{{ 0 if (value_json['states'] | selectattr('key', 'eq', 'POWER') | map(attribute='value') | first) < 0 else (value_json['states'] | selectattr('key', 'eq', 'POWER') | map(attribute='value') | first) }}"
      unit_of_measurement: "W"
      device_class: power
      state_class: measurement
      icon: "mdi:BatteryArrowDownOutline"      
      
    # Batterie (aktueller Input in Watt)
    - name: "neoom_storage_input"
      unique_id: "storage_input"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'POWER') | map(attribute='value') | first * -1) if (value_json['states'] | selectattr('key', 'eq', 'POWER') | map(attribute='value') | first) < 0 else 0 }}"
      unit_of_measurement: "W"
      device_class: power
      state_class: measurement
      icon: "mdi:BatteryArrowUpOutline"
      
    # Batterie (Ladezustand)
    - name: "neoom_state_of_charge"
      unique_id: "state_of_charge"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'STATE_OF_CHARGE') | map(attribute='value') | first) }}"
      unit_of_measurement: "%"
      device_class: battery
      state_class: measurement
      icon: "mdi:BatteryHeartVariant"                  
      
# BEAAM Inverter
- resource: http://10.10.10.10/api/v1/things/GUID/states  
  headers:
    Authorization: "Bearer sk_beaam_xxxxx" #Put your bearer token here, but do not delete Bearer at the beginning
    Content-Type: "application/json"
  method: GET
  scan_interval: 15  # Intervall für API-Aufrufe in Sekunden
    
  sensor:
    # Stromproduktion alle Panel (aktuelle Leistung in Watt)
    - name: "neoom_power_panels"
      unique_id: "power_panels"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'INPUTS_POWER') | map(attribute='value') | first)[0] + (value_json['states'] | selectattr('key', 'eq', 'INPUTS_POWER') | map(attribute='value') | first)[1] }}"
      unit_of_measurement: "W"
      device_class: power
      state_class: measurement
      icon: "mdi:SolarPanel"
    
    # Stromproduktion Panel West (aktuelle Leistung in Watt)
    - name: "neoom_power_panelwest"
      unique_id: "power_panelwest"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'INPUTS_POWER') | map(attribute='value') | first)[0] }}"
      unit_of_measurement: "W"
      device_class: power
      state_class: measurement
      icon: "mdi:SolarPanel"
            
    # Stromproduktion Panel Osten (aktuelle Leistung in Watt)
    - name: "neoom_power_paneleast"
      unique_id: "power_paneleast"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'INPUTS_POWER') | map(attribute='value') | first)[1] }}"
      unit_of_measurement: "W"
      device_class: power
      state_class: measurement
      icon: "mdi:SolarPanel"

# BEAAM AC (Grid)      
- resource: http://10.10.10.10/api/v1/things/GUID/states
  headers:
    Authorization: "Bearer sk_beaam_xxxxx" #Put your bearer token here, but do not delete Bearer at the beginning
    Content-Type: "application/json"
  method: GET
  scan_interval: 15  # Intervall für API-Aufrufe in Sekunden
    
  sensor:
    # Stromnetz (aktueller Bezug in Watt)
    - name: "neoom_power_grid_input"
      unique_id: "power_grid_input"
      value_template: "{{ 0 if (value_json['states'] | selectattr('key', 'eq', 'ACTIVE_POWER') | map(attribute='value') | first) < 0 else (value_json['states'] | selectattr('key', 'eq', 'ACTIVE_POWER') | map(attribute='value') | first) }}"
      unit_of_measurement: "W"
      device_class: power
      state_class: measurement
      icon: "mdi:TransmissionTower"
      
    # Stromnetz (aktuelle Einspeisung)
    - name: "neoom_power_grid_output"
      unique_id: "power_grid_output"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'ACTIVE_POWER') | map(attribute='value') | first * -1) if (value_json['states'] | selectattr('key', 'eq', 'ACTIVE_POWER') | map(attribute='value') | first) < 0 else 0 }}"
      unit_of_measurement: "W"
      device_class: power
      state_class: measurement
      icon: "mdi:TransmissionTower"      
      
# BEAAM Ladestation
- resource: http://10.10.10.10/api/v1/things/GUID/states
  headers:
    Authorization: "Bearer sk_beaam_xxxxx" #Put your bearer token here, but do not delete Bearer at the beginning
    Content-Type: "application/json"
  method: GET
  scan_interval: 15  # Intervall für API-Aufrufe in Sekunden
    
  sensor:
    # Ladestation (aktueller Verbrauch in Watt)
    - name: "neoom_car_charger"
      unique_id: "car_charger"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'ACTIVE_POWER') | map(attribute='value') | first) }}"
      unit_of_measurement: "W"
      device_class: power
      state_class: measurement
      icon: "mdi:EVStation"      

# BEAAM Boiler - Strom
- resource: http://10.10.10.10/api/v1/things/GUID/states
  headers:
    Authorization: "Bearer sk_beaam_xxxxx" #Put your bearer token here, but do not delete Bearer at the beginning
    Content-Type: "application/json"
  method: GET
  scan_interval: 15  # Intervall für API-Aufrufe in Sekunden
    
  sensor:
    # Boiler (aktueller Verbrauch in Watt)
    - name: "neoom_boiler_power"
      unique_id: "water_boiler_power"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'POWER') | map(attribute='value') | first) }}"
      unit_of_measurement: "W"
      device_class: power
      state_class: measurement
      icon: "mdi:WaterBoiler"

# BEAAM Boiler - Temperatur
- resource: http://10.10.10.10/api/v1/things/GUID/states
  headers:
    Authorization: "Bearer sk_beaam_xxxxx" #Put your bearer token here, but do not delete Bearer at the beginning
    Content-Type: "application/json"
  method: GET
  scan_interval: 15  # Intervall für API-Aufrufe in Sekunden
    
  sensor:
    # Boiler (Temperatur 1)
    - name: "neoom_boiler_temp01"
      unique_id: "water_boiler_temp01"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'TEMPERATURES') | map(attribute='value') | first)[0] | round(0) }}"
      unit_of_measurement: "°C"
      device_class: temperature
      state_class: measurement
      icon: "mdi:WaterBoiler"

    # Boiler (Temperatur 2)
    - name: "neoom_boiler_temp02"
      unique_id: "water_boiler_temp02"
      value_template: "{{ (value_json['states'] | selectattr('key', 'eq', 'TEMPERATURES') | map(attribute='value') | first)[1] | round(0) }}"
      unit_of_measurement: "°C"
      device_class: temperature
      state_class: measurement
      icon: "mdi:WaterBoiler"

I came across this when I was configuring the energy board, this always displayed incorrect values. The beeam sensors I created provide the current consumption in W (which is great for the power flow card plus), but the Energy-Board wants the values in kWh from energy sensors.

To be able to use the sensors in the Energy-Board, you have to create new “Integral Sensor” in the “Settings - Devices & Services - Helpers”. This can look like this for the grid current input:

You have to do this for the beaam sensors for the grid, solar and battery. These helper sensors can be used for the configuration of the energy board.

I hope this helps someone, I had to search a bit until I understood everything

nutriOn · February 12, 2025, 9:38am

Since yesterday, my old sensors work again
Hope you also got the software update!

Stephan_E · March 9, 2025, 5:44pm

First of all thanks to the work which is done here … and for my understanding as sum up : Using of the API is only possible atm if u leave the free account to a payment one? Because i dont pay atm but get always a “unauthorized” when i wanna access the data

Greetings
Stephan