API to Get the Energy Symbols Catalog Price

You need a reliable way to query the Energy Symbols Catalog and read the current catalog price for the BRENT_CRUDE symbol, using a simple HTTP GET with an API key. By the end of this guide, you will be able to confirm the symbol from the live list, request the latest catalog price, parse the response fields you actually need, and productionize the call with basic validation and caching.

What you will build: a first-request path for Energy Symbols Catalog (BRENT_CRUDE)

This guide focuses on the Energy Symbols Catalog with the symbol code BRENT_CRUDE. You will:

Illustration: API to Get the Energy Symbols Catalog Price

Confirm symbols from the live list endpoint.
Use an API key in the query string to authenticate.
Request the latest catalog price with a simple GET.
Parse the JSON response fields: base, rates, dates, and currencies.
Handle missing symbols and base-filter notes safely.

Units are mixed in this catalog. Always infer the correct unit per symbol from the currencies map and symbol documentation. When requesting multiple symbols that include TTF_GAS or EUA_CO2, do not pass base=USD in the same request. Use the default base or separate your calls accordingly.

Authentication and endpoints you will use

Authentication uses an api_key query parameter. Use YOUR_API_KEY as a placeholder during development. Do not place your real key in client-side code.

Live list (symbols catalog snapshot): GET https://energy-api.com/api/v1/symbols
Latest values for one or more specific symbols: GET https://energy-api.com/api/v1/latest?symbols=...

Pass api_key on every request as a query parameter. Example: ?api_key=YOUR_API_KEY.

Plan note: Starter $19.99/mo with a 7-day trial and 50 calls. If you are new to the API, you can create an account and obtain a key using the Register link below.

Copy-paste cURL for the live symbols catalog

This call retrieves the live symbols catalog response. Keep the URL, parameters, and field names exactly as shown.

curl -G "https://energy-api.com/api/v1/symbols" --data-urlencode "api_key=YOUR_API_KEY"

Official sample response: response fields you need to parse

This is the exact JSON you should expect to parse. Do not change the values when testing your parser.

{
"success": true,
"date": "2026-11-11",
"base": "EUR",
"rates": {
"OMIE_ES_DA": 210.9359
},
"dates": {
"OMIE_ES_DA": "2026-11-11"
},
"currencies": {
"OMIE_ES_DA": "EUR"
},
"base_filter_note": null,
"missing_symbols": null
}

Key fields to read:

success: Boolean flag. Check this first.
date: API-level date string (YYYY-MM-DD). Treat as the service’s own reference date; do not assume intraday granularity.
base: The default base currency for the rates payload.
rates: Map of symbol_code to numeric price.
dates: Map of symbol_code to the symbol’s last-available date.
currencies: Map of symbol_code to that symbol’s currency (useful because units are mixed).
base_filter_note: Nullable string; inspect when you filter by base or combine symbols with incompatible bases.
missing_symbols: Nullable array; populated when you request symbols the API cannot resolve.

Requesting BRENT_CRUDE: confirm the symbol, then fetch its latest value

First, confirm that BRENT_CRUDE appears on the live list. Use the symbols endpoint above and search for BRENT_CRUDE in the rates, dates, and currencies maps. If a symbol is not present, you will either find it in missing_symbols, or the symbol may not be part of your plan or the current base filter.

For requesting specific symbols, use GET /api/v1/latest?symbols=BRENT_CRUDE with the api_key parameter. Keep the authentication in the query string. If you later combine BRENT_CRUDE with TTF_GAS or EUA_CO2, do not pass base=USD in the same request; the service enforces base compatibility, and you should call them in separate requests if you need a different base.

Python quickstart: call the live list and read fields safely

This Python example wraps the same live list call as the cURL above, validates the response, and shows how to read a symbol’s price, date, and currency. Replace YOUR_API_KEY with your real key in production code.

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

API_KEY = os.getenv("ENERGY_API_KEY", "YOUR_API_KEY")
BASE_URL = "https://energy-api.com/api/v1/symbols"

