Historical Germany EPEX Day-Ahead Prices

You need reliable historical Germany EPEX Day-Ahead power prices for finance workflows—think PnL attribution, backtesting hedges, risk limits, and settlement checks. By the end of this guide, you’ll query, parse, and integrate the Energy API timeseries for the Germany EPEX Day-Ahead symbol (EPEX_DE_DA) into your pricing and risk pipelines.

What the Germany EPEX Day-Ahead series represents (finance context)

Germany EPEX Day-Ahead is a daily day-ahead auction clearing price for electricity in Germany, denominated in EUR/MWh. In finance terms, it feeds into power-linked derivatives valuation, spark/dark spread analysis, structured product cashflows, and VaR scenarios. It is a univariate daily series where the key outputs are the price level (EUR/MWh) and the date it applies to.

Illustration: Historical Germany EPEX Day-Ahead Prices

Core identifiers you will use:

Symbol name: Germany EPEX Day-Ahead
Symbol code: EPEX_DE_DA
Unit: EUR/MWh

Endpoint and authentication

Use the Energy API timeseries endpoint to fetch historical values over a date range. Authentication is via an api_key query parameter. Replace only the key value with your own; keep the parameter name and all other fields unchanged.

HTTP method: GET
Endpoint: /api/v1/timeseries
Query parameters: start, end, symbols, api_key
Base currency: EUR (no base override for this symbol)

Important finance note: Do not pass base=USD when you also need TTF_GAS or EUA_CO2 in the same query. Keep currency handling explicit downstream if you need multi-commodity analytics.

Official cURL request for Germany EPEX Day-Ahead

Copy and run the request below to pull the Germany EPEX Day-Ahead time series for Q1 2026. Keep the URL, parameters, and casing exactly as shown; update only YOUR_API_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=EPEX_DE_DA" --data-urlencode "api_key=YOUR_API_KEY"

Understanding the response schema

The response is designed to be symbol-centric. For each requested symbol, you can read:

rates.SYMBOL: numeric price value(s) keyed by symbol
dates.SYMBOL: date string(s) aligned with rates
currencies.SYMBOL: currency code for the symbol
base: the response base currency (EUR for EPEX_DE_DA)

Official sample response (verbatim)

The following JSON is an official sample you can use to validate field names and parsing logic. Field names and structure are the same when you request EPEX_DE_DA.

{
    "success": true,
    "date": "2026-10-31",
    "base": "EUR",
    "rates": {
        "OMIE_ES_DA": 208.9758
    },
    "dates": {
        "OMIE_ES_DA": "2026-10-31"
    },
    "currencies": {
        "OMIE_ES_DA": "EUR"
    },
    "base_filter_note": null,
    "missing_symbols": null
}

How to read it for finance workflows:

success: boolean for request status; handle false with retries or alerts.
date: the as-of date of the API calculation window; useful for caching/monitoring.
base: response base currency; for EPEX_DE_DA this will be EUR.
rates.SYMBOL: the price you plug into valuation, PnL, and backtesting models.
dates.SYMBOL: the date the rate applies to; align this with your contract delivery calendars.
currencies.SYMBOL: currency code; confirms units for cost and FX handling (EUR/MWh here).
missing_symbols: if present, indicates which requested symbols were unavailable.

Real response values for Germany EPEX Day-Ahead

Below is a real response snippet specifically for EPEX_DE_DA. Use it to verify symbol-specific parsing and units.

Key takeaways for finance integration:

rates.EPEX_DE_DA is the day-ahead auction price level in EUR/MWh.
dates.EPEX_DE_DA is the date key you should use for time indexing in risk and PnL datasets.
currencies.EPEX_DE_DA confirms the price is in EUR, matching common settlement and hedge books for German power.

End-to-end example in Python

The snippet below fetches Germany EPEX Day-Ahead prices for a date range, validates currency, and converts to a pandas Series indexed by the API’s dates field. Adjust the transformation logic to match your risk data model (e.g., business calendars or delivery periods).

import os
import requests

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

params = {
"start": "2026-01-01",
"end": "2026-03-31",
"symbols": "EPEX_DE_DA",
"api_key": API_KEY,
}

resp = requests.get(API_URL, params=params, timeout=30)
resp.raise_for_status()
data = resp.json()

# Basic checks
if not data.get("success", False):
raise RuntimeError("Energy API request failed")

base = data.get("base")
if base != "EUR":
# For EPEX_DE_DA, EUR is expected; flag if different
raise ValueError(f"Unexpected base currency: {base}")

rates = data.get("rates", {})
dates = data.get("dates", {})
curr = data.get("currencies", {})

