Tempo dans Home Assistant sans compte RTE

Couleur Tempo du jour et du lendemain, jours restants, risque de jour rouge et pilotage du chauffe-eau : tout se configure avec les intégrations natives REST et Template de Home Assistant, sans compte RTE, sans clé ni module de téléinformation.
Tempo dans Home Assistant sans compte RTE

Sommaire

⚠️
AVERTISSEMENT : la mise en œuvre de ce tutoriel, en particulier la commande d'un chauffe-eau, est réalisée sous la seule responsabilité de la personne qui l'entreprend. HACF et l'auteur de l'article déclinent toute responsabilité en cas de dommage ou d'incident.

Le contenu de cet article a été testé et validé avec la version 2026.10 de Home Assistant.

Introduction

Le problème

Avec l'option Tempo, le prix du kWh dépend de la couleur du jour : bleu, blanc ou rouge. En heures pleines, un jour rouge coûte nettement plus cher qu'un jour bleu.

Pour en profiter, Home Assistant doit connaître la couleur à temps, puis agir sur les gros consommateurs, comme le chauffe-eau.

Les solutions les plus répandues demandent :

  • soit un compte développeur sur le portail de données de RTE, avec une application et des identifiants à créer, une étape sur laquelle plusieurs membres du forum ont buté ;
  • soit un module branché sur la téléinformation (TIC) du compteur Linky, qui ne connaît la couleur du lendemain qu'à partir de 20 h.

La solution proposée

Interroger une API JSON publique, gratuite et sans clé avec les intégrations natives REST et Template de Home Assistant.

Quelques lignes de YAML créent les capteurs suivants :

  • couleur du jour, couleur de demain et couleur en cours, qui suit la journée Tempo de 6 h à 6 h ;
  • jours rouges et blancs restants dans la saison ;
  • prévision à J+2 et risque de jour rouge sur les jours suivants.

Trois automatisations s'appuient ensuite sur ces capteurs : couper le chauffe-eau en heures pleines les jours rouges, prévenir la veille d'un jour rouge, signaler un risque de rouge quelques jours à l'avance.

💬
L'API utilisée dans ce tutoriel est celle de Calendrier Tempo, un projet indépendant que je porte : couleur Tempo du jour, prévisions jusqu'à 15 jours et API JSON gratuite.

Prérequis

  • Home Assistant à jour ;
  • Une installation Home Assistant OS ou Container : HACS n'est pas nécessaire ;
  • Un accès au fichier configuration.yaml, par exemple avec l'application File editor ou Studio Code Server (les anciens add-ons, sur Home Assistant OS) ;
  • Pour le pilotage, un chauffe-eau commandé par une prise ou un relais connecté (Shelly, contacteur pilotable…) qui apparaît comme une entité switch ;
  • Pour les notifications, l'application mobile Home Assistant ou un autre service de notification.
💡
Vous préférez éviter le YAML ? L'intégration Calendrier Tempo EDF, installable via HACS en dépôt personnalisé, crée ces informations depuis l'interface, avec en plus un calendrier des jours blancs et rouges. Depuis la version 0.3.0, elle donne aussi le prix du kWh en cours et les prix heures pleines et heures creuses de chaque couleur, utilisables dans le tableau Énergie. Elle est présentée dans ce sujet du forum :
[Intégration] Calendrier Tempo EDF : couleur du jour/demain + prévisions jusqu’à 15 jours, sans compte RTE ni clé
Bonjour à tous, Je suis Jean-Pierre, de l’équipe qui a créé calendrier-tempo.fr, un service gratuit et indépendant (non affilié à EDF ni à RTE) qui affiche la couleur Tempo et la prévoit jusqu’à 15 jours. Je le précise d’entrée : c’est notre projet, je ne suis pas un simple utilisateur. Plusieurs sujets ici portent sur deux points : obtenir la couleur Tempo sans créer de compte sur l’API RTE, et avoir une prévision fiable au-delà de demain. Nous avons publié une intégration Home Assistant qui…

