---
title: "Shelly Plus Plug S"
description: "Shelly Plus Plug S in TapHome over local Gen2+ HTTP RPC: switch up to 12 A, measure power and energy, set LED ring mode and colours. No cloud needed."
url: "https://taphome.com/en/compatibility/shelly-plus-plug-s/"
language: en
lastmod: 2026-10-08
generator: hugo
ai:
  topics: ["http","smart-plug","electric-meter","wifi","gen2plus","rpc-api","mdns","power-metering","led-ring"]
  questions: ["How to integrate Shelly Plus Plug S with TapHome?","What does the Shelly Plus Plug S TapHome template measure?","How to connect Shelly Plus Plug S via HTTP to TapHome?","What are the three LED ring modes on Shelly Plus Plug S?","How to change the LED ring color from TapHome?","Why does Shelly Plus Plug S show zero power readings?"]
---

# Shelly Plus Plug S

Communication: Packet Parser → HTTP

- [Shelly Plus Plug S Knowledge Base](https://kb.shelly.cloud/knowledge-base/shelly-plus-plug-s)
- [Shelly Gen2+ RPC API Documentation](https://shelly-api-docs.shelly.cloud/gen2/)

> 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 Plus Plug S is a Gen2+ Wi-Fi smart plug with built-in power metering and a multicolour LED ring indicator. It plugs into a standard CEE 7/3 (Type-F / Schuko) socket and can switch loads up to 12 A / 2760 W at 230 V. TapHome communicates with the device locally over Wi-Fi using the Gen2+ JSON-RPC API on port 80 — no cloud connection is required.

The template exposes the plug as six TapHome devices: a relay switch, an electricity meter, an LED indication mode selector, two LED colour pickers (relay-ON and relay-OFF states) and a brightness dimmer for the power-indication mode.

## Configuration

### Pairing and network setup

Out of the box the device boots into access-point mode with SSID `ShellyPlusPlugS-XXXXXX` (LED flashes blue). Connect to this SSID, open `http://192.168.33.1/` and join your local Wi-Fi from the web UI. After the plug joins your LAN, it is reachable on port 80 at its station IP address and over mDNS at `shellyplusplugs-<MAC>.local`.

TapHome polls the Gen2+ RPC endpoints over plain HTTP — HTTPS is disabled by default and HTTP authentication (`Shelly.SetAuth`) must remain disabled for the template to work. Make sure the plug sits on the same LAN / VLAN as the TapHome Core.

During template import in TapHome, supply the plug's IP address as the `IpAddress` parameter. A static DHCP reservation is strongly recommended so the address does not change between reboots.

## Device capabilities

### Relay control

The relay is exposed as a switch device. Its state is read from `/rpc/Switch.GetStatus?id=0` (the `output` boolean) and controlled via `/rpc/Switch.Set?id=0&on=true|false`. The module caches the full `Switch.GetStatus` response so the relay, meter and service attributes all share one HTTP call per poll.

### Power and energy metering

The built-in meter on the Switch component provides:

- **Instantaneous power** — `apower` in watts, converted to kW by the template (divided by 1000)
- **Cumulative energy** — `aenergy.total` in watt-hours, converted to kWh (divided by 1000)

Three further readings are exposed as service attributes on the meter:

| Attribute | Unit | Source field |
|-----------|------|--------------|
| Current | A | `current` |
| Voltage | V | `voltage` |
| Temperature | °C | `temperature.tC` |

The meter is read-only and updates on every poll cycle.

### LED indication mode

The multicolour LED ring is controlled by the Plus-Plug-S-specific `PLUGS_UI` RPC component. TapHome exposes a mode selector with three valid options — despite the template listing ten enum slots, only the first three correspond to real firmware modes:

| Value | Behaviour |
|-------|-----------|
| `off` | LED ring disabled (Wi-Fi / AP / firmware diagnostic states are still shown) |
| `switch` | LED colour reflects the relay state — uses the user-defined OFF and ON colours |
| `power` | LED colour reflects measured load as a fraction of the configured power limit (green → yellow → red gradient) |

Switching between modes is a cosmetic change and does not require a reboot.

### LED colours (switch mode)

Two independent HSB devices let you pick the LED ring colour for each relay state:

- **LED Color (OFF state)** — colour + brightness shown while the relay is OFF
- **LED Color (ON state)** — colour + brightness shown while the relay is ON

Both map to `leds.colors.switch:0.{off|on}.{rgb,brightness}` in the `PLUGS_UI` config. Shelly stores RGB values as percent (0–100 per channel), not 0–255, so the template multiplies each channel by 2.55 when converting between HSV and the device's native format. This conversion is internal — from TapHome the devices behave like any other HSB colour picker.

### LED brightness (power mode)

When the LED is in `power` mode the colour is chosen automatically by the firmware based on load. Only the brightness is user-configurable, so the template exposes it as a dimmer (`leds.colors.power.brightness`, 0–100 % scaled to a 0.0–1.0 TapHome dimmer level).

### Module diagnostics and actions

The HTTP module exposes four service attributes parsed from `/rpc/WiFi.GetStatus` and `/rpc/Sys.GetStatus`:

| Attribute | Source |
|-----------|--------|
| Wi-Fi SSID | `ssid` |
| IP address | `sta_ip` |
| Signal strength | `rssi` (dBm) |
| MAC address | `mac` |

Two service actions are also available:

- **Firmware update** — triggers an OTA update on the stable channel (`/rpc/Shelly.Update?stage="stable"`). The firmware installs an update only if one is available (`available_updates.stable` in `Sys.GetStatus`).
- **Reboot** — reboots the device (`/rpc/Shelly.Reboot`), useful after network configuration changes or to clear transient issues.

> [!TIP]
> If you only need on/off control and basic energy monitoring, ignore the LED devices — they are optional. The relay and meter work independently of the LED indication mode.

## Troubleshooting

### Device not responding

1. Verify the plug is connected to Wi-Fi — the LED should not be flashing or solid red
2. Try the mDNS hostname `shellyplusplugs-<MAC>.local` instead of the IP address — the DHCP lease may have changed
3. Open `http://{device-ip}/rpc/Shelly.GetDeviceInfo` in a browser; if it responds with JSON the device is reachable
4. Confirm TapHome Core and the plug are on the same LAN / VLAN
5. Make sure HTTP authentication is disabled in the Shelly web UI — the template does not support digest auth

### Power readings show zero

1. Confirm a load is actually plugged into the Shelly, not bypassed
2. Check that the relay is ON — the meter reports 0 W when the relay is open
3. Query `/rpc/Switch.GetStatus?id=0` directly in a browser and verify that `apower` is non-zero

### LED does not change after a mode switch

1. The LED only reflects runtime state in `switch` and `power` modes; in `off` mode it stays dark except for system diagnostic patterns (AP mode, reconnecting, OTA)
2. In `switch` mode make sure the ON and OFF colours are not both set to black / 0 % brightness
3. System indications (blue flashing for AP mode, red for Wi-Fi problems) always override the user LED configuration — if the LED is flashing red, the plug is not on your Wi-Fi

### Firmware update action does not fire

1. The firmware installs an update only when `Sys.GetStatus` reports `available_updates.stable` — if the plug is already up to date, the action has nothing to install
2. The template targets the stable channel only; beta firmware must be installed from the Shelly web UI

## 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 6

These devices appear in TapHome after import.

Shelly Plus Plug S Module

Service Attributes

|                 |                                                                                                                          |
|-----------------|--------------------------------------------------------------------------------------------------------------------------|
| Wi-Fi SSID      |                                                                                                                          |
| IP address      |                                                                                                                          |
| Signal strength | Wi-Fi signal strength in dBm — values closer to 0 indicate a stronger connection (e.g. −55 dBm is good, −80 dBm is weak) |
| MAC address     |                                                                                                                          |

Service Actions

|                 |                                                                                              |
|-----------------|----------------------------------------------------------------------------------------------|
| Firmware update | Triggers an over-the-air firmware update from the Shelly stable channel                      |
| Reboot          | Reboots the device — useful after network configuration changes or to clear transient issues |

Custom Variables

Read (module)

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Sys.GetStatus");
IF response.IsSuccess
    Sys.GetStatus := response.Content;
END

response := SENDHTTPREQUEST("/rpc/Sys.GetConfig");
IF response.IsSuccess
    Sys.GetConfig := response.Content;
END

response := SENDHTTPREQUEST("/rpc/WiFi.GetStatus");
IF response.IsSuccess
    WiFi.GetStatus := response.Content;
END

response := SENDHTTPREQUEST("/rpc/PLUGS_UI.GetConfig");
IF response.IsSuccess
    PLUGS_UI.GetConfig := response.Content;
END

if ! ISNULL(parsejson(Sys.GetStatus, "available_updates.stable", true))
    addwarning("New firmware update is available");
end

if parsejson(Sys.GetStatus, "restart_required", true)
    addwarning("Restart required");
end
```

Service Attributes

Wifi

```taphome
PARSEJSON(WiFi.GetStatus, "ssid")
```

${ipAddress}

```taphome
PARSEJSON(WiFi.GetStatus, "sta_ip")
```

${xml\_signal\_strength} \[dB]

```taphome
PARSEJSON(WiFi.GetStatus, "rssi")
```

MAC

```taphome
PARSEJSON(Sys.GetStatus, "mac")
```

Service Actions

${xml\_update\_fw}

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Shelly.Update?stage=\"stable\"");
IF response.IsSuccess
    return("OK");
else
    return("Error");
END

```

Reboot

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Shelly.Reboot");
IF response.IsSuccess
    return("OK");
else
    return("Error");
END
```

Switch Switch Read and write

boolean

Values / States: ON · OFF

Read switch state

```taphome
var x := (sendhttprequest("/rpc/Switch.GetStatus?id=0"));
var status := x.Content;
return(PARSEJSON(status, "$.output", true));
```

Write switch state

```taphome
VAR response := SENDHTTPREQUEST("rpc/Switch.Set?id=0&on=" + if(St,"true","false"));
IF response.IsSuccess = false
  ADDERROR(response.StatusCode);
END
```

Electric Meter Electricity Meter Read-only

Instantaneous power (kW) and cumulative energy (kWh) measured by the built-in meter, with current, voltage and internal temperature diagnostics

numeric Unit: kW / kWh

Service Attributes

|             |                                                                                     |
|-------------|-------------------------------------------------------------------------------------|
| Current     |                                                                                     |
| Voltage     |                                                                                     |
| Temperature | Internal device temperature in °C — the plug shuts off automatically on overheating |

Read total consumption

```taphome
return(parsejson(parsejson(Switch.GetStatus,"aenergy"), "total")/1000);
```

Read demand

```taphome
return(parsejson(Switch.GetStatus,"apower")/1000);
```

Read (module)

```taphome
VAR response := SENDHTTPREQUEST("/rpc/Switch.GetStatus?id=0");
IF response.IsSuccess
    Switch.GetStatus := response.Content;
END
```

Service Attributes

${electric\_current} \[A]

```taphome
return(parsejson(Switch.GetStatus,"current"));
```

${electric\_voltage} \[V]

```taphome
return(parsejson(Switch.GetStatus,"voltage"));
```

${temperature} \[°C]

```taphome
return(parsejson(parsejson(Switch.GetStatus,"temperature"), "tC"));
```

LED Indication Mode Multi-value Switch Read and write

LED ring behaviour — Off (disabled), Switch (colour reflects relay state) or Power (colour reflects load as green → yellow → red)

string enum

Values / States: ${xml\_off} · ${switch} · ${xml\_power}

Read switch state

```taphome
switch(parsejson(PLUGS_UI.GetConfig, "leds.mode"), "power", 2, "switch", 1, 0)
```

Write switch state

```taphome
VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"mode\":\"" + switch(Mu, 2, "power", 1, "switch", "off") + "\"}}");

response := SENDHTTPREQUEST("/rpc/PLUGS_UI.GetConfig");
IF response.IsSuccess
    PLUGS_UI.GetConfig := response.Content;
END
```

LED Color (OFF state) HSB Light Read and write

RGB colour and brightness of the LED ring while the relay is OFF (used in Switch indication mode)

HSB (hue, saturation, brightness) hsv-to-rgb

Read brightness

```taphome
parsejson(PLUGS_UI.GetConfig, basePath + ".brightness") / 100
```

Write brightness

```taphome
VAR rgb := HSVTORGB( Hd, Sa, Hb);

VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"switch:0\":{\"off\":{\"brightness\":" + Hb*100 + "}}}}}");