# Validate symbol presence
symbol = "EPEX_DE_DA"
if symbol not in rates or symbol not in dates or symbol not in curr:
raise KeyError(f"Symbol {symbol} not found in response. Missing: {data.get('missing_symbols')}")

price = rates[symbol]
price_date = dates[symbol]
price_ccy = curr[symbol]

# At this point:
# - price: float (EUR/MWh)
# - price_date: "YYYY-MM-DD"
# - price_ccy: "EUR"
print({"date": price_date, "symbol": symbol, "price": price, "currency": price_ccy})

Operational details that save time

Units and currency: EPEX_DE_DA is in EUR/MWh. The response base is EUR. Keep units intact through your pipeline to avoid silent mispricing.
Dates and timezone: dates.SYMBOL provides the date key (YYYY-MM-DD). Treat it as the market delivery date for day-ahead purposes. If you align to a risk calendar, document any conversions you apply.
Non-trading days: Day-ahead auctions are typically daily. If you observe missing_symbols or unexpected gaps, log and reconcile against your market calendar.
Caching: For historical pulls, cache responses by date range and symbol to minimize repeated calls in backtests and PnL replays.
Pagination: The request model uses start/end boundaries and symbols. If you need very long histories, segment your range (e.g., by quarter) and stitch results offline.
Error handling: Check success, and inspect missing_symbols. For resilience, implement retries with backoff and alert on schema mismatches.
FX handling: Keep everything in EUR for this symbol. If your portfolio is USD-based, convert downstream with your chosen FX source. Do not pass base=USD alongside TTF_GAS or EUA_CO2 in the same request.

Integrating EPEX_DE_DA into finance workflows

Mark-to-market: Use rates.EPEX_DE_DA as the daily mark for German power exposures. Store alongside contract identifiers and tenor mapping rules.
Spark/dark spreads: Combine EPEX_DE_DA with your fuel and emissions inputs to compute margin metrics. Ensure synchronized dates and consistent units.
Risk and VaR: Build daily return series from the EUR/MWh levels, then feed into historical simulation or parametric engines. Verify day alignment to avoid look-ahead bias.
Backtesting hedges: For forwards or options strategies linked to spot/day-ahead references, replay PnL using the dates.SYMBOL index to reproduce historical cashflows.
Settlement checks: Compare contract settlement prices against the day-ahead series on the contractual delivery dates for discrepancy analysis.

Quality checks and data hygiene

Schema lock: Always reference fields exactly as returned: rates.EPEX_DE_DA, dates.EPEX_DE_DA, currencies.EPEX_DE_DA.
Monotone validation: Day-ahead price levels can be volatile; do not clamp. Instead, set statistical guards that alert on outliers without auto-correcting.
Reconciliation window: If you import intraday or balancing markets elsewhere, keep this series isolated and reconcile in a downstream layer to prevent unit contamination.
Reproducibility: Persist raw API JSON alongside your normalized time series so audits can retrace the exact values and response metadata (success, date, base).

Common pitfalls to avoid

Mixing units: Never combine EUR/MWh with €/kWh or €/MWh from other sources without explicit conversion.
Assuming business-day frequency: Treat the series as daily, not business-day. Forward-fill or filter only with documented rules in your valuation stack.
Implicit FX: Keep EUR values until the final reporting layer. Convert once, with documented FX, to prevent double conversion.
Parameter drift: Do not rename or omit required params (start, end, symbols, api_key). Keep symbol casing exact: EPEX_DE_DA.

Checklist before go-live

Access: Confirm your api_key is stored securely and rotated per policy.
Coverage: Verify the historical range you need by calling the endpoint in quarterly slices and checking for gaps.
Monitoring: Log success, date, base, and missing_symbols for each pull. Set alerts on non-success or empty symbol payloads.
Backfill plan: Establish a cron or batch job to backfill recent days and to refresh late corrections if your controls require it.

FAQ

Q: What is the unit and currency of EPEX_DE_DA?
A: EUR per MWh (EUR/MWh). The response base is EUR, and currencies.EPEX_DE_DA is EUR.

Q: How do I request a historical window?
A: Use GET /api/v1/timeseries with start, end, symbols=EPEX_DE_DA, and api_key. Slice long ranges by month or quarter if needed.

Q: How do I handle days with no data?
A: Inspect missing_symbols and validate dates.SYMBOL continuity. Decide whether to gap, forward-fill (with disclosure), or exclude from PnL—document your method.

Q: Can I request multiple commodities together?
A: Yes, by comma-separating symbols. However, do not pass base=USD when you also need TTF_GAS or EUA_CO2. Keep currency conversions downstream.

Q: Where can I see all response fields and edge cases?
A: Review the API reference in the Documentation.

Start pulling historical Germany EPEX Day-Ahead prices into your finance stack now. Create an account and get your key: Register.