Rappel : comment fonctionne Tempo

  • Une saison Tempo va du 1er septembre au 31 août. Elle compte 22 jours rouges, 43 jours blancs et 300 jours bleus (301 quand la saison compte un 29 février).
  • Les jours rouges tombent uniquement du 1er novembre au 31 mars, jamais le week-end ni un jour férié national, et au plus 5 jours de suite.
  • Les jours blancs ne tombent jamais le dimanche.
  • Une journée Tempo va de 6 h à 6 h le lendemain : heures pleines de 6 h à 22 h, heures creuses de 22 h à 6 h. Entre minuit et 6 h, c'est donc encore la couleur de la veille qui s'applique.
  • La couleur est fixée par RTE, le gestionnaire du réseau de transport. Sa publication définitive a lieu la veille à 10 h 30, avec parfois un pré-signalement indicatif entre 8 h et 10 h 30 ; il arrive qu'elle soit plus tardive. EDF la diffuse dès 11 h, et le compteur Linky l'affiche à partir de 20 h. En cas de doute, c'est le Linky qui fait foi.

Sources : la page Tempo d'EDF et le calendrier Tempo de RTE.

La source de données

L'API de Calendrier Tempo est gratuite, sans inscription ni clé. Elle relaie, via un service tiers, les couleurs officielles publiées par EDF, et fournit des prévisions calculées par le projet.

Quatre points d'accès servent dans ce tutoriel :

Point d'accès Contenu
/api/today couleur officielle du jour
/api/tomorrow couleur officielle de demain, dès qu'elle est publiée
/api/remaining jours restants par couleur dans la saison
/api/predictions prévisions jour par jour, d'aujourd'hui à J+15

Réponse de /api/today (extrait : elle donne aussi les prix du kWh, champs tarif et tarifs) :

{"status": "ok", "date": "2026-10-17", "couleur": "BLEU", "code": 1}

Le champ couleur vaut BLEU, BLANC ou ROUGE, et code vaut 1, 2 ou 3.

⚠️
Tant que la couleur de demain n'est pas publiée, /api/tomorrow renvoie "status": "unavailable" et un message, sans champ couleur. Les capteurs ci-dessous gèrent ce cas : « Tempo demain » reste indisponible chaque matin jusqu'à la publication, vers 11 h. C'est normal.

Extrait de /api/predictions (trois premiers éléments, champs abrégés) :

{
  "status": "ok",
  "predictions": [
    {"date": "2026-10-17", "couleur_predite": "BLEU", "probabilite_bleu": 1.0, "probabilite_blanc": 0.0, "probabilite_rouge": 0.0, "confirmed": true},
    {"date": "2026-10-18", "couleur_predite": "BLEU", "probabilite_bleu": 1.0, "probabilite_blanc": 0.0, "probabilite_rouge": 0.0, "confirmed": true},
    {"date": "2026-10-19", "couleur_predite": "BLEU", "probabilite_bleu": 0.984, "probabilite_blanc": 0.016, "probabilite_rouge": 0.0, "confirmed": false}
  ]
}

La liste commence à aujourd'hui : l'élément [0] est aujourd'hui, [1] demain, [2] après-demain, et ainsi de suite jusqu'à J+15. Les probabilités vont de 0 à 1. Chaque élément contient aussi d'autres champs (score de risque, températures prévues, raison, horizon). L'attribut confirmed passe à true quand la couleur officielle est connue : elle remplace alors la prévision.

Étape 1 : les capteurs REST

Ajoutez ce bloc dans configuration.yaml. Si vous y avez déjà une section rest:, ajoutez seulement les éléments de la liste à la suite.

