Germany EPEX Day-Ahead Historical Price API

You need to pull reliable historical day-ahead power prices for Germany and wire them into a finance workflow for valuation, PnL attribution, or risk reporting. By the end of this guide, you will query the Germany EPEX Day-Ahead timeseries using a single endpoint, parse only the fields you need, and handle practical concerns like dates, units, and caching so you can ship an integration fast.

What you’ll get: Germany EPEX Day-Ahead (EPEX_DE_DA) for finance use cases

This guide focuses on the Energy API symbol “Germany EPEX Day-Ahead”. It is identified by the symbol code EPEX_DE_DA and priced in EUR/MWh. You will learn how to fetch time-bounded historical data using GET /api/v1/timeseries and read the specific fields that matter for financial calculations: rates (the price), dates (the effective date per symbol), and currencies (the unit of account for the returned series).

Finance teams typically use this dataset to support:

• Backfilling pricing inputs in valuation models for German power exposures.
• Hedge effectiveness and mark-to-market reports where EPEX day-ahead serves as the observable price.
• Scenario testing and sensitivity analysis that require historical day-ahead prices in consistent units.

All examples below stay within this exact symbol, endpoint, and field set. You will not need to mix categories or handle cross-asset conversions for this basic integration. Keep your calculations in EUR unless your own risk engine mandates conversion downstream.

Endpoint and authentication: the one call you need

You will use the timeseries endpoint and pass your api_key as a query parameter. Do not use any other host, and do not add unsupported parameters. The three core parameters are start, end, and symbols.

• Endpoint: https://energy-api.com/api/v1/timeseries
• Method: GET (with query string parameters)
• Auth: api_key query parameter using the placeholder YOUR_API_KEY only
• Symbol: EPEX_DE_DA
• Units: EUR/MWh (exposed via currencies.EPEX_DE_DA)

Free trial details: Starter $19.99/mo, trial 7 days / 50 calls. If you are not yet set up, use the Register link at the end of this post to enroll and get an API key.

Official cURL example (copy-paste)

This cURL is the canonical format for retrieving a timeseries for a bounded range. Use it as-is when testing your key and connectivity. You may then narrow or widen dates as needed.

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"

Response structure: what to read and why it matters

The response includes high-level metadata and per-symbol fields you will actually consume in your finance logic. You will rely on:

• rates.EPEX_DE_DA — the price in EUR/MWh, keyed by the symbol.
• dates.EPEX_DE_DA — the date the rate applies to for this symbol.
• currencies.EPEX_DE_DA — confirms units (EUR) so you can avoid unit mismatches in valuation.
• base — the base currency context for the response (EUR in these examples).

Official sample JSON (copy verbatim)

This is the official sample block. Although it showcases a different market symbol (OMIE_ES_DA), the field structure is identical to EPEX_DE_DA. Use this to understand keys and their layout; then apply the same parsing to EPEX_DE_DA.

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

Field highlights for finance readers:

• success: Boolean health check; gate further processing on this.
• date: Top-level server date context; do not confuse with per-symbol dates.
• rates: Numeric values per symbol, in the currency shown under currencies.
• dates: Effective date per symbol; align with your valuation date to avoid off-by-one errors.
• currencies: The unit per symbol; for EPEX_DE_DA, it will be EUR.

Real EPEX_DE_DA JSON (copy verbatim)

Below is a real EPEX_DE_DA response sample to demonstrate the exact keys you will parse for Germany EPEX Day-Ahead. Use these values in your initial tests and confirm your parser correctly accesses the EPEX_DE_DA keys.

{"success":true,"date":"2026-10-16","base":"EUR","rates":{"EPEX_DE_DA":206.7074},"dates":{"EPEX_DE_DA":"2026-10-16"},"currencies":{"EPEX_DE_DA":"EUR"},"base_filter_note":null}

In production code, you will:

• Read rates.EPEX_DE_DA for the price.
• Read dates.EPEX_DE_DA to align with your report or valuation date.
• Verify currencies.EPEX_DE_DA to confirm your downstream calculations are in EUR/MWh.

Same EPEX_DE_DA structure emphasized

