Italy North IPEX Day-Ahead Historical Price API

You need reliable historical day-ahead power prices for Italy’s North bidding zone and a repeatable way to pull them into your finance workflows. By the end of this guide you will query the Energy API for the Italy North IPEX Day-Ahead symbol, parse the response safely, and integrate the EUR/MWh timeseries into models, backtests, and dashboards.

What you’ll build: a dependable pull of Italy North IPEX Day-Ahead prices

This post focuses on a single Energy API timeseries symbol used in finance and energy risk workflows:

• Symbol name: Italy North IPEX Day-Ahead
• Symbol code: IPEX_IT_NORD_DA
• Unit: EUR/MWh

You will hit the GET /api/v1/timeseries endpoint with a date range and read the fields you actually need (rates, dates, currencies). We’ll stay on this one symbol and keep all examples directly applicable to trading, budgeting, hedging, and valuation routines.

Endpoint and authentication

The Energy API exposes a timeseries endpoint you can call with a start date, end date, and one or more symbols. For this guide, we will request just IPEX_IT_NORD_DA.

• Endpoint: GET https://energy-api.com/api/v1/timeseries
• Parameters: start, end, symbols, api_key
• Authentication: pass your key via api_key query parameter (use YOUR_API_KEY in examples below)

Plan basics you should know before coding:

• Starter $19.99/mo, trial 7 days / 50 calls.
• Do not pass base=USD when you also need TTF_GAS or EUA_CO2 (not relevant for this single-symbol pull, but important if you expand your integration).
• No MCP host (you’ll query energy-api.com directly as shown).

Copy-paste cURL to fetch Italy North IPEX Day-Ahead

This is the official sample cURL for the timeseries endpoint. Keep the URL and parameters exactly as shown when testing the request structure. Replace only YOUR_API_KEY with your key when you run it locally.

curl -G "https://energy-api.com/api/v1/timeseries" --data-urlencode "start=2026-01-01" --data-urlencode "end=2026-03-31" --data-urlencode "symbols=IPEX_IT_NORD_DA" --data-urlencode "api_key=YOUR_API_KEY"

That request will retrieve the time-bounded daily series for the Italy North IPEX Day-Ahead symbol in EUR/MWh. In your application, you’ll typically parametrize start and end to align with your reporting window.

Understand the response fields you’ll use

The Energy API timeseries response carries the values you need in a compact shape. You will read:

• rates.IPEX_IT_NORD_DA: the numeric price for the symbol, in EUR/MWh.
• dates.IPEX_IT_NORD_DA: the ISO date string corresponding to the rate (day-aligned; no time-of-day component).
• currencies.IPEX_IT_NORD_DA: the currency code (EUR).
• base: the base currency context for the response (EUR).

Below are complete JSON examples you can rely on for parsing. Use them to verify your field names and object traversal logic before wiring to production code.

Official sample JSON (verbatim)

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

Field map to keep in mind while you adapt this shape to IPEX_IT_NORD_DA:

• success: boolean flag for request success.
• date: aggregated report date in the payload.
• base: base currency context (EUR).
• rates: map keyed by symbol code.
• dates: symbol-to-date map.
• currencies: symbol-to-currency map.
• base_filter_note: informational field, can be null.

Real API response for Italy North IPEX Day-Ahead (verbatim)

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

How you’ll use this:

• Read rates.IPEX_IT_NORD_DA as a float (223.8283 in this sample), the day-ahead price in EUR/MWh.
• Use dates.IPEX_IT_NORD_DA as the effective market date (2026-10-18 in this sample).
• Confirm currencies.IPEX_IT_NORD_DA is EUR for consistent downstream math.

Official sample JSON repeated for reference (verbatim)

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

This duplication is intentional so you can line up parsing logic against the same canonical structure with a different symbol key.

Python example: fetch and parse IPEX_IT_NORD_DA timeseries

The snippet below requests the date range you specify, checks for success, and extracts date, price, and currency for IPEX_IT_NORD_DA. Keep the parameter names exactly as shown; pass YOUR_API_KEY as your token placeholder while reading this example.

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

API_URL = "https://energy-api.com/api/v1/timeseries"
SYMBOL = "IPEX_IT_NORD_DA"

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

def parse_payload(payload):
# Validate success and expected structures.
if not payload.get("success"):
raise ValueError("API request was not successful")

base = payload.get("base")
rates = payload.get("rates", {})
dates = payload.get("dates", {})
currencies = payload.get("currencies", {})

# Extract values for the single symbol.
price = rates.get(SYMBOL)
price_date = dates.get(SYMBOL)
ccy = currencies.get(SYMBOL)

if price is None or price_date is None or ccy is None:
raise ValueError("Missing fields for IPEX_IT_NORD_DA")

return {
"date": price_date, # e.g., "2026-10-18"
"price": price, # e.g., 223.8283
"currency": ccy, # "EUR"
"base": base # "EUR"
}

if __name__ == "__main__":
# Set your window and API key. Replace YOUR_API_KEY before running.
start = "2026-01-01"
end = "2026-03-31"
api_key = "YOUR_API_KEY"

payload = fetch_ipex_it_nord_da(start, end, api_key)
record = parse_payload(payload)

# Persist or print a normalized row that your finance stack can ingest.
print(json.dumps(record, indent=2))

Notes for finance workflows:

• Store price as decimal in EUR/MWh to avoid floating rounding drift in valuation—convert only at the edges if you must present in another currency.
• Keep the raw JSON alongside normalized values for auditability (downstream model checks, P&L explain, or backtest replication).

