Ett hemmabatteri tjänar pengar på prisskillnader: ladda när elen är billig, använd eller sälj när den är dyr. Ett batteri som bara tittar bakåt missar det viktigaste, nämligen vad spotpriset gör de kommande timmarna. Med en elprisprognos kan styrningen planera framåt i stället för att gissa.
Den här guiden visar hur du hämtar kända spotpriser och vår prognos via Spotprisprognos API, med färdiga exempel i flera språk.
Varför prognosstyrning slår en fast tröskel
Den vanligaste batterilogiken är en fast tröskel: “ladda när priset är under X öre”. Antingen är tröskeln för snål och du missar billiga timmar, eller för generös och du laddar i onödan. Med en prognos för hela dygnet väljer du i stället de timmar som faktiskt är billigast jämfört med resten av dygnet, och sparar urladdningen till de dyraste.
Day-ahead-priserna är dessutom bara kända till och med imorgon. Vill du planera flera dygn framåt, till exempel inför en kall och vindstilla vecka, behöver du en prognos som sträcker sig längre.
API:t: spotpris och prognos i ett anrop
Det öppna endpointet kräver ingen nyckel och returnerar både kända spotpriser och prognosen för ett elområde:
curl "https://api.spotprisprognos.se:8443/api/predictions/public/electricity-latest?area=SE3"
Svaret (förkortat):
{
"area": "SE3",
"prices": [
{ "timestamp": "2026-10-29T10:45:00.000Z", "value": 1.11 },
{ "timestamp": "2026-10-29T11:00:00.000Z", "value": 1.08 }
],
"predictions": [
{ "targetTime": "2026-10-29T11:00:00.000Z", "value": 1.1468 },
{ "targetTime": "2026-10-29T12:00:00.000Z", "value": 1.0973 }
]
}
| Fält | Innehåll |
|---|---|
area | Elområdet: SE1–SE4, men även NO1–NO5, FI, DK1 och DK2. |
prices | Kända spotpriser per kvart: senaste 48 timmarna plus publicerade day-ahead-priser (morgondagens kommer runt kl. 13). |
predictions | Prognosen från innevarande timme: timvärden 7 dagar framåt, för SE1–SE4 sedan 4-timmarsvärden upp till 30 dagar. |
value | Pris i kr/kWh, spotpris exklusive moms och avgifter. Tider i UTC. |
Prognosen räknas om varje timme. Där det finns kända priser ska de gå före prognosen; exemplen nedan gör just det.
Snabbstart: billigaste timmarna
De fyra billigaste timmarna det kommande dygnet, i några rader:
curl -s "https://api.spotprisprognos.se:8443/api/predictions/public/electricity-latest?area=SE3" \
| jq -r '.predictions[:24] | sort_by(.value) | .[:4][] | "\(.targetTime) \(.value) kr/kWh"'
package main
import (
"encoding/json"
"fmt"
"log"
"net/http"
"sort"
"time"
)
const api = "https://api.spotprisprognos.se:8443/api/predictions/public/electricity-latest"
type Forecast struct {
Area string `json:"area"`
Predictions []struct {
TargetTime time.Time `json:"targetTime"`
Value float64 `json:"value"`
} `json:"predictions"`
}
func main() {
res, err := http.Get(api + "?area=SE3")
if err != nil {
log.Fatal(err)
}
defer res.Body.Close()
var f Forecast
if err := json.NewDecoder(res.Body).Decode(&f); err != nil {
log.Fatal(err)
}
// The forecast's next 24 hours, cheapest first.
next := f.Predictions
if len(next) > 24 {
next = next[:24]
}
sort.Slice(next, func(i, j int) bool { return next[i].Value < next[j].Value })
fmt.Println("Billigaste timmarna i", f.Area)
for _, p := range next[:4] {
fmt.Printf(" %s %.2f kr/kWh\n", p.TargetTime.Local().Format("Mon 15:04"), p.Value)
}
}
Bygg ett laddschema
Ett riktigt schema blandar kända priser med prognosen: kvartspriserna slås ihop till timmar, och prognosen fyller i timmarna efter det sista publicerade priset. Sedan rangordnas dygnets timmar; de billigaste blir laddning och de dyraste urladdning.
from collections import defaultdict
from datetime import datetime, timedelta, timezone
import requests
API = "https://api.spotprisprognos.se:8443/api/predictions/public/electricity-latest"
def hourly_prices(area: str) -> dict[datetime, float]:
"""Known spot prices where published, the forecast for every hour after."""
data = requests.get(API, params={"area": area}, timeout=15).json()
# Spot prices are quarter-hourly: average them per hour.
quarters = defaultdict(list)
for p in data["prices"]:
t = datetime.fromisoformat(p["timestamp"].replace("Z", "+00:00"))
quarters[t.replace(minute=0)].append(p["value"])
hours = {h: sum(v) / len(v) for h, v in quarters.items()}
for p in data["predictions"]:
t = datetime.fromisoformat(p["targetTime"].replace("Z", "+00:00"))
hours.setdefault(t, p["value"]) # known price wins
return hours
def plan(area: str, hours_ahead: int = 24, n: int = 4) -> list[tuple[datetime, float, str]]:
now = datetime.now(timezone.utc).replace(minute=0, second=0, microsecond=0)
prices = hourly_prices(area)
window = [(t, prices[t]) for t in sorted(prices) if now <= t < now + timedelta(hours=hours_ahead)]
ranked = sorted(window, key=lambda h: h[1])
charge = {t for t, _ in ranked[:n]}
discharge = {t for t, _ in ranked[-n:]}
return [
(t, price, "ladda" if t in charge else "urladda" if t in discharge else "vila")
for t, price in window
]
for t, price, action in plan("SE3"):
print(f"{t.astimezone():%a %H:%M} {price:6.2f} kr/kWh {action}")
const API = "https://api.spotprisprognos.se:8443/api/predictions/public/electricity-latest";
const HOUR = 3_600_000;
type Forecast = {
area: string;
prices: { timestamp: string; value: number }[];
predictions: { targetTime: string; value: number }[];
};
// Known spot prices where published, the forecast for every hour after.
async function hourlyPrices(area: string): Promise<Map<number, number>> {
const res = await fetch(`${API}?area=${area}`);
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const data: Forecast = await res.json();
// Spot prices are quarter-hourly: average them per hour.
const quarters = new Map<number, number[]>();
for (const p of data.prices) {
const hour = Math.floor(Date.parse(p.timestamp) / HOUR) * HOUR;
quarters.set(hour, [...(quarters.get(hour) ?? []), p.value]);
}
const hours = new Map<number, number>();
for (const [hour, v] of quarters) hours.set(hour, v.reduce((a, b) => a + b, 0) / v.length);
for (const p of data.predictions) {
const hour = Date.parse(p.targetTime);
if (!hours.has(hour)) hours.set(hour, p.value); // known price wins
}
return hours;
}
async function plan(area: string, hoursAhead = 24, n = 4) {
const now = Math.floor(Date.now() / HOUR) * HOUR;
const prices = await hourlyPrices(area);
const window = [...prices]
.filter(([t]) => t >= now && t < now + hoursAhead * HOUR)
.sort(([a], [b]) => a - b);
const ranked = [...window].sort(([, a], [, b]) => a - b);
const charge = new Set(ranked.slice(0, n).map(([t]) => t));
const discharge = new Set(ranked.slice(-n).map(([t]) => t));
return window.map(([t, price]) => ({
time: new Date(t),
price,
action: charge.has(t) ? "ladda" : discharge.has(t) ? "urladda" : "vila",
}));
}
for (const { time, price, action } of await plan("SE3")) {
const hhmm = time.toLocaleTimeString("sv-SE", { hour: "2-digit", minute: "2-digit" });
console.log(`${hhmm} ${price.toFixed(2)} kr/kWh ${action}`);
}
Utskriften är en timplan att mata vidare till växelriktaren eller energistyrningen, till exempel via Modbus, MQTT eller tillverkarens API:
Thu 16:00 1.63 kr/kWh urladda
Thu 17:00 2.40 kr/kWh urladda
…
Fri 00:00 0.85 kr/kWh ladda
Fri 06:00 0.70 kr/kWh ladda
Home Assistant
Med en REST-sensor får du
aktuellt spotpris och nästa billiga timme direkt i Home Assistant, utan egen
kod. Lägg till i configuration.yaml:
rest:
- resource: https://api.spotprisprognos.se:8443/api/predictions/public/electricity-latest?area=SE3
scan_interval: 900
sensor:
- name: Elpris SE3
unique_id: spotprisprognos_se3_price
unit_of_measurement: SEK/kWh
state_class: measurement
value_template: >
{% set ns = namespace(price=none) %}
{% for p in value_json.prices if as_timestamp(p.timestamp) <= as_timestamp(now()) %}
{% set ns.price = p.value %}
{% endfor %}
{{ ns.price }}
- name: Billigaste timmen SE3
unique_id: spotprisprognos_se3_cheapest
device_class: timestamp
value_template: >
{% set next = value_json.predictions[:24] | sort(attribute='value') %}
{{ (next[0].targetTime | as_datetime).isoformat() }}
Sensorn sensor.billigaste_timmen_se3 kan sedan trigga en automation som
startar laddboxen, diskmaskinen eller batteriladdningen.
Med API-nyckel
Det öppna endpointet räcker långt för hemmabruk. För integrationer med
prisarkiv och full prognos skapar du en API-nyckel under ditt konto
(ingår i Premium: 10 000 anrop per månad, högst 500 per minut) och skickar den
i headern X-API-Key:
# Spotpriser för en period (timvärden)
curl -H "X-API-Key: $API_KEY" \
"https://api.spotprisprognos.se:8443/api/v1/prices/electricity?area=SE3&startTime=2026-10-01T00:00:00Z&endTime=2026-10-07T23:00:00Z"
# Senaste prognosen
curl -H "X-API-Key: $API_KEY" \
"https://api.spotprisprognos.se:8443/api/v1/predictions/electricity?area=SE3"
import os
import requests
session = requests.Session()
session.headers["X-API-Key"] = os.environ["API_KEY"]
res = session.get(
"https://api.spotprisprognos.se:8443/api/v1/predictions/electricity",
params={"area": "SE3"},
timeout=15,
)
res.raise_for_status()
for p in res.json()["predictions"][:5]:
print(p["targetTime"], p["predictedValue"])
Spara nyckeln i en miljövariabel eller en hemlighetshanterare, aldrig direkt i
koden. Överskrider du kvoten svarar API:t med 429.
Gör det smartare
- Anpassa till batteriet. Antalet ladd- och urladdningstimmar ska följa kapacitet och effekt, inte vara hårdkodat till fyra.
- Räkna med förluster. Det lönar sig bara att cykla när prisskillnaden är större än verkningsgradsförlusten (ofta 10–20 %) plus slitage.
- Kombinera med solprognos. Ladda mindre från nätet de timmar du väntar överskott från solcellerna.
- Hämta om varje timme. Prognosen uppdateras löpande, och morgondagens kända priser kommer runt kl. 13.
Hur långt fram når prognosen?
Det öppna endpointet ger timprognos en vecka framåt, och för de svenska elområdena en grövre prognos upp till 30 dagar. Bygger du en kommersiell integration eller behöver större volym? Hör av dig så löser vi åtkomst.
Sammanfattning
Ett enda anrop ger både kända spotpriser och en elprisprognos för ditt elområde, vilket är allt som behövs för att ladda billigt och urladda dyrt, planerat i förväg. Läs mer om hur prognosen fungerar, om elområdena SE1–SE4 eller se elpriset i din kommun.