Austria EPEX Day-Ahead Historical Price API

You need reliable, machine-readable Austria EPEX Day-Ahead prices for finance workflows (backtesting, valuation inputs, and risk dashboards). By the end of this guide, you will be able to pull a clean historical time series for the EPEX_AT_DA symbol from the Energy API, parse the response, and integrate it into your analytics or ETL pipeline.

What you will integrate

This guide focuses on one instrument: Austria EPEX Day-Ahead electricity prices.

• Symbol name: Austria EPEX Day-Ahead
• Symbol code: EPEX_AT_DA
• Unit: EUR/MWh
• Endpoint: GET /api/v1/timeseries
• Auth: api_key query parameter (use YOUR_API_KEY)
• Starter plan: $19.99/mo, trial 7 days / 50 calls
• Note: Do not pass base=USD when you also need TTF_GAS or EUA_CO2.
• No MCP host is required.

We will stay on the Austria EPEX Day-Ahead symbol and use the timeseries endpoint with start, end, and symbols query parameters, plus api_key for authentication.

How the timeseries endpoint works

The timeseries endpoint accepts a date range and one or more symbols. It returns a JSON payload keyed by the symbol code. You will read the following fields:

• rates.EPEX_AT_DA: numeric price values in EUR/MWh
• dates.EPEX_AT_DA: the date associated with the returned price (ISO 8601)
• currencies.EPEX_AT_DA: the currency, which is EUR for this symbol
• base: base currency context (EUR in our examples)

In finance applications, you will typically map EPEX_AT_DA into a price factor table or a market data dimension keyed by date and symbol, and you’ll keep the unit metadata (EUR/MWh) for conversions such as EUR/kWh or cost estimation per load profile.

Quick start: cURL request you can paste

Use this exact cURL to request a historical range for Austria EPEX Day-Ahead (EPEX_AT_DA). It matches the official sample format and includes the documented parameters. Replace YOUR_API_KEY with your token.

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_AT_DA" --data-urlencode "api_key=YOUR_API_KEY"

If you request a multi-day range, the service returns a series you can store as a time-indexed dataset. If you request a single day (start=end), you can treat it like a daily fixing suitable for financial models that roll forward.

Response schema and field mapping

The following REAL API RESPONSE shows how a single-day payload for EPEX_AT_DA is structured. Use this to validate field names and data locations in your parser.

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

Interpretation for finance ingestion:

• success: true indicates the request completed successfully.
• date: an API-level date context; your primary time keys come from dates.EPEX_AT_DA.
• base: EUR indicates the base currency context for the response.
• rates.EPEX_AT_DA: 227.9771 is the Austria EPEX Day-Ahead price in EUR/MWh for the associated date.
• dates.EPEX_AT_DA: "2026-10-17" is the ISO date for that price point.
• currencies.EPEX_AT_DA: "EUR" confirms the currency of the price series.

In a relational schema, you can upsert a row such as: date=2026-10-17, symbol=EPEX_AT_DA, value=227.9771, currency=EUR, unit=EUR/MWh. In a time series store, use date as the index and attach unit/currency as attributes.

Additional sample payloads

This official sample from the documentation demonstrates the same schema for a different symbol. Do not use these values for Austria; they are provided to show the exact JSON layout you will receive.

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

And here is the REAL API RESPONSE for EPEX_AT_DA again, included to give you a second complete example of the exact symbol this article covers. Keep the field access logic identical across symbols; only the symbol code differs.

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

Python example: fetch and normalize EPEX_AT_DA

This script queries the same endpoint and extracts the fields you actually need for finance calculations. It prints a normalized CSV-like line you can redirect into a file or piping step.

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

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

def fetch_timeseries(start_date, end_date, symbol, api_key):
params = {
"start": start_date,
"end": end_date,
"symbols": symbol,
"api_key": api_key
}
url = BASE_URL + "?" + urllib.parse.urlencode(params)
with urllib.request.urlopen(url) as resp:
data = resp.read().decode("utf-8")
return json.loads(data)

def normalize_to_rows(payload, symbol):
rows = []
base = payload.get("base")
currency = payload.get("currencies", {}).get(symbol)
rate = payload.get("rates", {}).get(symbol)
pdate = payload.get("dates", {}).get(symbol)
# For a multi-day request, iterate your local date range and map into rates;
# the sample payloads show single entries keyed by symbol.
if pdate is not None and rate is not None:
# Emit: date,symbol,price,currency,unit,base
rows.append(f"{pdate},{symbol},{rate},{currency},EUR/MWh,{base}")
return rows

if __name__ == "__main__":
# Inputs: ISO dates, target symbol, API key from env or argv
start = "2026-01-01"
end = "2026-03-31"
symbol = "EPEX_AT_DA"
api_key = os.environ.get("ENERGY_API_KEY", "YOUR_API_KEY")