rest:
  - resource: https://www.calendrier-tempo.fr/api/today
    scan_interval: 3600
    sensor:
      - name: "Tempo aujourd'hui"
        unique_id: tempo_aujourdhui
        icon: mdi:calendar-today
        availability: "{{ value_json is defined and value_json.status == 'ok' }}"
        value_template: "{{ value_json.couleur }}"
        json_attributes:
          - date
          - code
  - resource: https://www.calendrier-tempo.fr/api/tomorrow
    scan_interval: 1800
    sensor:
      - name: "Tempo demain"
        unique_id: tempo_demain
        icon: mdi:calendar-arrow-right
        availability: "{{ value_json is defined and value_json.status == 'ok' }}"
        value_template: "{{ value_json.couleur }}"
        json_attributes:
          - date
          - code
  - resource: https://www.calendrier-tempo.fr/api/remaining
    scan_interval: 21600
    sensor:
      - name: "Tempo rouges restants"
        unique_id: tempo_rouges_restants
        icon: mdi:calendar-alert
        availability: "{{ value_json is defined and value_json.status == 'ok' }}"
        value_template: "{{ value_json.remaining.ROUGE }}"
        unit_of_measurement: "jours"
      - name: "Tempo blancs restants"
        unique_id: tempo_blancs_restants
        icon: mdi:calendar-blank
        availability: "{{ value_json is defined and value_json.status == 'ok' }}"
        value_template: "{{ value_json.remaining.BLANC }}"
        unit_of_measurement: "jours"
  - resource: https://www.calendrier-tempo.fr/api/predictions
    scan_interval: 21600
    sensor:
      - name: "Tempo prévision J+2"
        unique_id: tempo_prevision_j2
        icon: mdi:crystal-ball
        availability: "{{ value_json is defined and value_json.status == 'ok' }}"
        value_template: "{{ value_json.predictions[2].couleur_predite }}"
        json_attributes_path: "$.predictions[2]"
        json_attributes:
          - date
          - probabilite_bleu
          - probabilite_blanc
          - probabilite_rouge
          - confirmed
      - name: "Tempo risque de rouge J+2 à J+5"
        unique_id: tempo_risque_rouge_j2_j5
        icon: mdi:alert-outline
        availability: "{{ value_json is defined and value_json.status == 'ok' }}"
        value_template: >
          {% set p = value_json.predictions[2:6]
               | map(attribute='probabilite_rouge')
               | map('float', 0) | list %}
          {{ (p | max * 100) | round(0) | int if p else 0 }}
        unit_of_measurement: "%"

Ce que fait chaque option :

  • availability : le capteur passe à l'état indisponible quand l'API répond unavailable, au lieu d'afficher une valeur vide ou fausse.
  • scan_interval (en secondes) : une requête par heure pour aujourd'hui, toutes les 30 minutes pour demain afin de capter la publication de fin de matinée, toutes les 6 heures pour le reste. La couleur ne change qu'une fois par jour et les réponses sont en cache 2 minutes : inutile d'aller plus vite.
  • json_attributes_path : pour la prévision, on cible predictions[2], c'est-à-dire J+2.
  • Risque de rouge J+2 à J+5 : la plus forte probabilité de rouge parmi les éléments 2 à 5 de la liste, en pourcentage. C'est un indicateur de tendance, pas une couleur.

Étape 2 : la couleur en cours, de 6 h à 6 h

« Tempo aujourd'hui » suit le calendrier : il prend la couleur du nouveau jour peu après minuit, à sa première mise à jour. Or, entre minuit et 6 h, c'est encore la couleur de la veille qui s'applique : un suivi de consommation qui bascule à minuit range ces kWh dans la mauvaise couleur.

Ce capteur de modèle (template) ne prend la nouvelle couleur qu'à partir de 6 h. Ajoutez-le dans configuration.yaml, ou à la suite de votre section template: existante :

template:
  - triggers:
      - trigger: time
        at: "06:00:00"
      - trigger: state
        entity_id: sensor.tempo_aujourd_hui
      - trigger: homeassistant
        event: start
    sensor:
      - name: "Tempo couleur en cours"
        unique_id: tempo_couleur_en_cours
        icon: mdi:transmission-tower
        state: >
          {% set c = states('sensor.tempo_aujourd_hui') %}
          {% if now().hour >= 6 and c in ['BLEU', 'BLANC', 'ROUGE'] %}
            {{ c }}
          {% else %}
            {{ this.state }}
          {% endif %}

Comment ça marche :

  • avant 6 h, le capteur garde sa valeur précédente (this.state) ;
  • à 6 h, ou dès que « Tempo aujourd'hui » change après 6 h, il reprend la couleur du jour ;
  • un capteur de modèle à déclencheurs conserve sa valeur après un redémarrage. Seule la toute première nuit, s'il est créé avant 6 h, il reste « inconnu » jusqu'à 6 h.
TEMPO - Suivre sa consommation sur Home Assistant
Vous êtes abonné EDF Tempo ? Cet article est votre guide pour transformer Home Assistant en un véritable tableau de bord énergétique intelligent

