Tillbaka till bloggen

Styr hemmabatteriet med en elprisprognos – Spotprisprognos API

Hämta spotpris och elprisprognos via Spotprisprognos API och bygg ett laddschema som laddar batteriet när elen är billig – med kodexempel i Python, TypeScript, Go, curl och Home Assistant.

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ältInnehåll
areaElområdet: SE1–SE4, men även NO1–NO5, FI, DK1 och DK2.
pricesKända spotpriser per kvart: senaste 48 timmarna plus publicerade day-ahead-priser (morgondagens kommer runt kl. 13).
predictionsPrognosen från innevarande timme: timvärden 7 dagar framåt, för SE1–SE4 sedan 4-timmarsvärden upp till 30 dagar.
valuePris 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:

Skapa API-nyckel i Spotprisprognos – modal med fält för applikationsnamn
Skapa en API-nyckel för din batteri- eller energistyrning under ditt konto.
# 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.