Hier erkläre ich dir, wie du Ausreißer oder generell gesprochen falsche Statistiken deiner Home Assistant Entitäten korrigieren kannst.

Das ist vor allem für das Energiedashboard wichtig, kann aber auch für andere Entitäten relevant sein solltest du dich beispielsweise für Auswertungen auf die Home Assistant Statistiken verlassen.

Lass uns gemeinsam eintauchen und herausfinden, welche 3 Möglichkeiten es dafür gibt!

Inhaltsverzeichnis

• Voraussetzungen
• SQL-Kommandos für Möglichkeit 3
• Links zu SQL-Skripten
• Hinweis zu geänderten Einheiten
• Mehr Skripte zum modifizieren/korrigieren der Statistiken
  • kWh anstatt Wh – Beispiel
• 2026 – Mein neues Skript zum korrigieren vom Energiedashboard
  • 1. Skript – Finden der Werte
  • 2. Skript – Korrigieren der Werte
  • 3. Bonus-Skripte – Kosten bereinigen
    • Select-Statement (Nur gucken, nix anfassen)
    • Update-Statement
  • Skript zum korrigieren vom einzelnen Geräte-Verbräuchen
  • 1. Skript – Finden der Werte
  • 2. Skript – Korrigieren der Werte
• Skript-Toolbox
  • Short-Term Statistik eines Sensors anzeigen
• Fazit

Voraussetzungen

Home Assistant muss schon installiert sein, auf welcher Hardware spielt keine Rolle.

Außerdem sollte deine Datenbank auf SQLite laufen (nur für Maria-DB nutzer relevant, SQLite ist der Systemstandard)

SQL-Kommandos für Möglichkeit 3

Zuerst musst du mit dem Kommando SELECT * FROM "statistics_meta" where statistic_id LIKE "%strom%" herausfinden, welche ID (ganz linke spalte) deine Entität in der Meta-Tabelle hat. Hier wird nach dem Platzhalter Strom innerhalb des Entitäts-Namens gesucht.

Anschließend kopierst du dir die ID in ein Textdokument (Hier im Beispiel 18)

Danach suchen wir uns mit dem SQL-Query SELECT * FROM "statistics" where metadata_id = 18 Order BY state DESC den größten Statistischen Wert der Entität aus der Statistiktabelle raus.

ASC anstatt DESC gibt uns den kleinsten statistischen wert ganz oben aus 😉

Links zu SQL-Skripten

Für erweiterte Datenbereinigung oder hinzufügen von Statistischen Einträgen relevant. Nicht zu empfehlen, wenn man keinen Plan von SQL hat, weil man schnell mehr kaputt machen kann als vorher war 😉

• https://community.home-assistant.io/t/fix-bad-data-in-energy-tab/347792/53
• https://community.home-assistant.io/t/recalculate-statistics-table-sum-to-fix-wrong-energy-data/371334

Hinweis zu geänderten Einheiten

Ganz nebenbei bemerkt habe ich im Video vergessen, eine Möglichkeit zu erwähnen. Mit dem Statistik-Tool kann man Einheiten korrigieren, wenn sich die Einheit eines Sensors mal geändert haben sollte.

Beispiel: Man legt einen Template-Sensor an, vergisst die Einheit zu setzen und ergänzt diese danach erst (nach dem initialen Anlegen des Sensors). Somit weiß Home Assistant nicht mehr, welches die „richtige“ der beiden Einheiten (keine / die neue Einheit) ist.

Beheben kann man das Problem aber einfacher, als es zu erklären 😉:

Mehr Skripte zum modifizieren/korrigieren der Statistiken

kWh anstatt Wh – Beispiel

Du hast einen Sensor angelegt, der eigentlich Wh angibt jedoch hast du versehentlich diesen Sensor mit kWh erstellt. Nun musst du alle bisherigen werte durch 1000 teilen, damit das irgendwie noch Sinn macht

1. Meta-ID suchen:

SELECT * FROM "statistics_meta" where statistic_id LIKE "%solar%"

2. Daten anzeigen, das müssen wir in 2 Tabellen (jeweils) machen:

SELECT * FROM statistics WHERE metadata_id = 779
SELECT * FROM statistics_short_term WHERE metadata_id = 779

