bolt Energy API
Docs Symbols MCP Pricing Blog
Log in Get API Key

Historical Denmark West Nord Pool Day-Ahead Prices

Historical Denmark West Nord Pool Day-Ahead Prices

You need reliable historical Denmark West (DK1) Nord Pool day-ahead power prices to backtest hedges, reconcile settlements, and price structured energy products. By the end of this guide, you will be able to pull and parse the Energy API time series for Denmark West Nord Pool Day-Ahead (symbol NORDPOOL_DK1_DA), handle units and currency, and integrate the data into your finance workflows.

What you will query: the Denmark West day-ahead symbol

This guide focuses on a single market data symbol from the Energy API catalog:

Illustration: Historical Denmark West Nord Pool Day-Ahead Prices
  • Symbol name: Denmark West Nord Pool Day-Ahead
  • Symbol code: NORDPOOL_DK1_DA
  • Unit: EUR/MWh
  • Access: GET /api/v1/timeseries with api_key query parameter

You will read values from the timeseries endpoint using the api_key query parameter (use YOUR_API_KEY during setup). The response includes the current base currency for the dataset, the rate keyed by the symbol, a date mapping for the symbol, and a currencies mapping for each symbol.

Plan notes for budgeting: Starter is $19.99/mo with a 7-day trial / 50 calls. No separate MCP host is required. If you also need TTF gas or EUA carbon pricing later, do not pass base=USD together with those symbols.

Endpoint and parameters you will use

You will call the timeseries endpoint with a calendar range and the market symbol:

  • Method: GET
  • Path: /api/v1/timeseries
  • Query parameters:
    • start: inclusive start date (YYYY-MM-DD)
    • end: inclusive end date (YYYY-MM-DD)
    • symbols: one or more symbols, comma-separated (use NORDPOOL_DK1_DA)
    • api_key: YOUR_API_KEY

The response you will parse includes: base (currency of the dataset), rates (numeric values keyed by symbol), dates (ISO date strings keyed by symbol), and currencies (currency code per symbol).

Quick-start: curl you can copy

Run this from your terminal to fetch historical Denmark West day-ahead prices for Q1 2026. 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_DK1_DA" --data-urlencode "api_key=YOUR_API_KEY"

The JSON fields you will actually use

Below is an official response sample for the symbol and fields you will parse in code. Copy these exact values if you need a fixture for local testing.

{
    "success": true,
    "date": "2026-11-05",
    "base": "EUR",
    "rates": {
        "OMIE_ES_DA": 238.6863
    },
    "dates": {
        "OMIE_ES_DA": "2026-11-05"
    },
    "currencies": {
        "OMIE_ES_DA": "EUR"
    },
    "base_filter_note": null,
    "missing_symbols": null
}

How to read it:

  • success: boolean indicating the call succeeded.
  • date: the API’s response date context (not a substitute for the per-symbol date).
  • base: dataset base currency, here EUR.
  • rates.NORDPOOL_DK1_DA: the Denmark West day-ahead price level in EUR/MWh.
  • dates.NORDPOOL_DK1_DA: the market date associated with the rate.
  • currencies.NORDPOOL_DK1_DA: EUR, confirming the unit’s currency.
  • base_filter_note, missing_symbols: present for diagnostics when filtering or requesting unavailable symbols.

Python example: fetch and normalize DK1 day-ahead prices

This Python snippet calls the same endpoint, validates key fields, and turns the response into a simple record you can store in a database or use in a backtest pipeline.

import os
import sys
import urllib.parse
import json
import datetime
import http.client

BASE_URL = "energy-api.com"
PATH = "/api/v1/timeseries"

def fetch_dk1_prices(start_date, end_date, api_key):
params = {
"start": start_date,
"end": end_date,
"symbols": "NORDPOOL_DK1_DA",
"api_key": api_key
}
query = urllib.parse.urlencode(params)
conn = http.client.HTTPSConnection(BASE_URL, timeout=30)
conn.request("GET", f"{PATH}?{query}")
resp = conn.getresponse()
body = resp.read()
if resp.status != 200:
raise RuntimeError(f"HTTP {resp.status}: {body.decode('utf-8', 'ignore')}")
data = json.loads(body.decode("utf-8"))
if not data.get("success", False):
raise RuntimeError("API returned success=false")

symbol = "NORDPOOL_DK1_DA"
# Extract fields explicitly
rates = data.get("rates", {})
dates = data.get("dates", {})
currencies = data.get("currencies", {})

if symbol not in rates or symbol not in dates:
raise KeyError("Expected DK1 symbol missing from response")

record = {
"symbol": symbol,
"date": dates[symbol], # e.g., "2026-11-05"
"price": rates[symbol], # numeric price
"currency": currencies.get(symbol, data.get("base", "EUR")),
"unit": "EUR/MWh" # known unit for DK1 day-ahead
}
return record, data