Here is the same structural example again to emphasize exactly which fields you will reference in your scripts when building unit tests or quick diagnostics. Consistency in targeting the EPEX_DE_DA keys ensures your logic doesn’t drift if you later add more symbols to the same request.

{"success":true,"date":"2026-10-16","base":"EUR","rates":{"EPEX_DE_DA":206.7074},"dates":{"EPEX_DE_DA":"2026-10-16"},"currencies":{"EPEX_DE_DA":"EUR"},"base_filter_note":null}

End-to-end example in Python

The following snippet calls the same endpoint, checks success, and extracts the EPEX_DE_DA price, date, and currency. It avoids assumptions about missing fields and will fail fast if the response does not contain the expected keys.

import os
import sys
import json
import urllib.parse
import urllib.request

def fetch_epex_de_da(start_date, end_date, api_key):
base_url = "https://energy-api.com/api/v1/timeseries"
params = {
"start": start_date,
"end": end_date,
"symbols": "EPEX_DE_DA",
"api_key": api_key
}
url = base_url + "?" + urllib.parse.urlencode(params)
req = urllib.request.Request(url, method="GET")
with urllib.request.urlopen(req, timeout=30) as resp:
data = resp.read().decode("utf-8")
payload = json.loads(data)
return payload

def read_epex_fields(payload):
if not payload.get("success"):
raise RuntimeError("API reported unsuccessful response")
rates = payload.get("rates", {})
dates = payload.get("dates", {})
currencies = payload.get("currencies", {})

# Access the Germany EPEX Day-Ahead fields directly by symbol code
price = rates.get("EPEX_DE_DA")
price_date = dates.get("EPEX_DE_DA")
currency = currencies.get("EPEX_DE_DA")

if price is None or price_date is None or currency is None:
raise KeyError("Missing one of required keys: rates.EPEX_DE_DA, dates.EPEX_DE_DA, currencies.EPEX_DE_DA")

return price, price_date, currency

if __name__ == "__main__":
# Accept API key from ENV or replace with YOUR_API_KEY for quick tests
api_key = os.environ.get("ENERGY_API_KEY", "YOUR_API_KEY")

# Example time window: quarter-to-date for a historical backfill
start = "2026-01-01"
end = "2026-03-31"

try:
payload = fetch_epex_de_da(start, end, api_key)
price, price_date, currency = read_epex_fields(payload)
print(f"EPEX_DE_DA price: {price} {currency}/MWh on {price_date}")
except Exception as exc:
print(f"Error: {exc}", file=sys.stderr)
sys.exit(1)

Notes for integration:

• If you routinely need to compare multiple commodities in one pull, add more symbols to the same symbols parameter, then read each under its own key in rates, dates, and currencies.
• For finance control checks, assert currencies.EPEX_DE_DA == "EUR" and base == "EUR" before you use the price in your valuation pipeline.

Practical data handling: dates, units, and non-trading days

When building a production-grade finance integration, the following details reduce errors and rework:

• Dates: The timeseries request uses start and end in YYYY-MM-DD. The per-symbol date you should align to is in dates.EPEX_DE_DA. Treat this as the price’s effective date for Germany EPEX Day-Ahead.
• Units: Prices are EUR/MWh. The API exposes this via currencies.EPEX_DE_DA = "EUR". If you must convert to another currency, do so downstream in your valuation engine with your FX policy. Keep the raw power prices in EUR to avoid irreversibility.
• Time zone: The response date is a calendar date per symbol; you typically treat it as end-of-day for finance reporting. If you reconcile to exchange calendars, use dates.EPEX_DE_DA as your canonical anchor.
• Non-trading or holiday behavior: Day-ahead markets publish prices daily, but your backfill should still tolerate occasional gaps. Use a deterministic forward- or back-fill rule in your warehouse layer if your reports require continuity, and document your fill policy.
• Caching: If you re-run the same start/end window within short intervals, cache the response payload by a hash of the full URL (parameters included) to avoid burning trial calls. Store both the raw JSON and a parsed rowset keyed by dates.EPEX_DE_DA.

Using the endpoint for finance workflows

Common finance workflows that call this endpoint include:

• Daily pricing job: Pull yesterday’s value and write it to your pricing table keyed by dates.EPEX_DE_DA.
• Valuation batch: For revaluations, pass a historical range (e.g., quarter-to-date), then iterate the single response rather than firing multiple requests. If your organization mandates granular audit logs, persist the entire JSON for traceability.
• PnL explain: Keep a cache of prior day’s price and today’s price to compute the day-over-day delta from rates.EPEX_DE_DA for attribution. Always cite the date from dates.EPEX_DE_DA in your PnL explain table.

Common pitfalls and how to avoid them

• Mixing symbols that require different bases: Do not pass base=USD when you also need TTF_GAS or EUA_CO2. Keep the default base (EUR) for EPEX_DE_DA and handle currency conversion downstream if needed.
• Assuming one date field: The top-level date is not the same as dates.EPEX_DE_DA. For reconciliations and joins to your finance calendar, always use the per-symbol date.
• Silent unit mismatches: Read currencies.EPEX_DE_DA and assert it is EUR before any multiplication or unit cost allocation. This prevents mismatched unit bugs during downstream netback or tariff modeling.
• Under-parsing the timeseries: Even if you query a wide window, you still read by symbol keys. Keep your parser symbol-aware so it scales when you add more energy curves later.
• Overfetch during trial: The trial is 7 days / 50 calls. Cache aggressively during development to stay within this envelope.

Additional JSON examples for quick inspection

If you are wiring tests or writing fixtures, you can use the official sample block below to validate your JSON decoder and field lookup. It demonstrates identical structure, which your parser can handle without special cases.

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

And for the exact Germany EPEX Day-Ahead symbol you will parse in production:

{"success":true,"date":"2026-10-16","base":"EUR","rates":{"EPEX_DE_DA":206.7074},"dates":{"EPEX_DE_DA":"2026-10-16"},"currencies":{"EPEX_DE_DA":"EUR"},"base_filter_note":null}

Use this repeated EPEX_DE_DA fixture to ensure your tests assert both the numeric value and the expected date and unit keys:

{"success":true,"date":"2026-10-16","base":"EUR","rates":{"EPEX_DE_DA":206.7074},"dates":{"EPEX_DE_DA":"2026-10-16"},"currencies":{"EPEX_DE_DA":"EUR"},"base_filter_note":null}

Verification checklist before going live

• Authentication: Your request includes api_key=YOUR_API_KEY in the query parameters.
• Endpoint: Using GET https://energy-api.com/api/v1/timeseries with start, end, and symbols=EPEX_DE_DA.
• Parsing: Code reads rates.EPEX_DE_DA, dates.EPEX_DE_DA, currencies.EPEX_DE_DA, and validates success is true and base is EUR.
• Units: You log or assert currencies.EPEX_DE_DA == "EUR" before writing to your pricing tables.
• Caching: You store responses or derived rows to reduce repeated calls during development and CI.
• Observability: You capture the full URL and response payload for audit and incident triage.

Troubleshooting FAQ

Q: My response is missing EPEX_DE_DA under rates. What should I check?
A: Verify the symbols parameter is exactly EPEX_DE_DA and that success is true. Then confirm you are querying a date range that includes the dates you expect. Finally, inspect the JSON keys in rates, dates, and currencies to ensure you are not reading a different symbol by mistake.

Q: How do I ensure my valuation aligns to the correct date?
A: Use dates.EPEX_DE_DA, not the top-level date. Treat that per-symbol date as the effective date for Germany EPEX Day-Ahead in your joins and valuation cutoffs.

Q: Can I request multiple energy symbols in one call?
A: Yes—add them to symbols as a comma-separated list, then read each symbol’s values from the rates, dates, and currencies maps. Keep assertions per symbol to avoid unit or date mismatches.

Q: Should I convert prices to USD in the API call?
A: No. Do not pass base=USD when you also need TTF_GAS or EUA_CO2. For EPEX_DE_DA, keep the default base of EUR. If your finance stack requires USD, convert downstream using your approved FX source.

Q: How do I stay within the trial limits?
A: Cache by URL (including query parameters). During local development, store raw JSON files keyed by the date window and symbol set. Reuse those fixtures in tests to avoid repeated network calls.

Ready to pull Germany EPEX Day-Ahead historical prices into your finance pipeline? Create your key and start testing in minutes: Register. For full parameter details and further examples, see the Documentation.