Send your Amazfit’s heart rate, steps, sleep and battery to Home Assistant (and 10 automations)

AmazHA, a Home Assistant app for Amazfit watches, mostly works in one direction: your lights, covers and thermostats on your wrist. Its Watch sensors feature works the other way round. The watch reads its own data, from steps to sleep state to battery, and sends it to Home Assistant as sensor entities you can graph, show on a dashboard and use in automations.

Below: what is sent, how it gets there, how to turn it on, why sensors go missing, and ten automations to paste in.

The short answer

With AmazHA, an Amazfit watch can send up to 18 readings to Home Assistant: steps, distance, calories, heart rate, resting heart rate, blood oxygen, stress, sleep score, sleep duration, a live asleep/awake state, wear state, air pressure, battery and more. They arrive through Home Assistant’s Mobile App integration as sensor.<prefix>_<key>, at every app open and then every 1 to 6 minutes in the background.

What reaches Home Assistant

Eighteen sensors, in four groups, each one switched on separately. This is the full list, with the key that ends the entity id and the state you will see in Home Assistant:

In the AmazHA settings they are grouped as Activity, Health, Environment and Device, under the labels Steps, Distance, Calories, Standing hours, Intensive minutes, PAI, Heart rate, Resting heart rate, Blood oxygen (SpO2), Stress, Body temperature, Sleep score, Sleep duration, Sleep state, Air pressure, Altitude, Watch battery and Wear state.

Units, classes and long-term statistics

The sensors come with Home Assistant metadata, so they behave like any other sensor. The battery has the battery device class, so it gets the battery icon and fits a gauge. Distance and altitude are distance, air pressure is atmospheric_pressure, body temperature is temperature, intensive minutes and sleep duration are duration. Every sensor has its own icon.

The daily counters (steps, distance, calories, standing hours, intensive minutes) use the total_increasing state class: they go back to zero when the watch starts a new day, and Home Assistant reads that as a reset, not a drop. The gauges (heart rate, battery, pressure and the rest) use measurement. Either way Home Assistant keeps long-term statistics for them, so a statistics graph of your steps works without any extra setup.

sleep_state and wear are text states, with no unit and no class. Use them in state triggers and conditions.

Readings that are left out

The watch sends a sensor only when it has a valid reading. It does not send a zero or a placeholder instead:

• Heart rate, resting heart rate, stress, sleep score and sleep duration are left out while the watch reports 0, which means it has not measured yet. When the watch has no new sleep data, the sleep sensors keep their last value.
• Blood oxygen is a measurement, not a continuous signal. AmazHA sends the newest one it can find: one just taken, the last two hours of samples, or the last good value up to 24 hours old. So spo2 is “the latest measurement”, not “right now”.
• Body temperature is sent only on watches that have that sensor, and only once it has data.
• Air pressure and altitude are sent only on watches with a barometer.
• Sleep state is sent only when the watch says asleep or awake.

When a reading is left out, Home Assistant keeps the last value it had. That matters for automations: a sensor that has not changed may simply not have been updated.

The entity ids

Every entity is sensor.<prefix>_<key>. The prefix is what you type in Entity prefix (optional); left empty, it is your watch’s name made safe for an entity id, so an “Amazfit GTS 4” gives sensor.amazfit_gts_4_steps, sensor.amazfit_gts_4_battery and so on. The Watch sensors screen prints the exact id, with its unit, under every sensor, so you never have to guess.

The prefix is fixed the first time the watch sends its data. Renaming the watch later does not move your entities. Changing the prefix yourself does: it registers a second device with new entity ids, and the old device stays in Home Assistant until you delete it. Choose the prefix before you build automations on it.

How it works: the watch becomes a Mobile App device

The watch registers with Home Assistant’s Mobile App integration, the same one Home Assistant’s own Companion app uses. Your watch becomes a device, its readings become sensors of that device, and nothing has to be installed in HACS or written in configuration.yaml.

What happens, step by step:

