---
title: "go-e Gemini flex Wallbox"
description: "go-e Charger Gemini flex in TapHome over the local HTTP API v2 on Wi-Fi: charging current, mode, phase switching and inputs for PV surplus charging."
url: "https://taphome.com/en/compatibility/go-e-wallbox/"
language: en
lastmod: 2026-08-25
generator: hugo
ai:
  topics: ["http","wallbox","ev-charging","wifi","pv-surplus","3-phase"]
  questions: ["How to integrate go-e Gemini flex wallbox with TapHome?","What does the go-e wallbox TapHome template control and monitor?","How to enable the HTTP API on go-e Charger for TapHome?","How to set up PV surplus charging with go-e wallbox and TapHome?","Why does the go-e wallbox Charging Current only support 6 values?","How to switch between 1-phase and 3-phase charging on go-e via TapHome?"]
---

# go-e Gemini flex Wallbox

Communication: Packet Parser → HTTP

- [go-e Official Website](https://go-e.com)

> 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 go-e Gemini flex is an Austrian-made EV wallbox available in 11 kW (16 A) and 22 kW (32 A) variants, with a newer Gemini flex 2.0 model featuring integrated 4G LTE. TapHome communicates with the charger over its local HTTP API v2 on Wi-Fi — no cloud connection is required. The API must be explicitly enabled in the go-e app before TapHome can connect.

The template provides charger status monitoring, charging current, mode and force-state control, phase switching, per-phase voltage and current readings, an energy meter, and write-only inputs for external PV and grid power data to enable surplus charging.

## Configuration

### Enabling the HTTP API

The local HTTP API v2 is disabled by default. To enable it:

1. Connect to the go-e Charger via the go-e app (available for iOS and Android)
2. Navigate to **Settings > Connection > API Settings**
3. Enable **"Allow access to local HTTP API vX"**

Once enabled, the charger responds to HTTP requests on port 80. No authentication is required — access is controlled solely by this toggle.

### Network setup

The go-e Gemini flex connects via **Wi-Fi (802.11b/g/n, 2.4 GHz only)**. There is no wired Ethernet port. During TapHome template import, enter the charger's IP address.

The charger can operate in hotspot mode (direct connection) or join an existing Wi-Fi network. For TapHome integration, the charger must be on the same network as the TapHome CCU.

## Device capabilities

### Charger status

The Charger Status device reports the current connection and charging state as a read-only multi-value indicator. The API key `car` returns one of five states: **Failure** (0), **Available** (1), **Charging** (2), **Preparing** (3), or **Finished** (4). This allows TapHome automations to trigger based on whether a vehicle is connected, actively charging, or has completed a session.

### Charging current and mode control

Two controllable devices manage how the charger operates:

- **Charging Current** — selects the requested charging current from six discrete values: 6, 8, 10, 12, 14, and 16 A. The template maps these to switch positions 0–5 using the formula `amp/2 - 3` for reading and `(position + 3) × 2` for writing. Values are sent to the charger via `api/set?amp={value}`.

- **Charging Mode** — selects the charging logic: **Basic** (default continuous charging), **Eco** (price-optimized via Awattar tariff), or **Daily trip** (automatic stop after reaching a target). The API uses values 3, 4, and 5 respectively; the template maps these to positions 0, 1, and 2.

> [!NOTE]
> The Charging Current selector maps only six values (6–16 A in 2 A steps). The 22 kW variant of the Gemini flex supports up to 32 A, but values above 16 A are not covered by this template. To use higher currents, the `amp` API key can be set directly outside the template.

### Force state

The **Force State** device overrides the charger's own decision about whether to charge. The API key `frc` accepts **Neutral** (0 — the charger decides), **Stopped** (1 — charging blocked) and **Charge** (2 — charging forced on). The value is written via `api/set?frc={value}` and read back from the status response, which is why this template revision adds `frc` to the `api/status` filter.

> [!NOTE]
> The selector also lists positions 3–9 with numeric placeholder labels inherited from the template. The go-e API defines no meaning for them — use Neutral, Stopped and Charge only.

### Phase switching

The Phase Switching device controls how many phases the charger uses: **Automatic** (0), **1-Phase** (1), or **3-Phase** (2). The go-e Charger supports switching phases even during an active charging session. In Automatic mode, the charger selects the optimal phase configuration based on available power.

### Energy monitoring

The template reads per-phase voltage and current from the charger's `nrg` energy array, which contains 16 values updated every poll cycle:

| Device | Source | Unit |
|--------|--------|------|
| L1 Voltage | `nrg[0]` | V |
| L2 Voltage | `nrg[1]` | V |
| L3 Voltage | `nrg[2]` | V |
| L1 Current | `nrg[4]` | A |
| L2 Current | `nrg[5]` | A |
| L3 Current | `nrg[6]` | A |

The **Wallbox Electric Meter** device reports total delivered energy from the `eto` key (Wh) and instantaneous demand from `nrg[11]` divided by 1000. It replaces the former Current Consumption device. All energy values are read-only.

> [!WARNING]
> The template reads the phase currents from `nrg[4]`, `nrg[5]` and `nrg[6]`, and the meter demand from `nrg[11]`. The go-e API documentation places the phase currents at indices 5, 6 and 7, neutral power at index 11 and total power at index 12 — the previous template revision used exactly those. Check the readings against the charger before relying on them for billing or automations.

### PV surplus charging inputs

Two write-only devices allow TapHome to feed external energy data into the charger for surplus charging calculations:

- **Power to Grid** — sends the current grid export/import power (in kW, converted to W by multiplying by 1000) via `api/set?ids={"pGrid":value}`
- **PV Power** — sends the current photovoltaic production (in kW, converted to W by multiplying by 1000) via `api/set?ids={"pPv":value}`

These devices do **not** read data from the charger. The go-e Charger itself does not measure grid or PV power — it relies on external sources to provide this information. In a typical TapHome setup, values from a separate energy meter or solar inverter (also integrated into TapHome) are forwarded to the charger via these write-only devices, enabling the Eco charging mode to optimize for self-consumption.

> [!TIP]
> To use PV surplus charging, set the Charging Mode to **Eco**, then use TapHome automations to periodically write current grid power and PV production values to the Power to Grid and PV Power devices. The charger will adjust its charging current automatically based on the available surplus.

### Additional capabilities

The go-e Charger API v2 exposes additional data not currently mapped in the template: per-phase power (W) and power factor, neutral voltage, total power (`nrg[12]`), per-session energy (`wh`), error state codes, cable current limit, temperature sensors, grid frequency, energy limit settings, and minimum/maximum ampere configuration. These can be added in a future template update.

## Troubleshooting

### Device not responding

1. Verify the charger is connected to Wi-Fi and has a valid IP address — check the go-e app under **Settings > Connection**
2. Confirm the HTTP API is enabled (Settings > Connection > API Settings)
3. Open `http://{charger-ip}/api/status` in a browser — if it responds with JSON, the API is reachable
4. Check that TapHome CCU and the charger are on the same network / VLAN

### Charging current not changing

1. The template only maps six values (6, 8, 10, 12, 14, 16 A). If the charger shows a different value (e.g., 20 A set via the app), TapHome will display the nearest mapped position
2. Verify the charger firmware is 051.4 or newer — older firmware uses a different filter syntax that may cause parsing issues

### PV surplus charging not working

1. Confirm the Charging Mode is set to **Eco** — surplus logic only activates in this mode
2. Verify that Power to Grid and PV Power values are being written regularly (at least every 30 seconds)
3. Check that the values are in kW (the template converts to W automatically)
4. Open `http://{charger-ip}/api/status?filter=pgrid,ppv` to verify the charger is receiving the values

> [!TIP]
> The `eto` (total energy) API key is now exposed as the Wallbox Electric Meter device — the value fetched in the status filter is no longer unused.

## Available devices 14

These devices appear in TapHome after import.

go-e Wallbox Module

Custom Variables

Read (module)

```taphome
responseJson := "error";



VAR response := SENDHTTPREQUEST("api/status?filter=car,nrg,psm,amp,eto,lmo,frc");

IF response.IsSuccess
    responseJson := response.Content;
ELSE
    VAR contentJson := response.Content;
    VAR errCode := response.StatusCode;
    VAR message := PARSEJSON(contentJson, "message");
    #ADDERROR("Failed to read data - (" + errCode + ") " + message);
END
```

Charger Status Multi-value Switch Read-only

Car connection and charging state — Failure, Available, Charging, Preparing, Finished

uint8

Values / States: Failure · Available · Charging · Preparing · Finished

Read switch state

```taphome
RETURN(PARSEjson(responseJson, "car"));
```

Write switch state

```taphome
# Simple HTTP Request:
# VAR response := SENDHTTPREQUEST("/example/set/value=" + Mu);
# IF response.IsSuccess = false
#  ADDERROR(response.StatusCode);
# END
#
# Set Http request method, body and headers
# VAR response := SENDHTTPREQUEST("/example/setValue", "GET", "value=" + Mu, "header1:value1", "header2:value2", ...);\r
# Or VAR request := HTTPREQUEST("/example/setValue");
# request.Method := "PUT";
# VAR response := SENDHTTPREQUEST(request);
#r
#
# Send TCP, UDP data:
# VAR data1 := "{\"name\":\"John\", \"age\":" + Mu + "}";
# SENDDATA(data1);
# VAR data2 := TOBYTES("{\"name\":\"John\", \"age\":" + Mu + "}", "iso-8859-1");
# SENDDATA(data2);
# You can process received TCP or UDP data in the Listener script
#
#
# Upload data to FTP:
# FTPUPLOAD("filePath", "somedata=" + Mu, "write"); # use "append" mode to append data to existing file
```

Charging Current Multi-value Switch Read and write

Requested charging current selector — 6, 8, 10, 12, 14, 16 A in discrete steps

uint8 Unit: A numeric

Values / States: 6-Amp · 8-Amp · 10-Amp · 12-Amp · 14-Amp · 16-Amp

Read switch state

```taphome
VAR ampers := PARSEjson(responseJson, "amp");
RETURN(ampers/2-3);
```

Write switch state

```taphome
VAR amps:= (Mu +3)*2;
VAR response := SENDHTTPREQUEST("api/set?amp=" + amps);
IF response.IsSuccess = false
ADDERROR(response.StatusCode);
END
```

Charging Mode Multi-value Switch Read and write

Charging logic selector — Basic (continuous), Eco (price-optimized / PV surplus), Daily trip (auto-stop at target)

uint8 numeric

Values / States: Basic · Eco · Daily trip

Read switch state

```taphome
RETURN(PARSEjson(responseJson, "lmo")-3);
```

Write switch state

```taphome
VAR response := SENDHTTPREQUEST("api/set?lmo=" + (Mu+3));
IF response.IsSuccess = false
ADDERROR(response.StatusCode);
END
```

Force State Multi-value Switch Read and write

Charging override — Neutral leaves the decision to the charger, Stopped blocks charging, Charge forces it on

uint8

Values / States: Neutral · Stopped · Charge

Read switch state

```taphome
RETURN(PARSEjson(responseJson, "frc"));
```

Write switch state

```taphome
VAR response := SENDHTTPREQUEST("api/set?frc=" + (Mu));
IF response.IsSuccess = false
ADDERROR(response.StatusCode);
END
```

L1 Current Variable Read-only

numeric Unit: A json\_path

Read

```taphome
VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]");
VAR b := SPLIT(a,",");
RETURN(TODOUBLE(GETAT(b,4)))
```

Write

```taphome
# Simple HTTP Request:
# VAR response := SENDHTTPREQUEST("/example/set/value=" + Va);
# IF response.IsSuccess = false
#  ADDERROR(response.StatusCode);
# END
#
# Set Http request method, body and headers
# VAR response := SENDHTTPREQUEST("/example/setValue", "GET", "value=" + Va, "header1:value1", "header2:value2", ...);\r
# Or VAR request := HTTPREQUEST("/example/setValue");
# request.Method := "PUT";
# VAR response := SENDHTTPREQUEST(request);
#r
#
# Send TCP, UDP data:
# VAR data1 := "{\"name\":\"John\", \"age\":" + Va + "}";
# SENDDATA(data1);
# VAR data2 := TOBYTES("{\"name\":\"John\", \"age\":" + Va + "}", "iso-8859-1");
# SENDDATA(data2);
# You can process received TCP or UDP data in the Listener script
#
#
# Upload data to FTP:
# FTPUPLOAD("filePath", "somedata=" + Va, "write"); # use "append" mode to append data to existing file
```

Read (module)

```taphome
# Simple HTTP Request:
# VAR response := SENDHTTPREQUEST("/example/getValue");
# IF response.IsSuccess
#  VAR content := response.Content;
#  VAR responseHeaders := response.Headers;
#  RETURN(PARSEXML(content, "//element1/value1"));
# ELSE
#  ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")");
#  RETURN(NaN);
# END
#
# Set Http request method, body and headers
# VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...);
# OR
# VAR request := HTTPREQUEST("/example/getValue", "POST", "some data");
# request.headers := { "header1:value1", "header2:value2", ...};
# request.method := "GET";
# request.data := null;
# VAR response := SENDHTTPREQUEST(request);
#
#
# Send TCP, UDP data:
# VAR data1 := BYTECOLLECTION("0a bb ea df 01");
# SENDDATA(data1);
# VAR data2 := "{\"name\":\"John\", \"age\":32}";
# SENDDATA(data2);
# VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1");
# SENDDATA(data3);
# Process received TCP or UDP data and set device values in the Listener script
#
#
# Download data from FTP:
# FTPDOWNLOAD("filePath");
```

L1 Voltage Variable Read-only

numeric Unit: V json\_path

Read

```taphome
VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]");
VAR b := SPLIT(a,",");
RETURN(TODOUBLE(GETAT(b,0)))
```

Write

```taphome
# Simple HTTP Request:
# VAR response := SENDHTTPREQUEST("/example/set/value=" + Va);
# IF response.IsSuccess = false
#  ADDERROR(response.StatusCode);
# END
#
# Set Http request method, body and headers
# VAR response := SENDHTTPREQUEST("/example/setValue", "GET", "value=" + Va, "header1:value1", "header2:value2", ...);\r
# Or VAR request := HTTPREQUEST("/example/setValue");
# request.Method := "PUT";
# VAR response := SENDHTTPREQUEST(request);
#r
#
# Send TCP, UDP data:
# VAR data1 := "{\"name\":\"John\", \"age\":" + Va + "}";
# SENDDATA(data1);
# VAR data2 := TOBYTES("{\"name\":\"John\", \"age\":" + Va + "}", "iso-8859-1");
# SENDDATA(data2);
# You can process received TCP or UDP data in the Listener script
#
#
# Upload data to FTP:
# FTPUPLOAD("filePath", "somedata=" + Va, "write"); # use "append" mode to append data to existing file
```

Read (module)

```taphome
# Simple HTTP Request:
# VAR response := SENDHTTPREQUEST("/example/getValue");
# IF response.IsSuccess
#  VAR content := response.Content;
#  VAR responseHeaders := response.Headers;
#  RETURN(PARSEXML(content, "//element1/value1"));
# ELSE
#  ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")");
#  RETURN(NaN);
# END
#
# Set Http request method, body and headers
# VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...);
# OR
# VAR request := HTTPREQUEST("/example/getValue", "POST", "some data");
# request.headers := { "header1:value1", "header2:value2", ...};
# request.method := "GET";
# request.data := null;
# VAR response := SENDHTTPREQUEST(request);
#
#
# Send TCP, UDP data:
# VAR data1 := BYTECOLLECTION("0a bb ea df 01");
# SENDDATA(data1);
# VAR data2 := "{\"name\":\"John\", \"age\":32}";
# SENDDATA(data2);
# VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1");
# SENDDATA(data3);
# Process received TCP or UDP data and set device values in the Listener script
#
#
# Download data from FTP:
# FTPDOWNLOAD("filePath");
```

L2 Current Variable Read-only

numeric Unit: A json\_path

Read

```taphome
VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]");
VAR b := SPLIT(a,",");
RETURN(TODOUBLE(GETAT(b,5)))
```

Write

```taphome
# Simple HTTP Request:
# VAR response := SENDHTTPREQUEST("/example/set/value=" + Va);
# IF response.IsSuccess = false
#  ADDERROR(response.StatusCode);
# END
#
# Set Http request method, body and headers
# VAR response := SENDHTTPREQUEST("/example/setValue", "GET", "value=" + Va, "header1:value1", "header2:value2", ...);\r
# Or VAR request := HTTPREQUEST("/example/setValue");
# request.Method := "PUT";
# VAR response := SENDHTTPREQUEST(request);
#r
#
# Send TCP, UDP data:
# VAR data1 := "{\"name\":\"John\", \"age\":" + Va + "}";
# SENDDATA(data1);
# VAR data2 := TOBYTES("{\"name\":\"John\", \"age\":" + Va + "}", "iso-8859-1");
# SENDDATA(data2);
# You can process received TCP or UDP data in the Listener script
#
#
# Upload data to FTP:
# FTPUPLOAD("filePath", "somedata=" + Va, "write"); # use "append" mode to append data to existing file
```

Read (module)

```taphome
# Simple HTTP Request:
# VAR response := SENDHTTPREQUEST("/example/getValue");
# IF response.IsSuccess
#  VAR content := response.Content;
#  VAR responseHeaders := response.Headers;
#  RETURN(PARSEXML(content, "//element1/value1"));
# ELSE
#  ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")");
#  RETURN(NaN);
# END
#
# Set Http request method, body and headers
# VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...);
# OR
# VAR request := HTTPREQUEST("/example/getValue", "POST", "some data");
# request.headers := { "header1:value1", "header2:value2", ...};
# request.method := "GET";
# request.data := null;
# VAR response := SENDHTTPREQUEST(request);
#
#
# Send TCP, UDP data:
# VAR data1 := BYTECOLLECTION("0a bb ea df 01");
# SENDDATA(data1);
# VAR data2 := "{\"name\":\"John\", \"age\":32}";
# SENDDATA(data2);
# VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1");
# SENDDATA(data3);
# Process received TCP or UDP data and set device values in the Listener script
#
#
# Download data from FTP:
# FTPDOWNLOAD("filePath");
```

L2 Voltage Variable Read-only

numeric Unit: V json\_path

Read

```taphome
VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]");
VAR b := SPLIT(a,",");
RETURN(TODOUBLE(GETAT(b,1)))
```

Write

```taphome
# Simple HTTP Request:
# VAR response := SENDHTTPREQUEST("/example/set/value=" + Va);
# IF response.IsSuccess = false
#  ADDERROR(response.StatusCode);
# END
#
# Set Http request method, body and headers
# VAR response := SENDHTTPREQUEST("/example/setValue", "GET", "value=" + Va, "header1:value1", "header2:value2", ...);\r
# Or VAR request := HTTPREQUEST("/example/setValue");
# request.Method := "PUT";
# VAR response := SENDHTTPREQUEST(request);
#r
#
# Send TCP, UDP data:
# VAR data1 := "{\"name\":\"John\", \"age\":" + Va + "}";
# SENDDATA(data1);
# VAR data2 := TOBYTES("{\"name\":\"John\", \"age\":" + Va + "}", "iso-8859-1");
# SENDDATA(data2);
# You can process received TCP or UDP data in the Listener script
#
#
# Upload data to FTP:
# FTPUPLOAD("filePath", "somedata=" + Va, "write"); # use "append" mode to append data to existing file
```

Read (module)

```taphome
# Simple HTTP Request:
# VAR response := SENDHTTPREQUEST("/example/getValue");
# IF response.IsSuccess
#  VAR content := response.Content;
#  VAR responseHeaders := response.Headers;
#  RETURN(PARSEXML(content, "//element1/value1"));
# ELSE
#  ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")");
#  RETURN(NaN);
# END
#
# Set Http request method, body and headers
# VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...);
# OR
# VAR request := HTTPREQUEST("/example/getValue", "POST", "some data");
# request.headers := { "header1:value1", "header2:value2", ...};
# request.method := "GET";
# request.data := null;
# VAR response := SENDHTTPREQUEST(request);
#
#
# Send TCP, UDP data:
# VAR data1 := BYTECOLLECTION("0a bb ea df 01");
# SENDDATA(data1);
# VAR data2 := "{\"name\":\"John\", \"age\":32}";
# SENDDATA(data2);
# VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1");
# SENDDATA(data3);
# Process received TCP or UDP data and set device values in the Listener script
#
#
# Download data from FTP:
# FTPDOWNLOAD("filePath");
```

L3 Current Variable Read-only

numeric Unit: A json\_path

Read

```taphome
VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]");
VAR b := SPLIT(a,",");
RETURN(TODOUBLE(GETAT(b,6)))
```

Write

```taphome
# Simple HTTP Request:
# VAR response := SENDHTTPREQUEST("/example/set/value=" + Va);
# IF response.IsSuccess = false
#  ADDERROR(response.StatusCode);
# END
#
# Set Http request method, body and headers
# VAR response := SENDHTTPREQUEST("/example/setValue", "GET", "value=" + Va, "header1:value1", "header2:value2", ...);\r
# Or VAR request := HTTPREQUEST("/example/setValue");
# request.Method := "PUT";
# VAR response := SENDHTTPREQUEST(request);
#r
#
# Send TCP, UDP data:
# VAR data1 := "{\"name\":\"John\", \"age\":" + Va + "}";
# SENDDATA(data1);
# VAR data2 := TOBYTES("{\"name\":\"John\", \"age\":" + Va + "}", "iso-8859-1");
# SENDDATA(data2);
# You can process received TCP or UDP data in the Listener script
#
#
# Upload data to FTP:
# FTPUPLOAD("filePath", "somedata=" + Va, "write"); # use "append" mode to append data to existing file
```

Read (module)

```taphome
# Simple HTTP Request:
# VAR response := SENDHTTPREQUEST("/example/getValue");
# IF response.IsSuccess
#  VAR content := response.Content;
#  VAR responseHeaders := response.Headers;
#  RETURN(PARSEXML(content, "//element1/value1"));
# ELSE
#  ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")");
#  RETURN(NaN);
# END
#
# Set Http request method, body and headers
# VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...);
# OR
# VAR request := HTTPREQUEST("/example/getValue", "POST", "some data");
# request.headers := { "header1:value1", "header2:value2", ...};
# request.method := "GET";
# request.data := null;
# VAR response := SENDHTTPREQUEST(request);
#
#
# Send TCP, UDP data:
# VAR data1 := BYTECOLLECTION("0a bb ea df 01");
# SENDDATA(data1);
# VAR data2 := "{\"name\":\"John\", \"age\":32}";
# SENDDATA(data2);
# VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1");
# SENDDATA(data3);
# Process received TCP or UDP data and set device values in the Listener script
#
#
# Download data from FTP:
# FTPDOWNLOAD("filePath");
```

L3 Voltage Variable Read-only

numeric Unit: V json\_path

Read

```taphome
VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]");
VAR b := SPLIT(a,",");
RETURN(TODOUBLE(GETAT(b,2)))
```

Write

```taphome
# Simple HTTP Request:
# VAR response := SENDHTTPREQUEST("/example/set/value=" + Va);
# IF response.IsSuccess = false
#  ADDERROR(response.StatusCode);
# END
#
# Set Http request method, body and headers
# VAR response := SENDHTTPREQUEST("/example/setValue", "GET", "value=" + Va, "header1:value1", "header2:value2", ...);\r
# Or VAR request := HTTPREQUEST("/example/setValue");
# request.Method := "PUT";
# VAR response := SENDHTTPREQUEST(request);
#r
#
# Send TCP, UDP data:
# VAR data1 := "{\"name\":\"John\", \"age\":" + Va + "}";
# SENDDATA(data1);
# VAR data2 := TOBYTES("{\"name\":\"John\", \"age\":" + Va + "}", "iso-8859-1");
# SENDDATA(data2);
# You can process received TCP or UDP data in the Listener script
#
#
# Upload data to FTP:
# FTPUPLOAD("filePath", "somedata=" + Va, "write"); # use "append" mode to append data to existing file
```

Read (module)

```taphome
# Simple HTTP Request:
# VAR response := SENDHTTPREQUEST("/example/getValue");
# IF response.IsSuccess
#  VAR content := response.Content;
#  VAR responseHeaders := response.Headers;
#  RETURN(PARSEXML(content, "//element1/value1"));
# ELSE
#  ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")");
#  RETURN(NaN);
# END
#
# Set Http request method, body and headers
# VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...);
# OR
# VAR request := HTTPREQUEST("/example/getValue", "POST", "some data");
# request.headers := { "header1:value1", "header2:value2", ...};
# request.method := "GET";
# request.data := null;
# VAR response := SENDHTTPREQUEST(request);
#
#
# Send TCP, UDP data:
# VAR data1 := BYTECOLLECTION("0a bb ea df 01");
# SENDDATA(data1);
# VAR data2 := "{\"name\":\"John\", \"age\":32}";
# SENDDATA(data2);
# VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1");
# SENDDATA(data3);
# Process received TCP or UDP data and set device values in the Listener script
#
#
# Download data from FTP:
# FTPDOWNLOAD("filePath");
```

Phase Switching Multi-value Switch Read and write

Phase configuration — Automatic (charger decides), 1-Phase (forced), 3-Phase (forced). Can switch during active charging.

uint8

Values / States: Automatic · 1-Phase · 3-Phase

Read switch state

```taphome
RETURN(PARSEjson(responseJson, "psm"));
```

Write switch state

```taphome
VAR response := SENDHTTPREQUEST("api/set?psm=" + Mu);
IF response.IsSuccess = false
ADDERROR(response.StatusCode);
END
```

Power to Grid Variable Read and write

Write-only — sends external grid power data (kW) to the charger for surplus charging calculations

numeric Unit: kW json\_path

Write

```taphome
VAR pgrid := "{\"pGrid\":"+ Round(Va*1000)+"}";

VAR response := SENDHTTPREQUEST("api/set?ids=" + pgrid);

IF response.IsSuccess = false
ADDERROR(response.StatusCode);
END
```

Read (module)

```taphome
# Simple HTTP Request:
# VAR response := SENDHTTPREQUEST("/example/getValue");
# IF response.IsSuccess
#  VAR content := response.Content;
#  VAR responseHeaders := response.Headers;
#  RETURN(PARSEXML(content, "//element1/value1"));
# ELSE
#  ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")");
#  RETURN(NaN);
# END
#
# Set Http request method, body and headers
# VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...);
# OR
# VAR request := HTTPREQUEST("/example/getValue", "POST", "some data");
# request.headers := { "header1:value1", "header2:value2", ...};
# request.method := "GET";
# request.data := null;
# VAR response := SENDHTTPREQUEST(request);
#
#
# Send TCP, UDP data:
# VAR data1 := BYTECOLLECTION("0a bb ea df 01");
# SENDDATA(data1);
# VAR data2 := "{\"name\":\"John\", \"age\":32}";
# SENDDATA(data2);
# VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1");
# SENDDATA(data3);
# Process received TCP or UDP data and set device values in the Listener script
#
#
# Download data from FTP:
# FTPDOWNLOAD("filePath");
```

PV Power Variable Read and write

Write-only — sends external PV production data (kW) to the charger for surplus charging calculations

numeric Unit: kW json\_path

Write

```taphome
VAR pPv := "{\"pPv\":"+ Round(Va*1000)+"}";

VAR response := SENDHTTPREQUEST("api/set?ids=" + pPv);

IF response.IsSuccess = false
ADDERROR(response.StatusCode);
END
```

Read (module)

```taphome
# Simple HTTP Request:
# VAR response := SENDHTTPREQUEST("/example/getValue");
# IF response.IsSuccess
#  VAR content := response.Content;
#  VAR responseHeaders := response.Headers;
#  RETURN(PARSEXML(content, "//element1/value1"));
# ELSE
#  ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")");
#  RETURN(NaN);
# END
#
# Set Http request method, body and headers
# VAR response := SENDHTTPREQUEST("/example/getValue", "GET", "some data", "header1:value1", "header2:value2", ...);
# OR
# VAR request := HTTPREQUEST("/example/getValue", "POST", "some data");
# request.headers := { "header1:value1", "header2:value2", ...};
# request.method := "GET";
# request.data := null;
# VAR response := SENDHTTPREQUEST(request);
#
#
# Send TCP, UDP data:
# VAR data1 := BYTECOLLECTION("0a bb ea df 01");
# SENDDATA(data1);
# VAR data2 := "{\"name\":\"John\", \"age\":32}";
# SENDDATA(data2);
# VAR data3 := TOBYTES("{\"name\":\"John\", \"age\":32}", "iso-8859-1");
# SENDDATA(data3);
# Process received TCP or UDP data and set device values in the Listener script
#
#
# Download data from FTP:
# FTPDOWNLOAD("filePath");
```

Wallbox Electric Meter Electricity Meter Read-only

Energy meter — total energy delivered by the charger (eto) and instantaneous charging power

numeric Unit: kWh json\_path

Read total consumption

```taphome
RETURN(PARSEjson(responseJson, "eto"))
```

Read demand

```taphome
VAR a := PARSETEXT (PARSEjson(responseJson, "nrg"), "[", "]");
VAR b := SPLIT(a,",");
RETURN(TODOUBLE(GETAT(b,11))/1000)
```

**Connection:** Packet Parser → HTTP

Possible improvements (18)

- Voltage N — Neutral voltage in V, available in nrg array index 3
- Per-phase Power (L1, L2, L3) — Individual phase power in W — the template reads only element 11 (demand of the Wallbox Electric Meter)
- Power Total — Total power in W. The former 'Current consumption' device read this element; the Wallbox Electric Meter that replaced it reads element 11 instead. See inconsistency report
- Power Factor (L1, L2, L3) — Power factor per phase, available in nrg array
- Session Energy — Energy consumed in current charging session (Wh)
- Error State — Error code — None, FiAc, FiDc, Phase, Overvolt, Overamp, etc. Useful for diagnostics.
- Allow Charging — Whether the car is presently allowed to charge
- Force State — Force charger state: Neutral=0, Off=1, On=2. Read/write. Could override charging logic.
- Cable Current Limit — Maximum current the connected cable supports (A)
- Temperature Sensors — Controller and charger temperature sensors array
- Grid Frequency — Grid frequency in Hz
- Firmware Version — Current firmware version string
- Serial Number — Device serial number
- Uptime — Time since boot in milliseconds
- Energy Limit — Charging energy limit in Wh (null=disabled). Read/write.
- Ampere Maximum — Maximum ampere limit (R/W)
- Minimum Charging Current — Minimum charging current (R/W)
- PV Surplus Feature — Enable/disable PV surplus charging (boolean, R/W)

## Import parameters

Enter these values when you import the XML.

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

## Sources

- go-eCharger API v2 — HTTP API Reference
  
  [github.com](https://github.com/goecharger/go-eCharger-API-v2) 2026-03-27
- go-e Charger Gemini flex — Data Sheet V1.4
  
  [go-e.com](https://go-e.com/fileadmin/Support/Anleitungen/Englisch/go-e-gemini-flex-datasheet.pdf) 2026-03-27
  
  [PDF](https://taphome.com/compatibility/devices/go-e-wallbox/manufacturer/go-e-gemini-flex-datasheet.pdf)
- ha-goecharger-api2 — Home Assistant Integration
  
  [github.com](https://github.com/marq24/ha-goecharger-api2) 2026-03-27

Manufacturer documents are © their respective owners. They are provided as published by the manufacturer, for reference only.

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