Wie ich eine kostenlose Strompreis-API für Deutschland gebaut habe
Es gibt erstaunlich viele APIs für Krypto-Kurse, Wetter und Aktien — aber eine einfache, kostenlose API für den deutschen Strompreis? Die musste ich erst bauen. In diesem Artikel zeige ich dir, wie die Strompreis-API auf strom.nevik.de funktioniert, wie sie technisch aufgebaut ist und vor allem: wie du sie in deinen eigenen Projekten nutzen kannst.
👉 API-Dokumentation: strom.nevik.de/api/
Warum eine Strompreis-API?
Die Idee entstand aus einem konkreten Problem. Ich wollte einen Strompreis-Rechner bauen und brauchte aktuelle, verlässliche Preisdaten für Deutschland. Die vorhandenen Optionen waren:
- BNetzA (Bundesnetzagentur): Hat Daten, aber als Excel-Downloads, nicht als API
- SMARD: Bietet eine API, aber sie ist unzuverlässig, unvollständig dokumentiert und liefert Rohdaten, die erst aufbereitet werden müssen
- EEX: Kommerziell, teuer, für professionelle Händler
- Kommerzielle APIs: 50-500€/Monat
Also habe ich beschlossen, die Datenquellen selbst zu aggregieren und eine saubere, kostenlose JSON-API bereitzustellen — für alle Entwickler, die das gleiche Problem haben.
Die drei Endpoints
Die API ist bewusst minimalistisch gehalten. Drei Endpoints, klares JSON, keine Authentifizierung.
Endpoint 1: Aktueller Strompreis
curl https://strom.nevik.de/api/
Response:
{
"strompreis_ct_kwh": 39.42,
"strompreis_eur_kwh": 0.3942,
"datum": "2025-01-15",
"quelle": "BNetzA, SMARD, EEX",
"aufschluesselung": {
"strombeschaffung_vertrieb": {
"prozent": 25.0,
"ct_kwh": 9.85
},
"netzentgelte": {
"prozent": 22.0,
"ct_kwh": 8.67
},
"mehrwertsteuer": {
"prozent": 16.0,
"ct_kwh": 6.31
},
"stromsteuer": {
"prozent": 14.0,
"ct_kwh": 5.52
}
}
}
Das ist der Hauptendpoint. Er liefert den tagesaktuellen Durchschnittsstrompreis für Deutschland in Cent pro kWh — plus die vollständige Aufschlüsselung, aus welchen Komponenten sich der Preis zusammensetzt.
Endpoint 2: Historische Daten
curl https://strom.nevik.de/api/history/?days=30
Liefert die Preisentwicklung der letzten N Tage. Perfekt für Charts und Trend-Analysen.
Endpoint 3: Prognose
curl https://strom.nevik.de/api/forecast/
Basiert auf EEX-Futures und liefert eine Prognose für die kommende Woche.
CORS: Damit die API im Browser funktioniert
Eine API, die nur serverseitig funktioniert, ist für Web-Entwickler wertlos. Deshalb ist die API vollständig CORS-enabled:
Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: GET, OPTIONS
Access-Control-Allow-Headers: Content-Type
Das bedeutet: Du kannst die API direkt aus dem Browser per fetch() aufrufen, ohne einen Proxy-Server. Das ist für Frontend-Projekte entscheidend.
Code-Beispiel 1: Mit JavaScript / fetch
Hier ist ein komplettes Beispiel, wie du die API in einer Web-App nutzt:
// Aktuellen Strompreis abrufen
async function getCurrentElectricityPrice() {
try {
const response = await fetch('https://strom.nevik.de/api/');
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
const data = await response.json();
console.log(`Aktueller Strompreis: ${data.strompreis_ct_kwh} ct/kWh`);
console.log(`Datum: ${data.datum}`);
console.log(`Quelle: ${data.quelle}`);
return data;
} catch (error) {
console.error('Fehler beim Abrufen des Strompreises:', error);
return null;
}
}
// Preis für einen bestimmten Verbrauch berechnen
function calculateCost(consumptionKwh, priceData) {
const totalEur = consumptionKwh * priceData.strompreis_eur_kwh;
const breakdown = {};
for (const [key, value] of Object.entries(priceData.aufschluesselung)) {
breakdown[key] = (consumptionKwh * value.ct_kwh) / 100;
}
return {
total: totalEur,
breakdown: breakdown
};
}
// Nutzung
const priceData = await getCurrentElectricityPrice();
const cost = calculateCost(2500, priceData); // 2500 kWh/Jahr
console.log(`Jahreskosten: ${cost.total.toFixed(2)} €`);
Code-Beispiel 2: Mit Python
Für Datenanalyse und Backend-Skripte ist Python die erste Wahl:
import requests
import pandas as pd
import matplotlib.pyplot as plt
# Aktuellen Strompreis abrufen
def get_current_price():
response = requests.get('https://strom.nevik.de/api/')
response.raise_for_status()
return response.json()
# Historische Daten laden
def get_price_history(days=30):
url = f'https://strom.nevik.de/api/history/?days={days}'
response = requests.get(url)
response.raise_for_status()
return response.json()
# Preisentwicklung visualisieren
def plot_price_trend():
history = get_price_history(days=90)
df = pd.DataFrame(history['data'])
df['datum'] = pd.to_datetime(df['datum'])
plt.figure(figsize=(12, 6))
plt.plot(df['datum'], df['strompreis_ct_kwh'], marker='o', linewidth=2)
plt.title('Strompreis-Entwicklung (letzte 90 Tage)')
plt.xlabel('Datum')
plt.ylabel('Preis (ct/kWh)')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('strompreis-verlauf.png', dpi=150)
print('Chart gespeichert: strompreis-verlauf.png')
# Hauptprogramm
if __name__ == '__main__':
current = get_current_price()
print(f"Aktueller Strompreis: {current['strompreis_ct_kwh']} ct/kWh")
print(f"Datenquelle: {current['quelle']}")
print(f"Stand: {current['datum']}")
print()
print("Preis-Zusammensetzung:")
for component, data in current['aufschluesselung'].items():
print(f" {component}: {data['prozent']}% ({data['ct_kwh']} ct/kWh)")
print()
plot_price_trend()
Dieses Skript gibt dir den aktuellen Preis, die Zusammensetzung und einen matplotlib-Chart der letzten 90 Tage.
Code-Beispiel 3: Mit Node.js
const axios = require('axios');
async function monitorElectricityPrices() {
try {
const response = await axios.get('https://strom.nevik.de/api/');
const data = response.data;
const threshold = 35; // ct/kWh
if (data.strompreis_ct_kwh > threshold) {
console.warn(`⚠️ Strompreis über Schwellwert: ${data.strompreis_ct_kwh} ct/kWh`);
// Hier z.B. Notification senden
} else {
console.log(`✅ Strompreis im Normalbereich: ${data.strompreis_ct_kwh} ct/kWh`);
}
return data;
} catch (error) {
console.error('API-Fehler:', error.message);
}
}
// Alle Stunde prüfen
setInterval(monitorElectricityPrices, 3600 * 1000);
monitorElectricityPrices(); // sofort beim Start
Die technische Architektur
Wie ist die API aufgebaut? Hier ist der Tech-Stack:
Backend
- Python (FastAPI) — leichtgewichtig, schnell, exzellente JSON-Unterstützung
- Automatisierte Daten-Aggregation — ein Cronjob zieht stündlich Daten von BNetzA, SMARD und EEX
- Redis-Caching — API-Responses werden für 1 Stunde gecacht
- PostgreSQL — für historische Daten und Validierung
Datenquellen
Die API aggregiert aus drei Quellen:
- Bundesnetzagentur (BNetzA) — offizielle Preisdaten und Monitoring-Berichte
- SMARD.de — tagesaktuelle Strommarktdaten der Bundesnetzagentur
- EEX (European Energy Exchange) — Börsenpreise und Futures für Prognosen
Dabei werden die Daten normalisiert, Plausibilitätschecks durchgeführt und der Durchschnittspreis berechnet.
Hosting & Verfügbarkeit
- Uptime-Ziel: 99.5%
- Rate-Limiting: Fair-Use (keine harten Limits, aber bitte nicht flood-den)
- Caching: Serverseitig 1 Stunde, Client-seitig via Cache-Headers
- Format: JSON, UTF-8, konsistente Schema-Versionierung
Datenqualität und Validierung
Ein großer Teil der Arbeit ist Datenvalidierung. Strompreisdaten sind fehleranfällig — fehlende Tage, Ausreißer, Formatierungsunterschiede. Die Pipeline enthält mehrere Validierungs-Schritte:
def validate_price_data(raw_data):
"""Validiere Rohdaten vor der Speicherung."""
errors = []
# Plausibilitätscheck: Preis muss zwischen 10 und 100 ct/kWh liegen
price = raw_data.get('strompreis_ct_kwh')
if price is None:
errors.append('Preis fehlt')
elif not (10 <= price <= 100):
errors.append(f'Preis unplausibel: {price} ct/kWh')
# Datum-Check
datum = raw_data.get('datum')
if not datum:
errors.append('Datum fehlt')
# Quellen-Check: Mindestens 2 Quellen müssen übereinstimmen
sources = raw_data.get('quellen', [])
if len(sources) < 2:
errors.append('Zu wenige Datenquellen für Kreuzcheck')
# Aufschlüsselung muss 100% ergeben (mit Toleranz)
if raw_data.get('aufschluesselung'):
total_percent = sum(
v['prozent'] for v in raw_data['aufschluesselung'].values()
)
if abs(total_percent - 100) > 2:
errors.append(f'Aufschlüsselung ergibt {total_percent}%, nicht 100%')
return errors
Nur Daten, die alle Checks bestehen, werden veröffentlicht. Das sorgt für verlässliche API-Responses.
Use Cases: Was du mit der API bauen kannst
Hier sind konkrete Projektideen, für die du die API nutzen kannst:
1. Smart Home Dashboard
Integriere den aktuellen Strompreis in dein Home Assistant oder ioBroker Dashboard. Wenn der Preis hoch ist, schaltet die Waschmaschine erst morgen an.
2. PV-Anlagen-Rendite-Rechner
Berechne, wie viel eine Photovoltaikanlage einspart, basierend auf aktuellen Strompreisen und historischen Verläufen.
3. Heizkosten-Vergleichsportal
Vergleiche Strom-, Gas- und Wärmepumpenheizungen mit tagesaktuellen Preisen.
4. Finanz-App für Haushaltsbudget
Tracke die Stromkosten im Monatsbudget und warne Nutzer vor Preissteigerungen.
5. Forschung & Datenanalyse
Für Studenten, Journalisten und Forscher, die Strompreisdaten für Analysen, Visualisierungen oder Artikel benötigen.
Fair-Use & Einschränkungen
Die API ist kostenlos, aber es gibt sinnvolle Limits:
- Keine Authentifizierung erforderlich — einfach loslegen
- Rate-Limiting: Bitte nicht mehr als ~100 Requests/Minute aus einer IP
- Caching: Die Daten aktualisieren sich nur stündlich, also cache auch clientseitig
- Keine Garantie: Die Daten sind sorgfältig aggregiert, aber ohne Gewähr. Für verbindliche Preisentscheidungen immer die offiziellen Quellen prüfen.
Wenn du die API kommerziell nutzen möchtest oder höhere Limits brauchst, schreib mir gerne.
Roadmap: Was kommt noch?
Die API entwickelt sich weiter. Geplante Features:
- [x] Aktueller Durchschnittspreis
- [x] Vollständige Preisaufschlüsselung
- [x] Historische Daten (bis zu 365 Tage)
- [ ] Regionale Preise (Bundesland / Postleitzahl)
- [ ] Börsenpreis (Spotmarkt EPEX Spot) stündlich
- [ ] GraphQL-Endpoint für flexible Queries
- [ ] Webhook für Preisalarme
Fazit
Offene Daten machen offene Anwendungen möglich. Die Strompreis-API ist mein Beitrag dazu — eine kleine, fokussierte API, die ein konkretes Problem löst: den Zugang zu aktuellen, verlässlichen Strompreisdaten für Deutschland.
Die wichtigsten Punkte:
- Drei Endpoints: aktueller Preis, Verlauf, Prognose
- CORS-enabled: direkt aus dem Browser nutzbar
-
Keine Auth: einfach
fetch()oderrequests.get() - Aggregiert aus BNetzA, SMARD, EEX
- Kostenlos & Open für alle Entwickler
Probiere die API aus und baue etwas damit. Ob Dashboard, Rechner oder Analyse-Tool — ich bin gespannt, was ihr entwickelt.
🔗 Live Strompreis-Rechner (nutzt die API)
Schreib gerne einen Kommentar, wenn du Fragen hast oder ein Projekt mit der API baust — ich helfe gerne weiter!
Top comments (0)