3. Die Ziele finden, bis zu welcher das Problem bestand (falls du das Template oder die Einheit inzwischen angepasst hast, und über das Statistik-Tool wurde dir nicht angeboten die bisherigen Werte zu ändern) und dann alle werte kleiner als der Timestamp anzeigen:

SELECT * FROM statistics WHERE metadata_id = 779 AND created_ts < 1720942810.3191178
SELECT * FROM statistics_short_term WHERE metadata_id = 779 AND created_ts < 1720942810.3191178

4. Werte verändern, in diesem Beispiel werden diese durch 1000 geteilt (Wattstunden in Kilowattstunden umrechnen). Sind hier natürlich auch wieder 2 Statements für jeweils eine der Tabellen:

UPDATE "statistics" SET state = state / 1000, sum = sum / 1000 WHERE metadata_id = 779 AND created_ts < 1720942810.3191178
UPDATE "statistics_short_term" SET state = state / 1000, sum = sum / 1000 WHERE metadata_id = 779 AND created_ts < 1720942810.3191178

2026 – Mein neues Skript zum korrigieren vom Energiedashboard

Ich hatte bei einem bekannten das Problem, dass die Werte im Energiedashboard von einem Lesekopf verfälscht waren. Hier wurde teilweise 1-2 mal pro Tag der Zählerstand genullt, was dazu führt, dass in Home Assistant die Statistiken direkt danach den gesamten Verbrauch des Stromzählers als verbrauch zählen.

Daraufhin habe ich 2 Skripte für das SQLLite-Web Addon geschrieben.

Eines zum Finden auffälliger Verbräuche und ein 2. Skript, was die gefundenen Verbräuche mathematisch bereinigt. Ist getestet mit einem normalen Stromverbrauchszähler (Einspeisung und Netzbezug), sollte aber auch für alle anderen Statistiken funktionieren.

Wichtig ist folgendes:

• Vorher UNBEDINGT ein Backup machen und bei Bedarf wiederherstellen! Ich übernehme keine Garantie für Funktion des Skriptes, verlorene Daten oder sonst was.
• Die Range, also ab welchem Wert die Werte als „zu korrigieren“ angesehen werden, ist in beiden Skripten (Finden der Werte (1) und Korrigieren der Werte (2)) statisch auf 100 eingestellt. Für Stromzähler von Privatwohnungen ganz passen, für Gewerbe-Strom oder Wasserzähler entsprechend anpassen.
• Die korrekten Werte werden mathematisch aus dem Stand davor und danach ermittelt.

