Norway Nord Pool Day-Ahead Historical Price API

You need reliable, day-ahead power price history for Norway to backtest strategies, value exposures, and automate risk reporting. By the end of this guide, you will fetch and parse Norway Nord Pool Day-Ahead historical prices from the Energy API timeseries endpoint, understand the response structure, and integrate the data into your finance workflows with robust handling for units, dates, and caching.

What this data is and how to use it in finance

The Norway Nord Pool Day-Ahead symbol delivers daily day-ahead electricity prices for Norway, quoted in EUR per megawatt hour (EUR/MWh). This is the price level many hedging programs, PPAs, and mark-to-market workflows depend on. With historical timeseries you can:

• Backtest hedging and procurement strategies against realized day-ahead levels.
• Compute exposure sensitivities and P&L attribution to power price changes.
• Feed risk dashboards and VaR engines with consistent daily market data.

Key facts you will use throughout this article:

• Symbol name: Norway Nord Pool Day-Ahead
• Symbol code: NORDPOOL_NO_DA
• Unit: EUR/MWh
• Auth: pass api_key as a query parameter (use YOUR_API_KEY in examples)
• Pricing: Starter $19.99/mo, trial 7 days / 50 calls
• Endpoint: GET /api/v1/timeseries with start, end, symbols, api_key
• You will read: rates.NORDPOOL_NO_DA, dates.NORDPOOL_NO_DA, currencies.NORDPOOL_NO_DA (base is EUR)

Endpoint and authentication

All queries in this guide use the Energy API timeseries endpoint:

GET https://energy-api.com/api/v1/timeseries

Required query parameters:

• start: ISO date (YYYY-MM-DD) inclusive window start
• end: ISO date (YYYY-MM-DD) inclusive window end
• symbols: the instrument code, here NORDPOOL_NO_DA
• api_key: your API key string (use YOUR_API_KEY in tests)

Authentication is by query parameter only for the examples here. Do not add headers or bearer tokens unless your environment requires request signing at the edge. Keep the symbol list minimal—just NORDPOOL_NO_DA for this post—so you avoid parsing overhead.

Quick-start with curl

Copy-paste the official curl command to pull a historical window. This is fully runnable—replace YOUR_API_KEY with your key:

curl -G "https://energy-api.com/api/v1/timeseries" --data-urlencode "start=2026-01-01" --data-urlencode "end=2026-03-31" --data-urlencode "symbols=NORDPOOL_NO_DA" --data-urlencode "api_key=YOUR_API_KEY"

If you are just getting started, there is a 7-day free trial (50 calls) on the Starter plan. You can create a key here: Register. For reference, see the endpoint docs: Documentation.

Response anatomy you will integrate

The timeseries endpoint returns a compact object keyed by symbol. For Norway Nord Pool Day-Ahead (NORDPOOL_NO_DA), read:

• rates.NORDPOOL_NO_DA: numeric price in EUR/MWh
• dates.NORDPOOL_NO_DA: the date associated with the price
• currencies.NORDPOOL_NO_DA: currency code (EUR)
• base: base currency for the payload (EUR)

Use the following official examples verbatim for your tests and parsers.

Real API response: Norway Nord Pool Day-Ahead

{"success":true,"date":"2026-10-17","base":"EUR","rates":{"NORDPOOL_NO_DA":146.3001},"dates":{"NORDPOOL_NO_DA":"2026-10-17"},"currencies":{"NORDPOOL_NO_DA":"EUR"},"base_filter_note":null}

Field mapping you will actually use:

• base = EUR confirms the price is already in EUR.
• rates.NORDPOOL_NO_DA = 146.3001 is the daily day-ahead level.
• dates.NORDPOOL_NO_DA = 2026-10-17 is the value date.
• currencies.NORDPOOL_NO_DA = EUR is redundant but useful for validation.

Official sample response from the live source

The official sample below is provided by the source and must be copied verbatim. It references a different symbol (OMIE_ES_DA) but has the same schema you will parse for NORDPOOL_NO_DA:

{
"success": true,
"date": "2026-10-18",
"base": "EUR",
"rates": {
"OMIE_ES_DA": 76.2848
},
"dates": {
"OMIE_ES_DA": "2026-10-18"
},
"currencies": {
"OMIE_ES_DA": "EUR"
},
"base_filter_note": null
}

For your Norway integration, treat OMIE_ES_DA as a structural reference only and continue to request NORDPOOL_NO_DA in your own calls and parsing logic.

Fixture copy for integration tests (Norway symbol)

Use this real NORDPOOL_NO_DA payload as a fixture to validate your parsing and unit checks:

{"success":true,"date":"2026-10-17","base":"EUR","rates":{"NORDPOOL_NO_DA":146.3001},"dates":{"NORDPOOL_NO_DA":"2026-10-17"},"currencies":{"NORDPOOL_NO_DA":"EUR"},"base_filter_note":null}

Parsing the timeseries in Python

The snippet below calls the same endpoint and extracts the fields a finance system typically needs: the value date, EUR/MWh price, and base currency. It also includes defensive checks for missing fields.