1. The watch reads the sensors you switched on and sends them to your phone over Bluetooth.
2. AmazHA’s phone side, running inside the Zepp app, registers the watch once with Home Assistant’s Mobile App integration. The device is listed with Amazfit as its manufacturer.
3. Each sensor is registered once, with its unit, class and icon. After that, every update is a single batched call for all the sensors.

Because these are real entities in Home Assistant’s registry, with a unique id, you can rename them, change their icon, hide them or put them in an area from the Home Assistant interface. They stay through Home Assistant restarts. If you delete the device in Home Assistant, AmazHA registers it again at the next push.

The Mobile App integration is part of Home Assistant’s default configuration, so almost every installation already has it. If yours does not load it, AmazHA falls back to writing the states directly, which works but gives entities that Home Assistant cannot manage from its interface and that disappear when it restarts. If that is your case, add mobile_app: to your configuration.

The watch never talks to Home Assistant itself. The phone does, using the same addresses as the rest of AmazHA: the local address at home, the remote address when you are out. If you only set a local address, updates sent while you are away cannot reach Home Assistant. Remote access for your watch explains the options.

Turn it on, step by step

You need the full version and a working connection to Home Assistant first. Then it takes a minute, as shown in tutorial 9, Watch sensors:

1. Open Watch sensors. In the AmazHA settings (in the Zepp app: Profile › your watch › Apps › AmazHA › Settings), tap Watch sensors. Step 1.
2. Switch it on. Switch on Send to Home Assistant. Step 2.
3. Name it, if you like. Entity prefix (optional) names every entity sensor.<prefix>_…. Left empty, it uses your watch’s name. Step 3.
4. Set how often. Update every sets the background interval, from 1 to 6 minutes. Step 4.
5. Pick the sensors. Switch on the ones you want. All of them start off. Step 5.
6. Open AmazHA on the watch. The watch sends its first readings and asks for Background activity. Allow it. Step 6.
7. Find it in Home Assistant. Go to Settings › Devices & services › Mobile App and open your watch. Step 7.

If the Watch sensors screen shows an unlock card instead, the full version is not active yet: see unlock the full version. If it says Connect to Home Assistant first, set up the connection as in Connect Home Assistant.

Once data has arrived, the Watch sensors screen shows a line such as Sent 6 sensors · 14:05, with · background at the end when it came from a background update. That line is the quickest check that everything works.

Background updates: every 1 to 6 minutes

The watch sends its sensors at every app open, and then in the background at the interval you chose, as long as the Background activity permission is granted. Without the permission, the sensors only update when you open AmazHA.

Both need the phone nearby, with Bluetooth on and the Zepp app running, because the phone is what sends the data to Home Assistant.

Granting the permission

On a watch with AmazHA installed from the Zepp App Store, the watch asks for Background activity the next time you open AmazHA after switching the feature on. It asks once. If you declined, or the request never appeared, you have two ways back:

• Allow it in the watch’s own settings: App permissions (or Privacy, depending on the watch), then AmazHA, then allow background activity.
• Or switch Send to Home Assistant off and on in the AmazHA settings, then open AmazHA on the watch: it asks again.

What else to know

• Changes reach the background at the next app open. If you switch a sensor on or off, or change Update every, open AmazHA on the watch once. The background updates keep the old selection until then.
• Battery saver stops background updates. While the watch is in its battery saver mode it runs no background tasks, so the sensors pause; opening AmazHA afterwards brings them back at once.
• A watch restart is not the end. After a short restart the background updates come back on their own, usually within the hour. Opening AmazHA brings them back straight away.

Why your watch sensors don’t show up

When sensors are missing, the cause is almost always one of the items below. Work through them in this order:

1. Send to Home Assistant is off. The Settings menu shows Watch sensors as On or Off. It must be On.
2. The individual sensors are off. Every sensor starts off. The Watch sensors screen shows how many you send, for example “6 of 18 sensors sent to HA”.
3. You haven’t opened AmazHA on the watch since. The first data is sent from the watch when you open the app. Open it once after changing anything.
4. The full version isn’t active. Without the licence the screen shows an unlock card and nothing is sent.
5. Home Assistant isn’t connected. The screen says Connect to Home Assistant first. Fix the connection: tutorial 4, and for errors, When something’s wrong.
6. The sensor has no valid reading yet. Blood oxygen, stress and body temperature appear only after a measurement; pressure and altitude only on watches with a barometer. If the status line reads No sensors enabled, none of the sensors you switched on had a reading to send.
7. It only updates when you open the app. That is the Background activity permission: see above.
8. You are looking in the wrong place. The sensors belong to a device under Settings › Devices & services › Mobile App, named after your prefix. You can also search for the prefix in the Entities tab of Settings › Devices & services.
9. The phone can’t reach Home Assistant. Away from home, the phone needs a remote address. Open your Home Assistant address in the phone’s browser: if it fails there, it fails for the sensors as well. Step 3 of the troubleshooting tutorial covers it.
10. The values look frozen. Check the time on the status line. If it is old, the phone or the watch has not sent anything since: phone out of range, Zepp app closed, battery saver on, or the permission missing.

Ten automations

The ten automations below cover the requests that come up again and again: a low battery, going to sleep, waking up, the watch left on the charger, activity goals. They use the current Home Assistant syntax and can be pasted as they are.

To add one: Settings › Automations & scenes › Create automation › Create new automation, then the three-dot menu, Edit in YAML, and paste.

Every entity id here is an example. The watch sensors use the prefix amazfit_gts_4; replace it with yours. notify.mobile_app_your_phone is the notification action of a phone running Home Assistant’s Companion app; find yours under Developer tools › Actions by typing “notify”. Lights, covers, scenes and the person entity are placeholders for your own. The thresholds are starting points: look at a week of history before you settle on yours.

1. Watch battery low

A notification when the watch drops below 15 %.

alias: Watch battery low
description: Notify when the watch battery drops below 15 %
triggers:
  - trigger: numeric_state
    entity_id: sensor.amazfit_gts_4_battery
    below: 15
actions:
  - action: notify.mobile_app_your_phone
    data:
      title: Watch battery low
      message: "Your watch is at {{ states('sensor.amazfit_gts_4_battery') }} %."
mode: single

A numeric_state trigger fires when the value crosses the line, not at every update below it, so this notifies you once per discharge.

2. Charge it before bed

If you want sleep tracking, the watch has to last the night. A reminder in the evening when it won’t:

alias: Charge the watch before bed
triggers:
  - trigger: time
    at: "21:30:00"
conditions:
  - condition: numeric_state
    entity_id: sensor.amazfit_gts_4_battery
    below: 30
actions:
  - action: notify.mobile_app_your_phone
    data:
      message: "Watch at {{ states('sensor.amazfit_gts_4_battery') }} %: charge it now to track tonight's sleep."
mode: single

3. Asleep: lights off, heating down

When the watch says you are asleep, and has said so for ten minutes, turn off the living room lights and lower the bedroom thermostat.

alias: Asleep - lights off
triggers:
  - trigger: state
    entity_id: sensor.amazfit_gts_4_sleep_state
    to: "asleep"
    for:
      minutes: 10
conditions:
  - condition: time
    after: "21:00:00"
    before: "04:00:00"
actions:
  - action: light.turn_off
    target:
      area_id: living_room
  - action: climate.set_temperature
    target:
      entity_id: climate.bedroom
    data:
      temperature: 18
mode: single

The time window keeps an afternoon nap from switching the house off; a window that crosses midnight is fine in a time condition. The ten minutes of for: filter out a short doze on the sofa. Bear in mind that the state reaches Home Assistant only at the next update, so the real delay is your interval plus the for:.

4. Awake: the morning routine

When you wake up on a weekday morning, open the bedroom blinds, turn on the kitchen light and start the coffee machine, once a day.

