Aqara Gas Detector JT-BZ-01AQ: Zigbee2MQTT + Home Assistant

A gas detector is one of those devices where “it phones home” stops being a minor annoyance and becomes a real problem. If your kitchen’s natural gas sensor needs a working cloud connection to alert you, that is an unacceptable dependency for something in the safety category.

The Aqara Smart Natural Gas Detector (JT-BZ-01AQ/A) avoids that problem when you pair it via Zigbee2MQTT. Once it’s in your Z2M network, everything — alarms, sensitivity configuration, self-test — runs locally. No Aqara hub, no Aqara cloud, no account.

This guide covers the full Z2M + Home Assistant setup: pairing, what each of the 10 exposed entities actually does, sensitivity threshold configuration, automation patterns, and a few things that confuse people on first boot.

Safety note. A natural gas detector is life-safety equipment. Treat a Home Assistant–integrated detector as a convenience and monitoring layer on top of — not a replacement for — a properly installed, certified standalone gas alarm. The device’s own onboard buzzer and local Zigbee linkage must remain your primary alert; HA notifications and automations can fail silently (server down, network issue, automation typo) in exactly the situation where you need them most. Follow your local regulations and the manufacturer’s installation instructions for placement and maintenance.

This site uses affiliate links where available. None apply to this article — the JT-BZ-01AQ isn’t currently carried by affiliate programs I use.

JT-BZ-01AQ vs the Older JTQJ-BF-01LM: What Changed

If you’ve read older community posts about Aqara gas sensors, you’ll encounter both model numbers. They are different devices with different firmware lineages, and Z2M treats them separately.

The JTQJ-BF-01LM is the older Xiaomi-branded model. It runs on battery (4 x AA), which made it portable but limited for continuous monitoring.

The JT-BZ-01AQ is the current Aqara-branded model. It’s mains-powered (220VAC), which means it runs continuously and, more usefully for your Zigbee mesh, it functions as a Zigbee router rather than an end device. A sensor wired into the wall that also strengthens your mesh is a net win, especially in kitchens that might be far from your coordinator.

If you’re buying new, the JT-BZ-01AQ is the one to get. If you already have the JTQJ-BF-01LM, the Z2M device page for that model is separate — don’t mix up the setup guides.

There’s also a JT-BZ-03AQ/A, which is a confirmed white-label variant with identical Z2M support.

Prerequisites

Before pairing, a few things to confirm:

Zigbee2MQTT version: Any recent stable release works. The JT-BZ-01AQ has been supported for a while.

Coordinator firmware: Outdated coordinator firmware is the most common pairing failure cause I’ve seen with newer Aqara devices. Minimums for the JT-BZ-01AQ:

Check your coordinator firmware version in the Z2M settings panel before you blame the device for not pairing.

Placement: Mount the detector near the ceiling per gas sensor placement standards — natural gas (methane) is lighter than air and rises. Don’t pair it while it’s on the floor and then move it; the Zigbee mesh will work fine either way, but you want it in its final, code-compliant location before the warm-up period completes.

For the broader picture of running Aqara Zigbee devices without the Aqara hub, see our hub-free Aqara setup guide.

Pairing

Put Z2M into pairing mode, then on the detector:

Triple-press the button on the side of the unit — three quick taps in a row. A single press or long-press won’t start pairing; it must be three quick taps. (If pairing stalls, keep the device awake by pressing the button about once per second until it completes.)

The device will appear in Z2M, and this is where a lot of people get confused.

The “Preparation” State — Not a Failure

After pairing, the device immediately shows a gas_sensitivity reading and reports its state as preparation rather than work.

This is the warm-up period. The semiconductor sensor needs time to stabilize — typically a few minutes, though it can run longer depending on ambient conditions. During preparation, the device does not measure gas concentration or trigger alarms; that only happens in work state.

Once the sensor stabilizes, the device transitions to work state on its own. You don’t need to do anything. If you see preparation and assume something is broken, you’ll end up re-pairing it repeatedly for no reason.

Wait for work before you test the sensor or set up automations that depend on the gas entity.

Entities in Home Assistant

