Historical EUA CO2 Prices
Finance teams and quant engineers often need a clean, auditable history of EU Allowance (EUA) carbon prices to reconcile exposures, price structured products, or build risk and P&L explain. By the end of this guide you will be able to fetch historical EUA CO2 prices programmatically using a single timeseries endpoint, parse the response safely, and integrate the data into your pricing or analytics stack.
What you are pulling: EUA CO2, units, and base currency
EUA CO2 is the Energy API symbol for European Union Allowance carbon prices. In this feed:
- Symbol name: EUA CO2
- Symbol code: EUA_CO2
- Unit: EUR/MT (euros per metric ton of CO2)
- Base currency: EUR (the API returns data under a base of EUR for this symbol)
All examples below use the EUA_CO2 symbol and the Energy API Finance timeseries endpoint. Keep the base in EUR when working with EUA or TTF symbols. Do not add a base conversion parameter for these symbols.
Endpoint and authentication
Historical EUA CO2 prices are retrieved via a single HTTP GET request:
- Endpoint: /api/v1/timeseries
- Method: GET
- Query parameters:
- start: inclusive start date (YYYY-MM-DD)
- end: inclusive end date (YYYY-MM-DD)
- symbols: comma-separated list of symbols (use EUA_CO2 for this post)
- api_key: pass your API key in the query string (Auth is via api_key parameter)
Response fields you will use in code:
- rates.EUA_CO2: the numeric price for the EUA CO2 symbol
- dates.EUA_CO2: the date associated with the returned rate
- currencies.EUA_CO2: the currency code for the symbol (EUR)
Pricing: Starter is $19.99/mo with a 7-day trial and 50 calls to get you going. There is no MCP host; use the endpoint shown here directly.
Quick start: cURL for EUA CO2 timeseries
Run this from your terminal to retrieve EUA CO2 over a fixed window. Replace YOUR_API_KEY with your actual key.
curl -G "https://energy-api.com/api/v1/timeseries" --data-urlencode "start=2026-01-01" --data-urlencode "end=2026-03-31" --data-urlencode "symbols=EUA_CO2" --data-urlencode "api_key=YOUR_API_KEY"
This will return a JSON payload keyed by symbol. You will read values from the rates, dates, and currencies maps, using EUA_CO2 as the key.
Response anatomy and field mapping
The timeseries endpoint returns a compact schema. The following official sample shows the shape of the response. Note that the symbol in this particular example differs; you will still parse EUA_CO2 in exactly the same way.
{
"success": true,
"date": "2026-11-18",
"base": "EUR",
"rates": {
"OMIE_ES_DA": 52.1318
},
"dates": {
"OMIE_ES_DA": "2026-11-18"
},
"currencies": {
"OMIE_ES_DA": "EUR"
},
"base_filter_note": null,
"missing_symbols": null
}
What your code should rely on:
- success: boolean status for the call.
- base: the base currency of the feed; for EUA_CO2 this is EUR.
- rates: a map of symbol to numeric value for that date or window.
- dates: a map of symbol to the date associated with the returned rate.
- currencies: a map of symbol to the currency code.
- base_filter_note and missing_symbols: informative fields you can log to detect filtering or missing data.
Real EUA CO2 JSON example (use these values as-is)
Below is a real response sample for EUA CO2. Use these exact values in your tests to validate your parser.
{"success":true,"date":"2026-11-01","base":"EUR","rates":{"EUA_CO2":78.82},"dates":{"EUA_CO2":"2026-11-01"},"currencies":{"EUA_CO2":"EUR"},"base_filter_note":null,"missing_symbols":null}
Field usage in a finance workflow:
- rates.EUA_CO2: 78.82 is the EUR/MT level you would plug into pricing or P&L explain for the indicated date.
- dates.EUA_CO2: 2026-11-01 is the effective date to align with valuation calendars and end-of-day processes.
- currencies.EUA_CO2: Always EUR for this symbol; maintain currency-safe pipelines even when a series is fixed-currency.
Python example: fetch and normalize EUA CO2
This script fetches a date range for EUA CO2, validates the response, extracts the numeric price and associated date, and prints a normalized record. Customize the date window as needed.
import os
import sys
import json
import urllib.parse
import urllib.request
API_URL = "https://energy-api.com/api/v1/timeseries"
API_KEY = os.environ.get("ENERGY_API_KEY", "YOUR_API_KEY") # replace for local tests
def fetch_eua_co2(start_date, end_date):
params = {
"start": start_date,
"end": end_date,
"symbols": "EUA_CO2",
"api_key": API_KEY
}
url = API_URL + "?" + urllib.parse.urlencode(params)
with urllib.request.urlopen(url) as resp:
raw = resp.read().decode("utf-8")
data = json.loads(raw)
return data
def read_eua_fields(payload):
# Mandatory checks
if not payload or not payload.get("success"):
raise RuntimeError("API call failed or returned no data.")
base = payload.get("base")
if base != "EUR":
# For EUA_CO2, base should be EUR
raise ValueError(f"Unexpected base currency: {base}")
rates = payload.get("rates", {})
dates = payload.get("dates", {})
currencies = payload.get("currencies", {})
if "EUA_CO2" not in rates:
raise KeyError("EUA_CO2 not present in rates.")
value = rates["EUA_CO2"]
value_date = dates.get("EUA_CO2")
ccy = currencies.get("EUA_CO2")
if ccy != "EUR":
raise ValueError(f"Unexpected currency for EUA_CO2: {ccy}")
return {
"symbol": "EUA_CO2",
"date": value_date,
"price": value,
"unit": "EUR/MT",
"currency": ccy
}
if __name__ == "__main__":
# Example window for a finance pricing job
start = "2026-01-01"
end = "2026-03-31"
payload = fetch_eua_co2(start, end)
record = read_eua_fields(payload)
print(json.dumps(record, indent=2))
Notes for production:
- Always check success before parsing body fields.
- Validate base and currencies to keep FX and commodity books consistent.
- Log base_filter_note and missing_symbols to detect upstream issues without breaking pipelines.
Practical integration details that save time
- Units: EUA_CO2 is quoted in EUR/MT. Store the unit alongside the value to avoid silent unit mismatches in downstream analytics.
- Base and currencies: The base for this endpoint is EUR in the samples shown. Do not pass a base override when requesting EUA_CO2.
- Timestamps and timezone: The API returns dates in YYYY-MM-DD. Align to your EOD convention. If you snapshot at a fixed time, persist both the API date and your valuation run timestamp.
- Calendar gaps: Energy and carbon markets may not update on every calendar date. Use dates.EUA_CO2 to anchor your valuation and avoid assuming that each day in your range has a unique print.
- Caching: If your valuation cycle reruns intra-day with the same inputs, cache the last successful payload keyed by date, symbol, and base to reduce call volume.
- Pagination: The endpoint in this guide does not document pagination parameters here. For larger pulls, segment by month or quarter and stitch results in your data layer.
- Error handling: Check missing_symbols for visibility if a requested symbol is unavailable for the given window. Log and fallback gracefully.
JSON examples for testing your parser
Use the following complete JSON responses to unit-test your serializer and validation logic. The first one is the official structure sample; the second one is a real EUA CO2 sample you should treat as canonical for symbol-specific parsing.
Official structure sample (symbol differs, structure identical)
{
"success": true,
"date": "2026-11-18",
"base": "EUR",
"rates": {
"OMIE_ES_DA": 52.1318
},
"dates": {
"OMIE_ES_DA": "2026-11-18"
},
"currencies": {
"OMIE_ES_DA": "EUR"
},
"base_filter_note": null,
"missing_symbols": null
}
EUA CO2 snapshot (copy exact values)
{"success":true,"date":"2026-11-01","base":"EUR","rates":{"EUA_CO2":78.82},"dates":{"EUA_CO2":"2026-11-01"},"currencies":{"EUA_CO2":"EUR"},"base_filter_note":null,"missing_symbols":null}
Official structure sample again for schema validation
{
"success": true,
"date": "2026-11-18",
"base": "EUR",
"rates": {
"OMIE_ES_DA": 52.1318
},
"dates": {
"OMIE_ES_DA": "2026-11-18"
},
"currencies": {
"OMIE_ES_DA": "EUR"
},
"base_filter_note": null,
"missing_symbols": null
}
EUA CO2 canonical sample for regression tests
{"success":true,"date":"2026-11-01","base":"EUR","rates":{"EUA_CO2":78.82},"dates":{"EUA_CO2":"2026-11-01"},"currencies":{"EUA_CO2":"EUR"},"base_filter_note":null,"missing_symbols":null}
Each of these examples is complete and can be dropped into JSON schema or integration tests. Your parser should read rates.EUA_CO2, dates.EUA_CO2, and currencies.EUA_CO2 for EUA CO2, and gracefully ignore other symbols while preserving structure.
JavaScript example: ingest and persist EUA CO2
This Node.js snippet calls the same endpoint, validates the payload, and prints a normalized object suitable for inserting into a price-history table keyed by (symbol, date).
import fetch from "node-fetch";
const API_URL = "https://energy-api.com/api/v1/timeseries";
const API_KEY = process.env.ENERGY_API_KEY || "YOUR_API_KEY";
async function getEuaCo2(start, end) {
const params = new URLSearchParams({
start,
end,
symbols: "EUA_CO2",
api_key: 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 data = await res.json();
if (!data.success) {
throw new Error("API response not successful");
}
const base = data.base;
if (base !== "EUR") {
throw new Error(`Unexpected base: ${base}`);
}
const price = data.rates?.EUA_CO2;
const date = data.dates?.EUA_CO2;
const ccy = data.currencies?.EUA_CO2;
if (price == null || !date || ccy !== "EUR") {
throw new Error("Missing or invalid EUA_CO2 fields");
}
return {
symbol: "EUA_CO2",
date,
price,
currency: ccy,
unit: "EUR/MT"
};
}
(async () => {
try {
const record = await getEuaCo2("2026-01-01", "2026-03-31");
console.log(record);
} catch (err) {
console.error(err);
process.exit(1);
}
})();
Store the returned record in your price table as a unique key on symbol+date. If you run intraday refreshes, append a valuation run timestamp column to track when a value was ingested.
Quality checks for finance-grade pipelines
Before you ship this into production, add a few basic controls to prevent bad data from contaminating P&L or VaR:
- Schema checks: Assert that success is true, base is EUR, and currencies.EUA_CO2 is EUR.
- Value sanity: Reject negative values or absurd magnitudes for EUA_CO2; log and alert instead of propagating.
- Completeness: If dates.EUA_CO2 is missing for a requested window, treat the response as incomplete and retry or fall back to the last-known-good value according to your valuation policy.
- Idempotency: Cache responses for a given symbol-date to avoid inadvertent double-writes during retries.
Frequently asked questions
Q: How do I request multiple symbols with EUA CO2?
A: Pass a comma-separated list in symbols. Keep base in EUR for EUA_CO2 and do not add a conflicting base parameter.
Q: What time of day are values stamped?
A: The response includes dates.EUA_CO2 in YYYY-MM-DD. Align processing to your EOD cut. If you need clock-time stamps, store your ingestion timestamp alongside the API date.
Q: What should I do if a date in my window has no print?
A: Use dates.EUA_CO2 as the source of truth and do not assume daily continuity. You can choose to forward-fill in analytics, but keep raw values unaltered for audit.
Q: Can I convert EUA CO2 to another currency on the fly?
A: The samples here are EUR-based. If you require cross-currency valuation, convert outside this call using your firm’s FX sources and policies; do not pass a base override alongside EUA_CO2.
Q: How do I get started and test without committing?
A: Use the 7-day trial (50 calls) on the Starter plan to validate integration end to end.
Register for API access and start pulling historical EUA CO2 prices in minutes: Register. For parameter details and additional endpoints, see the Documentation.
Ready to get started?
Get your API key and start querying energy commodity prices in minutes.
Get API Key