France EPEX Day-Ahead Historical Price API

You need reliable day-ahead power prices for France in EUR/MWh to drive finance workflows like valuation, PnL attribution, and risk backtesting. By the end of this guide, you will query the France EPEX Day-Ahead timeseries (symbol EPEX_FR_DA), parse the response fields you actually need, and integrate them into pricing pipelines with correct units, currency handling, and date alignment.

What you get: France day-ahead power prices in EUR/MWh

The timeseries endpoint returns the EPEX France Day-Ahead auction price for each requested date. Key facts for this symbol and API:

• Symbol name: France EPEX Day-Ahead
• Symbol code: EPEX_FR_DA
• Unit: EUR/MWh
• Authentication: api_key query parameter (use YOUR_API_KEY)
• Plan notes: Starter $19.99/mo, trial 7 days / 50 calls
• Do not pass base=USD when you also need TTF_GAS or EUA_CO2

Each response provides a per-symbol value keyed in the rates object, plus currency metadata. Finance systems should treat values as daily auction settlement levels in EUR/MWh, suitable for valuation, normalization, and hedging analytics.

Endpoint and authentication

Use the GET timeseries endpoint:

• Method: GET
• URL: https://energy-api.com/api/v1/timeseries
• Required query params:
  • start: inclusive start date (YYYY-MM-DD)
  • end: inclusive end date (YYYY-MM-DD)
  • symbols: comma-separated symbols; here, EPEX_FR_DA
  • api_key: YOUR_API_KEY

This API returns JSON with rates keyed by symbol, and currency metadata keyed by the same symbol. You will read rates.EPEX_FR_DA and currencies.EPEX_FR_DA in your code. Refer to the Documentation for additional field descriptions and behavior.

Quick start with cURL

The following request fetches France EPEX Day-Ahead historical prices for Q1 2026. Copy-paste and replace YOUR_API_KEY with your credential.

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

Response examples and field mapping

Use these complete JSON examples to understand the exact field names you will parse in production. Where provided, values must be used verbatim.

Official sample (verbatim)

{
"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
}

This control sample shows the shape: a top-level date/base, and per-symbol entries in rates, dates, and currencies. Your finance code will apply the same parsing logic for EPEX_FR_DA.

Real API response for EPEX_FR_DA (verbatim)

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

For France EPEX Day-Ahead, read rates.EPEX_FR_DA to get the price (unit: EUR/MWh). dates.EPEX_FR_DA gives the effective date, and currencies.EPEX_FR_DA confirms the unit currency.

Real API response repeated for sanity checks in tests

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

Teams often pin a fixture to validate parsing and PnL transforms. Keeping a verbatim sample in tests helps catch regressions in response parsing and date alignment.

Official sample reused as a parser control

{
"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
}

Keep one official sample in your unit tests to verify the traversal of rates, dates, and currencies with any symbol.

Parsing the timeseries in Python

The snippet below calls the same endpoint and extracts the price, currency, and date for EPEX_FR_DA. It uses only fields documented here, and guards against missing keys so your finance code fails fast.

import os
import requests
from datetime import date

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

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

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

# Basic validations
if not data.get("success", False):
raise RuntimeError("API returned success=false")

base = data.get("base", "EUR") # will be EUR for this symbol
rates = data.get("rates", {})
dates = data.get("dates", {})
currencies = data.get("currencies", {})

if SYMBOL not in rates:
raise KeyError(f"Missing rate for {SYMBOL}")

price_eur_per_mwh = rates[SYMBOL]
price_date = dates.get(SYMBOL)
price_ccy = currencies.get(SYMBOL, base)

if price_ccy != "EUR":
raise ValueError(f"Unexpected currency for {SYMBOL}: {price_ccy}")

print(f"{SYMBOL} {price_date}: {price_eur_per_mwh} {price_ccy}/MWh")

For finance-grade robustness, persist the raw JSON alongside your transformed timeseries. This enables deterministic reruns of PnL and backtests against the exact historical payloads.

Designing reliable finance workflows with EPEX_FR_DA

Day-ahead auction prices are daily. Most finance workflows need day-level alignment and consistent units.

• Units: Always interpret rates.EPEX_FR_DA as EUR per MWh. If you calculate cost per kWh, divide by 1000.
• Currency: The top-level base is EUR, and currencies.EPEX_FR_DA is EUR. Do not pass base=USD when you also need TTF_GAS or EUA_CO2; keep your valuation layer responsible for FX if you convert.
• Valuation date: Use dates.EPEX_FR_DA as the effective date for your ledger entries and PnL buckets.
• PnL attribution: For power exposure, align hedge volumes (MWh) with the same day and multiply by the EPEX_FR_DA rate to compute EUR impact.
• Backtesting: Query ranges with start/end, store the daily vector, and ensure weekends/holidays remain present or logically handled (see below).

End-to-end timeseries flow

1) Fetch

Call GET /api/v1/timeseries with start, end, symbols=EPEX_FR_DA, and api_key. Keep a stable client timeout and backoff strategy in your HTTP code.

2) Normalize

Extract rates.EPEX_FR_DA, dates.EPEX_FR_DA, currencies.EPEX_FR_DA into a typed structure with fields: date (YYYY-MM-DD), price (float), currency=EUR, unit=EUR/MWh.

