Switzerland EPEX Day-Ahead (EPEX_CH_DA) Price API

You need reliable, queryable day-ahead power prices for Switzerland to drive finance workflows—mark-to-market on physical positions, PnL sensitivity for hedges, or dashboards that reconcile procurement with spot volatility. By the end of this guide, you will be able to list available energy symbols, confirm Switzerland EPEX Day-Ahead is included, fetch its latest price within a finance-grade unit system, and integrate it into your code with working curl and Python examples.

What the Switzerland EPEX Day-Ahead symbol provides

The Energy API exposes Switzerland’s EPEX Day-Ahead price as a first-class symbol you can query directly:

• Symbol name: Switzerland EPEX Day-Ahead
• Symbol code: EPEX_CH_DA
• Unit: EUR/MWh

This symbol is designed for finance contexts: daily day-ahead settlement values that you can pull into PnL, VaR scenario loaders, or budget variance models. Pricing is returned alongside metadata telling you the base currency of the response and the unit-per-symbol via a currencies map, which minimizes ambiguity when you combine multiple energy instruments.

List symbols and confirm EPEX_CH_DA is available

Before building downstream logic, fetch the catalog of available symbols and confirm the one you need is listed. Use GET /api/v1/symbols with api_key authentication via query parameter. Then verify EPEX_CH_DA appears in the result set by code or a quick text search in your terminal.

curl -G "https://energy-api.com/api/v1/latest" --data-urlencode "symbols=EPEX_CH_DA" --data-urlencode "api_key=YOUR_API_KEY"

Practical notes:

• Authentication: use api_key as a query parameter. Do not substitute any other auth style here.
• Verification: ensure the list includes the exact code EPEX_CH_DA (no variations). This avoids surprises later when you wire selectors or CI checks.
• Do not pass base=USD when you also need TTF_GAS or EUA_CO2. When combining multiple instruments, the API may return a mixed base; your integration should handle that explicitly (details below).

Fetch the latest Switzerland EPEX Day-Ahead price (official sample)

Once the symbol is confirmed, pull the latest price with the official endpoint below. This call returns the price for EPEX_CH_DA plus per-symbol metadata that you will read for unit-aware computations.

Official JSON response example

{
"success": true,
"date": "2026-10-03",
"base": "EUR",
"rates": {
"EPEX_CH_DA": 168.4263
},
"dates": {
"EPEX_CH_DA": "2026-10-03"
},
"currencies": {
"EPEX_CH_DA": "EUR"
},
"base_filter_note": null
}

What you will actually use in finance code:

• rates.EPEX_CH_DA: the numeric price (168.4263) for Switzerland EPEX Day-Ahead.
• dates.EPEX_CH_DA: the date associated with this symbol’s value.
• currencies.EPEX_CH_DA: the currency for this symbol’s quote (EUR). Combine this with your unit logic: the instrument is in EUR per MWh.
• base: the response’s base currency context. base may be MIXED if you query heterogeneous instruments together; handle that explicitly.

Field semantics and unit safety

Energy data often spans multiple marketplaces and currencies; the API therefore splits three key concerns:

• rates: the core numeric price for each symbol you requested.
• dates: the price date per symbol, enabling you to confirm the trading or publication day behind each value.
• currencies: the currency associated with each symbol’s price, so you can enforce correct conversions before aggregating.

The base field reflects the base currency context of the response. When you query multiple heterogeneous instruments together, base may be MIXED. Your finance code should not assume a single uniform base across symbols; instead, leverage currencies. for precise handling. If you later introduce other instruments (e.g., TTF or EUA), avoid passing base=USD in the same request that also needs TTF_GAS or EUA_CO2. That constraint keeps your portfolio queries consistent and prevents silent conversions that could distort PnL.

Production integration details that save time

Authentication and setup:

• Auth: pass api_key as a query parameter. Use YOUR_API_KEY in local development; inject the real one via your secrets manager in production.
• Plans: Starter $19.99/mo; trial 7 days with 50 calls. Use the trial to validate workflows and performance.

Caching and refresh cadence:

• Day-ahead prices typically update once per market day. Cache the latest response and refresh on your ingestion schedule aligned with day-ahead publication windows.
• For intraday dashboards, a fetch every 30–60 minutes is usually sufficient given the daily cycle; for batch PnL, fetch once in your nightly job.

Time and dates:

• Use dates.EPEX_CH_DA to stamp your records. Store both the API response date and your ingestion timestamp to audit drift or reruns.
• Market holidays and weekends may produce the same published date for multiple runs; your code should treat idempotent loads as no-ops.

Error handling:

• Check success is true before consuming rates. If not true, branch to your retry or fallback handler.
• Build fast-failure: if currencies.EPEX_CH_DA is missing or unexpected, block aggregation until you reconcile metadata.

