Brent (BRENT_CRUDE) latest via Energy API — quality sample 28 Sep 2026

You need the latest Brent crude price you can trust, and you need to wire it into finance workflows fast—risk limits, P&L, dashboards, or automated hedging checks. By the end of this post you’ll pull the current BRENT_CRUDE price from a single REST endpoint, chart a historical series, compute fluctuations, and ship finance-grade features without touching a government portal or stitching CSVs.

Introduction

Finance and energy teams often burn days normalizing oil prices from fragmented sources, dealing with changing formats, and writing glue code to join crude oil with gas, carbon, or electricity for portfolio context. Even a “simple” Brent latest quote can hide edge cases: non-publishing days, inconsistent currency codes, or lagged timestamps that break your overnight processes.

This post shows how to fetch Brent (BRENT_CRUDE) latest and history using a single JSON schema from Energy API. You’ll make one request for the live price, enrich it with nearby commodities (gas and carbon) in the same call when needed, and add timeseries, fluctuation, and OHLC views for trading analytics. All examples are designed for finance use cases—risk checks, P&L, budgeting, and treasury reporting—so you can drop them straight into production.

We’ll use BRENT_CRUDE (USD/barrel) as our anchor symbol. Where helpful, we’ll note how to combine it with related market data, since traders and treasury teams often compare crude movements with gas (TTF_GAS) or carbon allowances (EUA_CO2) to contextualize spreads and sensitivity.

Why Energy API

• One normalized REST surface: Replace the patchwork of official energy sources with one JSON schema. For finance engineering, this means fewer brittle adapters and faster time to production.
• Query multiple commodities at once: Pull BRENT_CRUDE alongside TTF_GAS and EUA_CO2 in a single /latest call. This removes cross-source reconciliation and makes cross-commodity views trivial.
• Developer-first primitives: Endpoints for latest, historical snapshots, timeseries, fluctuation windows, and OHLC candles let you build P&L, VaR context, and dashboards without custom ETL.
• Deterministic rules for non-publishing days: For /historical, if a date falls on a non-publishing day, you get the most recent prior value. That means fewer null checks and cleaner finance reporting closeouts.

Quick Start

Base URL: https://energy-api.com/api/v1

Authentication: Pass your key as an api_key query parameter.

First request: latest Brent crude (BRENT_CRUDE)

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

Real response (values below are provided for this sample):

{"success":true,"date":"2026-09-22","base":"USD","rates":{"BRENT_CRUDE":114.89},"dates":{"BRENT_CRUDE":"2026-09-22"},"currencies":{"BRENT_CRUDE":"USD"},"base_filter_note":null}

Field notes for finance use:

• success: True if the request succeeded.
• date: The API’s effective date for the response (YYYY-MM-DD).
• base: The base currency context of the response (here USD).
• rates: Keyed by symbol. For BRENT_CRUDE the value is the latest USD/barrel price.
• dates: Per-symbol date of the underlying quote.
• currencies: Per-symbol currency code. Brent is USD.

Minimal Python example reading the same fields:

import requests

BASE_URL = "https://energy-api.com/api/v1/latest"
params = {
"symbols": "BRENT_CRUDE",
"api_key": "YOUR_API_KEY"
}

r = requests.get(BASE_URL, params=params, timeout=10)
r.raise_for_status()
data = r.json()

# Core finance fields you’ll use
brett_date = data["dates"]["BRENT_CRUDE"]
brett_price = data["rates"]["BRENT_CRUDE"]
brett_ccy = data["currencies"]["BRENT_CRUDE"]

print(f"BRENT_CRUDE {brett_date}: {brett_price} {brett_ccy} per barrel")

Core Endpoints

1) Latest: get the current Brent price

Path: GET /latest

Key params:

• symbols (required): one or many, comma-separated. Example: BRENT_CRUDE
• base (optional): filter by currency code

cURL:

curl -G https://energy-api.com/api/v1/latest \
--data-urlencode "symbols=BRENT_CRUDE,TTF_GAS,EUA_CO2" \
--data-urlencode "api_key=YOUR_API_KEY"

Illustrative JSON (structure accurate; values except the earlier real sample are examples):

{
"success": true,
"date": "2026-09-22",
"base": "MIXED",
"rates": {
"BRENT_CRUDE": 114.89,
"TTF_GAS": 35.10,
"EUA_CO2": 70.25
},
"dates": {
"BRENT_CRUDE": "2026-09-22",
"TTF_GAS": "2026-09-22",
"EUA_CO2": "2026-09-22"
},
"currencies": {
"BRENT_CRUDE": "USD",
"TTF_GAS": "EUR",
"EUA_CO2": "EUR"
}
}