3) Validate

• Non-null checks: success==true, symbol keys exist in rates/dates/currencies.
• Monotone date coverage: ensure each requested date is present or intentionally missing (documented below).
• Currency lock: assert EUR for EPEX_FR_DA.

4) Persist

Store raw JSON and normalized rows. The raw snapshot lets you reconstruct historical states for audits and PnL reruns.

5) Consume

Use normalized rows for risk, pricing, and ledger postings. For composite indices or spread strategies, join EPEX_FR_DA with peer energy symbols using shared date keys.

Field-by-field guidance

• success: Boolean success flag. If false, treat as a hard error and retry or surface to ops.
• date: A top-level convenience date. Use the per-symbol dates map to bind each symbol to its effective date.
• base: Base currency of the response. For this symbol, EUR.
• rates: Dictionary keyed by symbol. Read rates.EPEX_FR_DA for the price.
• dates: Dictionary keyed by symbol, value is the symbol’s effective date string.
• currencies: Dictionary keyed by symbol, value is the symbol’s currency code.
• base_filter_note: Optional field; treat as informational if present.

Time, calendars, and missing dates

Day-ahead auctions are scheduled daily, including weekends and many holidays, but operational exceptions can occur. When backfilling:

• Expect most calendar days to have a value; fill strategies should be explicit, not implicit.
• Avoid forward-filling prices in PnL; prefer gap-aware reporting.
• Persist the dates.EPEX_FR_DA string and cast to date in your warehouse for exact joins.

If your portfolio requires business-day alignment, precompute a business-day calendar and map daily auction dates onto it for analytics while keeping the raw auction calendar in storage.

Caching and performance

• Cache immutable historical windows (e.g., prior months) at the application layer to reduce calls.
• For daily jobs, fetch the narrow window you need (e.g., start=end=today) and append to storage.
• Keep the response JSON as-is in blob storage; parse once, store normalized rows, and reuse downstream.

Error handling and idempotency

• HTTP errors: Retry with exponential backoff and jitter. Stop after a small bounded number of attempts to avoid hammering.
• Parsing errors: Validate presence of rates.EPEX_FR_DA, dates.EPEX_FR_DA, currencies.EPEX_FR_DA before computing PnL.
• Idempotent ingestion: Use a unique key of (symbol, date) to upsert, ensuring reruns do not duplicate rows.

Data checks that save debugging time

• Unit test: Assert that currencies.EPEX_FR_DA == "EUR".
• Schema test: Assert that rates is a dict and that EPEX_FR_DA in rates.
• Date test: Parse dates.EPEX_FR_DA successfully and ensure it lies within requested [start, end].
• No base override: If also working with TTF_GAS or EUA_CO2, do not pass base=USD; handle FX separately in your stack.

Minimal JavaScript example (Node.js)

This snippet demonstrates a simple fetch and extraction of the three fields your finance pipeline needs.

import fetch from "node-fetch";

const API_URL = "https://energy-api.com/api/v1/timeseries";
const params = new URLSearchParams({
start: "2026-01-01",
end: "2026-03-31",
symbols: "EPEX_FR_DA",
api_key: "YOUR_API_KEY",
});

const url = `${API_URL}?${params.toString()}`;

const res = await fetch(url, { method: "GET" });
if (!res.ok) {
throw new Error(`HTTP ${res.status}`);
}
const json = await res.json();
if (!json.success) {
throw new Error("API returned success=false");
}

const symbol = "EPEX_FR_DA";
const price = json.rates?.[symbol];
const ccy = json.currencies?.[symbol] ?? json.base;
const dt = json.dates?.[symbol];

if (price == null || ccy == null || dt == null) {
throw new Error("Missing required fields for EPEX_FR_DA");
}

console.log(`${symbol} ${dt}: ${price} ${ccy}/MWh`);

Quality gates for deployment

• Reproducibility: Store raw responses for audit and deterministic reruns.
• Observability: Log the request window, symbol, and returned date to catch calendar shifts early.
• Validation: On ingestion, assert EUR currency and non-null price before writing to PnL tables.
• Docs bookmark: Keep a direct link to the Documentation in your repo README for quick field lookups.

FAQ

Which fields do I use for price, date, and currency?
Read rates.EPEX_FR_DA for the price (EUR/MWh), dates.EPEX_FR_DA for the effective date, and currencies.EPEX_FR_DA (expected EUR) for currency.

Can I request multiple symbols at once?
Yes, pass a comma-separated list in symbols. Ensure you parse each symbol’s entry in rates, dates, and currencies independently.

Should I convert to USD in the API?
Do not pass base=USD when you also need TTF_GAS or EUA_CO2. Keep the API in its native base and perform FX conversions in your valuation layer if required.

How do I handle non-trading or missing days?
Treat gaps explicitly. Avoid forward-filling in PnL; instead, report missing data or fetch a larger window to confirm availability.

What’s the fastest way to get started?
Use the cURL above with your API key, parse the three fields, and add idempotent upserts keyed by (symbol, date) to your datastore.

Ready to ship your integration? Create an account to get an API key and start pulling the France EPEX Day-Ahead series today: Register.