import os
import sys
import json
from datetime import date
from urllib.parse import urlencode
from urllib.request import urlopen, Request

API_URL = "https://energy-api.com/api/v1/timeseries"
API_KEY = os.environ.get("ENERGY_API_KEY", "YOUR_API_KEY")
SYMBOL = "NORDPOOL_NO_DA"

def fetch_timeseries(start, end, symbol=SYMBOL, api_key=API_KEY):
params = {
"start": start, # "YYYY-MM-DD"
"end": end, # "YYYY-MM-DD"
"symbols": symbol,
"api_key": api_key,
}
url = f"{API_URL}?{urlencode(params)}"
req = Request(url, headers={"Accept": "application/json"})
with urlopen(req, timeout=30) as resp:
payload = json.loads(resp.read().decode("utf-8"))
return payload

def extract_points(payload, symbol=SYMBOL):
# Required top-level fields
base = payload.get("base")
rates = payload.get("rates", {})
dates = payload.get("dates", {})
currencies = payload.get("currencies", {})

if base is None:
raise ValueError("Missing 'base' in response")

# We expect EUR prices; verify currency map if present
ccy = currencies.get(symbol)
if ccy and ccy != base:
raise ValueError(f"Currency mismatch for {symbol}: {ccy} vs base {base}")

# Build a list of (date, price, currency)
# For day-ahead daily data, a single or few points per symbol are typical
results = []
price = rates.get(symbol)
dval = dates.get(symbol)
if price is not None and dval is not None:
results.append({
"symbol": symbol,
"date": dval, # "YYYY-MM-DD"
"price_eur_per_mwh": float(price),
"base": base,
})
return results

if __name__ == "__main__":
start = "2026-01-01"
end = "2026-03-31"
data = fetch_timeseries(start, end)
points = extract_points(data)
for p in points:
print(f"{p['date']} {p['symbol']}: {p['price_eur_per_mwh']} {p['base']}/MWh")

Notes:

• Keep YOUR_API_KEY during local tests and switch to an environment variable for CI/CD.
• The fields are flat enough that no pagination logic is needed in the snippet above.
• The base is EUR. Do not pass base=USD in the same request when you also need TTF_GAS or EUA_CO2.

JavaScript example (Node.js, fetch API)

This example demonstrates identical logic in JavaScript using global fetch (Node 18+). It reads the same fields and prints a compact CSV line for ingestion.

import { createWriteStream } from "node:fs";
import { pipeline } from "node:stream/promises";
import { Readable } from "node:stream";

const API_URL = "https://energy-api.com/api/v1/timeseries";
const API_KEY = process.env.ENERGY_API_KEY || "YOUR_API_KEY";
const SYMBOL = "NORDPOOL_NO_DA";

function qs(params) {
return new URLSearchParams(params).toString();
}

async function fetchTimeseries(start, end) {
const url = `${API_URL}?${qs({
start,
end,
symbols: SYMBOL,
api_key: API_KEY,
})}`;
const resp = await fetch(url, { headers: { Accept: "application/json" }, method: "GET" });
if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
return await resp.json();
}

function extractPoint(payload) {
if (!payload) throw new Error("Empty payload");
const base = payload.base;
const price = payload?.rates?.[SYMBOL];
const dval = payload?.dates?.[SYMBOL];
const ccy = payload?.currencies?.[SYMBOL];
if (!base || price === undefined || !dval) return null;
if (ccy && ccy !== base) throw new Error(`Currency mismatch: ${ccy} vs ${base}`);
return { date: dval, symbol: SYMBOL, price_eur_per_mwh: Number(price), base };
}

async function main() {
const start = "2026-01-01";
const end = "2026-03-31";
const data = await fetchTimeseries(start, end);
const point = extractPoint(data);
if (!point) {
console.error("No data point available for the given range.");
return;
}
const line = `${point.date},${point.symbol},${point.price_eur_per_mwh},${point.base}/MWh\n`;
await pipeline(Readable.from(line), createWriteStream("nordpool_no_da.csv", { flags: "a" }));
console.log("Wrote:", line.trim());
}

main().catch((e) => {
console.error(e);
process.exit(1);
});

Field-by-field guide to stable ingestion

When integrating into portfolio or risk systems, focus on a narrow and stable subset of fields and enforce strong validation rules in your adapters:

• base: Expect EUR. Validate and hard-fail on unexpected base to avoid silent unit errors.
• rates.NORDPOOL_NO_DA: Numeric price in EUR/MWh. Parse as decimal or double; avoid float rounding when exporting to accounting systems.
• dates.NORDPOOL_NO_DA: Date string (YYYY-MM-DD). Treat as local market date; you do not need timezone offsets because it is a daily day-ahead series.
• currencies.NORDPOOL_NO_DA: Reinforces that the number is in EUR. Use to cross-check with base.

If you cache, include base and symbol in your cache key to prevent cross-symbol contamination (e.g., cache key: timeseries:NORDPOOL_NO_DA:EUR:2026-01-01..2026-03-31).

Official samples you should keep for tests