response := SENDHTTPREQUEST("/rpc/PLUGS_UI.GetConfig");
IF response.IsSuccess
    PLUGS_UI.GetConfig := response.Content;
END
```

Read hue

```taphome
VAR HSVColor := RGBTOHSV(parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[0]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[1]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[2]") *2.55);

HSVColor.Hue
```

Write hue

```taphome
VAR rgb := HSVTORGB( Hd, Sa, Hb);

VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"switch:0\":{\"off\":{\"rgb\":[" + rgb.red/2.55 + "," + rgb.green/2.55 + "," + rgb.blue/2.55 + "],\"brightness\":" + Hb*100 + "}}}}}");

response := SENDHTTPREQUEST("/rpc/PLUGS_UI.GetConfig");
IF response.IsSuccess
    PLUGS_UI.GetConfig := response.Content;
END
```

Read saturation

```taphome
VAR HSVColor := RGBTOHSV(parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[0]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[1]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[2]") *2.55);

HSVColor.Saturation
```

Write saturation

```taphome
VAR rgb := HSVTORGB( Hd, Sa, Hb);

VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"switch:0\":{\"off\":{\"rgb\":[" + rgb.red/2.55 + "," + rgb.green/2.55 + "," + rgb.blue/2.55 + "],\"brightness\":" + Hb*100 + "}}}}}");