payload = fetch_timeseries(start, end, symbol, api_key)
rows = normalize_to_rows(payload, symbol)
print("date,symbol,price,currency,unit,base")
for r in rows:
print(r)

Notes:

• Set ENERGY_API_KEY in your environment or replace with YOUR_API_KEY in the code (do not hardcode real keys in shared repos).
• The example maps one date/value pair for clarity. For a true multi-day response, iterate over your expected date range and extract values for each calendar day, preserving EUR/MWh.
• Always persist both currency and unit to prevent downstream misinterpretation in P&L calculations or risk factor transforms.

Data handling details for finance workflows

Units and currency:

• Unit is EUR/MWh. Do not drop units; transformations (e.g., EUR/kWh) change magnitudes by 1/1000.
• base is EUR in the provided samples. Your finance layer should not assume a different base without checking this field.

Dates and time zones:

• The API returns ISO dates such as 2026-10-17. Treat these as daily fixings for valuation date t.
• When aligning with portfolios, pin the fixing to your valuation date convention (e.g., end-of-day Europe/Vienna). The payload itself provides the date string; time zone handling is a consumer-side convention.

Gaps and non-trading days:

• Day-ahead power prices are typically published daily, including weekends; however, calendar effects and market holidays can still create edge cases in your time series.
• For robust backtests, implement forward-fill or business-day interpolation rules explicitly in your analytics layer rather than assuming a dense series.

Caching and retries:

• Cache raw JSON payloads keyed by (start, end, symbols) to make your runs reproducible.
• If you parallelize requests across many symbols, add retry logic with jitter to avoid transient network errors.

Multi-symbol calls:

• You can pass a comma-separated list to symbols to reduce round trips. Keep symbol-level metadata (unit, currency) alongside each value in your schema.

Currency conversion:

• Keep the original EUR values for auditability. If you convert to another currency for reporting, record the FX source and fixing date separately.

Transformations you’ll actually use

EUR/MWh to EUR/kWh

Finance teams often need per-kWh prices for cost allocation or unit harmonization across assets:

• EUR/kWh = (EUR/MWh) / 1000
• Preserve precision to at least 4–6 decimals after conversion when passing to billing or P&L systems.

Rolling averages and risk features

• Compute rolling means over 7, 30, 90 calendar days for smoothing spot volatility before feeding models.
• Use aligned windows against the dates.EPEX_AT_DA key. Avoid look-ahead by anchoring each window to the valuation date.

Costing a load profile

• Multiply daily EUR/MWh by expected daily MWh load to estimate daily energy cost. If you maintain sub-daily shapes, aggregate to daily before applying a daily day-ahead fix.

Testing your parser with real payloads

Use these complete samples to verify your field extraction and mapping logic. The first is the REAL API RESPONSE for EPEX_AT_DA; the second is the official schema sample for a different symbol; the third reprints the REAL API RESPONSE to validate idempotent parsing runs.

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

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

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

End-to-end validation checklist

• Authentication: api_key is present as a query parameter and set to YOUR_API_KEY in templates and environment variables in real code.
• Symbol integrity: symbols=EPEX_AT_DA is used for Austria EPEX Day-Ahead, not a sibling market.
• Units preserved: Store EUR/MWh in your database for traceability; do not strip or convert without recording the transform.
• Date alignment: Use dates.EPEX_AT_DA for indexing your series and for valuation-day alignment.
• Schema coupling: rates, dates, and currencies must be read from the symbol key, not from hard-coded locations.
• Batch stability: When requesting large windows, segment by month or quarter to make retries and caching simpler.

FAQs

Q: How do I authenticate?
A: Pass your token via the api_key query parameter. In examples here we use YOUR_API_KEY as a placeholder. Do not include real keys in code samples committed to version control.

Q: What unit are Austria EPEX Day-Ahead prices in?
A: EUR/MWh. Keep this alongside your stored values. If you need EUR/kWh, divide by 1000 and label the result correctly.

Q: Can I request multiple symbols at once?
A: Yes, the symbols parameter supports multiple comma-separated symbols. Always read values per-symbol from rates, dates, and currencies to avoid mixing metadata.

Q: How do I handle days with missing data?
A: Implement explicit gap-handling in your analytics layer (e.g., forward-fill with a max lookback, or exclude gaps) based on your risk policy. Do not assume a fully dense series for all calendars.

Q: Do I need to set a base currency parameter?
A: The base field is provided in the response. Do not pass base=USD when you also need TTF_GAS or EUA_CO2. Use the currency metadata in currencies.EPEX_AT_DA for symbol-level accuracy.

Next step

Set up your account and pull your first range for EPEX_AT_DA. Start with the cURL above, then drop the Python snippet into your ETL. For full parameter details and schema notes, see the Documentation. When you’re ready to run this in your finance pipeline, create an account here: Register.