Why this matters: finance teams can compute same-day spreads and stress checks across oil, gas, and carbon with one request and a consistent field layout.

2) Historical: backfill a specific date (with non-publishing guardrails)

Path: GET /historical

Behavior: If the requested date is a non-publishing day, returns the most recent prior value. This is ideal for month-end or quarter-end reports.

Key params:

• date (YYYY-MM-DD, required)
• symbols (required): e.g., BRENT_CRUDE
• base (optional)

cURL (illustrative):

curl -G https://energy-api.com/api/v1/historical \
--data-urlencode "date=2026-06-30" \
--data-urlencode "symbols=BRENT_CRUDE" \
--data-urlencode "api_key=YOUR_API_KEY"

Illustrative JSON (structure accurate, values illustrative):

{
"success": true,
"date": "2026-06-30",
"base": "USD",
"rates": {
"BRENT_CRUDE": 98.42
},
"currencies": {
"BRENT_CRUDE": "USD"
}
}

Use it for: EOD valuation, backtesting a model on a specific date, or reconciling treasury reports.

3) Timeseries: chart Brent over a window

Path: GET /timeseries

Returns a date-indexed series per symbol—perfect for trend lines, moving averages, and P&L explanations.

Key params:

• start (required)
• end (required)
• symbols (required)
• base (optional)

cURL (illustrative):

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

Illustrative JSON (structure accurate, values illustrative):

{
"success": true,
"base": "USD",
"start_date": "2026-01-01",
"end_date": "2026-03-31",
"rates": {
"BRENT_CRUDE": {
"2026-01-02": 86.10,
"2026-01-03": 86.55
}
},
"frequencies": {
"BRENT_CRUDE": "daily"
},
"currencies": {
"BRENT_CRUDE": "USD"
}
}

Finance angle: compute rolling vol, drawdowns, or explain P&L swings by plotting daily Brent changes alongside exposure.

4) Fluctuation: changes and returns between two dates

Path: GET /fluctuation

Gives start_value, end_value, change, and change_pct for the window, so you can calculate period returns without pulling the full series.

Key params:

• start (required)
• end (required)
• symbols (required)
• base (optional)

cURL (illustrative):

curl -G https://energy-api.com/api/v1/fluctuation \
--data-urlencode "start=2026-01-01" \
--data-urlencode "end=2026-01-31" \
--data-urlencode "symbols=BRENT_CRUDE" \
--data-urlencode "api_key=YOUR_API_KEY"

Illustrative JSON (structure accurate, values illustrative):

{
"success": true,
"base": "USD",
"start_date": "2026-01-01",
"end_date": "2026-01-31",
"rates": {
"BRENT_CRUDE": {
"start_value": 85.00,
"end_value": 88.25,
"change": 3.25,
"change_pct": 3.82
}
}
}

Use it for: period returns in performance decks, risk threshold checks, or alerting when change_pct exceeds a configured limit.

5) OHLC: monthly or weekly candles for volatility analysis

Path: GET /ohlc

Summarizes open, high, low, close per period for charting and vol insight. Good for finance dashboards and monthly review packs.

Key params:

• symbols (required): e.g., BRENT_CRUDE
• period (optional): weekly|monthly|quarterly (default monthly)
• start, end (optional)
• base (optional)

cURL (illustrative):

curl -G https://energy-api.com/api/v1/ohlc \
--data-urlencode "symbols=BRENT_CRUDE" \
--data-urlencode "period=monthly" \
--data-urlencode "start=2026-01-01" \
--data-urlencode "end=2026-06-30" \
--data-urlencode "api_key=YOUR_API_KEY"

Illustrative JSON (structure accurate, values illustrative):

{
"success": true,
"base": "USD",
"rates": {
"BRENT_CRUDE": [
{ "period": "2026-01", "open": 85.1, "high": 89.7, "low": 83.9, "close": 88.2, "data_points": 22 },
{ "period": "2026-02", "open": 88.2, "high": 91.5, "low": 86.4, "close": 90.7, "data_points": 20 }
]
}
}

Field tips: period is a YYYY-MM string for monthly. data_points indicates how many underlying data rows contributed to that candle in the window.

Real-World Use Cases