response := SENDHTTPREQUEST("/rpc/PLUGS_UI.GetConfig");
IF response.IsSuccess
    PLUGS_UI.GetConfig := response.Content;
END
```

LED Color (ON state) HSB Light Read and write

RGB colour and brightness of the LED ring while the relay is ON (used in Switch indication mode)

HSB (hue, saturation, brightness) hsv-to-rgb

Read brightness

```taphome
parsejson(PLUGS_UI.GetConfig, basePath + ".brightness") / 100
```

Write brightness

```taphome
VAR rgb := HSVTORGB( Hd, Sa, Hb);

VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"switch:0\":{\"on\":{\"brightness\":" + Hb*100 + "}}}}}");

response := SENDHTTPREQUEST("/rpc/PLUGS_UI.GetConfig");
IF response.IsSuccess
    PLUGS_UI.GetConfig := response.Content;
END
```

Read hue

```taphome
VAR HSVColor := RGBTOHSV(parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[0]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[1]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[2]") *2.55);

HSVColor.Hue
```

Write hue

```taphome
VAR rgb := HSVTORGB( Hd, Sa, Hb);

VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"switch:0\":{\"on\":{\"rgb\":[" + rgb.red/2.55 + "," + rgb.green/2.55 + "," + rgb.blue/2.55 + "],\"brightness\":" + Hb*100 + "}}}}}");

