Build a TTF/Brent Energy Ratio Tracker in 5 Minutes

TTF/Brent Ratio = (TTF_EUR × EUR_USD) / (Brent_USD / 1.7)

import requests
from datetime import datetime

API_KEY = "your_api_key_here"
BASE_URL = "https://api.oilpriceapi.com/v1"
HEADERS = {"Authorization": f"Token \{API_KEY\}"}

def get_latest_price(code: str) -> float:
    """Fetch latest price for a commodity code."""
    response = requests.get(
        f"\{BASE_URL\}/prices/latest",
        headers=HEADERS,
        params={"by_code": code}
    )
    response.raise_for_status()
    data = response.json()
    return data["data"]["price"]

def calculate_ttf_brent_ratio() -> dict:
    """Calculate the TTF/Brent energy-equivalent ratio."""
    # Fetch current prices
    ttf_eur = get_latest_price("DUTCH_TTF_EUR")      # EUR/MWh
    brent_usd = get_latest_price("BRENT_CRUDE_USD")   # USD/barrel
    eur_usd = get_latest_price("EUR_USD")             # USD per EUR

    # Convert TTF to USD/MWh
    ttf_usd = ttf_eur * eur_usd

    # Convert Brent to USD/MWh (1 barrel = 1.7 MWh)
    brent_usd_mwh = brent_usd / 1.7

    # Calculate ratio
    ratio = ttf_usd / brent_usd_mwh

    return {
        "ratio": round(ratio, 3),
        "ttf_eur_mwh": ttf_eur,
        "ttf_usd_mwh": round(ttf_usd, 2),
        "brent_usd_bbl": brent_usd,
        "brent_usd_mwh": round(brent_usd_mwh, 2),
        "eur_usd": eur_usd,
        "timestamp": datetime.utcnow().isoformat()
    }

def analyze_ratio(ratio: float) -> str:
    """Interpret the ratio relative to historical context."""
    if ratio < 0.50:
        return "CRISIS LOW: Below pre-2021 average. Check for data anomaly."
    elif ratio < 0.65:
        return "OVERSUPPLY: Gas discounted to oil. Bullish for industrials."
    elif ratio <= 0.90:
        return "NEW NORMAL: LNG-dominated market. Structural premium."
    elif ratio <= 1.20:
        return "STRESS: Gas at/above oil parity. Demand destruction likely."
    else:
        return "CRISIS: Extreme gas premium. Check for supply disruption."

# Run the tracker
if __name__ == "__main__":
    result = calculate_ttf_brent_ratio()
    analysis = analyze_ratio(result["ratio"])

    print(f"""
TTF/Brent Energy Ratio Tracker
==============================
Ratio: \{result['ratio']\} (Historical avg: 0.40)

Prices:
  TTF:   EUR \{result['ttf_eur_mwh']\}/MWh (USD \{result['ttf_usd_mwh']\}/MWh)
  Brent: USD \{result['brent_usd_bbl']\}/bbl (USD \{result['brent_usd_mwh']\}/MWh)
  EUR/USD: \{result['eur_usd']\}

Analysis: \{analysis\}

Updated: \{result['timestamp']\}
    """)

const API_KEY = "your_api_key_here";
const BASE_URL = "https://api.oilpriceapi.com/v1";

interface PriceResponse {
  data: {
    price: number;
    code: string;
    updated_at: string;
  };
}

interface RatioResult {
  ratio: number;
  ttfEurMwh: number;
  ttfUsdMwh: number;
  brentUsdBbl: number;
  brentUsdMwh: number;
  eurUsd: number;
  timestamp: string;
}

async function getLatestPrice(code: string): Promise<number> {
  const response = await fetch(
    `${BASE_URL}/prices/latest?by_code=${code}`,
    {
      headers: { Authorization: `Token ${API_KEY}` },
    }
  );

  if (!response.ok) {
    throw new Error(`Failed to fetch ${code}: ${response.statusText}`);
  }

  const data: PriceResponse = await response.json();
  return data.data.price;
}

async function calculateTtfBrentRatio(): Promise<RatioResult> {
  // Fetch all prices in parallel
  const [ttfEur, brentUsd, eurUsd] = await Promise.all([
    getLatestPrice("DUTCH_TTF_EUR"),
    getLatestPrice("BRENT_CRUDE_USD"),
    getLatestPrice("EUR_USD"),
  ]);

  // Convert TTF to USD/MWh
  const ttfUsd = ttfEur * eurUsd;

  // Convert Brent to USD/MWh (1 barrel = 1.7 MWh)
  const brentUsdMwh = brentUsd / 1.7;

  // Calculate ratio
  const ratio = ttfUsd / brentUsdMwh;

  return {
    ratio: Math.round(ratio * 1000) / 1000,
    ttfEurMwh: ttfEur,
    ttfUsdMwh: Math.round(ttfUsd * 100) / 100,
    brentUsdBbl: brentUsd,
    brentUsdMwh: Math.round(brentUsdMwh * 100) / 100,
    eurUsd: eurUsd,
    timestamp: new Date().toISOString(),
  };
}

// Ratio interpretation bands
function analyzeRatio(ratio: number): string {
  if (ratio < 0.50) return "CRISIS LOW";
  if (ratio < 0.65) return "OVERSUPPLY";
  if (ratio <= 0.90) return "NEW NORMAL";
  if (ratio <= 1.20) return "STRESS";
  return "CRISIS";
}

// Run
calculateTtfBrentRatio().then((result) => {
  console.log(`TTF/Brent Ratio: ${result.ratio}`);
  console.log(`Status: ${analyzeRatio(result.ratio)}`);
  console.log(`Historical avg: 0.40 | Current: ${result.ratio}`);
});

def get_historical_ratio(days: int = 30) -> list:
    """Fetch historical prices and calculate ratio over time."""
    # Get historical data for each commodity
    ttf_history = requests.get(
        f"{BASE_URL}/prices/historical",
        headers=HEADERS,
        params={"code": "DUTCH_TTF_EUR", "days": days}
    ).json()["data"]

    brent_history = requests.get(
        f"{BASE_URL}/prices/historical",
        headers=HEADERS,
        params={"code": "BRENT_CRUDE_USD", "days": days}
    ).json()["data"]

    # For simplicity, use a fixed EUR/USD rate
    # (For production, fetch historical EUR/USD as well)
    eur_usd = 1.168

    ratios = []
    for ttf, brent in zip(ttf_history, brent_history):
        ttf_usd = ttf["price"] * eur_usd
        brent_mwh = brent["price"] / 1.7
        ratio = ttf_usd / brent_mwh
        ratios.append({
            "date": ttf["created_at"][:10],
            "ratio": round(ratio, 3),
            "ttf": ttf["price"],
            "brent": brent["price"]
        })

    return ratios

def check_ratio_alerts(ratio: float, previous_ratio: float = None) -> list:
    """Check if ratio has crossed key thresholds."""
    alerts = []
    thresholds = [
        (0.65, "OVERSUPPLY", "below"),
        (0.90, "NEW_NORMAL_TOP", "above"),
        (1.00, "OIL_PARITY", "above"),
        (1.20, "CRISIS", "above"),
    ]

    for threshold, name, direction in thresholds:
        if direction == "above" and ratio > threshold:
            if previous_ratio and previous_ratio <= threshold:
                alerts.append(f"ALERT: Ratio crossed ABOVE {threshold} ({name})")
        elif direction == "below" and ratio < threshold:
            if previous_ratio and previous_ratio >= threshold:
                alerts.append(f"ALERT: Ratio crossed BELOW {threshold} ({name})")

    return alerts