WITH error_marks AS (
    -- 1. Wir finden die Fehlerstellen mit gelockertem Filter
    SELECT 
        s.id,
        s.start_ts,
        -- Berechnung des Offsets: Summen-Sprung MINUS echter Zähler-Zuwachs
        (s.sum - s_prev.sum) - (s.state - s_prev.state) as offset_delta
    FROM statistics s
    JOIN statistics s_prev ON s.metadata_id = s_prev.metadata_id 
         AND s_prev.start_ts = (SELECT MAX(start_ts) FROM statistics WHERE metadata_id = s.metadata_id AND start_ts < s.start_ts)
    WHERE s.metadata_id = (SELECT id FROM statistics_meta WHERE statistic_id = 'sensor.netzeinspeisung')
      -- Wir suchen Summen-Sprünge über 100...
      AND (s.sum - s_prev.sum) > 100
      -- ...während der echte Zählerstand sich im plausiblen Rahmen (0-1000) bewegte
      AND (s.state - s_prev.state) BETWEEN 0 AND 1000
),
all_data AS (
    SELECT 
        s.id,
        s.start_ts,
        s.sum as original_sum,
        s.state,
        em.offset_delta
    FROM statistics s
    LEFT JOIN error_marks em ON s.id = em.id
    WHERE s.metadata_id = (SELECT id FROM statistics_meta WHERE statistic_id = 'sensor.netzeinspeisung')
)
SELECT 
    datetime(start_ts, 'unixepoch', 'localtime') as zeitpunkt,
    state as zählerstand,
    ROUND(original_sum, 1) as summe_alt,
    -- Kumulierung der Offsets über die Zeit
    ROUND(SUM(COALESCE(offset_delta, 0)) OVER (ORDER BY start_ts ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 1) as kumulierter_fehler,
    -- Berechnung der neuen Ziel-Summe
    ROUND(original_sum - SUM(COALESCE(offset_delta, 0)) OVER (ORDER BY start_ts ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 1) as summe_neu_vorgeschlagen
FROM all_data
ORDER BY start_ts DESC
LIMIT 1500;

WITH target_sensor AS (
    SELECT id FROM statistics_meta WHERE statistic_id = 'sensor.netzeinspeisung'
),
error_marks AS (
    -- 1. Identifikation der Fehler-Zeitpunkte
    SELECT 
        s.id,
        s.start_ts,
        ((s.sum - s_prev.sum) - (s.state - s_prev.state)) as offset_delta
    FROM statistics s
    JOIN statistics s_prev ON s.metadata_id = s_prev.metadata_id 
         AND s_prev.start_ts = (SELECT MAX(start_ts) FROM statistics WHERE metadata_id = s.metadata_id AND start_ts < s.start_ts)
    WHERE s.metadata_id = (SELECT id FROM target_sensor)
      -- Wir korrigieren Summen-Sprünge über 100...
      AND (s.sum - s_prev.sum) > 100
      -- ...während der echte Zählerstand sich im plausiblen Rahmen (0-1000) bewegte
      AND (s.state - s_prev.state) BETWEEN 0 AND 1000
),
correction_map AS (
    -- 2. Zuordnung jeder ID zu ihrem spezifischen Korrektur-Offset
    SELECT 
        s.id,
        SUM(COALESCE(em.offset_delta, 0)) OVER (ORDER BY s.start_ts ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) as total_offset
    FROM statistics s
    LEFT JOIN error_marks em ON s.id = em.id
    WHERE s.metadata_id = (SELECT id FROM target_sensor)
)
-- 3. Das eigentliche Update
UPDATE statistics
SET sum = sum - (
    SELECT total_offset 
    FROM correction_map 
    WHERE correction_map.id = statistics.id
)
WHERE id IN (SELECT id FROM correction_map);

WITH 
-- 1. Definition der beiden betroffenen Sensoren
target_ids AS (
    SELECT 
        (SELECT id FROM statistics_meta WHERE statistic_id = 'sensor.netzbezug') as energy_id,
        (SELECT id FROM statistics_meta WHERE statistic_id = 'sensor.netzbezug_cost') as cost_id
),
-- 2. Holen der Energie-Daten (wir nutzen die bereits korrigierte 'sum'-Spalte)
energy_data AS (
    SELECT 
        start_ts,
        (sum - LAG(sum) OVER (ORDER BY start_ts)) as energy_delta
    FROM statistics, target_ids
    WHERE metadata_id = energy_id
),
-- 3. Holen der Kosten-Daten
cost_data AS (
    SELECT 
        id, start_ts, sum,
        (sum - LAG(sum) OVER (ORDER BY start_ts)) as cost_delta
    FROM statistics, target_ids
    WHERE metadata_id = cost_id
),
-- 4. Zusammenführung und Ermittlung des realen Preises (aus sauberen Daten)
combined AS (
    SELECT 
        c.id, c.start_ts, c.sum as cost_sum, c.cost_delta,
        e.energy_delta,
        CASE 
            WHEN c.cost_delta > 0 AND c.cost_delta < 2 AND e.energy_delta > 0 
            THEN c.cost_delta / e.energy_delta 
            ELSE NULL 
        END as calculated_unit_price
    FROM cost_data c
    JOIN energy_data e ON c.start_ts = e.start_ts
),
-- 5. Durchschnittspreis festlegen
reference_price AS (
    SELECT AVG(calculated_unit_price) as val FROM combined WHERE calculated_unit_price IS NOT NULL
),
-- 6. Fehlerstellen exakt berechnen
error_marks AS (
    SELECT 
        c.id,
        c.start_ts,
        -- Fehler = Tatsächlicher Sprung - (Echter Verbrauch * Preis)
        c.cost_delta - (COALESCE(c.energy_delta, 0) * (SELECT val FROM reference_price)) as offset_delta
    FROM combined c
    WHERE c.cost_delta > 10.0 -- Schwelle für Kostensprung
)
-- 7. Die finale "perfekte" Vorschau
SELECT 
    datetime(c.start_ts, 'unixepoch', 'localtime') as zeitpunkt,
    ROUND(c.energy_delta, 3) as echter_verbrauch,
    ROUND(c.cost_sum, 2) as kosten_summe_alt,
    ROUND(SUM(COALESCE(em.offset_delta, 0)) OVER (ORDER BY c.start_ts ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 2) as kumulierter_fehler_euro,
    ROUND(c.cost_sum - SUM(COALESCE(em.offset_delta, 0)) OVER (ORDER BY c.start_ts ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 2) as kosten_summe_perfekt
FROM combined c
LEFT JOIN error_marks em ON c.id = em.id
ORDER BY c.start_ts DESC
LIMIT 1500;

WITH 
-- 1. IDs festlegen
target_ids AS (
    SELECT 
        (SELECT id FROM statistics_meta WHERE statistic_id = 'sensor.netzbezug') as energy_id,
        (SELECT id FROM statistics_meta WHERE statistic_id = 'sensor.netzbezug_cost') as cost_id
),
-- 2. Energie-Deltas (bereits korrigiert)
energy_data AS (
    SELECT 
        start_ts,
        (sum - LAG(sum) OVER (ORDER BY start_ts)) as energy_delta
    FROM statistics, target_ids
    WHERE metadata_id = energy_id
),
-- 3. Kosten-Deltas
cost_data AS (
    SELECT 
        id, start_ts, sum,
        (sum - LAG(sum) OVER (ORDER BY start_ts)) as cost_delta
    FROM statistics, target_ids
    WHERE metadata_id = cost_id
),
-- 4. Preis ermitteln aus sauberen Stunden (Sprung < 2€)
reference_price AS (
    SELECT AVG(c.cost_delta / e.energy_delta) as val
    FROM cost_data c
    JOIN energy_data e ON c.start_ts = e.start_ts
    WHERE c.cost_delta > 0 AND c.cost_delta < 2.0 AND e.energy_delta > 0
),
-- 5. Exakten Fehler pro Stunde berechnen
error_marks AS (
    SELECT 
        c.id,
        c.start_ts,
        -- Fehler = Tatsächlicher Sprung - (Echter Verbrauch * Durchschnittspreis)
        c.cost_delta - (COALESCE(e.energy_delta, 0) * (SELECT val FROM reference_price)) as offset_delta
    FROM cost_data c
    JOIN energy_data e ON c.start_ts = e.start_ts
    WHERE c.cost_delta > 10.0 -- Schwelle für unplausible Kosten
),
-- 6. Kumulierter Korrekturwert für jede Zeile der Tabelle
correction_map AS (
    SELECT 
        s.id,
        SUM(COALESCE(em.offset_delta, 0)) OVER (ORDER BY s.start_ts ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) as total_offset
    FROM statistics s
    LEFT JOIN error_marks em ON s.id = em.id
    WHERE s.metadata_id = (SELECT cost_id FROM target_ids)
)
-- 7. Das finale Update
UPDATE statistics
SET sum = sum - (
    SELECT total_offset 
    FROM correction_map 
    WHERE correction_map.id = statistics.id
)
WHERE id IN (SELECT id FROM correction_map);

Skript zum korrigieren vom einzelnen Geräte-Verbräuchen

Außerdem habe ich auch noch 2 Skripte erstellt um den Verbrauch einzelner Geräte wieder zu korrigieren. Denn z.B. bei manchen Shelly-Firmwares kommt es ohne ersichtlichen Grund vor, dass auf einmal z.B. 3000 kWh Verbrauch gemeldet werden. Ein zurücksetzen der Counter des Shelly-Gerätes schafft da oft Abhilfe.

Natürlich alles auf eigene Gefahr -> Kein Backup kein Mitleid! ⚠️

Die beiden Skripte zeigen (Skript 1) und korrigieren Skript 2 unplausibel hohe werte (über 1000 kwh), in dem diese einfach auf 0 gesetzt werden. Klar, ist nicht perfekt, aber für Einzelgeräte statistisch gesehen vernachlässigbar.

WITH target_sensor AS (
    -- HIER die Entity-ID des Shellys eintragen
    SELECT id FROM statistics_meta WHERE statistic_id = 'sensor.licht_spiegelschrank_energie'
),
error_marks AS (
    -- 1. Wir finden die "Phantom-Sprünge" (größer als 1000 kWh)
    SELECT 
        s.id,
        s.start_ts,
        -- Wir definieren den gesamten Zuwachs dieser Stunde als Fehler
        (s.sum - s_prev.sum) as offset_delta
    FROM statistics s
    JOIN statistics s_prev ON s.metadata_id = s_prev.metadata_id 
         AND s_prev.start_ts = (SELECT MAX(start_ts) FROM statistics WHERE metadata_id = s.metadata_id AND start_ts < s.start_ts)
    WHERE s.metadata_id = (SELECT id FROM target_sensor)
      AND (s.sum - s_prev.sum) > 1000 -- Schwelle für den kWh-Fehler
),
all_data AS (
    SELECT 
        s.id,
        s.start_ts,
        s.sum as original_sum,
        em.offset_delta
    FROM statistics s
    LEFT JOIN error_marks em ON s.id = em.id
    WHERE s.metadata_id = (SELECT id FROM target_sensor)
)
SELECT 
    datetime(start_ts, 'unixepoch', 'localtime') as zeitpunkt,
    ROUND(original_sum, 2) as summe_alt,
    ROUND(SUM(COALESCE(offset_delta, 0)) OVER (ORDER BY start_ts ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 2) as abgezogener_fehler,
    ROUND(original_sum - SUM(COALESCE(offset_delta, 0)) OVER (ORDER BY start_ts ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 2) as summe_neu_geglättet
FROM all_data
ORDER BY start_ts DESC
LIMIT 500;

WITH target_sensor AS (
    -- HIER die Entity-ID des Shellys eintragen
    SELECT id FROM statistics_meta WHERE statistic_id = 'sensor.licht_spiegelschrank_energie'
),
error_marks AS (
    SELECT 
        s.id,
        s.start_ts,
        -- Wir definieren den gesamten Zuwachs dieser Stunde als Fehler
        (s.sum - s_prev.sum) as offset_delta
    FROM statistics s
    JOIN statistics s_prev ON s.metadata_id = s_prev.metadata_id 
         AND s_prev.start_ts = (SELECT MAX(start_ts) FROM statistics WHERE metadata_id = s.metadata_id AND start_ts < s.start_ts)
    WHERE s.metadata_id = (SELECT id FROM target_sensor)
      AND (s.sum - s_prev.sum) > 1000 -- Schwelle für den kWh-Fehler
),
correction_map AS (
    SELECT 
        s.id,
        SUM(COALESCE(em.offset_delta, 0)) OVER (ORDER BY s.start_ts ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) as total_offset
    FROM statistics s
    LEFT JOIN error_marks em ON s.id = em.id
    WHERE s.metadata_id = (SELECT id FROM target_sensor)
)
UPDATE statistics
SET sum = sum - (
    SELECT total_offset 
    FROM correction_map 
    WHERE correction_map.id = statistics.id
)
WHERE id IN (SELECT id FROM correction_map);

DELETE FROM statistics_short_term
WHERE metadata_id = (SELECT id FROM statistics_meta WHERE statistic_id = 'sensor.licht_spiegelschrank_energie');

Skript-Toolbox

Hilfreiche Skripte zum anzeigen der Statistiken usw.

Short-Term Statistik eines Sensors anzeigen

SELECT 
    datetime(start_ts, 'unixepoch', 'localtime') as zeitpunkt,
    state,
    sum
FROM statistics_short_term
WHERE metadata_id = (SELECT id FROM statistics_meta WHERE statistic_id = 'sensor.licht_spiegelschrank_energie')
ORDER BY start_ts DESC
LIMIT 500;

Fazit

Insgesamt eine tolle Möglichkeit, Home Assistant Statistiken zu korrigieren oder leere Zwischenräume aufzufüllen, sollte es doch mal zu Falschmeldungen von Sensoren kommen.

Wenn du Fragen oder Anmerkungen hast, zögere nicht, sie mir unten in den Kommentaren mitzuteilen und ich werde mein Bestes tun, um dir zu helfen. Vielen Dank fürs Zuschauen!

Bitte dieses Feld leer lassen

Verpasse keine Tipps!

Ich sende keinen Spam! Erfahre mehr in der Datenschutzerklärung.

Prüfe deinen Posteingang oder Spam-Ordner, um deine Anmeldung zu bestätigen.