alias: Awake - morning routine
triggers:
  - trigger: state
    entity_id: sensor.amazfit_gts_4_sleep_state
    from: "asleep"
    to: "awake"
    for:
      minutes: 5
conditions:
  - condition: time
    after: "05:30:00"
    before: "10:30:00"
    weekday:
      - mon
      - tue
      - wed
      - thu
      - fri
  - condition: template
    value_template: >-
      {{ this.attributes.last_triggered is none
         or this.attributes.last_triggered < today_at() }}
actions:
  - action: cover.open_cover
    target:
      entity_id: cover.bedroom_blinds
  - action: light.turn_on
    target:
      entity_id: light.kitchen
    data:
      brightness_pct: 60
  - action: switch.turn_on
    target:
      entity_id: switch.coffee_machine
mode: single

from: "asleep" matters: only a real change from asleep to awake counts, not the sensor coming back from unknown or unavailable, which could otherwise start your morning at 3 a.m. The template condition lets it run only once a day, so waking at 6, dozing off and waking again at 7 opens the blinds once.

5. Charged and left on the charger

The watch is full but still off your wrist: a nudge to put it back on.

alias: Watch charged, put it back on
triggers:
  - trigger: state
    entity_id: sensor.amazfit_gts_4_wear
    to: "not_worn"
    for:
      minutes: 45
conditions:
  - condition: numeric_state
    entity_id: sensor.amazfit_gts_4_battery
    above: 90
  - condition: time
    after: "07:00:00"
    before: "22:00:00"
actions:
  - action: notify.mobile_app_your_phone
    data:
      message: Your watch is charged and has been off your wrist for 45 minutes.
mode: single

Off the wrist with a high battery usually means it is on the charger or on the desk. Note that unknown is also a valid wear value: the watch was not sure. In Home Assistant it looks just like the “unknown” of a sensor with no data, so never trigger on it.

6. Resting heart rate above your usual

A gentle heads-up when your resting heart rate stays above your normal range. This is a nudge to check how you feel, not a medical alert.

alias: Resting heart rate above usual
triggers:
  - trigger: numeric_state
    entity_id: sensor.amazfit_gts_4_resting_heart_rate
    above: 80
    for:
      hours: 1
actions:
  - action: notify.mobile_app_your_phone
    data:
      message: "Resting heart rate {{ states('sensor.amazfit_gts_4_resting_heart_rate') }} bpm, above your usual."
mode: single

Set the threshold from your own history: open the sensor in Home Assistant and look at a few weeks. A value 10 to 15 bpm above your usual resting rate is a reasonable starting point.

7. Step goal reached

A notification the moment you pass 10,000 steps.

alias: Step goal reached
triggers:
  - trigger: numeric_state
    entity_id: sensor.amazfit_gts_4_steps
    above: 9999
actions:
  - action: notify.mobile_app_your_phone
    data:
      message: "10,000 steps today. Nice work."
mode: single

above is strictly greater than, hence 9999. The steps go back to zero when the watch starts a new day, so the trigger is ready again the next day.

8. Evening walk nudge

At 18:30, if you are wearing the watch and are still under 5,000 steps, a suggestion to go for a walk.

alias: Evening walk nudge
triggers:
  - trigger: time
    at: "18:30:00"
conditions:
  - condition: numeric_state
    entity_id: sensor.amazfit_gts_4_steps
    below: 5000
  - condition: state
    entity_id: sensor.amazfit_gts_4_wear
    state:
      - worn
      - in_motion
actions:
  - action: notify.mobile_app_your_phone
    data:
      message: "{{ states('sensor.amazfit_gts_4_steps') }} steps so far today. Time for a walk?"
mode: single

The wear condition avoids nagging you on a day the watch stayed on the charger: the low count would be the watch’s, not yours.

9. Morning sleep report

A short summary of the night at 9:00, in hours and minutes.

alias: Morning sleep report
triggers:
  - trigger: time
    at: "09:00:00"
