Denmark West Nord Pool Day-Ahead Historical Price API

You need reliable, queryable historical day-ahead power prices for the Denmark West bidding zone (DK1) to drive finance workflows like PnL attribution, hedging backtests, invoice validation, or risk factor calibration. By the end of this guide, you will retrieve and parse Denmark West Nord Pool Day-Ahead prices via the Energy API timeseries endpoint, extract the unit- and currency-correct values, and integrate them into a finance-grade pipeline.

What you’re pulling: the Denmark West Nord Pool Day-Ahead series

This post focuses on a single, finance-relevant market data symbol from the Energy API catalog:

• Symbol name: Denmark West Nord Pool Day-Ahead
• Symbol code: NORDPOOL_DK1_DA
• Unit: EUR/MWh

The series is designed for finance and risk applications: daily day-ahead settlement prices for the DK1 bidding zone. Values are denominated in EUR per MWh, enabling consistent portfolio normalization and cross-market comparisons without FX translation at the point of ingestion.

Endpoint, authentication, and plan basics

You will query the timeseries endpoint:

• HTTP method: GET
• Endpoint: /api/v1/timeseries
• Query parameters: start, end, symbols, api_key
• Auth: api_key as a query parameter (use YOUR_API_KEY only in examples)

Starter plan is $19.99/mo with a 7-day trial and 50 calls included, suitable for proof-of-concept backfills and small batch finance jobs. There is no MCP host requirement.

Important note for multi-commodity finance stacks: do not pass base=USD when you also need TTF_GAS or EUA_CO2 in the same call. Keep the base in EUR to avoid base filtering interactions, then convert downstream in your pricing engine if required.

Quickstart: copy-paste cURL for Denmark West Nord Pool Day-Ahead

Call the timeseries endpoint over a defined delivery window, filtering to the DK1 day-ahead symbol. 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"

This request asks for the Denmark West Nord Pool Day-Ahead series over 2026-01-01 to 2026-03-31. Store the response as JSON; you will read the values from the rates, dates, and currencies maps keyed by the symbol code NORDPOOL_DK1_DA.

Official JSON examples you should model against

Use the following samples to validate parsing logic, response shape, and field names in your finance integration.

REAL API RESPONSE for Denmark West Nord Pool Day-Ahead

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

What to read and why (finance use):

• base: EUR. Treat the numeric tick as a EUR-based figure for valuation.
• rates.NORDPOOL_DK1_DA: 162.1159 (EUR/MWh). Use in PnL, VaR inputs, and accruals.
• dates.NORDPOOL_DK1_DA: 2026-10-18. Use as the valuation/delivery date index key.
• currencies.NORDPOOL_DK1_DA: EUR. Confirms currency of the returned series.

OFFICIAL SAMPLE (shape reference)

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

This official example demonstrates the same field layout you’ll parse for NORDPOOL_DK1_DA: maps keyed by symbol, a base currency field, and the latest date. The symbol in this sample is different but the structure is identical.

REAL API RESPONSE (repeat for cache verification and test fixtures)

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

Reusing this response as a test fixture helps verify idempotent caching and correct symbol-key lookups in downstream risk engines and finance data lakes.

How the JSON maps into your finance model

Finance systems typically normalize market data into fact tables keyed by date, symbol, currency, and unit. From the REAL API RESPONSE above, you would write the following record:

• valuation_date: 2026-10-18
• symbol_code: NORDPOOL_DK1_DA
• price: 162.1159
• unit: EUR/MWh
• currency: EUR

This table becomes the single source of truth for:

• Backtesting day-ahead procurement or hedge strategies in DK1
• Marking to market structured power deals whose pricing references Nord Pool DK1 DA
• Accruing invoices and validating settlement using day-ahead references

Reading the fields you actually need

Keep the parsing logic minimal and robust:

• Use the symbol key NORDPOOL_DK1_DA consistently when accessing rates, dates, and currencies.
• Interpret base as a contextual field. Values for NORDPOOL_DK1_DA are in EUR as shown by currencies.NORDPOOL_DK1_DA; keep this explicit in your records.
• Use dates.NORDPOOL_DK1_DA as the canonical observation date for your time index.

When requesting a range (start and end provided), deserialize the response once and iterate the symbol’s returned map(s). The endpoint and samples provided here illustrate symbol-keyed maps; consult the Documentation for any additional structures you might encounter for multi-day retrievals.

Python example: query and insert into a finance datastore

This example requests the DK1 day-ahead series and extracts price, currency, and date for persistence. It follows the same endpoint and fields you saw in the REAL API RESPONSE.

import os
import json
import datetime as dt
import urllib.parse
import urllib.request

API_URL = "https://energy-api.com/api/v1/timeseries"

def fetch_dk1_da(start_date: str, end_date: str, api_key: str) -> dict:
params = {
"start": start_date,
"end": end_date,
"symbols": "NORDPOOL_DK1_DA",
"api_key": api_key
}
url = API_URL + "?" + urllib.parse.urlencode(params)
with urllib.request.urlopen(url) as resp:
return json.loads(resp.read().decode("utf-8"))

def extract_rows(payload: dict):
sym = "NORDPOOL_DK1_DA"
base = payload.get("base")
rates = payload.get("rates", {})
dates = payload.get("dates", {})
currencies = payload.get("currencies", {})
if sym not in rates:
raise KeyError(f"{sym} missing in rates")
if sym not in dates:
raise KeyError(f"{sym} missing in dates")
if sym not in currencies:
raise KeyError(f"{sym} missing in currencies")