• Daily finance dashboard with oil/gas/carbon context: - Pull /latest for BRENT_CRUDE, TTF_GAS, EUA_CO2 in one call and display spot prices, daily deltas (via /fluctuation for yesterday to today), and exposure-weighted P&L. This helps treasury and trading see macro energy moves without hopping between portals.
• Month-end close and variance analysis: - Use /historical for the last calendar day of the month for BRENT_CRUDE and the prior month-end. Compute month-over-month change_pct and reconcile with budget assumptions. Non-publishing day handling simplifies your close checklist.
• Volatility and risk thresholds: - Fetch /timeseries for the past 90 days of BRENT_CRUDE and compute realized volatility and max drawdown. Add /ohlc (monthly) to a management pack to illustrate longer-term context. Trigger alerts when change_pct from /fluctuation breaches defined limits.

Practical integration notes

• Units and currency: - BRENT_CRUDE is quoted in USD per barrel. The currencies map confirms per-symbol currency in each response.
• Dates and publishing schedule: - date fields are YYYY-MM-DD. For /historical on a non-publishing day, the API returns the most recent prior value, reducing null handling in reports.
• Batching symbols: - You can request multiple symbols in the same /latest, /historical, or /timeseries call. Responses keep a stable shape across commodities to simplify joins.
• Error handling: - 401 for missing/invalid api_key, 404 when no data for symbols/date, 422 for validation errors, 429 for rate limits (use exponential backoff). Error shape: {"success":false,"error":"..."}.
• Caching: - Latest endpoints can be cached briefly in your app layer if you refresh at a schedule that matches your trading or reporting windows. Historical and OHLC responses are stable; cache aggressively if you fan out analyses.

End-to-end example: Brent spot, a quick sanity check, and a log line

This mini workflow pulls the latest BRENT_CRUDE, checks the currency, and prints a clean log line you can ship to a metrics sink.

#!/usr/bin/env python3
import requests
from datetime import datetime

API_URL = "https://energy-api.com/api/v1/latest"
params = {
"symbols": "BRENT_CRUDE",
"api_key": "YOUR_API_KEY"
}

r = requests.get(API_URL, params=params, timeout=10)
r.raise_for_status()
j = r.json()

if not j.get("success", False):
raise RuntimeError("Energy API returned unsuccessful response")

date_str = j["dates"]["BRENT_CRUDE"]
price = float(j["rates"]["BRENT_CRUDE"])
ccy = j["currencies"]["BRENT_CRUDE"]

if ccy != "USD":
raise ValueError(f"Unexpected currency for BRENT_CRUDE: {ccy}")

timestamp = datetime.utcnow().isoformat(timespec="seconds") + "Z"
print(f"{timestamp} BRENT_CRUDE {date_str} {price:.2f} {ccy}/bbl")

FAQ

How often is the Brent (BRENT_CRUDE) price updated?

Use GET /latest to retrieve the most recent available value. For programmatic workflows, poll on a schedule aligned with your trading or reporting cadence and implement 429 backoff if you hit rate limits.

Can I query Brent together with gas or carbon in a single request?

Yes. Pass multiple symbols to /latest (e.g., BRENT_CRUDE,TTF_GAS,EUA_CO2). The response preserves a consistent JSON shape across commodities so you can compute spreads or correlations without extra mapping code.

How do I get a clean month-end Brent price for finance reports?

Call /historical with the month-end date and symbol=BRENT_CRUDE. If that date is a non-publishing day, you’ll receive the most recent prior value, which simplifies reporting and reconciliations.

What’s the quickest way to compute a period return for Brent?

Use /fluctuation with start and end dates. You’ll get start_value, end_value, change, and change_pct so you can show a return without pulling and scanning a full timeseries.

Do I get the same JSON schema across commodities?

Yes. The schema for fields like rates, dates, and currencies is consistent for oil, gas, electricity, coal, carbon, and carbon intensity. That uniformity speeds up finance feature development across markets.

Conclusion + CTA

Brent is often the first building block for energy-aware finance: exposure reporting, P&L drivers, and macro risk checks. With a single REST call you can fetch the latest BRENT_CRUDE price, then expand into historicals, fluctuations, and OHLC for richer analytics without writing custom scrapers or per-provider adapters.

If you’re integrating energy data into finance systems, Try Energy API for free, browse the Documentation, and set up your first BRENT_CRUDE call. Ready to wire this into production? Register and start shipping reliable finance features powered by normalized energy market data from Energy API.