Pour répartir votre consommation par couleur et par plage horaire, l'article du portail ci-dessus détaille la méthode avec les compteurs de services publics et le panneau Énergie. Le capteur « Tempo couleur en cours » peut remplacer le capteur de couleur de son automatisation d'aiguillage : son filtre | lower transforme BLEU en bleu.

Vérifier et redémarrer

  1. Ouvrez Paramètres > Outils > YAML et cliquez sur Vérifier la configuration.
  2. Au premier ajout des sections rest: et template:, redémarrez Home Assistant. Pour les modifications suivantes, les boutons Entités REST et services de notification et Entités basées sur modèle du même écran suffisent.
  3. Contrôlez les entités dans Paramètres > Outils > États :
Nom Entité
Tempo aujourd'hui sensor.tempo_aujourd_hui
Tempo demain sensor.tempo_demain
Tempo couleur en cours sensor.tempo_couleur_en_cours
Tempo rouges restants sensor.tempo_rouges_restants
Tempo blancs restants sensor.tempo_blancs_restants
Tempo prévision J+2 sensor.tempo_prevision_j_2
Tempo risque de rouge J+2 à J+5 sensor.tempo_risque_de_rouge_j_2_a_j_5

Si une entité porte déjà le même identifiant, Home Assistant ajoute le suffixe _2 : adaptez alors les automatisations.

💡
Copier-coller : utilisez le bouton de copie des blocs de code. Des guillemets typographiques (« », ’) à la place des guillemets droits (' ") suffisent à casser un modèle, et l'erreur n'est pas toujours explicite.

Étape 3 : les automatisations

Collez ces automatisations dans automations.yaml (sur une installation neuve, ce fichier contient seulement [] : remplacez-le par le bloc ci-dessous, sinon la configuration devient invalide), ou une par une dans l'éditeur : Paramètres > Automatisations et scènes > Créer une automatisation > Créer une nouvelle automatisation, menu ⋮ puis Modifier en YAML (dans ce cas, sans le tiret ni l'indentation du début).

Remplacez switch.chauffe_eau par votre entité. notify.notify envoie la notification à tous les téléphones sur lesquels l'application Home Assistant est connectée ; sans application, il ne fait rien, sans message d'erreur. Pour viser un seul téléphone, remplacez-le par notify.mobile_app_<votre_telephone>.

- id: tempo_chauffe_eau_jour_rouge
  alias: "Tempo : chauffe-eau coupé en heures pleines les jours rouges"
  triggers:
    - trigger: time
      at: "06:00:00"
      id: debut_hp
    - trigger: time
      at: "22:00:00"
      id: debut_hc
  actions:
    - choose:
        - conditions:
            - condition: trigger
              id: debut_hp
          sequence:
            - action: homeassistant.update_entity
              target:
                entity_id: sensor.tempo_aujourd_hui
            - delay: "00:00:10"
            - if:
                - condition: state
                  entity_id: sensor.tempo_aujourd_hui
                  state: "ROUGE"
              then:
                - action: switch.turn_off
                  target:
                    entity_id: switch.chauffe_eau
        - conditions:
            - condition: trigger
              id: debut_hc
            - condition: state
              entity_id: sensor.tempo_couleur_en_cours
              state: "ROUGE"
          sequence:
            - action: switch.turn_on
              target:
                entity_id: switch.chauffe_eau
  mode: single
- id: tempo_alerte_demain_rouge
  alias: "Tempo : alerte jour rouge demain"
  triggers:
    - trigger: state
      entity_id: sensor.tempo_demain
      to: "ROUGE"
  conditions:
    - condition: template
      value_template: >
        {{ this.attributes.last_triggered is none
           or now() - this.attributes.last_triggered > timedelta(hours=12) }}
  actions:
    - action: notify.notify
      data:
        title: "Jour rouge demain"
        message: "Demain est un jour rouge Tempo (couleur officielle). Le chauffe-eau sera coupé de 6 h à 22 h."
  mode: single