conditions:
  - condition: template
    value_template: "{{ states('sensor.amazfit_gts_4_sleep_duration') | is_number }}"
actions:
  - variables:
      mins: "{{ states('sensor.amazfit_gts_4_sleep_duration') | int(0) }}"
  - action: notify.mobile_app_your_phone
    data:
      title: Last night
      message: >-
        {{ mins // 60 }} h {{ mins % 60 }} min,
        sleep score {{ states('sensor.amazfit_gts_4_sleep_score') }}.
mode: single

Sleep score and duration follow the watch’s own sleep summary, which the watch updates on its own schedule. A report at a fixed time well after you get up is more reliable than one triggered the moment you wake.

10. Stressful evening: calmer lights

When the stress value stays high for a quarter of an hour in the evening while you are at home, switch the living room to a calm scene.

alias: Stress high - calm lights
triggers:
  - trigger: numeric_state
    entity_id: sensor.amazfit_gts_4_stress
    above: 75
    for:
      minutes: 15
conditions:
  - condition: state
    entity_id: person.you
    state: "home"
  - condition: time
    after: "17:00:00"
    before: "23:00:00"
actions:
  - action: scene.turn_on
    target:
      entity_id: scene.living_room_calm
mode: single

Presence comes from person.you, not from the watch. The 15 minutes of for: mean the value has to stay high over several updates, which filters out a single spike after climbing the stairs.

A note on timing

Every automation above reacts to a state Home Assistant received from the phone. With a 5-minute interval, a change on the watch can take up to 5 minutes to arrive, and a for: adds its own time on top. Pick automations where a few minutes don’t matter: lights after you fall asleep, yes; an alarm when you leave the house, no.

Dashboard ideas

The watch sensors are normal Home Assistant sensors, so every standard card works with them. A few layouts that read well:

• A watch card at the top of your phone dashboard: a Tile card for battery, wear and sleep_state side by side.
• Battery as a gauge: a Gauge card on battery with severity colours, for example red under 20 and amber under 40.
• Heart rate over the day: a History graph card with heart_rate and resting_heart_rate over 24 hours.
• Steps per day: a Statistics graph card on steps with the daily period and the “change” statistic. It works because the daily counters use the total_increasing state class.
• The night in one row: an Entities card with sleep_score, sleep_duration and spo2.
• Weather station on the wrist: on watches with a barometer, a History graph card of pressure over two or three days shows the trend a weather change brings.

Sleep duration arrives in minutes. If you prefer hours on the dashboard, add a template sensor: Settings › Devices & services › Helpers › Create helper › Template › Template a sensor, with this state template and h as its unit:

{{ (states('sensor.amazfit_gts_4_sleep_duration') | float(0) / 60) | round(1) }}

What it is not

The watch sensors are useful for automations that can wait a few minutes. They are not a replacement for dedicated sensors, and three limits are worth knowing before you rely on them.

Not instant. Updates arrive at every app open and then at your interval, from 1 to 6 minutes. A state change on the watch can take that long to reach Home Assistant, and longer when the phone is out of range, the Zepp app is closed or battery saver is on. Background updates also depend on the Background activity permission.

Not a presence sensor. None of the 18 sensors says where you are. wear says whether the watch is on a wrist, not whose wrist or which house. Updates need the phone nearby, but that says nothing about whether you are home. Use your phone, a person entity or a room sensor for presence.

Not medical data. Heart rate, blood oxygen, stress and body temperature come from the watch’s own sensors. They are good for trends and gentle nudges, not for diagnosis or alarms you would stake your health on. Blood oxygen in particular is the latest measurement the watch took, which can be hours old.

Your data stays yours. The readings go from the watch to your phone over Bluetooth, and from the phone to your own Home Assistant. AmazHA has no accounts, no analytics and no server of its own, and health data is never sent to the developer or any third party. In Home Assistant they are stored like any other sensor, under your retention settings. Every sensor is off until you switch it on, so you send exactly what you choose. The privacy policy has the details.