value = float(rates[sym])
obs_date = dates[sym] # "YYYY-MM-DD"
ccy = currencies[sym] # "EUR"

# Normalize into a finance-ready row
return {
"valuation_date": obs_date,
"symbol_code": sym,
"price": value,
"unit": "EUR/MWh",
"currency": ccy,
"base": base
}

if __name__ == "__main__":
api_key = os.environ.get("ENERGY_API_KEY", "YOUR_API_KEY")
payload = fetch_dk1_da("2026-01-01", "2026-03-31", api_key)
row = extract_rows(payload)
# Example: print or insert into a DB table (omitted)
print(json.dumps(row, indent=2))

In a production finance pipeline, write the returned row into your market data table keyed by (valuation_date, symbol_code). If you are retrieving multiple days, extend the extraction logic to iterate the symbol-keyed series layout per the Documentation.

Production details that save time in finance workflows

• Units and currencies: The DK1 day-ahead series is in EUR/MWh and reported as EUR in the currencies map. Avoid double-converting by keeping all power legs in EUR and converting at your FX layer later if needed for USD reporting.
• Base currency field: base: "EUR" appears at the top level. This reflects the reference currency context; the per-symbol currencies map is authoritative for symbol currency.
• Date semantics: The dates map provides the market date for the value. Index your fact table by this date to align with settlements and day-ahead delivery conventions.
• Weekends and non-trading days: Day-ahead power runs daily; nevertheless, always trust the dates map provided in the response when generating your calendar for accruals.
• Caching: Cache by (start, end, symbols) plus your normalized key (valuation_date, symbol). Validate caches by comparing both the response date field and the symbol-level dates map.
• Backfills: For historical finance backfills, step through monthly windows and write idempotently by upsert on (valuation_date, symbol_code). Respect trial call caps (7 days / 50 calls) by batching ranges.
• Portfolio joins: Map symbol_code=NORDPOOL_DK1_DA to trade legs that reference Nord Pool DK1. Ensure contract UOM is MWh to avoid scaling errors.
• Multi-commodity calls: If mixing with other symbols like TTF_GAS or EUA_CO2, do not add base=USD. Keep base in EUR and convert externally to maintain consistency and avoid base filter notes.

End-to-end workflow: from API call to PnL impact

Here’s a compact flow you can adapt:

1. Schedule a nightly job to request NORDPOOL_DK1_DA for the relevant window using GET /api/v1/timeseries with your api_key.
2. Parse base, rates.NORDPOOL_DK1_DA, dates.NORDPOOL_DK1_DA, and currencies.NORDPOOL_DK1_DA.
3. Insert into a market data table keyed by (valuation_date, symbol_code) with price and currency stored as numeric and text fields respectively; enforce unit EUR/MWh.
4. Run PnL calc by revaluing positions whose price index equals NORDPOOL_DK1_DA, multiplying by exposure (MWh) and converting to report currency as needed.
5. Archive raw JSON responses for audit; store the base_filter_note field alongside for completeness (null in current samples).

Verifying integration with sample responses

Use the following JSON to validate your pipeline. Ensure your parser reads the same values and writes the same database row, including currency and date fields.

Shape validation using the official sample

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

Even though this symbol differs from DK1, the structure is the same. Your DK1 parser should work identically once keyed to NORDPOOL_DK1_DA.

Value and date verification using the real DK1 response

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

Confirm that your loader writes price=162.1159, currency=EUR, valuation_date=2026-10-18, symbol=NORDPOOL_DK1_DA, unit=EUR/MWh.

Common pitfalls and how to avoid them

• Mixing bases: Do not request base=USD when also pulling TTF_GAS or EUA_CO2. Keep EUR base and handle FX later to maintain parity across energy legs in your finance stack.
• Assuming the wrong unit: Always store unit=EUR/MWh in your market data schema for DK1 DA. Unit errors can silently skew PnL and risk by orders of magnitude.
• Discarding dates: Use the dates map to index your time series. Never infer dates from filenames or job timestamps.
• Ignoring currency map: currencies.NORDPOOL_DK1_DA confirms EUR. Store explicitly and convert at the reporting layer only when necessary.
• Skipping symbol keys: Read values by the exact code NORDPOOL_DK1_DA across rates, dates, and currencies. Hardcoding positions in arrays will break on format changes or additional symbols.

FAQ

Q: What is the correct symbol code for Denmark West Nord Pool Day-Ahead?
A: Use NORDPOOL_DK1_DA. It is quoted in EUR/MWh.

Q: Where do I find the numeric price, date, and currency in the response?
A: Read rates.NORDPOOL_DK1_DA for the value, dates.NORDPOOL_DK1_DA for the YYYY-MM-DD date, and currencies.NORDPOOL_DK1_DA for the currency (EUR). The base field at the root is EUR in the samples.

Q: Can I query a historical range for backtesting?
A: Yes. Supply start and end with symbols=NORDPOOL_DK1_DA on GET /api/v1/timeseries. Parse the symbol-keyed maps as shown. For additional response shapes when retrieving multiple days, see the Documentation.

Q: How should I handle currency conversions for finance reporting?
A: Store the DK1 DA series natively in EUR/MWh and convert at your reporting layer using your internal FX stack to avoid inconsistencies across multi-commodity portfolios.

Q: What are the trial limits?
A: The trial period is 7 days with 50 calls, which is typically enough to validate your integration and run a small historical test.

Get access and start pulling DK1 day-ahead data

Register for an API key and run the cURL in this guide against your finance environment. You’ll have DK1 day-ahead prices ready for PnL and risk within minutes. Start here: Register. For endpoint specifics and additional symbols, read the Documentation.