def fetch_symbols(api_key: str):
params = {"api_key": api_key}
url = BASE_URL + "?" + urllib.parse.urlencode(params)
req = urllib.request.Request(url)
with urllib.request.urlopen(req, timeout=15) as resp:
if resp.status != 200:
raise RuntimeError(f"HTTP {resp.status}")
data = json.loads(resp.read().decode("utf-8"))
return data

def read_symbol(data: dict, symbol_code: str):
if not data.get("success", False):
raise RuntimeError("API returned success=false")
rates = data.get("rates", {}) or {}
dates = data.get("dates", {}) or {}
currencies = data.get("currencies", {}) or {}
missing = data.get("missing_symbols", None)

if symbol_code in rates:
return {
"symbol": symbol_code,
"price": rates[symbol_code],
"date": dates.get(symbol_code),
"currency": currencies.get(symbol_code),
"base": data.get("base"),
}
# If not present, inspect missing_symbols to guide retries
return {
"symbol": symbol_code,
"price": None,
"date": None,
"currency": None,
"base": data.get("base"),
"missing_symbols": missing
}

if __name__ == "__main__":
try:
payload = fetch_symbols(API_KEY)
# Replace with "BRENT_CRUDE" in your integration if present on the live list
result = read_symbol(payload, "BRENT_CRUDE")
print(json.dumps(result, indent=2, sort_keys=True))
except Exception as e:
print(f"Error: {e}", file=sys.stderr)
sys.exit(1)

Notes:

Parse success before using the body.
Use the currencies map to select the unit per symbol because units are mixed.
Check missing_symbols when you request a symbol that does not appear in the response.
Handle null base_filter_note; if it becomes non-null, log it to correlate data filtering with your query choices.

Multiple JSON examples you can reuse for parser tests

Use the following official sample JSON blocks as fixtures while building your response parser and test assertions. Keep the values intact so that your parsing logic remains stable across environments. These blocks are identical by design, ensuring your parser is robust against repeated structures.

Catalog response: parser fixture A

{
"success": true,
"date": "2026-11-11",
"base": "EUR",
"rates": {
"OMIE_ES_DA": 210.9359
},
"dates": {
"OMIE_ES_DA": "2026-11-11"
},
"currencies": {
"OMIE_ES_DA": "EUR"
},
"base_filter_note": null,
"missing_symbols": null
}

Catalog response: parser fixture B

{
"success": true,
"date": "2026-11-11",
"base": "EUR",
"rates": {
"OMIE_ES_DA": 210.9359
},
"dates": {
"OMIE_ES_DA": "2026-11-11"
},
"currencies": {
"OMIE_ES_DA": "EUR"
},
"base_filter_note": null,
"missing_symbols": null
}

Catalog response: parser fixture C

{
"success": true,
"date": "2026-11-11",
"base": "EUR",
"rates": {
"OMIE_ES_DA": 210.9359
},
"dates": {
"OMIE_ES_DA": "2026-11-11"
},
"currencies": {
"OMIE_ES_DA": "EUR"
},
"base_filter_note": null,
"missing_symbols": null
}

Catalog response: parser fixture D

{
"success": true,
"date": "2026-11-11",
"base": "EUR",
"rates": {
"OMIE_ES_DA": 210.9359
},
"dates": {
"OMIE_ES_DA": "2026-11-11"
},
"currencies": {
"OMIE_ES_DA": "EUR"
},
"base_filter_note": null,
"missing_symbols": null
}

How to construct a targeted request for BRENT_CRUDE

After you confirm that BRENT_CRUDE is available in the live list, request its latest value using the dedicated endpoint that accepts a symbols filter. Keep authentication in the api_key query parameter. If you mix BRENT_CRUDE with symbols like TTF_GAS or EUA_CO2 in the same call, avoid forcing base=USD; split the calls if you need a different base for those symbols.

URL pattern:

/api/v1/latest?symbols=BRENT_CRUDE&api_key=YOUR_API_KEY

Field parsing is the same as in the catalog response above: read success, then extract the symbol price from rates[symbol], the per-symbol date from dates[symbol], and its currency from currencies[symbol]. Base affects cross-symbol normalization; do not assume a different base than what the API reports in the base field.

