Germany EPEX Day-Ahead Price API
You need a reliable way to fetch the latest Germany EPEX Day-Ahead power price for trading, risk, and settlement workflows. By the end of this guide, you’ll be able to call the Energy API’s latest-price endpoint for the EPEX_DE_DA symbol, parse the response fields you need (rate, date, unit, currency), and ship a production-ready integration with clear rules on units, base currency, and update cadence.
What the Germany EPEX Day-Ahead symbol represents
Germany EPEX Day-Ahead provides the latest day-ahead wholesale electricity price for Germany from EPEX, denominated in EUR per MWh. The Energy API symbol code for this market is EPEX_DE_DA. You will read the numeric value from rates.EPEX_DE_DA and the ISO date from dates.EPEX_DE_DA. The unit is EUR/MWh and the currency is provided at currencies.EPEX_DE_DA.
This symbol is frequently used in finance workflows such as P&L for power trading desks, risk factor marks, indexation for PPAs, and settlement preparation. Because it is a day-ahead benchmark, treat its update cadence as daily and build your caches and cron schedules accordingly.
Endpoint, authentication, and required parameters
Use the latest endpoint with a simple GET request. Authentication is via an api_key query parameter. Pass the symbol code EPEX_DE_DA via symbols, and do not include any base= parameter unless you explicitly need it for other multi-symbol scenarios.
- HTTP method: GET
- URL: https://energy-api.com/api/v1/latest
- Required query parameters: symbols, api_key
- Auth: api_key query parameter; use YOUR_API_KEY as a placeholder during setup
- Response fields of interest: rates.EPEX_DE_DA, dates.EPEX_DE_DA, currencies.EPEX_DE_DA, base
Catalog and pricing facts you should be aware of:
- Symbol name: Germany EPEX Day-Ahead
- Symbol code: EPEX_DE_DA
- Unit: EUR/MWh
- Auth: api_key query parameter (use YOUR_API_KEY placeholder)
- Do not pass base=USD when you also need TTF_GAS or EUA_CO2 (their base is MIXED)
- No MCP host
- Starter plan: $19.99/mo; trial is 7 days / 50 calls
If you need plan or field-level clarifications beyond what’s covered here, see the official Documentation.
Quickstart: copy-paste cURL
Use this request to fetch the current Germany EPEX Day-Ahead price. Replace YOUR_API_KEY with your token from registration.
curl -G "https://energy-api.com/api/v1/latest" --data-urlencode "symbols=EPEX_DE_DA" --data-urlencode "api_key=YOUR_API_KEY"
Reading the latest-price JSON response
The Energy API latest endpoint returns a compact JSON object with a top-level base, a rates map keyed by the symbol code, per-symbol dates, and per-symbol currencies. Below are complete examples you can use to validate your parser and unit tests.
Example A — Germany EPEX Day-Ahead (official live response)
{"success":true,"date":"2026-11-17","base":"EUR","rates":{"EPEX_DE_DA":211.5799},"dates":{"EPEX_DE_DA":"2026-11-17"},"currencies":{"EPEX_DE_DA":"EUR"},"base_filter_note":null,"missing_symbols":null}
What to read:
- rates.EPEX_DE_DA = 211.5799 (numerical latest price)
- dates.EPEX_DE_DA = 2026-11-17 (ISO date for the symbol)
- currencies.EPEX_DE_DA = EUR (matches the unit currency)
- base = EUR (base currency context for this response)
Example B — Official sample block (verbatim)
The following JSON is an official sample. Use it to structure your parser, but rely on Example A for the EPEX_DE_DA price value.
{
"success": true,
"date": "2026-11-17",
"base": "EUR",
"rates": {
"OMIE_ES_DA": 64.5631
},
"dates": {
"OMIE_ES_DA": "2026-11-17"
},
"currencies": {
"OMIE_ES_DA": "EUR"
},
"base_filter_note": null,
"missing_symbols": null
}
Example C — Germany EPEX Day-Ahead (repeat for integration testing)
{"success":true,"date":"2026-11-17","base":"EUR","rates":{"EPEX_DE_DA":211.5799},"dates":{"EPEX_DE_DA":"2026-11-17"},"currencies":{"EPEX_DE_DA":"EUR"},"base_filter_note":null,"missing_symbols":null}
This repeated example is identical to Example A and is useful for writing deterministic tests in CI until you wire your integration to live tokens and dynamic assertions.
Python example: fetch and parse EPEX_DE_DA
The snippet below retrieves the latest price for EPEX_DE_DA, converts the rate to a float, validates the currency and unit assumptions, and prints a structured record suitable for databases or time-series pipelines.
import os
import sys
import json
import urllib.parse
import urllib.request
API_URL = "https://energy-api.com/api/v1/latest"
API_KEY = os.environ.get("ENERGY_API_KEY", "YOUR_API_KEY")
SYMBOL = "EPEX_DE_DA"
def fetch_latest(symbol):
params = {
"symbols": symbol,
"api_key": API_KEY
}
url = API_URL + "?" + urllib.parse.urlencode(params)
req = urllib.request.Request(url, method="GET")
with urllib.request.urlopen(req, timeout=20) as resp:
body = resp.read().decode("utf-8")
return json.loads(body)
def main():
data = fetch_latest(SYMBOL)
# Basic validations
if not data.get("success", False):
print("API did not return success=true", file=sys.stderr)
sys.exit(1)
base = data.get("base")
rate = data.get("rates", {}).get(SYMBOL)
date_str = data.get("dates", {}).get(SYMBOL)
ccy = data.get("currencies", {}).get(SYMBOL)
if rate is None or date_str is None or ccy is None:
print("Missing expected fields for symbol", SYMBOL, file=sys.stderr)
sys.exit(1)
# For EPEX_DE_DA we expect EUR/MWh. Validate currency field.
if ccy != "EUR":
print(f"Unexpected currency for {SYMBOL}: {ccy}", file=sys.stderr)
sys.exit(1)
record = {
"symbol": SYMBOL,
"price": float(rate), # EUR per MWh
"price_unit": "EUR/MWh",
"price_date": date_str, # ISO date
"response_base": base # "EUR" in the sample shown
}
print(json.dumps(record, ensure_ascii=False))
if __name__ == "__main__":
main()
Notes:
- The code reads rates.EPEX_DE_DA, dates.EPEX_DE_DA, currencies.EPEX_DE_DA, and base.
- Keep your timeout reasonable (e.g., 20 seconds) and handle non-success responses.
- Avoid applying cross-currency conversion when you only fetch EPEX_DE_DA; treat the value as EUR/MWh directly.
When to trust base, currency, and unit
For EPEX_DE_DA, the unit is EUR/MWh and the currencies.EPEX_DE_DA field will be EUR. The top-level base in the examples is EUR, which is consistent with a single-symbol request for a euro-denominated series. If you ever request baskets that include symbols with heterogeneous currencies (for example, cases that involve TTF_GAS or EUA_CO2), the base may be MIXED. In those baskets, do not pass base=USD for TTF_GAS or EUA_CO2 and handle currency per symbol using currencies.<SYMBOL>.
Many financial systems store both the raw quote and a normalized value. For EPEX_DE_DA, the raw quote is already in EUR/MWh, so normalization is usually a 1:1 mapping unless your internal books require conversion to a reporting currency.
Update cadence, market days, and caching
Germany EPEX Day-Ahead is published on a daily cadence aligned with the day-ahead schedule. Treat missing intraday changes as expected behavior for a day-ahead index and build your polling windows around daily updates rather than intraday ticks. If your workflow runs nightly marks, a single fetch per update window is often sufficient.
Practical tips:
- Cache the last successful response for at least a few minutes to protect against transient network issues.
- Store both the response date and dates.EPEX_DE_DA; they can differ from your server clock, and the symbol date is authoritative for the mark.
- If you hit nulls in missing_symbols, log and alert. It indicates symbols that were not recognized.
- Use idempotent retries with exponential backoff and do not hammer the endpoint.
Error handling and field-by-field validation
Always verify success is true before parsing rates. Validate that rates.EPEX_DE_DA is numeric, dates.EPEX_DE_DA is a YYYY-MM-DD string, and currencies.EPEX_DE_DA is an expected currency code (EUR here). The base_filter_note field may be null; you can log it when present to understand any base-related adjustments.
Example of a robust parse routine:
- Check HTTP 200 and JSON parse success.
- Assert data.success == true.
- Assert "EPEX_DE_DA" in data.rates and data.dates and data.currencies.
- Assert data.currencies["EPEX_DE_DA"] == "EUR" and treat the value as EUR/MWh.
- Persist the trio (value, date, currency) with a recorded API response timestamp from your system.
Official samples required for integration
Use the following official cURL exactly as shown when testing connectivity and query parameter formatting. It targets the latest endpoint and the EPEX_DE_DA symbol using an api_key:
curl -G "https://energy-api.com/api/v1/latest" --data-urlencode "symbols=EPEX_DE_DA" --data-urlencode "api_key=YOUR_API_KEY"
And keep this official sample JSON handy to confirm your parser handles the fields properly (this block is verbatim):
{
"success": true,
"date": "2026-11-17",
"base": "EUR",
"rates": {
"OMIE_ES_DA": 64.5631
},
"dates": {
"OMIE_ES_DA": "2026-11-17"
},
"currencies": {
"OMIE_ES_DA": "EUR"
},
"base_filter_note": null,
"missing_symbols": null
}
For your Germany integration, parse EPEX_DE_DA values using the real response example shown earlier.
Operational guidance for finance teams
Many finance users incorporate EPEX_DE_DA into daily VAR, P&L explain, hedge ratios, and pricing models for structured power deals. Common operational practices include:
- Storing the day-ahead price keyed by trade date or delivery date, depending on your internal convention.
- Versioning: keep a snapshot per API response date to allow recon and audit of marks.
- Validation rules: reject values that deviate beyond reasonable bounds relative to a rolling average, and queue for manual review rather than overwriting production marks.
- Downstream propagation: publish normalized JSON or CSV to a message bus so risk engines and reporting systems don’t have to integrate the external API directly.
Frequently asked questions
Q1: What symbol code should I request for the Germany EPEX day-ahead price?
A1: Use EPEX_DE_DA. Read the numeric from rates.EPEX_DE_DA and the date from dates.EPEX_DE_DA.
Q2: What unit and currency does the price use?
A2: EUR/MWh. The currency field for this symbol is EUR, and the unit is implied by the symbol’s catalog definition.
Q3: Do I need to pass a base= parameter?
A3: Not for a single EPEX_DE_DA request. If you later request baskets that include symbols such as TTF_GAS or EUA_CO2, do not pass base=USD when you also need those; handle currencies per symbol via currencies.<SYMBOL> as the base may be MIXED.
Q4: How often should I poll the endpoint?
A4: EPEX_DE_DA is a day-ahead series, so daily polling around the publication window is appropriate. Cache and avoid unnecessary intraday calls for the same date.
Q5: What are the plan and trial details?
A5: The Starter plan is $19.99 per month, and the trial lasts 7 days with 50 calls.
Next step
Create your API key and ship your integration. Register for access here: Register. For endpoint specifics, field definitions, and additional examples, see the Documentation.
Ready to get started?
Get your API key and start querying energy commodity prices in minutes.
Get API KeyRelated posts
Unlock the power of the Finance API to seamlessly integrate Germany EPEX Day-Ahead prices into your workflows....
Read more →
Unlock reliable historical day-ahead power prices in Germany with our Finance API guide. Streamline your valua...
Read more →