response := SENDHTTPREQUEST("/rpc/PLUGS_UI.GetConfig");
IF response.IsSuccess
    PLUGS_UI.GetConfig := response.Content;
END
```

Read saturation

```taphome
VAR HSVColor := RGBTOHSV(parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[0]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[1]") *2.55, parsejson(PLUGS_UI.GetConfig, basePath + ".rgb[2]") *2.55);

HSVColor.Saturation
```

Write saturation

```taphome
VAR rgb := HSVTORGB( Hd, Sa, Hb);

VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"switch:0\":{\"on\":{\"rgb\":[" + rgb.red/2.55 + "," + rgb.green/2.55 + "," + rgb.blue/2.55 + "],\"brightness\":" + Hb*100 + "}}}}}");

response := SENDHTTPREQUEST("/rpc/PLUGS_UI.GetConfig");
IF response.IsSuccess
    PLUGS_UI.GetConfig := response.Content;
END
```

LED Brightness (Power mode) Dimmer Read and write

Brightness of the LED ring in Power indication mode — colour itself is auto-selected by the firmware based on load

numeric

Read level

```taphome
parsejson(PLUGS_UI.GetConfig, "leds.colors.power.brightness") / 100
```

Write level

```taphome
VAR response := SENDHTTPREQUEST("rpc/PLUGS_UI.SetConfig?config={\"leds\":{\"colors\":{\"power\":{\"brightness\":" + Le*100 + "}}}}");