if __name__ == "__main__":
api_key = os.environ.get("ENERGY_API_KEY", "YOUR_API_KEY")
start = "2026-01-01"
end = "2026-03-31"
rec, raw = fetch_dk1_prices(start, end, api_key)
print(json.dumps(rec, indent=2))

How the timeseries data maps to finance workloads

Because NORDPOOL_DK1_DA is quoted in EUR/MWh, you can directly use it to compute hourly or daily settlement deltas for EUR-denominated portfolios without FX translation. For PnL on EUR books, multiply the price by your contracted MWh volume. For cross-currency books, apply your own FX logic outside this response; do not alter the Energy API request with base transforms when mixing with symbols like TTF_GAS or EUA_CO2.

For backtesting hedges, build a date-indexed series from the API’s dates.NORDPOOL_DK1_DA and rates.NORDPOOL_DK1_DA. Align that with your trade ledger’s delivery dates. If you operate on month buckets, aggregate the daily series to month-average EUR/MWh before valuation.

Handling date ranges, gaps, and caching

Day-ahead power prices are published daily; however, your historical pulls should be robust to missing dates. Use dates.NORDPOOL_DK1_DA as the authoritative date field for each returned point and do not infer dates solely from request parameters. If your workflow expects a full calendar series, forward-fill or flag gaps in your own datastore rather than assuming the API will fill non-trading or maintenance days.

Caching is recommended on your side for static historical ranges, since historical day-ahead prints rarely change after publication. A simple file or key-value cache keyed by (symbol, start, end) can reduce duplicate calls during development and CI test runs.

Error handling and validation

When building production integrations, guard against:

  • HTTP status errors: surface the status and body for debugging.
  • success=false in the payload: log and retry or alert.
  • missing_symbols: if present, inspect to detect typos in symbols.
  • Currency/unit checks: confirm currencies.NORDPOOL_DK1_DA is EUR and treat base as informational for DK1.

Persist both the numeric rate and the API-provided date to ensure reproducible backtests and auditability of settlements.

JavaScript example: fetch and read the same fields

If you prefer JavaScript, the following example uses fetch to call the timeseries endpoint and extract the Denmark West day-ahead rate and date fields.

async function fetchDk1Prices(start, end, apiKey) {
const url = new URL("https://energy-api.com/api/v1/timeseries");
url.searchParams.set("start", start);
url.searchParams.set("end", end);
url.searchParams.set("symbols", "NORDPOOL_DK1_DA");
url.searchParams.set("api_key", apiKey);

const res = await fetch(url.toString(), { method: "GET" });
if (!res.ok) {
const text = await res.text();
throw new Error(`HTTP ${res.status}: ${text}`);
}
const data = await res.json();
if (!data.success) throw new Error("API returned success=false");

const symbol = "NORDPOOL_DK1_DA";
const price = data.rates?.[symbol];
const day = data.dates?.[symbol];
const ccy = data.currencies?.[symbol] ?? data.base;

if (price == null || !day) {
throw new Error("Missing DK1 data in response");
}

return {
symbol,
date: day,
price,
currency: ccy,
unit: "EUR/MWh"
};
}

// Example usage
fetchDk1Prices("2026-01-01", "2026-03-31", "YOUR_API_KEY")
.then(console.log)
.catch(console.error);

Checklist for production readiness

  • Symbol: use NORDPOOL_DK1_DA only when you need Denmark West day-ahead.
  • Auth: supply api_key via query param (YOUR_API_KEY during setup).
  • Units and currency: EUR/MWh, with currencies.NORDPOOL_DK1_DA confirming EUR.
  • Dates: rely on dates.NORDPOOL_DK1_DA to index your time series.
  • Range calls: use start and end for reproducible backfills, and cache responses for stable windows.
  • Do not mix base conversions with symbols requiring their native base for accurate valuation alongside TTF_GAS or EUA_CO2.

FAQ

How do I request multiple symbols at once?

Pass a comma-separated list to the symbols parameter (e.g., symbols=NORDPOOL_DK1_DA,ANOTHER_SYMBOL). Parse rates, dates, and currencies by their symbol keys.

What currency is the DK1 day-ahead price returned in?

EUR, as indicated by currencies.NORDPOOL_DK1_DA and base=EUR. The unit is EUR/MWh.

Does the API return every calendar day?

Treat dates.NORDPOOL_DK1_DA as authoritative. If your application requires a continuous calendar index, implement gap handling (e.g., forward-fill or flagging) in your datastore.

Can I rely on the top-level date field?

Use dates.NORDPOOL_DK1_DA for the market date of the rate. The top-level date is response context and is not a substitute for the per-symbol date mapping.

How should I budget calls during onboarding?

The Starter plan includes a 7-day trial with 50 calls. Cache static historical ranges to stay within your trial allocation.

Next step

Create your key and run the curl above against your target date range. If you need full parameter details, see the docs. Start here: Register and review the Documentation.

Keywords
historical Denmark West prices Nord Pool day-ahead prices Energy API time series power price backtesting structured energy products

Ready to get started?

Get your API key and start querying energy commodity prices in minutes.

Get API Key

Related posts