- id: tempo_alerte_risque_rouge
  alias: "Tempo : risque de jour rouge dans les prochains jours"
  triggers:
    - trigger: numeric_state
      entity_id: sensor.tempo_risque_de_rouge_j_2_a_j_5
      above: 49
  conditions:
    - condition: template
      value_template: "{{ trigger.from_state.state not in ['unavailable', 'unknown'] }}"
  actions:
    - action: notify.notify
      data:
        title: "Risque de jour rouge"
        message: >
          Risque de jour rouge estimé à {{ states('sensor.tempo_risque_de_rouge_j_2_a_j_5') }} %
          entre J+2 et J+5. Prévision indicative : seule la couleur publiée la veille fait foi.
  mode: single

Points à connaître :

  • Chauffe-eau : à 6 h, l'automatisation force une mise à jour de « Tempo aujourd'hui », attend 10 secondes, puis coupe le ballon si le jour est rouge. À 22 h, elle ne le rallume que les jours rouges, pour ne pas annuler un arrêt manuel (absence, vacances) un autre jour. Elle s'appuie alors sur « Tempo couleur en cours », qui garde la couleur du jour même si l'API ne répond plus : une panne de l'API n'empêche donc pas de rallumer le ballon le soir d'un jour rouge. Si Home Assistant est arrêté à 22 h pile (mise à jour, redémarrage) ou si la prise ne répond pas, le ballon reste coupé : rallumez-le à la main.
  • Le ballon chauffe ainsi la nuit, en heures creuses. Même un jour rouge, le kWh en heures creuses reste un peu moins cher que le kWh en heures pleines d'un jour bleu : 0,1615 € contre 0,1654 € TTC (grille EDF au 1er août 2026).
  • Si votre ballon est déjà asservi aux heures creuses par un contacteur jour/nuit, la coupure de 6 h fait doublon : gardez seulement les notifications.
  • Alerte de la veille : elle se déclenche quand la couleur officielle de demain passe à rouge, en fin de matinée, une seule fois même si l'API a un raté dans la journée.
  • Risque de rouge : la notification part quand l'indicateur atteint 50 %, puis une seule fois tant qu'il reste au-dessus. Baissez le seuil pour être prévenu plus tôt, avec plus de fausses alertes.

Étape 4 : une carte pour le tableau de bord

Sur une installation récente, la « Vue d'ensemble » est générée automatiquement. Créez d'abord un tableau de bord : Paramètres > Tableaux de bord > Ajouter un tableau de bord > Nouveau tableau de bord vide. Ouvrez-le, cliquez sur Modifier le tableau de bord (crayon), puis Ajouter une carte, choisissez la carte Manuel et collez ce YAML.

type: entities
title: Tempo
entities:
  - entity: sensor.tempo_couleur_en_cours
    name: En ce moment
  - entity: sensor.tempo_demain
    name: Demain
  - entity: sensor.tempo_prevision_j_2
    name: Prévision J+2
  - entity: sensor.tempo_risque_de_rouge_j_2_a_j_5
    name: Risque de rouge (J+2 à J+5)
  - entity: sensor.tempo_rouges_restants
    name: Rouges restants
  - entity: sensor.tempo_blancs_restants
    name: Blancs restants

Étape 4 bis : une carte en couleurs, sans HACS

La carte native Markdown sait afficher des modèles : elle peut montrer un rond de couleur pour chaque jour. Ajoutez une seconde carte Manuel avec ce YAML :

type: markdown
title: Couleurs Tempo
content: |-
  {%- set rond = {'BLEU': '🔵', 'BLANC': '⚪', 'ROUGE': '🔴'} -%}
  {%- macro couleur(entite, attente) -%}
  {%- set c = states(entite) -%}
  {%- if c in rond -%}
  {{ rond[c] }} {{ c | capitalize }}
  {%- elif attente -%}
  ⏳ en attente
  {%- else -%}
  ❔ inconnu
  {%- endif -%}
  {%- endmacro -%}
  {%- macro nombre(entite, apres) -%}
  {%- set n = states(entite) -%}
  {%- if is_number(n) -%}
  **{{ n | int }}{{ apres }}**
  {%- else -%}
  ❔ inconnu
  {%- endif -%}
  {%- endmacro -%}
  | En ce moment | Demain | Prévision J+2 |
  |:-:|:-:|:-:|
  | {{ couleur('sensor.tempo_couleur_en_cours', false) }} | {{ couleur('sensor.tempo_demain', true) }} | {{ couleur('sensor.tempo_prevision_j_2', false) }} |

  Risque de rouge de J+2 à J+5 : {{ nombre('sensor.tempo_risque_de_rouge_j_2_a_j_5', ' %') }}
  {%- set r = states('sensor.tempo_rouges_restants') -%}
  {%- set b = states('sensor.tempo_blancs_restants') %}

  {% if is_number(r) and is_number(b) -%}
  Jours restants : 🔴 **{{ r | int }}** rouges, ⚪ **{{ b | int }}** blancs
  {%- else -%}
  Jours restants : ❔ inconnu
  {%- endif %}