Practical production details: dates, timezones, units, and caching

Timestamps and timezone: The date fields are provided as YYYY-MM-DD strings. Treat them as service-level dates. Do not assume an intraday timestamp unless the endpoint documentation states otherwise.
Units: The catalog unit is mixed; you must consult the currencies map to pick the correct unit per symbol at runtime. Never hardcode a single unit across symbols.
Base handling: Read the base field from the response. When aggregating symbols, ensure your calculations align with the base or normalize externally. Do not pass base=USD alongside TTF_GAS or EUA_CO2 requests in a single call; separate those requests if you need USD-normalized values.
Caching: Cache successful responses for short intervals based on your update needs. Also cache negative lookups (missing_symbols) briefly to avoid repeated invalid symbol requests.
Validation: Always check success first, validate presence of the symbol in rates, and log base_filter_note when present for diagnostics.
Error handling: If missing_symbols is not null, surface it in logs and consider a fallback flow (e.g., prompt to re-check the live list).

End-to-end steps to get the BRENT_CRUDE price into your app

Step 1 — Register and get an API key

Create an account and start the trial (7 days / 50 calls) to obtain an API key. Store it in your server-side secrets. Do not embed your key in browser code.

Step 2 — Confirm symbols from the live list

Use the cURL above or your preferred HTTP client to call /api/v1/symbols with api_key. Verify that BRENT_CRUDE is present. If you do not find it, inspect the missing_symbols field or adjust your query parameters according to the docs.

Step 3 — Request the latest value for BRENT_CRUDE

Call GET /api/v1/latest?symbols=BRENT_CRUDE with api_key. Keep base handling in mind if you intend to request other symbols such as TTF_GAS or EUA_CO2 in the same call; do not pass base=USD together with those symbols.

Step 4 — Parse and store

From the JSON, read:

rates["BRENT_CRUDE"] as the price
dates["BRENT_CRUDE"] as the price date
currencies["BRENT_CRUDE"] as the currency
base as the response base used for normalization

Write these values to your cache or database, and propagate to your application logic.

Testing your integration: using the official sample blocks

While you integrate, use the official sample JSON blocks above to test your parser and error paths. Keep the structure strict: validate success, ensure rates is a map, and verify that symbol-level maps (dates, currencies) carry a matching key.

When your tests pass against the fixtures, switch the code to live calls using your api_key and verify that BRENT_CRUDE appears on the live list before wiring up production flows.

Operational tips and guardrails

Server-side only: Keep api_key server-side and proxy calls from your backend if you have a browser front-end.
Normalize cautiously: If you must convert or aggregate values across symbols, verify that the base and currencies align with your calculation model.
Separate incompatible batches: If your symbol batch includes TTF_GAS or EUA_CO2 and you want USD, make individual requests or use the default base. Do not pass base=USD with those in one call.
Monitoring: Log base, base_filter_note, and any missing_symbols to aid troubleshooting.
Pagination: If you later expand to endpoints that list more items, consult the documentation for pagination parameters and patterns.

FAQ

How do I authenticate requests?
Pass your key as a query parameter: api_key=YOUR_API_KEY. Keep it server-side.

Which endpoint should I call to get the BRENT_CRUDE price?
Confirm the symbol with /api/v1/symbols, then request GET /api/v1/latest?symbols=BRENT_CRUDE with the same api_key parameter.

Why are units mixed across symbols?
The catalog uses mixed units. Use the currencies map in the response to determine the unit for each symbol at runtime.

Can I force base=USD for all symbols?
Do not pass base=USD when your request also includes TTF_GAS or EUA_CO2. Split your requests or use the default base reported by the API.

What should I do if a symbol is missing?
Check missing_symbols in the response. If your target symbol appears there, re-verify the symbol code on the live list, adjust your request, or consult the Documentation.

Get your key and ship your first request

Start your 7-day trial (50 calls) and get your api_key. With the live list cURL above and a targeted GET for /api/v1/latest?symbols=BRENT_CRUDE, you can integrate the Energy Symbols Catalog into your app in minutes. Create your account here: Register. For endpoint details and field definitions, see the Documentation.