response := SENDHTTPREQUEST("/rpc/PLUGS_UI.GetConfig");
IF response.IsSuccess
    PLUGS_UI.GetConfig := response.Content;
END
```

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

Possible improvements (23)

- Power Factor — Power factor (0.0–1.0) reported in Switch.GetStatus response for metered devices
- Line Frequency — AC line frequency in Hz, available in Switch.GetStatus response
- Returned Energy — Returned/exported energy in Wh, for bi-directional metering scenarios
- Per-minute Energy History — Rolling three-minute energy buffer in mWh, useful for fine-grained load profiling
- Toggle Relay — Toggles the relay state without needing to know current state; not mapped as a TapHome service action
- Auto-off Timer — Optional toggle\_after parameter (seconds) on Switch.Set — relay auto-reverts after N seconds
- Overpower Protection — Configurable power limit (W); firmware turns the relay off when exceeded. Template does not expose a setter
- Over-voltage / Over-current Protection — Voltage and current safety thresholds configurable via Switch.SetConfig; not exposed by template
- Initial State After Power-up — Relay behaviour after power loss (off / on / restore\_last / match\_input); not exposed by template
- Reset Energy Counters — Resets aenergy / ret\_aenergy counters; not exposed by template
- Button Input Mode — Physical button behaviour (momentary / detached); device-internal, not exposed as a TapHome input
- LED Night Mode — Dims the LED ring during a configurable HH:MM window (wraps midnight); not mapped by template
- Local Scheduler — On-device cron-like scheduler for relay actions; no TapHome equivalent (TapHome uses its own schedules)
- Webhooks — Outbound HTTP webhooks on device events; not used by template (TapHome polls instead)
- mJS Scripts — Up to 10 on-device mJS scripts; out of scope for TapHome integration
- Shelly Cloud Connection — Cloud connection status and enable/disable toggle; not mapped by template (TapHome communicates locally)
- Bluetooth LE Configuration — BLE gateway enable/disable and observer mode; not exposed by template
- MQTT Transport Config — Inbound/outbound MQTT RPC transport config; template uses HTTP exclusively
- System Diagnostics — Uptime, RAM/FS utilisation, last reset reason — available in cached Sys.GetStatus but not surfaced as attributes
- Device Time — Device wall-clock (HH:MM) and unix epoch; not surfaced as attribute
- Beta Firmware Availability — Template warns on available\_updates.stable but ignores the beta channel
- Factory Reset — Restores factory defaults; not exposed by template (deliberately destructive)
- HTTP Authentication — Enables digest auth on the RPC endpoint; template assumes no-auth local access

## Import parameters

Enter these values when you import the XML.

| Asked in the app | Default       |
|------------------|---------------|
| IP address       | `192.168.0.1` |

## Sources

- Shelly Gen2+/Gen3 RPC API Reference
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/) 2026-03-29
- Shelly Gen2+ Switch Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Switch/) 2026-03-29
- Shelly Gen2+ System (Sys) Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Sys/) 2026-03-29
- Shelly Gen2+ WiFi Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/WiFi/) 2026-03-29
- Shelly Gen2+ MQTT Component API
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Mqtt/) 2026-03-29
- Home Assistant Shelly Integration
  
  [www.home-assistant.io](https://www.home-assistant.io/integrations/shelly/) 2026-03-29
- Shelly Plus Plug S Knowledge Base — specs, wiring, LED indication
  
  [kb.shelly.cloud](https://kb.shelly.cloud/knowledge-base/shelly-plus-plug-s) 2026-04-24
- Shelly Plus Plug S RPC API — PLUGS\_UI component (device-specific)
  
  [shelly-api-docs.shelly.cloud](https://shelly-api-docs.shelly.cloud/gen2/Devices/Gen2/ShellyPlusPlugS/) 2026-04-24

## 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/)