Attention au copier-coller : les lignes vides à l'intérieur de content sont nécessaires, elles séparent le tableau et les paragraphes.

Tableau de bord Home Assistant avec les couleurs Tempo du 19 octobre 2026
Les deux cartes du tutoriel le 19 octobre 2026 : couleur en cours, couleur de demain, prévision à J+2, risque de rouge et jours restants.

Tant qu'EDF n'a pas publié la couleur de demain, la carte affiche « en attente ». Si l'API ne répond pas, les autres lignes affichent « inconnu » au lieu d'une valeur fausse.

Tableau de bord Home Assistant un jour blanc, veille d'un jour rouge
Le même tableau de bord le 27 janvier 2026 à 14 h, jour blanc et veille d'un jour rouge, reconstitué avec les couleurs officielles (les prévisions de ce jour-là n'ont pas été archivées).

Pour colorer l'icône selon la couleur du jour, une carte personnalisée à modèle (Mushroom Template, via HACS) fait l'affaire.

Ce que valent les prévisions

Une prévision n'est pas une couleur officielle. Elle repose surtout sur les températures attendues et sur le nombre de jours rouges et blancs restant à placer. Elle peut se tromper, et l'incertitude augmente avec l'échéance.

Le bon usage, souvent évoqué sur le forum : anticiper une lessive, la recharge d'une voiture ou une flambée, mais ne pas piloter d'équipement sur la seule prévision. C'est pourquoi l'automatisation du chauffe-eau n'utilise que la couleur officielle.

Pour juger sur pièces, les prévisions sont figées au moment où elles sont émises et leur historique est public, jour par jour, erreurs comprises. La méthode de calcul est décrite sur le site.

🙏
Peu de retours pour l'instant. Ces capteurs et l'API ont encore peu d'utilisateurs, et le modèle de prévision actuel, mis à jour fin septembre, n'a pas encore connu de jour rouge ; il sera mesuré en conditions réelles cet hiver. Si quelque chose coince ou si un champ vous manque, signalez-le dans le sujet de discussion de l'article, je corrigerai.

Limites et alternatives

  • Dépendance à un service en ligne. Si l'API ne répond pas, les capteurs passent en indisponible et l'automatisation de 6 h ne coupe rien : le ballon reste dans son état précédent. Le confort passe alors avant l'économie. Le service est gratuit et indépendant, sans garantie de disponibilité.
  • La référence reste la couleur officielle. Les prévisions ne font que l'anticiper : c'est la couleur publiée la veille, celle qu'applique votre compteur Linky, qui compte.
  • Les autres approches sont tout à fait valables :
    • un compte API sur le portail de données de RTE, utilisé par plusieurs intégrations disponibles dans HACS, si la création du compte ne vous pose pas de problème ;
    • la téléinformation (TIC) du Linky, avec un module Zigbee ou un montage ESPHome (composant teleinfo) : la couleur vient du compteur, sans Internet, et vous récupérez aussi vos consommations. La couleur du lendemain n'arrive alors qu'à 20 h.

Conclusion

Avec quatre requêtes REST, un capteur de modèle et trois automatisations, Home Assistant connaît la couleur Tempo du jour, du lendemain et de la journée Tempo en cours, coupe le chauffe-eau les jours rouges et prévient à l'avance des jours à risque, sans compte RTE ni module de téléinformation.

Vos variantes (chauffage, recharge de voiture, batterie) sont les bienvenues dans le sujet de discussion de l'article.