The JT-BZ-01AQ exposes 10 entities via Z2M. Here’s what each one is for:

binary_sensor.gas — The main alarm: on when gas concentration exceeds the configured threshold, off otherwise. This is what you automate against.

sensor.gas_density — Numeric reading in %LEL (percent of Lower Explosive Limit). The Lower Explosive Limit is the minimum concentration at which a gas becomes combustible. Methane’s LEL is roughly 5% by volume in air; the detector scales its range against that. A reading of 5 means you’re at 5% of the LEL, which is well below the alarm threshold of 10% or 15%.

select.gas_sensitivity — Alarm threshold configuration: 10%LEL (default) or 15%LEL. More on this below.

button.selftest — Triggers the built-in self-test: buzzer activates, LED flashes, the test entity goes on. Useful for verifying the device is working without needing actual gas.

binary_sensor.test — on while a self-test is in progress, off otherwise. Lets you automate “don’t alert on gas during scheduled test.”

switch.buzzer — Controls the onboard buzzer. You can mute it from HA when an alarm is active. It also allows triggering the buzzer manually.

binary_sensor.buzzer_manual_alarm — on when the buzzer is in a manually triggered alarm state.

binary_sensor.buzzer_manual_mute — on when the buzzer has been manually muted.

switch.linkage_alarm — Enables or disables Zigbee linkage behavior (details in the linkage section below).

sensor.power_outage_count — Counts how many times the device has lost mains power. A rising number here is worth investigating — mains-powered safety devices shouldn’t be losing power regularly.

Configuring the Sensitivity Threshold

The gas_sensitivity select entity gives you two options:

• 10%LEL (default) — More sensitive. Alarms at a lower gas concentration. Appropriate for most residential installations.
• 15%LEL — Higher threshold. The device needs to detect more gas before alarming. Reduces nuisance alarms in environments with occasional very low-level gas presence (e.g., near a gas range during cooking), at the cost of a higher alarm trigger point.

If you’re getting nuisance alarms during cooking, switching to 15%LEL is the reasonable adjustment before giving up on the device entirely. For most kitchens, 10%LEL is the right default, and the more sensitive setting is the safer one.

The setting persists across Z2M restarts. Setting it once is sufficient.

Running the Self-Test

From Home Assistant, press the selftest button entity. The detector will:

1. Sound the buzzer briefly
2. Flash its LED
3. Report binary_sensor.test as on for the duration

This verifies the buzzer and LED are functional and that the Z2M communication path is working. It does not inject test gas — it’s purely an electronics self-check, so passing a self-test does not confirm the gas-sensing element itself is responding to gas.

Run this test after initial setup and periodically (monthly is reasonable for safety devices). You can automate it:

automation:
  - alias: "Monthly gas detector self-test"
    trigger:
      - platform: time
        at: "10:00:00"
    condition:
      - condition: template
        value_template: "{{ now().day == 1 }}"
    action:
      - service: button.press
        target:
          entity_id: button.gas_detector_selftest

If you schedule automated tests, create a separate automation that suppresses gas alarm notifications while binary_sensor.test is on — the self-test shouldn’t trigger your notifications.

Automations

Treat everything in this section as a supplementary layer. The detector’s onboard buzzer and Zigbee linkage are your primary alert; HA automations add convenience and remote notification on top.

Gas Alarm Notification

The minimum useful automation: alert immediately when binary_sensor.gas turns on.

automation:
  - alias: "Gas alarm notification"
    trigger:
      - platform: state
        entity_id: binary_sensor.gas_detector_gas
        to: "on"
    action:
      - service: notify.mobile_app_your_phone
        data:
          title: "Gas alarm"
          message: >
            Gas detected. Density: {{ states('sensor.gas_detector_gas_density') }}%LEL.
            Check immediately.

Include the gas_density reading in the notification — it gives you a sense of concentration before you’ve even looked at the detector.

Automated Gas Shutoff via Smart Plug

If a portable gas appliance draws power from a socket (some portable gas stoves do — this applies far less to fixed installations), you can cut power to that socket when gas is detected. Pair it with the Aqara SP-EUC01 smart plug:

automation:
  - alias: "Cut gas appliance power on alarm"
    trigger:
      - platform: state
        entity_id: binary_sensor.gas_detector_gas
        to: "on"
    action:
      - service: switch.turn_off
        target:
          entity_id: switch.gas_cooker_plug
      - service: notify.mobile_app_your_phone
        data:
          message: "Gas alarm: plug cut, check immediately."

Treat this as a nice-to-have, not a safety mechanism: cutting the socket only stops electric ignition or a powered valve on that one appliance — it does not stop a gas leak from the supply itself, and it depends on HA being up. For a fixed gas supply, shutting off gas safely is a job for a properly rated motorized gas valve installed to code, which is a hardware decision outside Z2M scope. In any real gas-leak situation, ventilate, leave, and shut off the gas at the source.

Buzzer Mute from HA

When the alarm triggers, the onboard buzzer fires. You can silence it from HA without being physically at the device:

automation:
  - alias: "Mute gas detector buzzer on confirmation"
    trigger:
      - platform: state
        entity_id: input_boolean.gas_alarm_acknowledged
        to: "on"
    action:
      - service: switch.turn_off
        target:
          entity_id: switch.gas_detector_buzzer

This pattern works better than auto-muting on alarm — you want the buzzer to keep sounding until someone explicitly confirms they’ve seen the alert.

Linkage Alarm

The linkage_alarm switch enables Zigbee binding behavior: when this device detects gas, it can trigger other Aqara safety devices on the same Zigbee network (hubs with sirens, other gas or smoke detectors) without routing through HA.

This works at the Zigbee protocol level, so it functions even if your HA instance is down. That makes it a genuinely useful resilience layer for a safety device — and the reason to leave it enabled.

If you don’t have other Aqara safety devices on your network, leaving linkage alarm enabled does nothing — it has no targets to reach. If you do have an Aqara hub with a siren, or another gas detector elsewhere in the property, enabling linkage lets them respond to this detector’s alarm independently of your automations.

This is entirely local — no Aqara cloud is involved when operating via Z2M.

OTA Firmware Updates

OTA updates are supported through Z2M. Check the Zigbee2MQTT OTA update panel after pairing and install any available update before finalizing your setup. For a safety device, running current firmware matters more than for a light switch.

The update process is standard: Z2M downloads the firmware and flashes it over the air. The device will show as unavailable briefly during the update.

ZHA Support

ZHA support for the JT-BZ-01AQ/A is listed as unconfirmed on the Zigbee compatibility database. Z2M is the only fully validated local integration path for this device. If you’re committed to ZHA and want to use this detector, you’d need to test it yourself and report back to the Zigbee compatibility project.

For the wider question of whether Aqara gear keeps working offline, see our explainer on whether Aqara works without internet.

Cloud Posture

Once paired to Z2M, the JT-BZ-01AQ has no ongoing cloud dependency. The detector doesn’t require an Aqara account, doesn’t need to reach Aqara’s servers, and doesn’t lose functionality if you block its outbound traffic at the firewall.

The only cloud-adjacent step in the entire process is if you need to check for firmware availabliity outside of Z2M’s OTA mechanism — and that’s optional. For routine use, everything runs locally.

What to Expect

The setup is clean. Triple-press to pair, wait out the preparation state, configure the sensitivity threshold to your preference, and set up the gas alarm notification automation. That’s the critical path.

The 10-entity surface gives you more control than you might expect from a single sensor — the ability to mute the buzzer remotely, run scheduled self-tests, and configure alarm thresholds from HA is genuinely useful for a device you hope never triggers.

One thing worth flagging: check the power_outage_count entity periodically. If it climbs unexpectedly, something is cutting mains power to the device — worth investigating before you assume the detector is online when it may not be.

The JT-BZ-01AQ works reliably on Z2M with no meaningful integration caveats. For a safety-category sensor, that’s the bar you want it to clear — just remember that the local Z2M integration is the convenience layer, and the detector’s own buzzer and a code-compliant installation are what keep you safe. If you’re building out a broader local Aqara setup, our hub-free Aqara device guide is the place to start.