Keep the official curl and JSON samples in your test suite to lock in compatibility:

Official curl (copy unchanged)

curl -G "https://energy-api.com/api/v1/timeseries" --data-urlencode "start=2026-01-01" --data-urlencode "end=2026-03-31" --data-urlencode "symbols=NORDPOOL_NO_DA" --data-urlencode "api_key=YOUR_API_KEY"

Official JSON (schema reference only)

{
"success": true,
"date": "2026-10-18",
"base": "EUR",
"rates": {
"OMIE_ES_DA": 76.2848
},
"dates": {
"OMIE_ES_DA": "2026-10-18"
},
"currencies": {
"OMIE_ES_DA": "EUR"
},
"base_filter_note": null
}

Real Norway JSON (use in symbol-specific tests)

{"success":true,"date":"2026-10-17","base":"EUR","rates":{"NORDPOOL_NO_DA":146.3001},"dates":{"NORDPOOL_NO_DA":"2026-10-17"},"currencies":{"NORDPOOL_NO_DA":"EUR"},"base_filter_note":null}

Dates, units, and market-specific nuances

Day-ahead power is a daily series aligned to market dates. For Norway Nord Pool Day-Ahead:

• Unit consistency: All values are EUR/MWh—validate this before P&L or VaR aggregation.
• Base currency: EUR is the base. If your internal base is USD, convert downstream; do not request base=USD in the same call when you also need TTF_GAS or EUA_CO2.
• Weekends and holidays: Power markets generally publish day-ahead prices for non-business days. Do not assume gaps are weekends—always rely on returned dates.
• Timestamps and timezones: The endpoint provides dates (YYYY-MM-DD) rather than timestamps, which simplifies ingestion into EOD pipelines.

Error handling, retries, and caching

Stabilize production pipelines with a few simple patterns:

• Timeouts: Use short timeouts on HTTP calls (e.g., 10–30 seconds) and retry idempotent GETs once or twice on transient network errors.
• Response validation: Assert the presence of base, rates.NORDPOOL_NO_DA, dates.NORDPOOL_NO_DA, and currencies.NORDPOOL_NO_DA (if present). Raise on inconsistencies.
• Caching: Cache successful responses by (symbol, base, start, end) for a day; day-ahead numbers are stable for historical dates.
• Idempotency: GET timeseries calls are safe to retry; guard against writing duplicate rows by de-duplicating on (symbol, date) at the storage layer.

Data modeling for portfolios and risk

Map the series into your analytics with explicit semantics:

• Primary key: (symbol = NORDPOOL_NO_DA, date).
• Measure: price_eur_per_mwh as a decimal type to preserve cents-level precision.
• Currency: store base and currency columns; both should be EUR for this symbol.
• Valuation usage: use the daily value directly for EOD P&L on spot-linked exposures; for hedges, align to your deal calendar and delivery profile downstream.

If you maintain a cross-commodity cube with Brent, TTF gas, or EUA carbon, keep conversion at the analytics layer to avoid mixing base currency logic at fetch time.

Testing strategy that prevents regressions

Adopt three layers of tests around this endpoint:

• Parser unit tests: Use the real NORDPOOL_NO_DA JSON example to assert field extraction and unit checks.
• Schema snapshot: Keep the official sample JSON (OMIE_ES_DA) to catch unexpected field changes while remaining symbol-agnostic.
• Integration smoke: Run the official curl with a short window in CI (guarded behind a feature flag) to verify key/endpoint health within the 50-call trial if applicable.

Common pitfalls to avoid

• Mixing base currencies: Do not pass base=USD in requests when you also need TTF_GAS or EUA_CO2 alongside NORDPOOL_NO_DA; normalize post-fetch instead.
• Assuming continuous dates: Always use the dates field returned by the API—do not auto-fill weekends or holidays.
• Floating-point drift: Use decimal where required by finance controls; round only at reporting boundaries.
• Overbroad symbol lists: Request just NORDPOOL_NO_DA for this workflow to reduce payload size and parsing branches.

Frequently asked questions

Q1: What symbol should I request for Norway’s day-ahead prices?
A1: Use NORDPOOL_NO_DA. The unit is EUR/MWh and the base is EUR.

Q2: How do I authenticate?
A2: Provide your key as the query parameter api_key=YOUR_API_KEY. No extra headers are required in the examples above.

Q3: Do I need to handle timezones?
A3: The endpoint returns daily dates (YYYY-MM-DD) for day-ahead prices. Treat this as an end-of-day value; timezone conversions are not required for ingestion.

Q4: Can I request multiple symbols in one call?
A4: The symbols parameter accepts a list, but in this guide we focus on a single symbol (NORDPOOL_NO_DA) to keep parsing strict and unambiguous.

Q5: Is USD conversion supported?
A5: Convert downstream if you need USD. Do not set base=USD in the same request when you also need TTF_GAS or EUA_CO2.

Get your API key and ship the integration

Create an account and start with the 7-day trial (50 calls) to wire this into your pricing and risk stack. Generate a key here: Register. For request/response details and additional parameters, see the Documentation.