Combining instruments and currency conversions:

• When aggregating multiple energy instruments, read currencies.<symbol> for each line item and normalize via your own FX layer before summation.
• Do not pass base=USD when you also need TTF_GAS or EUA_CO2; request raw values and convert explicitly in your pipeline.

Python example: fetch and parse EPEX_CH_DA for finance

The snippet below calls the same latest endpoint, validates the response, and extracts the fields your finance pipeline typically needs. It demonstrates explicit handling of base and per-symbol currency.

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

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

def fetch_latest_epex_ch_da(api_key: str):
params = {
"symbols": "EPEX_CH_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=20) as resp:
body = resp.read().decode("utf-8")
return json.loads(body)

def main():
data = fetch_latest_epex_ch_da(API_KEY)

# Basic validation
if not data or not data.get("success", False):
print("Error: API call unsuccessful or response malformed", file=sys.stderr)
sys.exit(1)

# Extract finance-relevant fields
base = data.get("base")
rates = data.get("rates", {})
dates = data.get("dates", {})
currencies = data.get("currencies", {})

# Read Switzerland EPEX Day-Ahead
symbol = "EPEX_CH_DA"
price = rates.get(symbol)
price_date = dates.get(symbol)
currency = currencies.get(symbol)

if price is None or price_date is None or currency is None:
print("Error: Missing expected fields for EPEX_CH_DA", file=sys.stderr)
sys.exit(1)

# Print a normalized record you can store into your pricing table
record = {
"symbol": symbol,
"price": price,
"currency": currency, # EUR for EPEX_CH_DA
"unit": "EUR/MWh", # known unit for this symbol
"price_date": price_date, # per-symbol date from the API
"response_base": base # may be 'EUR' or 'MIXED' depending on query scope
}
print(json.dumps(record, separators=(',', ':')))

if __name__ == "__main__":
main()

Operational notes for this example:

• It uses standard library HTTP; you can swap in requests or aiohttp if you prefer. Keep the same URL, query parameters, and field names.
• The record includes both the per-symbol currency and the response base, enabling audit-friendly storage and safe downstream conversions.
• Write the record into your pricing table keyed by (symbol, price_date), and backfill when rerunning for the same date.

Verifying symbol coverage in CI

To ensure your finance jobs don’t regress when symbol coverage changes, add a lightweight CI check:

• Call GET /api/v1/symbols during your build or nightly monitor.
• Assert that EPEX_CH_DA exists; if not, page your data engineering channel.
• Optionally, fetch the latest price and confirm currencies.EPEX_CH_DA equals EUR and unit is EUR/MWh in your metadata map.

This protects your portfolio loaders from silent schema drift or symbol deprecations.

Handling day-ahead specifics in finance workflows

Day-ahead markets publish once per day for delivery profiles on the following day. In finance terms, that means:

• Store dates.EPEX_CH_DA as the official price date for your valuation run.
• If your PnL uses delivery-day accrual, align the price date with your delivery calendar mapping.
• For weekend or holiday effects, you may see repeated publication dates or shifted availability windows; treat repeated loads as idempotent.

If you reconcile physical procurement with financial hedges, keep the symbol-level currency explicit in your PnL logic. Price normalization should occur before any aggregation or sensitivity rollups. Because base may be MIXED when querying multiple instruments, always trust currencies.EPEX_CH_DA for the symbol’s true currency and convert in your finance layer.

Practical curl you can copy now

Use this to validate connectivity and inspect the exact fields your code will parse. It is the official, current sample and should be copied without modification except the API key value.

After running it, confirm:

• success is true
• rates.EPEX_CH_DA is present and numeric
• dates.EPEX_CH_DA is a valid date string
• currencies.EPEX_CH_DA is EUR

FAQ

How do I authenticate?
Pass your API key via the api_key query parameter on each request. Store it in your secrets manager and inject at runtime.

How can I confirm the symbol exists before coding downstream logic?
Call GET /api/v1/symbols with your api_key and verify EPEX_CH_DA appears in the list. Gate your jobs on that check.

What unit and currency should I store for Switzerland EPEX Day-Ahead?
Unit: EUR/MWh. Currency: read currencies.EPEX_CH_DA (EUR). Persist both alongside the price and price_date to keep your ledger unambiguous.

Can I request multiple instruments in one call?
Yes, but when mixing instruments, base may be MIXED. Do not pass base=USD when you also need TTF_GAS or EUA_CO2. Normalize currencies per symbol in your finance code before aggregation.

What are my plan options for testing?
Starter is $19.99/mo with a 7-day trial and 50 calls, which is sufficient to wire CI checks, build your data model, and run a few PnL dry runs.

Ready to integrate Switzerland EPEX Day-Ahead into your finance pipeline? Start your trial to get an API key and ship your first request today: Register. For endpoint and field references, see the Documentation.