Timeseries mechanics for day-ahead electricity

Practical considerations that save time and avoid rework when running IPEX_IT_NORD_DA in production:

• Date alignment: dates are ISO-8601 date strings without time-of-day. Treat them as market dates for day-ahead settlement references.
• Units: EUR/MWh, as delivered in rates.IPEX_IT_NORD_DA. Do not assume kWh or convert without explicit logic.
• Base currency: base is EUR. currencies.IPEX_IT_NORD_DA also returns EUR. If you post-convert to other currencies, apply your FX layer separately and document that transform.
• Availability and weekends: day-ahead markets are scheduled daily; your range requests may return prices for weekends and holidays depending on market operations. Code defensively for missing days by checking presence of the symbol in rates, not inferring a continuous series.
• Caching: cache responses by (start, end, symbols) tuple to avoid re-pulling large windows repeatedly during backtests or batch production runs.
• Chunk long ranges: if you build UI scrubbing across years, split calls by quarter or month boundaries to manage payload size and latency, then merge in your store.

Validation and guardrails in your parser

Implement checks that fail fast in CI and staging:

• Symbol presence: assert SYMBOL in rates, dates, and currencies maps.
• Currency match: assert currencies.IPEX_IT_NORD_DA == base == "EUR" if your workflow assumes a single-currency book for this series.
• Numeric sanity: verify price is numeric and non-negative before persistence; log/reject otherwise.
• Idempotence: hashing (date, symbol, price) lets you dedupe inserts on reruns.

Integrating with portfolio, budget, and risk models

For finance contexts, you will typically do one or more of the following with IPEX_IT_NORD_DA:

• Budget indexation: map monthly budgets to the arithmetic mean of day-ahead prices across the month. Do this after ensuring all expected days are present; if a day is missing, decide on a policy (skip, carry, or fill) and annotate.
• Mark-to-model: if you model spreads (e.g., clean spark), keep IPEX_IT_NORD_DA in its original EUR/MWh unit and align input dates precisely. Do your CO2 and gas legs separately; do not pass base=USD alongside symbols like TTF_GAS or EUA_CO2 per the catalog guidance.
• Backtesting: prefetch the whole backtest window once, cache locally, and re-slice for scenarios to avoid repeated network trips.

Operational tips and common pitfalls

• Strict field names: use exact keys rates.IPEX_IT_NORD_DA, dates.IPEX_IT_NORD_DA, and currencies.IPEX_IT_NORD_DA. Do not attempt to guess alias fields.
• Null handling: base_filter_note can be null; don’t treat it as an error condition.
• Single vs multi-symbol: even if you later add symbols, keep parsing by explicit symbol key lookups to avoid cross-series confusion.
• Serialization: store both the original JSON and your normalized structure to help reconcile pricing disputes or audit results.

Error handling and retries

If you deploy this in jobs (ETL, CRON, Airflow), follow a simple pattern:

• Retry transient network errors with exponential backoff.
• Fail closed on semantic errors (missing symbol keys, unexpected currency changes) and alert.
• Log the full request tuple (start, end, symbols) and the first 200 characters of the response for fast debugging, redacting the api_key.

Testing strategy for finance teams

Before shipping to production:

• Golden files: pin 2–3 known responses (like the ones above) as fixtures and assert parsing results exactly.
• Range boundaries: test month-end and quarter-end windows to verify your range merging is correct.
• Currency assumptions: assert that base == EUR and currencies.IPEX_IT_NORD_DA == EUR in all observed responses for this symbol.

Full field-walkthrough on the provided examples

Italy North IPEX Day-Ahead sample

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

• Extracted price: 223.8283 (EUR/MWh).
• Effective date: 2026-10-18.
• Currency: EUR; Base: EUR.

Official structure check

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

• Same field shapes; substitute IPEX_IT_NORD_DA when you request that symbol.

Deploy checklist

• Use GET /api/v1/timeseries with start, end, symbols=IPEX_IT_NORD_DA, api_key=YOUR_API_KEY.
• Parse rates.IPEX_IT_NORD_DA (float), dates.IPEX_IT_NORD_DA (YYYY-MM-DD), currencies.IPEX_IT_NORD_DA (EUR), base (EUR).
• Persist normalized records with explicit unit (EUR/MWh) and date-based primary key.
• Implement retries for transient failures; alert on parsing anomalies.
• Cache range pulls by (start, end, symbols) to control costs and latency.

FAQ

Q: What unit is the Italy North IPEX Day-Ahead price?
A: EUR/MWh. Use rates.IPEX_IT_NORD_DA directly; document the unit in your data model to prevent downstream confusion.

Q: How do I authenticate?
A: Pass api_key=YOUR_API_KEY as a query parameter on the GET /api/v1/timeseries call.

Q: Can I request multiple symbols together?
A: Yes, but this guide focuses on IPEX_IT_NORD_DA. If you add more symbols, continue to read their specific keys from rates, dates, and currencies maps and avoid using base=USD if you also need TTF_GAS or EUA_CO2.

Q: Are weekends included?
A: Day-ahead power pricing is produced daily. Handle presence or absence of dates by checking for the symbol key in the response for each day in your window rather than assuming continuity.

Q: What plan should I start with?
A: Use the trial (7 days / 50 calls) to validate your integration and move to Starter $19.99/mo when you go live.

Ready to integrate Italy North IPEX Day-Ahead into your finance workflows? Create your key and start pulling EUR/MWh day-ahead history now: Register. For complete parameter coverage and additional options, see the Documentation.