Historical EUA CO2 Prices

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:

Illustration: Historical EUA CO2 Prices
  • 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