---
title: "Shelly RGBW2 White"
description: "Shelly RGBW2 in White mode as four independent 12/24 V LED dimmer channels with per-channel power metering, controlled from TapHome over local HTTP."
url: "https://taphome.com/en/compatibility/shelly-rgbw2-white/"
language: en
lastmod: 2026-04-24
generator: hugo
ai:
  topics: ["http","lighting","wifi","dimmer","led-controller","shelly","gen1"]
  questions: ["How to integrate Shelly RGBW2 in White mode with TapHome?","How do I switch Shelly RGBW2 from Color mode to White mode?","Can I control four separate white LED strips with one Shelly RGBW2?","Why does Shelly RGBW2 White show a \"Mode is not supported\" error?","What is the maximum power per channel on Shelly RGBW2?","Is the Shelly RGBW2 still available or has it been discontinued?"]
---

# Shelly RGBW2 White

Communication: Packet Parser → HTTP

- [Shelly RGBW2 Product Page](https://www.shelly.com/en/products/shop/shelly-rgbw2)
- [Shelly RGBW2 API Documentation (White mode)](https://shelly-api-docs.shelly.cloud/gen1/#shelly-rgbw2-white-mode)
- [Shelly RGBW2 Knowledge Base](https://kb.shelly.cloud/knowledge-base/shelly-rgbw2)

> Network address
> 
> TapHome reaches this device at the address entered on import. Give the device a fixed address — an IP reservation in the router, or its mDNS name if it supports one — otherwise the integration stops working when the router changes the address.
> 
> [Network Preparation](https://taphome.com/en/docs/setup/network-preparation/)

## Integration guide

The Shelly RGBW2 is a Wi-Fi LED strip controller with four PWM outputs (12/24 V DC). In **White mode**, the four outputs — normally used for R, G, B, and W of an RGBW strip — become four independent single-color dimmer channels. Each channel can drive its own white LED strip, LED bulb, or spotlight group. TapHome communicates with the device over HTTP on the local network; no cloud connection is required.

This template is the White-mode counterpart to the [Shelly RGBW2](https://taphome.com/en/compatibility/shelly-rgbw2/) Color-mode template. Both templates share the same hardware but the firmware operates in mutually exclusive modes selected via the device settings. Before importing this template, the device must be configured in White mode — the template validates the mode on every poll and shows an error if the device is set to Color.

> [!NOTE]
> Shelly has marked the RGBW2 as **discontinued** — it is no longer produced or sold by Shelly Group. Existing units continue to function and receive firmware updates.

## Wiring

The Shelly RGBW2 is powered from a 12 V or 24 V DC supply (V+ / GND). Each of the four outputs (labeled R, G, B, W on the device) drives one white LED load. Typical wiring layouts for White mode:

- **Four independent white LED strips or bulbs** — each channel controls one strip/bulb, common anode (+) to V+
- **Multiple spotlights per channel** — several 12/24 V spotlights wired in parallel per output
- **Two white strips with doubled power** — pair two channels per strip (parallel) to double output power

Per-channel load limits (from Shelly's specification) are **45 W at 12 V** and **90 W at 24 V**. Combined load across all four channels must not exceed 144 W at 12 V or 288 W at 24 V.

## Configuration

The template connects over Wi-Fi. During TapHome template import, enter the device's IP address (default placeholder `192.168.0.1`) and an optional transition time in milliseconds (default `300`).

The transition time controls how quickly each channel fades between brightness levels. It is sent with every write command and also defines the debounce window — the template ignores polled brightness values for `transitionTime + 500 ms` after each write to prevent stale reads during a fade.

## Mode switching

If the device is currently in Color mode, switch it to White mode before importing this template. Either:

- Open the Shelly web interface at `http://{device-ip}` and change the operating mode in the settings, or
- Send `GET /settings?mode=white` directly, or
- Import the Color-mode template temporarily and use its **Set mode White** service action, then reimport this White-mode template

Mode changes require a device restart. After the device reboots, reimport the White-mode template in TapHome.

## Device capabilities

### Four independent dimmers

The template exposes four independent dimmer channels, one per PWM output:

| Channel | Output pin | Endpoint     | Poll interval |
|---------|------------|--------------|---------------|
| Ch1     | R          | `/light/0`   | 2.5 s         |
| Ch2     | G          | `/light/1`   | 2.5 s         |
| Ch3     | B          | `/light/2`   | 2.5 s         |
| Ch4     | W          | `/light/3`   | 2.5 s         |

Each dimmer reads `lights[N].ison` and `lights[N].brightness` (0-100, normalized to 0-1) from the `/status` response. Write commands use `/light/N?turn=on|off&brightness=VALUE&transition=T`. The template uses the legacy `/light/{idx}` endpoint, which Shelly firmware accepts as an alias of the current `/white/{idx}` endpoint.

### Per-channel power metering

Each channel has its own energy meter — **Electric Meter Ch1** through **Electric Meter Ch4** — reading from `meters[0]` through `meters[3]`:

- **Real-time power** — `meters[N].power` in watts, converted to kW
- **Total consumption** — `meters[N].total` in watt-minutes, converted to kWh

Channel 1 polls at 2.5 s together with its dimmer; channels 2-4 poll at 15 s intervals to reduce load on the Gen1 HTTP stack (which tolerates only two concurrent connections).

### Service diagnostics

The template exposes 10 service attributes for device monitoring:

- **Network** — IP address, MAC address (formatted with colons), Wi-Fi signal strength (dB)
- **Connectivity** — cloud enabled/connected, MQTT connected
- **Device info** — device time, uptime (formatted as days/hours/minutes), RAM usage
- **Firmware** — firmware update available

### Service actions

Three service actions are available:

- **Enable cloud** — enables or disables Shelly Cloud connectivity
- **Reboot** — triggers a device reboot
- **Set mode White** — writes `/settings?mode=white` to enforce White operating mode (useful after a factory reset or if someone changed the mode via the Shelly app)

The Shelly Cloud API is **not** used by this template — communication is local HTTP polling only.

## Troubleshooting

### Device not responding

1. Verify the Shelly is connected to Wi-Fi and has a valid IP address
2. Try using the mDNS hostname (`shellyrgbw2-AABBCCDDEE.local`) instead of the IP address — the IP may have changed after a DHCP renewal
3. Open `http://{device-ip}/shelly` in a browser — if it responds, the device is reachable
4. Check that TapHome CCU and Shelly are on the same network / VLAN

### "Mode White is not supported" error

This error means the device is currently set to Color mode. To resolve:

1. Open the Shelly web interface at `http://{device-ip}` and switch the operating mode to White, or
2. Send `GET /settings?mode=white` directly from a browser or curl, or
3. If you have the Color-mode template imported, run the **Set mode White** service action from there
4. The device needs to reboot after a mode change — wait a few seconds and reload TapHome

### Power readings show zero

1. Confirm white LEDs are connected to the relevant Shelly RGBW2 output (R, G, B, or W pin)
2. Open the Shelly app or web interface and verify the device model is configured under Settings -> Device Model — without this the meter returns zero
3. Check that the channel is turned on — the meter only reads when current flows through the output
4. Poll `/status` manually and verify `meters[N].power` returns a non-zero value for the channel in question

### Channel does not dim smoothly

1. Check that the transition time parameter matches the behavior you expect — the default 300 ms is a short crossfade; longer values (e.g., 1500 ms) produce slower fades
2. Remember that the debounce window equals `transitionTime + 500 ms` — changes sent faster than this can be coalesced
3. Verify the LED load is dimmable (some drivers are not PWM-compatible) and that the power supply provides a stable 12/24 V DC

> [!WARNING]
> Gen1 Shelly devices support only **2 concurrent HTTP connections**. If TapHome and another system (e.g., Home Assistant) poll the same device simultaneously, communication may become unreliable. Keep the poll interval at 10-30 seconds per extra client.

## How to install in TapHome

### Prerequisites

- Shelly device installed and powered on
- Local Wi-Fi network (2.4 GHz)
- TapHome CCU on the same network

### Step 1 — Connect Shelly to Wi-Fi

**Option A — Shelly app (recommended):**

1. Download the [Shelly app](https://www.shelly.com/en/support/shelly-app) (iOS / Android)
2. Tap **+** → **Add Device** and follow the Bluetooth pairing wizard
3. Enter your Wi-Fi credentials when prompted

**Option B — AP mode (no app):**

1. On first power-up the device creates a hotspot: `ShellyXXX-AABBCCDDEE`
2. Connect your phone/PC to that hotspot
3. Open `http://192.168.33.1` → **Internet & Security** → **Wi-Fi Mode - Client**
4. Enter SSID and password → **Save**

> [!NOTE]
> Shelly only supports **2.4 GHz** networks. 5 GHz networks will not appear in the scan.

### Step 2 — Find the device address

Shelly Gen1 devices support **mDNS** (Zeroconf). You can reach the device using a hostname instead of an IP address:

```
shelly<model>-<MAC>.local
```

For example: `shelly1pm-AABBCCDDEE.local` (MAC address in uppercase hex, no colons).

> [!TIP]
> **Recommended: use the TapHome IP Scanner.** Open the TapHome app and use the **IP Scanner** (Settings → Network → Scan). The scanner will discover devices on your network and show both the IP address and the mDNS hostname. Use the **hostname** instead of the IP address for a more reliable connection — it stays the same even if the device's IP changes after a router reboot.

**Alternative methods** to find the IP address:

- **Shelly app:** Device detail → **Device info** → IP address
- **Shelly web UI:** Connect to the device AP before Wi-Fi setup — the IP is shown after saving
- **Router DHCP table:** Look for a hostname like `shelly1pm-AABBCCDDEE`

### Step 3 — Configure in TapHome

1. In TapHome, add a new **Packet Parser (HTTP)** module
2. **Address:** enter the mDNS hostname (e.g., `shelly1pm-AABBCCDDEE.local`) or IP address from Step 2
3. **Port:** `80` (default, no change needed)
4. Import the template — TapHome will poll `/status` to read device state

> [!NOTE]
> HTTP authentication is disabled by default on Shelly devices. If you have enabled login protection, TapHome does not support HTTP Basic Auth at this time — keep auth disabled for TapHome integration.

## Available devices 8

These devices appear in TapHome after import.

Shelly RGBW2 White Module

Service Attributes

|                     |                                                                                                  |
|---------------------|--------------------------------------------------------------------------------------------------|
| IP Address          | Current IP address assigned to the device (reads /status -&gt; wifi\_sta.ip)                     |
| MAC Address         | Device MAC address, formatted with colons (reads /status -&gt; mac)                              |
| WIFI signal         | Wi-Fi signal strength in dB (reads /status -&gt; wifi\_sta.rssi)                                 |
| Cloud enabled       | Whether Shelly Cloud is enabled on the device (reads /status -&gt; cloud.enabled)                |
| Cloud connected     | Whether the device is currently connected to Shelly Cloud (reads /status -&gt; cloud.connected)  |
| MQTT connected      | Whether the device is currently connected to an MQTT broker (reads /status -&gt; mqtt.connected) |
| Device time         | Current time reported by the device (reads /status -&gt; time)                                   |
| FW update available | True if a firmware update is available for the device (reads /status -&gt; has\_update)          |
| Uptime              | Time elapsed since the last reboot, formatted as days/hours/minutes (reads /status -&gt; uptime) |
| RAM                 | RAM total and free bytes (reads /status -&gt; ram\_total, ram\_free)                             |

Service Actions

|                |                                                                                                                                          |
|----------------|------------------------------------------------------------------------------------------------------------------------------------------|
| Enable cloud   | Enable or disable Shelly Cloud connectivity (writes /settings/cloud?enabled=...)                                                         |
| Reboot         | Trigger an immediate device reboot (writes /reboot)                                                                                      |
| Set mode White | Switch the device to White operating mode; a device restart is required before the new mode becomes active (writes /settings?mode=white) |

Custom Variables

|                                             |                                                                                                                                                                                                   |
|---------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `transitionTime` (numeric) = TransitionTime | Light transition duration in milliseconds (import parameter, default 300 ms). Also defines the debounce window (transitionTime + 500 ms) during which polled values are ignored after each write. |

Read (module)

```taphome
VAR now := NOW();

IF now.Ticks < debounceTimestamp
    RETURN(0);
END

VAR response := SENDHTTPREQUEST("/status");

IF response.IsSuccess
    jsonStatus := response.Content;
    
    if PARSEJSON(jsonStatus, "$.mode", 1) = "color"
    adderror("Mode Color is not supported");
    end
ELSE
    jsonStatus := NULL;
END
```

Service Attributes

IP Address

```taphome
VAR response := SENDHTTPREQUEST("/status");

IF response.IsSuccess
    jsonStatus := response.Content;
ELSE
    jsonStatus := NULL;
END

VAR address := PARSEJSON(jsonStatus, "$.wifi_sta.ip", 1);
IF (ISNULL(address), "-", address)
```

MAC Address

```taphome
VAR value := PARSEJSON(jsonStatus, "$.mac", 1);
IF ISNULL(value)
    RETURN("-");
END;

STRING mac;
INT i := 0;
INT len := LENGTH(value);

WHILE i < len
    mac += GETAT(value, i);
    i += 1;
    
    IF MOD(i, 2) = 0 AND i < len
        mac += ":";
    END
LOOP

mac
```

WIFI signal

```taphome
VAR signal := PARSEJSON(jsonStatus, "$.wifi_sta.rssi", 1);
IF (ISNULL(signal), "-", signal + "db");
```

Cloud enabled

```taphome
VAR value := PARSEJSON(jsonStatus, "$.cloud.enabled", 1);
IF (ISNULL(value), "-", value)
```

Cloud connected

```taphome
VAR value := PARSEJSON(jsonStatus, "$.cloud.connected", 1);
IF (ISNULL(value), "-", value)
```

MQTT connected

```taphome
VAR value := PARSEJSON(jsonStatus, "$.mqtt.connected", 1);
IF (ISNULL(value), "-", value)
```

Device time

```taphome
VAR value := PARSEJSON(jsonStatus, "$.time", 1);
IF (ISNULL(value), "-", value)
```

FW update available

```taphome
VAR value := PARSEJSON(jsonStatus, "$.has_update");
IF (ISNULL(value), "-", value)
```

Uptime

```taphome
VAR value := PARSEJSON(jsonStatus, "$.uptime", 1);
IF ISNULL(value)
    RETURN("-");
END

VAR days := FLOOR(value/86400, 1);
value := MOD(value, 86400);
VAR hours := FLOOR(value/3600, 1);
value := MOD(value, 3600);
VAR minutes := FLOOR(value/60, 1);

days + "day(s) " + hours + "h " + minutes + "m"
```

RAM

```taphome
VAR ramFree := PARSEJSON(jsonStatus, "$.ram_free", 1);
VAR ramTotal := PARSEJSON(jsonStatus, "$.ram_total", 1);

IF ISNULL(ramFree) OR ISNULL(ramTotal)
    RETURN("-");
END

ramFree + " bytes free of " + ramTotal
```

Service Actions

Enable cloud

Parameters: Enable (Enable / Disable)

```taphome
VAR response := SENDHTTPREQUEST("/settings/cloud?enabled=" + enable);
VAR contentJson := response.Content;
VAR wasEnabled := PARSEJSON(contentJson, "enabled");

IF(wasEnabled, "Cloud enabled", "Cloud disabled");
```

Reboot

```taphome
VAR response := SENDHTTPREQUEST("/reboot");
VAR contentJson := response.Content;
VAR wasRebooted := PARSEJSON(contentJson, "ok");

IF(wasRebooted, "Reboot successful", "Error");
```

Set mode White

```taphome
VAR response := SENDHTTPREQUEST("/settings?mode=white");
IF(response.isSuccess, "White mode is set", "Error");
```

Electric Meter Ch1 Electricity Meter Read-only

Channel 1 (R pin) power consumption — instantaneous power (kW) and cumulative energy (kWh)

numeric Unit: W / kWh

Read total consumption

```taphome
IF LENGTH(jsonStatus) = 0
    RETURN(NaN);
END

VAR power := PARSEJSON(jsonStatus, "$.meters[0].power");
VAR total := PARSEJSON(jsonStatus, "$.meters[0].total");
BOOL isOn := PARSEJSON(jsonStatus, "$.lights[0].ison");

IF ISNULL(power) OR ISNULL(total) OR (ison AND power=0)
    ADDWARNING("To enable power monitoring, open device settings in Shelly app or web browser and configure device model in Settings->Device Model");
    
    RETURN(NaN);
END

total / 60000.0
```

Read demand

```taphome
IF LENGTH(jsonStatus) = 0
    RETURN(NaN);
END

VAR power := PARSEJSON(jsonStatus, "$.meters[0].power", 1);

IF ISNULL(power)
    RETURN(NaN);
END

power / 1000.0
```

Dimmer Ch1 (R) Dimmer Read and write

Channel 1 white dimmer (R pin output) — brightness 0-100% via /light/0 endpoint

numeric Unit: 0–1

Read level

```taphome
IF LENGTH(jsonStatus) = 0
    RETURN(NaN);
END

VAR now := NOW();
var tmp := now.Ticks - debounceTimestamp;
if now.Ticks > debounceTimestamp
    BOOL isOn := PARSEJSON(jsonStatus, "$.lights[0].ison");
    var brightness := PARSEJSON(jsonStatus, "$.lights[0].brightness");

    if isOn
        return(brightness / 100);
    else
        return(0);
    end
else
    return(le);
end
```

Write level

```taphome
IF St > 0.5
    SENDHTTPREQUEST("light/0?turn=on&transition=" + transitionTime + "&brightness=" + ROUND(Le*100.0));
ELSE
    SENDHTTPREQUEST("light/0?turn=off&transition=" + transitionTime);
END

VAR now := NOW();
debounceTimestamp := now.Ticks + transitionTime + 500;
```

Electric Meter Ch2 Electricity Meter Read-only

Channel 2 (G pin) power consumption — instantaneous power (kW) and cumulative energy (kWh)

numeric Unit: W / kWh

Read total consumption

```taphome
IF LENGTH(jsonStatus) = 0
    RETURN(NaN);
END

VAR power := PARSEJSON(jsonStatus, "$.meters[1].power");
VAR total := PARSEJSON(jsonStatus, "$.meters[1].total");
BOOL isOn := PARSEJSON(jsonStatus, "$.lights[1].ison");

IF ISNULL(power) OR ISNULL(total) OR (ison AND power=0)
    ADDWARNING("To enable power monitoring, open device settings in Shelly app or web browser and configure device model in Settings->Device Model");
    
    RETURN(NaN);
END

total / 60000.0
```

Read demand

```taphome
IF LENGTH(jsonStatus) = 0
    RETURN(NaN);
END

VAR power := PARSEJSON(jsonStatus, "$.meters[1].power", 1);

IF ISNULL(power)
    RETURN(NaN);
END

power / 1000.0
```

Dimmer Ch2 (G) Dimmer Read and write

Channel 2 white dimmer (G pin output) — brightness 0-100% via /light/1 endpoint

numeric Unit: 0–1

Read level

```taphome
IF LENGTH(jsonStatus) = 0
    RETURN(NaN);
END

VAR now := NOW();
var tmp := now.Ticks - debounceTimestamp;
if now.Ticks > debounceTimestamp
    BOOL isOn := PARSEJSON(jsonStatus, "$.lights[1].ison");
    var brightness := PARSEJSON(jsonStatus, "$.lights[1].brightness");

    if isOn
        return(brightness / 100);
    else
        return(0);
    end
else
    return(le);
end
```

Write level

```taphome
IF St > 0.5
    SENDHTTPREQUEST("light/1?turn=on&transition=" + transitionTime + "&brightness=" + ROUND(Le*100.0));
ELSE
    SENDHTTPREQUEST("light/1?turn=off&transition=" + transitionTime);
END

VAR now := NOW();
debounceTimestamp := now.Ticks + transitionTime + 500;
```

Electric Meter Ch3 Electricity Meter Read-only

Channel 3 (B pin) power consumption — instantaneous power (kW) and cumulative energy (kWh)

numeric Unit: W / kWh

Read total consumption

```taphome
IF LENGTH(jsonStatus) = 0
    RETURN(NaN);
END

VAR power := PARSEJSON(jsonStatus, "$.meters[2].power");
VAR total := PARSEJSON(jsonStatus, "$.meters[2].total");
BOOL isOn := PARSEJSON(jsonStatus, "$.lights[2].ison");

IF ISNULL(power) OR ISNULL(total) OR (ison AND power=0)
    ADDWARNING("To enable power monitoring, open device settings in Shelly app or web browser and configure device model in Settings->Device Model");
    
    RETURN(NaN);
END

total / 60000.0
```

Read demand

```taphome
IF LENGTH(jsonStatus) = 0
    RETURN(NaN);
END

VAR power := PARSEJSON(jsonStatus, "$.meters[2].power", 1);

IF ISNULL(power)
    RETURN(NaN);
END

power / 1000.0
```

Dimmer Ch3 (B) Dimmer Read and write

Channel 3 white dimmer (B pin output) — brightness 0-100% via /light/2 endpoint

numeric Unit: 0–1

Read level

```taphome
IF LENGTH(jsonStatus) = 0
    RETURN(NaN);
END

VAR now := NOW();
var tmp := now.Ticks - debounceTimestamp;
if now.Ticks > debounceTimestamp
    BOOL isOn := PARSEJSON(jsonStatus, "$.lights[2].ison");
    var brightness := PARSEJSON(jsonStatus, "$.lights[2].brightness");

    if isOn
        return(brightness / 100);
    else
        return(0);
    end
else
    return(le);
end
```

Write level

```taphome
IF St > 0.5
    SENDHTTPREQUEST("light/2?turn=on&transition=" + transitionTime + "&brightness=" + ROUND(Le*100.0));
ELSE
    SENDHTTPREQUEST("light/2?turn=off&transition=" + transitionTime);
END

VAR now := NOW();
debounceTimestamp := now.Ticks + transitionTime + 500;
```

Electric Meter Ch4 Electricity Meter Read-only

Channel 4 (W pin) power consumption — instantaneous power (kW) and cumulative energy (kWh)

numeric Unit: W / kWh

Read total consumption

```taphome
IF LENGTH(jsonStatus) = 0
    RETURN(NaN);
END

VAR power := PARSEJSON(jsonStatus, "$.meters[3].power");
VAR total := PARSEJSON(jsonStatus, "$.meters[3].total");
BOOL isOn := PARSEJSON(jsonStatus, "$.lights[3].ison");

IF ISNULL(power) OR ISNULL(total) OR (ison AND power=0)
    ADDWARNING("To enable power monitoring, open device settings in Shelly app or web browser and configure device model in Settings->Device Model");
    
    RETURN(NaN);
END

total / 60000.0
```

Read demand

```taphome
IF LENGTH(jsonStatus) = 0
    RETURN(NaN);
END

VAR power := PARSEJSON(jsonStatus, "$.meters[3].power", 1);

IF ISNULL(power)
    RETURN(NaN);
END

power / 1000.0
```

Dimmer Ch4 (W) Dimmer Read and write

Channel 4 white dimmer (W pin output) — brightness 0-100% via /light/3 endpoint

numeric Unit: 0–1

Read level

```taphome
IF LENGTH(jsonStatus) = 0
    RETURN(NaN);
END

VAR now := NOW();
var tmp := now.Ticks - debounceTimestamp;
if now.Ticks > debounceTimestamp
    BOOL isOn := PARSEJSON(jsonStatus, "$.lights[3].ison");
    var brightness := PARSEJSON(jsonStatus, "$.lights[3].brightness");

    if isOn
        return(brightness / 100);
    else
        return(0);
    end
else
    return(le);
end
```

Write level

```taphome
IF St > 0.5
    SENDHTTPREQUEST("light/3?turn=on&transition=" + transitionTime + "&brightness=" + ROUND(Le*100.0));
ELSE
    SENDHTTPREQUEST("light/3?turn=off&transition=" + transitionTime);
END

VAR now := NOW();
debounceTimestamp := now.Ticks + transitionTime + 500;
```

**Connection:** Packet Parser → HTTP • Hostname: `shellyrgbw2-{MAC}.local`

Possible improvements (10)

- Auto-off timer per channel — Each /white/{idx} (or legacy /light/{idx}) accepts a timer=N parameter for auto-off countdown; timer\_remaining is readable from /status
- Per-channel default state & auto-on/auto-off — Per-channel settings (default\_state off/on/last, auto\_on, auto\_off, name) — not exposed as service action
- Night mode (per channel) — Time-window auto-dim (enabled, start\_time, end\_time, brightness) per white channel — fw v1.12.0+
- Input State — Physical button/switch input state (0/1), available in /status response
- WiFi RSSI (numeric) — WiFi RSSI in dBm as numeric value — template reads it only as a formatted string with 'db' suffix
- Power protection — Max power setting in Watts, available in /settings; read + write possible via /settings?max\_power=N
- OTA firmware update — Trigger OTA firmware update via /ota?update=true
- Internal device temperature — Internal temperature in °C, available in /status response (Gen1 devices)
- Overheated — Overtemperature flag, boolean, available in /status response
- Set mode Color — Switch back to Color mode — template only exposes Set mode White; inverse action omitted (by design, this template is White-only)

## Import parameters

Enter these values when you import the XML.

| Asked in the app     | Default       |
|----------------------|---------------|
| IP address           | `192.168.0.1` |
| Transition time (ms) | `300`         |

## Sources

- Shelly Gen1 API Reference
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen1/) 2026-03-12
- Home Assistant Shelly Integration
  
  [www.home-assistant.io](https://www.home-assistant.io/integrations/shelly/) 2026-03-12
- Shelly RGBW2 API — Color & White Mode Endpoints
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen1/#shelly-rgbw2-white-mode) 2026-03-30
- Shelly RGBW2 Knowledge Base
  
  [kb.shelly.cloud](https://kb.shelly.cloud/knowledge-base/shelly-rgbw2) 2026-03-30

## Related Documentation

- [Packet Parser Integration](https://taphome.com/en/compatibility/packet-parser-guide/)
- [Packet Parser (HTTP, TCP, UDP, FTP, MQTT)](https://taphome.com/en/docs/integration/packet-parser/)
- [Packet parser functions](https://taphome.com/en/docs/script/packet-parser/)
- [Parsing functions](https://taphome.com/en/docs/script/parsing-functions/)