Historical France EPEX Day-Ahead Prices
Energy and finance teams tracking power procurement and P&L exposure to French spot electricity often struggle to source reliable day-ahead prices in a developer-friendly format. By the end of this guide, you will be able to programmatically fetch Historical France EPEX Day-Ahead prices (symbol EPEX_FR_DA) as a time series using a single endpoint, parse the response fields you actually need, and integrate the data into your financial models and dashboards.
What you will build: a reproducible EPEX France Day-Ahead time series pull
This post shows how to query the Energy API’s timeseries endpoint for the France EPEX Day-Ahead symbol (EPEX_FR_DA), transform the JSON fields into a daily series in EUR/MWh, and store or visualize it for finance workflows such as forward mark reconciliation, hedge effectiveness analysis, daily P&L, and risk metrics.
Key facts you will rely on throughout this guide:
- Symbol name: France EPEX Day-Ahead
- Symbol code: EPEX_FR_DA
- Unit: EUR/MWh
- Auth: api_key query parameter (use YOUR_API_KEY).
- Endpoint: GET /api/v1/timeseries with query parameters start, end, symbols, api_key.
- Plan note: Starter $19.99/mo, trial 7 days / 50 calls.
- Data fields: read rates.EPEX_FR_DA keyed by the returned date context, plus currencies.EPEX_FR_DA for units and dates.EPEX_FR_DA for the effective date.
- When pairing with other energy symbols (e.g., TTF_GAS, EUA_CO2), do not add a base=USD parameter; keep the native base returned by the API.
Endpoint, parameters, and authentication
The Energy API provides a single time series endpoint for historical pulls:
- Method: GET
- URL: https://energy-api.com/api/v1/timeseries
- Query params:
- start: inclusive start date (YYYY-MM-DD)
- end: inclusive end date (YYYY-MM-DD)
- symbols: comma-separated symbols, e.g., EPEX_FR_DA
- api_key: your API key provided as a query parameter
Authentication uses the api_key query parameter only. Use the literal placeholder YOUR_API_KEY in copy-pasteable examples. Avoid any header-based auth unless documented; here it is not required.
For account setup and API details, use:
Official curl request you can paste
This is the official, copy-pasteable curl example targeting the time series endpoint. Keep the URL, parameters, and field names unchanged; just replace YOUR_API_KEY with your own value after you register.
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 shape: fields that matter for finance
Below is an official sample from the live docs that demonstrates the response shape. It uses a different symbol in the payload but shows the structure you will parse. You will then see a France EPEX Day-Ahead example.
{
"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
}
Use this structure to locate:
- date: the context date for the snapshot.
- rates.SYMBOL: the numeric value for your symbol on that date.
- dates.SYMBOL: the specific effective date for that symbol.
- currencies.SYMBOL: the currency for that symbol’s rate.
France-specific JSON example you will integrate
Use these exact France values for a quick sanity-check call and for writing your parser. The values below are real and must be copied exactly for tests and documentation stubs.
{"success":true,"date":"2026-11-17","base":"EUR","rates":{"EPEX_FR_DA":64.581},"dates":{"EPEX_FR_DA":"2026-11-17"},"currencies":{"EPEX_FR_DA":"EUR"},"base_filter_note":null,"missing_symbols":null}
How to read this for financial workflows:
- rates.EPEX_FR_DA is the French EPEX Day-Ahead price, in EUR per MWh.
- currencies.EPEX_FR_DA confirms the unit currency: EUR.
- dates.EPEX_FR_DA matches the date of that rate. Use this to align time indices in your portfolio models or P&L backfills.
- base indicates the base returned by the service for the payload; in this case EUR. Do not force a different base when combining with other energy symbols that expect native units.
Another copy-ready JSON example for testing pipelines
Teams often maintain parser tests in CI to guard against regressions. You can reuse the France example below as a fixture in a separate test file (e.g., a round-trip serialize/deserialize test or a resilience test for null optional fields like base_filter_note).
{"success":true,"date":"2026-11-17","base":"EUR","rates":{"EPEX_FR_DA":64.581},"dates":{"EPEX_FR_DA":"2026-11-17"},"currencies":{"EPEX_FR_DA":"EUR"},"base_filter_note":null,"missing_symbols":null}
End-to-end Python example: fetch, validate, and normalize
The script below queries the endpoint for EPEX_FR_DA, validates required keys, and emits a normalized row you can store in a data warehouse table keyed by date, symbol, and value. Keep the query parameters from the documented endpoint exactly as shown.
import os
import sys
import json
import datetime as dt
import urllib.parse
import urllib.request
API_URL = "https://energy-api.com/api/v1/timeseries"
API_KEY = os.getenv("ENERGY_API_KEY", "YOUR_API_KEY") # replace in production
def build_url(start, end, symbols):
params = {
"start": start,
"end": end,
"symbols": symbols,
"api_key": API_KEY
}
return API_URL + "?" + urllib.parse.urlencode(params)
def fetch_timeseries(start, end, symbols="EPEX_FR_DA"):
url = build_url(start, end, symbols)
with urllib.request.urlopen(url) as resp:
body = resp.read().decode("utf-8")
return json.loads(body)
def extract_epex_fr_da(payload):
# Validate structural keys
for k in ["success", "date", "base", "rates", "dates", "currencies"]:
if k not in payload:
raise KeyError(f"Missing key in response: {k}")
if not payload["success"]:
raise ValueError("API response not successful")
sym = "EPEX_FR_DA"
if sym not in payload["rates"]:
raise KeyError(f"Missing symbol in rates: {sym}")
value = payload["rates"][sym]
value_currency = payload["currencies"].get(sym, payload["base"])
value_date = payload["dates"].get(sym, payload["date"])
# Normalize to a single output record
return {
"symbol": sym,
"date": value_date,
"price": value, # numeric
"currency": value_currency, # should be EUR
"unit": "EUR/MWh" # from catalog facts
}
if __name__ == "__main__":
# Example: pull a quarter for backfill
start = "2026-01-01"
end = "2026-03-31"
payload = fetch_timeseries(start, end)
record = extract_epex_fr_da(payload)
# Emit CSV-like line for ingestion
sys.stdout.write(f"{record['date']},{record['symbol']},{record['price']},{record['currency']},{record['unit']}\n")
Notes for finance integration:
- The unit is EUR/MWh for EPEX_FR_DA. Keep native units for valuation layers and convert only at the reporting layer if needed.
- Use the dates.EPEX_FR_DA field for time alignment, not just the top-level date.
- If joining to positions or exposures by delivery date, consistently define your date key (e.g., trade date vs. delivery date) and transform as needed in your ETL step.
JavaScript example: fetch and consume in a dashboard
This example uses the same endpoint. It demonstrates a minimal browser-friendly call pattern and field extraction for client-side charts or an internal risk dashboard.
async function fetchEpexFRDA(start, end) {
const params = new URLSearchParams({
start,
end,
symbols: "EPEX_FR_DA",
api_key: "YOUR_API_KEY"
});
const url = `https://energy-api.com/api/v1/timeseries?${params.toString()}`;
const res = await fetch(url, { method: "GET" });
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const data = await res.json();
const sym = "EPEX_FR_DA";
if (!data.success || !data.rates || !(sym in data.rates)) {
throw new Error("Invalid payload or missing symbol");
}
return {
date: data.dates?.[sym] || data.date,
value: data.rates[sym],
currency: data.currencies?.[sym] || data.base,
unit: "EUR/MWh"
};
}
fetchEpexFRDA("2026-01-01", "2026-03-31")
.then((point) => {
console.log(`EPEX_FR_DA ${point.date}: ${point.value} ${point.currency} (${point.unit})`);
})
.catch((err) => console.error(err));
Validating responses: quick checks to keep pipelines safe
When building finance pipelines, protect downstream models from malformed or partial payloads. A practical approach is to assert the presence of required keys and exact symbol matches before transforming the data. Use the known-good France example below as a test fixture in unit tests that verify your parsing logic.
{"success":true,"date":"2026-11-17","base":"EUR","rates":{"EPEX_FR_DA":64.581},"dates":{"EPEX_FR_DA":"2026-11-17"},"currencies":{"EPEX_FR_DA":"EUR"},"base_filter_note":null,"missing_symbols":null}
Recommended validations:
- Assert payload.success is true.
- Assert rates.EPEX_FR_DA exists and is numeric.
- Assert currencies.EPEX_FR_DA is EUR for EPEX_FR_DA.
- Assert dates.EPEX_FR_DA is a valid YYYY-MM-DD string.
How to build a historical index for EPEX France Day-Ahead
Many finance teams need a contiguous daily time series. The timeseries endpoint returns data for the requested range; you can backfill longer histories by iterating over date windows (e.g., monthly or quarterly) and merging results into a single series indexed by dates.EPEX_FR_DA. Practical details:
- Indexing: Use dates.EPEX_FR_DA as the definitive key per data point.
- Units: Always treat values as EUR/MWh for EPEX_FR_DA. Do not rescale unless explicitly desired.
- Currency: The base is EUR for this symbol; currencies.EPEX_FR_DA will confirm.
- Gaps: Day-ahead calendars can include weekends and holidays, but you may still encounter gaps due to market or data availabilities. Your ETL should detect and log any missing days.
- Merges: If you join EPEX_FR_DA with other energy symbols such as TTF_GAS or EUA_CO2, keep native bases; do not pass base=USD in the request.
Data modeling for financial workflows
To make historical prices useful for mark-to-market and risk metrics, normalize your storage schema:
- Primary key: (symbol, date).
- Columns: symbol (text), date (date), price (numeric), currency (text), unit (text), ingestion_ts (timestamp), source (text).
- Constraints: currency must equal EUR for EPEX_FR_DA; unit must equal EUR/MWh.
- Checks: non-null price; date parses to a valid calendar day.
In calculation layers, keep derived series separate (e.g., rolling averages, daily changes, volatility). This avoids accidental overwrites of raw vendor prices and eases auditing during close.
Caching and rate considerations
For daily workflows, a small cache with a TTL that matches your data refresh cadence can prevent redundant calls. On first run for a given date, fetch and persist. On subsequent reads the same day, load from cache. This improves reliability in batch P&L recalculations and reduces the chance of hitting trial call limits (7 days / 50 calls on the trial, Starter $19.99/mo thereafter).
When requesting long ranges, prefer a few larger calls instead of many small calls to avoid unnecessary round trips. Organize backfills in monthly or quarterly windows to parallelize safely while staying within reasonable API usage.
Production hardening tips
- Observability: Log the top-level date, the symbol, and the returned dates.SYMBOL to detect any misalignments.
- Idempotence: Writes should upsert by (symbol, date) so re-runs do not duplicate data.
- Variance checks: If you track expected ranges for EPEX_FR_DA, alert when a new value is outside anticipated bounds before it flows into P&L.
- Backfill hygiene: If you discover a gap, isolate an on-demand range pull for the missing dates and rerun only the dependent downstream metrics.
Troubleshooting common integration pitfalls
- Wrong symbol: Ensure the symbols parameter is exactly EPEX_FR_DA. Typos will result in missing_symbols or absent rates keys.
- Auth errors: Pass the api_key query parameter; do not attempt to use a header if not specified.
- Mismatched currencies: For EPEX_FR_DA, currencies.EPEX_FR_DA is EUR. Do not coerce to a different base in the request when also working with other energy symbols.
- Time alignment: Use dates.EPEX_FR_DA for the final series index, not just the top-level date field.
End-to-end checklist before you ship
- Can you fetch a known range using curl and store the payload as raw JSON for auditing?
- Does your parser assert presence of success, rates.EPEX_FR_DA, dates.EPEX_FR_DA, currencies.EPEX_FR_DA?
- Are you storing unit as EUR/MWh and currency as EUR for this symbol?
- Do you upsert by (symbol, date) and record ingestion timestamps?
- Have you set caching to avoid redundant calls in the same accounting cycle?
FAQ
Which endpoint should I use for historical France EPEX Day-Ahead prices?
Use GET /api/v1/timeseries with start, end, symbols=EPEX_FR_DA, and api_key=YOUR_API_KEY as query parameters.
What unit and currency do EPEX_FR_DA prices use?
EUR/MWh, with currencies.EPEX_FR_DA returned as EUR and base reported as EUR.
Do I need to pass base=USD when combining with other symbols?
No. When you also need TTF_GAS or EUA_CO2, do not pass base=USD. Keep native bases and convert downstream if needed.
How should I index the time series?
Use dates.EPEX_FR_DA as the authoritative date for each rate. Do not rely solely on the top-level date.
How do I get started and what are the trial limits?
Sign up to obtain YOUR_API_KEY. The trial is 7 days / 50 calls; the Starter plan is $19.99/mo.
Get access and start pulling France EPEX Day-Ahead data
Create an account to obtain an API key and run the curl and code samples in this guide. Use the Registration link to begin, and keep the Documentation open for reference on the single timeseries endpoint and symbol usage.
Ready to get started?
Get your API key and start querying energy commodity prices in minutes.
Get API KeyRelated posts
Unlock reliable France day-ahead power prices with our Finance API guide. Learn to query, parse, and integrate...
Read more →