---
title: "OKTE Spotpreise"
description: "OKTE Day-Ahead-Spotpreise für Elektrizität in der Slowakei. Überwachung stündlicher EUR/MWh-Preise, Rankings, Min/Max/Durchschnitt und Zeitfensteranalyse."
url: "https://taphome.com/de/compatibility/okte-spot-prices/"
language: de
lastmod: 2026-10-08
generator: hugo
ai:
  topics: ["http","data-service","data-pp","spot-prices","electricity-market","energy-management","packet-parser"]
  questions: ["Wie integriert man OKTE-Spotpreise mit TapHome?","Was bietet die OKTE-Spotpreise-TapHome-Vorlage?","Wie automatisiert man Geräte basierend auf dem Spotpreis für Elektrizität?","Wie funktioniert die OKTE-Zeitfensterfunktion (Von/Bis)?","Wie findet man die günstigste Stunde des Tages in TapHome?","Was ist der aktuelle Periodenrang bei den OKTE-Spotpreisen?"]
---

# OKTE Spotpreise

Kommunikation: Packet Parser → HTTP

- [Offizielle OKTE-Website](https://www.okte.sk/)
- [OKTE ISOT Marktdaten](https://isot.okte.sk/)

## Integrationsanleitung

OKTE (Organizátor krátkodobého trhu s elektrinou) ist der slowakische Strommarktbetreiber. Er veröffentlicht Day-Ahead-Markt (DAM) Spotpreise — den stündlichen Großhandelspreis für Elektrizität in EUR/MWh, der durch die Auktion des Vortages bestimmt wird.

Die TapHome-Vorlage ruft diese Preise über HTTP Packet Parser von der öffentlichen OKTE-API (`isot.okte.sk`) ab. Sie liefert den Preis der aktuellen Stunde, Preisrankings, Min/Max/Durchschnittsberechnungen und Zeitfensteranalysen — alles wird automatisch jede Stunde aktualisiert. Keine Authentifizierung erforderlich.

## Konfiguration

Die Vorlage verbindet sich mit `isot.okte.sk` über HTTPS (Port 443). Keine IP-Adresse oder Zugangsdaten erforderlich — der Endpunkt ist eine öffentliche API.

Beim Vorlagenimport können zwei optionale benutzerdefinierte Variablen festgelegt werden:

- **Von** — Startstunde eines benutzerdefinierten Zeitfensters (0–23, Standard: 9)
- **Bis** — Endstunde eines benutzerdefinierten Zeitfensters (0–23, Standard: 17)

Diese Variablen steuern die Gerätevarianten „im Zeitfenster". Die Standardwerte (9–17) decken die üblichen Arbeitszeiten ab. Falls nicht benötigt, belassen Sie sie auf den Standardwerten — die Ganztagesgeräte funktionieren unabhängig.

## Funktionsweise

Das Modul fragt die OKTE-DAM-API einmal pro Stunde ab (Intervall 3600 s). Die API-Anfrage verwendet das heutige Datum:

```
GET /api/v1/dam/results?deliveryDayFrom={today}&deliveryDayTo={today}
```

Die Antwort enthält ein Array von Preisobjekten, jeweils mit einer `period`-Nummer und einem `price` in EUR/MWh. Je nach Tageszeit und OKTE-Veröffentlichungszeitplan kann die Antwort Preise nur für heute (24 Perioden) oder für bis zu 3 Tage (72 Perioden) enthalten.

Jedes Geräteskript parst dieses JSON-Array mit `PARSEJSON(output, "$..price")` und wendet Sortier-, Filter- oder Aggregationsfunktionen an, um seinen Wert abzuleiten.

## Gerätefähigkeiten

Die Vorlage stellt 13 Sensorgeräte bereit. Alle sind schreibgeschützt — sie leiten Werte aus derselben API-Antwort ab.

### Aktueller Preis und Rang

- **Aktueller Preis** — der Spotpreis für die aktuelle Stundenperiode in EUR/MWh. Das Skript bestimmt den aktuellen Periodenindex aus `NOW()` und gibt den entsprechenden Preis aus dem Array zurück.
- **Aktueller Periodenrang** — der Rang des Preises der aktuellen Stunde unter allen verfügbaren Perioden (1 = günstigste). Nützlich für Automatisierungsregeln wie „Wärmepumpe nur einschalten, wenn die aktuelle Stunde zu den 8 günstigsten gehört."
- **Aktueller Periodenrang im Zeitfenster** — wie oben, aber begrenzt auf das benutzerdefinierte Von–Bis-Fenster. Gibt NaN zurück, wenn die aktuelle Stunde außerhalb des Fensters liegt oder wenn Von >= Bis.

### Preisextreme

- **Höchster Tagespreis** — maximaler Spotpreis über alle verfügbaren Perioden
- **Niedrigster Tagespreis** — minimaler Spotpreis über alle verfügbaren Perioden
- **Höchster Preis im Zeitfenster** — maximaler Preis innerhalb des Von–Bis-Fensters
- **Niedrigster Preis im Zeitfenster** — minimaler Preis innerhalb des Von–Bis-Fensters

### Durchschnitte

- **Durchschnittlicher Tagespreis** — arithmetisches Mittel aller verfügbaren Periodenpreise
- **Durchschnittlicher Preis im Zeitfenster** — arithmetisches Mittel innerhalb des Von–Bis-Fensters

### Periodenidentifikation

- **Günstigste Periode des Tages** — die 1-basierte Periodennummer der günstigsten Stunde (z.B. 3 bedeutet 02:00–03:00)
- **Günstigste verbleibende Periode** — die günstigste Stunde ab der aktuellen Stunde. Aktualisiert sich dynamisch im Tagesverlauf.

### Anzahlen

- **Periodenanzahl** — Gesamtzahl der Preisperioden in der API-Antwort (typischerweise 24 oder 72)
- **Periodenanzahl im Zeitfenster** — Anzahl der Perioden innerhalb des Von–Bis-Fensters

## Service-Attribute

Das Modul stellt bis zu 96 Service-Attribute bereit (Periode 1 bis Periode 96), die jeweils den Spotpreis für die jeweilige 15-Minuten-Periode als Zeichenkette mit „EUR"-Suffix anzeigen. Seit OKTE den Day-Ahead-Markt auf 15-Minuten-Perioden umgestellt hat, sind für einen Tag alle 96 Attribute ausgefüllt.

Diese Attribute bieten einen vollständigen Preisplan, der in der TapHome-Moduldetailansicht sichtbar ist.

## Benutzerdefinierte Variablen (Von / Bis)

Mehrere Geräte haben Varianten „im Zeitfenster", die die Preisdaten auf eine Teilmenge von Stunden filtern. Das Fenster wird durch zwei benutzerdefinierte Variablen definiert, die beim Vorlagenimport festgelegt werden:

- **Von** — die Startstunde (einschließlich), Wert 0–23
- **Bis** — die Endstunde (ausschließlich), Wert 0–23

Zum Beispiel analysiert die Einstellung Von=8 und Bis=16 Preise nur zwischen 08:00 und 16:00. Dies ist nützlich, wenn Sie den Energieverbrauch zu bestimmten Zeiten optimieren möchten — etwa Geräte nur während der günstigsten Stunden Ihres Arbeitstages laufen lassen.

Wenn Von >= Bis, geben alle Fenstergeräte NaN zurück.

## Automatisierungsbeispiele

### Geräte während der günstigsten Stunden betreiben

Verwenden Sie das Gerät **Aktueller Periodenrang** in einer smart rule Bedingung. Um beispielsweise eine Poolpumpe nur während der 6 günstigsten Stunden des Tages zu betreiben:

- Bedingung: Aktueller Periodenrang <= 6
- Aktion: Poolpumpe einschalten

### Spitzenpreise vermeiden

Verwenden Sie das Gerät **Aktueller Preis** mit einem Schwellenwert:

- Bedingung: Aktueller Preis > 150 (EUR/MWh)
- Aktion: Nicht wesentliche Verbraucher ausschalten

### Zeitfensteroptimierung

Setzen Sie Von=0, Bis=6, um ein Nachtfenster (Mitternacht bis 06:00) zu definieren, und verwenden Sie dann **Niedrigster Preis im Zeitfenster** oder **Aktueller Periodenrang im Zeitfenster**, um das Laden der Batterie oder den Betrieb des Warmwasserbereiters während der günstigsten Nachtstunden zu planen. Fenster über Mitternacht (Von >= Bis) werden nicht unterstützt.

## Fehlerbehebung

### Alle Geräte zeigen Null oder keine Daten an

1. Prüfen Sie die Internetverbindung am TapHome Core — die Vorlage erfordert ausgehenden HTTPS-Zugang zu `isot.okte.sk`
2. Überprüfen Sie, ob die API antwortet — öffnen Sie `https://isot.okte.sk/api/v1/dam/results?deliveryDayFrom=2026-03-28&deliveryDayTo=2026-03-28` im Browser
3. DAM-Preise für den nächsten Tag werden typischerweise nach 12:45 CET veröffentlicht. Vor der Veröffentlichung liefern Anfragen für das morgige Datum leere Ergebnisse.

### Fenstergeräte geben NaN zurück

1. Überprüfen Sie, dass Von < Bis in den Vorlagenimport-Parametern
2. Prüfen Sie, ob die aktuelle Stunde in den Von–Bis-Bereich fällt (für Aktueller Periodenrang im Zeitfenster)
3. Beachten Sie, dass Von und Bis das 24-Stunden-Format verwenden (0–23)

### Preiswerte erscheinen falsch

OKTE veröffentlicht Preise in EUR/MWh. Zur Umrechnung in EUR/kWh (Haushaltsmaßstab) teilen Sie durch 1000. Die Vorlage zeigt Rohwerte aus der API ohne Umrechnung an.

## Verfügbare Geräte 13

Diese Geräte erscheinen nach dem Import in TapHome.

OKTE Spotpreise Modul

Serviceattribute

|           |
|-----------|
| Period 1  |
| Period 2  |
| Period 3  |
| Period 4  |
| Period 5  |
| Period 6  |
| Period 7  |
| Period 8  |
| Period 9  |
| Period 10 |
| Period 11 |
| Period 12 |
| Period 13 |
| Period 14 |
| Period 15 |
| Period 16 |
| Period 17 |
| Period 18 |
| Period 19 |
| Period 20 |
| Period 21 |
| Period 22 |
| Period 23 |
| Period 24 |
| Period 25 |
| Period 26 |
| Period 27 |
| Period 28 |
| Period 29 |
| Period 30 |
| Period 31 |
| Period 32 |
| Period 33 |
| Period 34 |
| Period 35 |
| Period 36 |
| Period 37 |
| Period 38 |
| Period 39 |
| Period 40 |
| Period 41 |
| Period 42 |
| Period 43 |
| Period 44 |
| Period 45 |
| Period 46 |
| Period 47 |
| Period 48 |
| Period 49 |
| Period 50 |
| Period 51 |
| Period 52 |
| Period 53 |
| Period 54 |
| Period 55 |
| Period 56 |
| Period 57 |
| Period 58 |
| Period 59 |
| Period 60 |
| Period 61 |
| Period 62 |
| Period 63 |
| Period 64 |
| Period 65 |
| Period 66 |
| Period 67 |
| Period 68 |
| Period 69 |
| Period 70 |
| Period 71 |
| Period 72 |
| Period 73 |
| Period 74 |
| Period 75 |
| Period 76 |
| Period 77 |
| Period 78 |
| Period 79 |
| Period 80 |
| Period 81 |
| Period 82 |
| Period 83 |
| Period 84 |
| Period 85 |
| Period 86 |
| Period 87 |
| Period 88 |
| Period 89 |
| Period 90 |
| Period 91 |
| Period 92 |
| Period 93 |
| Period 94 |
| Period 95 |
| Period 96 |

Benutzerdefinierte Variablen

|                      |                                                                                   |
|----------------------|-----------------------------------------------------------------------------------|
| `From` (numeric) = 9 | Startstunde (0–23) des Zeitfensters für die Fensterpreisrangfolge und Statistiken |
| `To` (numeric) = 17  | Endstunde (0–23) des Zeitfensters für die Fensterpreisrangfolge und Statistiken   |

Lesen (Modul)

```taphome
VAR today := tostring(NOW(), "yyyy-MM-dd");;
VAR response := SENDHTTPREQUEST("/api/v1/dam/results?deliveryDayFrom=" + today + "&deliveryDayTo=" + today);
IF response.IsSuccess
    output := response.Content;
ELSE
    ADDERROR(response.StatusCode + " (" + response.ReasonPhrase + ")");
END
```

Serviceattribute

Perióda 1

```taphome
PARSEJSON(output, "$[?(@.period == 1)].price") + " EUR"
```

Perióda 2

```taphome
PARSEJSON(output, "$[?(@.period == 2)].price") + " EUR"
```

Perióda 3

```taphome
PARSEJSON(output, "$[?(@.period == 3)].price") + " EUR"
```

Perióda 4

```taphome
PARSEJSON(output, "$[?(@.period == 4)].price") + " EUR"
```

Perióda 5

```taphome
PARSEJSON(output, "$[?(@.period == 5)].price") + " EUR"
```

Perióda 6

```taphome
PARSEJSON(output, "$[?(@.period == 6)].price") + " EUR"
```

Perióda 7

```taphome
PARSEJSON(output, "$[?(@.period == 7)].price") + " EUR"
```

Perióda 8

```taphome
PARSEJSON(output, "$[?(@.period == 8)].price") + " EUR"
```

Perióda 9

```taphome
PARSEJSON(output, "$[?(@.period == 9)].price") + " EUR"
```

Perióda 10

```taphome
PARSEJSON(output, "$[?(@.period == 10)].price") + " EUR"
```

Perióda 11

```taphome
PARSEJSON(output, "$[?(@.period == 11)].price") + " EUR"
```

Perióda 12

```taphome
PARSEJSON(output, "$[?(@.period == 12)].price") + " EUR"
```

Perióda 13

```taphome
PARSEJSON(output, "$[?(@.period == 13)].price") + " EUR"
```

Perióda 14

```taphome
PARSEJSON(output, "$[?(@.period == 14)].price") + " EUR"
```

Perióda 15

```taphome
PARSEJSON(output, "$[?(@.period == 15)].price") + " EUR"
```

Perióda 16

```taphome
PARSEJSON(output, "$[?(@.period == 16)].price") + " EUR"
```

Perióda 17

```taphome
PARSEJSON(output, "$[?(@.period == 17)].price") + " EUR"
```

Perióda 18

```taphome
PARSEJSON(output, "$[?(@.period == 18)].price") + " EUR"
```

Perióda 19

```taphome
PARSEJSON(output, "$[?(@.period == 19)].price") + " EUR"
```

Perióda 20

```taphome
PARSEJSON(output, "$[?(@.period == 20)].price") + " EUR"
```

Perióda 21

```taphome
PARSEJSON(output, "$[?(@.period == 21)].price") + " EUR"
```

Perióda 22

```taphome
PARSEJSON(output, "$[?(@.period == 22)].price") + " EUR"
```

Perióda 23

```taphome
PARSEJSON(output, "$[?(@.period == 23)].price") + " EUR"
```

Perióda 24

```taphome
PARSEJSON(output, "$[?(@.period == 24)].price") + " EUR"
```

Perióda 25

```taphome
PARSEJSON(output, "$[?(@.period == 25)].price") + " EUR"
```

Perióda 26

```taphome
PARSEJSON(output, "$[?(@.period == 26)].price") + " EUR"
```

Perióda 27

```taphome
PARSEJSON(output, "$[?(@.period == 27)].price") + " EUR"
```

Perióda 28

```taphome
PARSEJSON(output, "$[?(@.period == 28)].price") + " EUR"
```

Perióda 29

```taphome
PARSEJSON(output, "$[?(@.period == 29)].price") + " EUR"
```

Perióda 30

```taphome
PARSEJSON(output, "$[?(@.period == 30)].price") + " EUR"
```

Perióda 31

```taphome
PARSEJSON(output, "$[?(@.period == 31)].price") + " EUR"
```

Perióda 32

```taphome
PARSEJSON(output, "$[?(@.period == 32)].price") + " EUR"
```

Perióda 33

```taphome
PARSEJSON(output, "$[?(@.period == 33)].price") + " EUR"
```

Perióda 34

```taphome
PARSEJSON(output, "$[?(@.period == 34)].price") + " EUR"
```

Perióda 35

```taphome
PARSEJSON(output, "$[?(@.period == 35)].price") + " EUR"
```

Perióda 36

```taphome
PARSEJSON(output, "$[?(@.period == 36)].price") + " EUR"
```

Perióda 37

```taphome
PARSEJSON(output, "$[?(@.period == 37)].price") + " EUR"
```

Perióda 38

```taphome
PARSEJSON(output, "$[?(@.period == 38)].price") + " EUR"
```

Perióda 39

```taphome
PARSEJSON(output, "$[?(@.period == 39)].price") + " EUR"
```

Perióda 40

```taphome
PARSEJSON(output, "$[?(@.period == 40)].price") + " EUR"
```

Perióda 41

```taphome
PARSEJSON(output, "$[?(@.period == 41)].price") + " EUR"
```

Perióda 42

```taphome
PARSEJSON(output, "$[?(@.period == 42)].price") + " EUR"
```

Perióda 43

```taphome
PARSEJSON(output, "$[?(@.period == 43)].price") + " EUR"
```

Perióda 44

```taphome
PARSEJSON(output, "$[?(@.period == 44)].price") + " EUR"
```

Perióda 45

```taphome
PARSEJSON(output, "$[?(@.period == 45)].price") + " EUR"
```

Perióda 46

```taphome
PARSEJSON(output, "$[?(@.period == 46)].price") + " EUR"
```

Perióda 47

```taphome
PARSEJSON(output, "$[?(@.period == 47)].price") + " EUR"
```

Perióda 48

```taphome
PARSEJSON(output, "$[?(@.period == 48)].price") + " EUR"
```

Perióda 49

```taphome
PARSEJSON(output, "$[?(@.period == 49)].price") + " EUR"
```

Perióda 50

```taphome
PARSEJSON(output, "$[?(@.period == 50)].price") + " EUR"
```

Perióda 51

```taphome
PARSEJSON(output, "$[?(@.period == 51)].price") + " EUR"
```

Perióda 52

```taphome
PARSEJSON(output, "$[?(@.period == 52)].price") + " EUR"
```

Perióda 53

```taphome
PARSEJSON(output, "$[?(@.period == 53)].price") + " EUR"
```

Perióda 54

```taphome
PARSEJSON(output, "$[?(@.period == 54)].price") + " EUR"
```

Perióda 55

```taphome
PARSEJSON(output, "$[?(@.period == 55)].price") + " EUR"
```

Perióda 56

```taphome
PARSEJSON(output, "$[?(@.period == 56)].price") + " EUR"
```

Perióda 57

```taphome
PARSEJSON(output, "$[?(@.period == 57)].price") + " EUR"
```

Perióda 58

```taphome
PARSEJSON(output, "$[?(@.period == 58)].price") + " EUR"
```

Perióda 59

```taphome
PARSEJSON(output, "$[?(@.period == 59)].price") + " EUR"
```

Perióda 60

```taphome
PARSEJSON(output, "$[?(@.period == 60)].price") + " EUR"
```

Perióda 61

```taphome
PARSEJSON(output, "$[?(@.period == 61)].price") + " EUR"
```

Perióda 62

```taphome
PARSEJSON(output, "$[?(@.period == 62)].price") + " EUR"
```

Perióda 63

```taphome
PARSEJSON(output, "$[?(@.period == 63)].price") + " EUR"
```

Perióda 64

```taphome
PARSEJSON(output, "$[?(@.period == 64)].price") + " EUR"
```

Perióda 65

```taphome
PARSEJSON(output, "$[?(@.period == 65)].price") + " EUR"
```

Perióda 66

```taphome
PARSEJSON(output, "$[?(@.period == 66)].price") + " EUR"
```

Perióda 67

```taphome
PARSEJSON(output, "$[?(@.period == 67)].price") + " EUR"
```

Perióda 68

```taphome
PARSEJSON(output, "$[?(@.period == 68)].price") + " EUR"
```

Perióda 69

```taphome
PARSEJSON(output, "$[?(@.period == 69)].price") + " EUR"
```

Perióda 70

```taphome
PARSEJSON(output, "$[?(@.period == 70)].price") + " EUR"
```

Perióda 71

```taphome
PARSEJSON(output, "$[?(@.period == 71)].price") + " EUR"
```

Perióda 72

```taphome
PARSEJSON(output, "$[?(@.period == 72)].price") + " EUR"
```

Perióda 73

```taphome
PARSEJSON(output, "$[?(@.period == 73)].price") + " EUR"
```

Perióda 74

```taphome
PARSEJSON(output, "$[?(@.period == 74)].price") + " EUR"
```

Perióda 75

```taphome
PARSEJSON(output, "$[?(@.period == 75)].price") + " EUR"
```

Perióda 76

```taphome
PARSEJSON(output, "$[?(@.period == 76)].price") + " EUR"
```

Perióda 77

```taphome
PARSEJSON(output, "$[?(@.period == 77)].price") + " EUR"
```

Perióda 78

```taphome
PARSEJSON(output, "$[?(@.period == 78)].price") + " EUR"
```

Perióda 79

```taphome
PARSEJSON(output, "$[?(@.period == 79)].price") + " EUR"
```

Perióda 80

```taphome
PARSEJSON(output, "$[?(@.period == 80)].price") + " EUR"
```

Perióda 81

```taphome
PARSEJSON(output, "$[?(@.period == 81)].price") + " EUR"
```

Perióda 82

```taphome
PARSEJSON(output, "$[?(@.period == 82)].price") + " EUR"
```

Perióda 83

```taphome
PARSEJSON(output, "$[?(@.period == 83)].price") + " EUR"
```

Perióda 84

```taphome
PARSEJSON(output, "$[?(@.period == 84)].price") + " EUR"
```

Perióda 85

```taphome
PARSEJSON(output, "$[?(@.period == 85)].price") + " EUR"
```

Perióda 86

```taphome
PARSEJSON(output, "$[?(@.period == 86)].price") + " EUR"
```

Perióda 87

```taphome
PARSEJSON(output, "$[?(@.period == 87)].price") + " EUR"
```

Perióda 88

```taphome
PARSEJSON(output, "$[?(@.period == 88)].price") + " EUR"
```

Perióda 89

```taphome
PARSEJSON(output, "$[?(@.period == 89)].price") + " EUR"
```

Perióda 90

```taphome
PARSEJSON(output, "$[?(@.period == 90)].price") + " EUR"
```

Perióda 91

```taphome
PARSEJSON(output, "$[?(@.period == 91)].price") + " EUR"
```

Perióda 92

```taphome
PARSEJSON(output, "$[?(@.period == 92)].price") + " EUR"
```

Perióda 93

```taphome
PARSEJSON(output, "$[?(@.period == 93)].price") + " EUR"
```

Perióda 94

```taphome
PARSEJSON(output, "$[?(@.period == 94)].price") + " EUR"
```

Perióda 95

```taphome
PARSEJSON(output, "$[?(@.period == 95)].price") + " EUR"
```

Perióda 96

```taphome
PARSEJSON(output, "$[?(@.period == 96)].price") + " EUR"
```

Aktueller Preis Variable Nur lesen

Spotpreis für die aktuelle Stundenperiode in EUR/MWh — dynamisch aus dem Preisarray basierend auf der aktuellen Zeit ermittelt

numeric Einheit: EUR json\_path

Lesen

```taphome
var prices := PARSEJSON(output, "$..price");
VAR date := NOW();
var periodHour := LENGTH(prices) / 24;	
var actualperiod := FLOOR(((date.hour * 60) + date.minute) * periodHour / 60);

GETAT(prices, actualperiod)
```

Aktueller Periodenrang Variable Nur lesen

Rang des Preises der aktuellen Stunde unter allen Perioden (1 = günstigste Stunde des Tages)

numeric json\_path

Lesen

```taphome
var prices := PARSEJSON(output, "$..price");
var byPrice := ORDERINDEX(prices);
VAR date := NOW();
var periodHour := LENGTH(prices) / 24;	
var actualperiod := FLOOR(((date.hour * 60) + date.minute) * periodHour / 60);

INDEXOF(byPrice, actualperiod) + 1
```

Aktueller Periodenrang im Zeitfenster Variable Nur lesen

Rang des Preises der aktuellen Stunde innerhalb eines benutzerdefinierten Von–Bis-Zeitfensters — gibt NaN außerhalb des Fensters zurück

numeric json\_path

Lesen

```taphome
VAR date := NOW();
IF date.hour < From or date.hour > To or From >= To
	RETURN(NaN);
ELSE
	var prices := PARSEJSON(output, "$..price");
	var periodHour := LENGTH(prices) / 24;
	var windowPrices := COPY(prices, From * periodHour, (To - From) * periodHour);
	var byPrice := ORDERINDEX(windowPrices);
	
	var actualperiod := FLOOR(((date.hour * 60) + date.minute) * periodHour / 60);

	RETURN(INDEXOF(byPrice, actualperiod - From * periodHour) +1);
END
```

Höchster Tagespreis Variable Nur lesen

Maximaler Spotpreis über alle verfügbaren Perioden (EUR/MWh)

numeric Einheit: EUR json\_path

Lesen

```taphome
var prices := PARSEJSON(output, "$..price");
GETAT(ORDERDESC(prices), 0)
```

Höchster Preis im Zeitfenster Variable Nur lesen

Maximaler Spotpreis innerhalb des benutzerdefinierten Von–Bis-Zeitfensters (EUR/MWh)

numeric Einheit: EUR json\_path

Lesen

```taphome
VAR date := NOW();
IF From >= To
	RETURN(NaN);
ELSE
	var prices := PARSEJSON(output, "$..price");
	var periodHour := LENGTH(prices) / 24;	
	var actualperiod := FLOOR(((date.hour * 60) + date.minute) * periodHour / 60);
	var windowPrices := COPY(prices, From * periodHour, (To - From) * periodHour);
	var byPrice := ORDERDESC(windowPrices);

	RETURN(GETAT(byPrice, 0));
END
```

Niedrigster Tagespreis Variable Nur lesen

Minimaler Spotpreis über alle verfügbaren Perioden (EUR/MWh)

numeric Einheit: EUR json\_path

Lesen

```taphome
var prices := PARSEJSON(output, "$..price");
GETAT(ORDER(prices), 0)
```

Niedrigster Preis im Zeitfenster Variable Nur lesen

Minimaler Spotpreis innerhalb des benutzerdefinierten Von–Bis-Zeitfensters (EUR/MWh)

numeric Einheit: EUR json\_path

Lesen

```taphome
VAR date := NOW();
IF From >= To
	RETURN(NaN);
ELSE
	var prices := PARSEJSON(output, "$..price");
	var periodHour := LENGTH(prices) / 24;	
	#var actualperiod := FLOOR(((date.hour * 60) + date.minute) * periodHour / 60);
	var windowPrices := COPY(prices, From * periodHour, (To - From) * periodHour);
	var byPrice := ORDER(windowPrices);

	RETURN(GETAT(byPrice, 0));
END
```

Günstigste Periode des Tages Variable Nur lesen

1-basierte Periodennummer der günstigsten Stunde des Tages (z.B. 3 = 02:00–03:00)

numeric json\_path

Lesen

```taphome
var prices := PARSEJSON(output, "$..price");
GETAT(ORDERINDEX(prices), 0) +1
```

Günstigste verbleibende Periode Variable Nur lesen

1-basierte Periodennummer der günstigsten Stunde ab der aktuellen Stunde

numeric json\_path

Lesen

```taphome
var prices := PARSEJSON(output, "$..price");
VAR date := NOW();
var periodHour := LENGTH(prices) / 24;	
var actualperiod := FLOOR(((date.hour * 60) + date.minute) * periodHour / 60);
var remainingPrices := COPY(prices, actualperiod, LENGTH(prices) - actualperiod);
var byPrice := ORDERINDEX(remainingPrices);

GETAT(byPrice, 0) + actualperiod +1
```

Periodenanzahl Variable Nur lesen

Gesamtzahl der stündlichen Preisperioden in der API-Antwort (typischerweise 24 oder 72)

numeric json\_path

Lesen

```taphome
var prices := PARSEJSON(output, "$..price");
LENGTH(prices);
```

Periodenanzahl im Zeitfenster Variable Nur lesen

Anzahl der stündlichen Preisperioden innerhalb des benutzerdefinierten Von–Bis-Zeitfensters

numeric json\_path

Lesen

```taphome
VAR date := NOW();
IF From >= To
	RETURN(NaN);
ELSE
	var prices := PARSEJSON(output, "$..price");
	var periodHour := LENGTH(prices) / 24;
	var windowPrices := COPY(prices, From * periodHour, (To - From) * periodHour);

	RETURN(LENGTH(windowPrices));
END
```

Durchschnittlicher Tagespreis Variable Nur lesen

Arithmetisches Mittel aller verfügbaren Periodenpreise (EUR/MWh)

numeric Einheit: EUR json\_path

Lesen

```taphome
var prices := PARSEJSON(output, "$..price");
AVG(prices)
```

Durchschnittlicher Preis im Zeitfenster Variable Nur lesen

Arithmetisches Mittel der Spotpreise innerhalb des benutzerdefinierten Von–Bis-Zeitfensters (EUR/MWh)

numeric Einheit: EUR json\_path

Lesen

```taphome
VAR date := NOW();
IF From >= To
	RETURN(NaN);
ELSE
	var prices := PARSEJSON(output, "$..price");
	var periodHour := LENGTH(prices) / 24;	
	#var actualperiod := FLOOR(((date.hour * 60) + date.minute) * periodHour / 60);
	var windowPrices := COPY(prices, From * periodHour, (To - From) * periodHour);

	RETURN(AVG(windowPrices));
END
```

**Verbindung:** Packet Parser → HTTP

## Verwandte Dokumentation

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