Errors

SENTINEL = 0.0001

def is_line_available(value):
    """Return True if the line value is real, not the sentinel."""
    return value is not None and value != SENTINEL

spread = event["spread"]["point_spread_home"]
if is_line_available(spread):
    print(f"Home spread: {spread}")
else:
    print("Home spread: not available")

const SENTINEL = 0.0001;

function isLineAvailable(value) {
  return value !== null && value !== undefined && value !== SENTINEL;
}

const spread = event.spread.point_spread_home;
if (isLineAvailable(spread)) {
  console.log(`Home spread: ${spread}`);
} else {
  console.log("Home spread: not available");
}

import os
import requests
import time
import random

API_KEY = os.environ["THERUNDOWN_API_KEY"]
BASE = "https://therundown.io/api/v2"
RETRYABLE = {429, 500, 502, 503}

def fetch_with_retry(url, params=None, max_retries=3):
    """Fetch a URL with exponential backoff for transient errors."""
    for attempt in range(max_retries + 1):
        resp = requests.get(
            url,
            headers={"X-TheRundown-Key": API_KEY},
            params=params,
        )

        if resp.status_code == 200:
            return resp.json()

        if resp.status_code not in RETRYABLE or attempt == max_retries:
            resp.raise_for_status()

        if resp.status_code == 429:
            retry_after = resp.headers.get("Retry-After")
            wait = max(int(retry_after), 1) if retry_after else 60
        else:
            wait = min(2 ** attempt + random.uniform(0, 1), 30)

        print(f"Retrying in {wait:.1f}s (attempt {attempt + 1}/{max_retries})")
        time.sleep(wait)

# Usage
events = fetch_with_retry(f"{BASE}/sports/4/events/2026-02-26")

const API_KEY = process.env.THERUNDOWN_API_KEY;
if (!API_KEY) throw new Error("Set THERUNDOWN_API_KEY in the Node.js server environment");
const BASE = "https://therundown.io/api/v2";
const RETRYABLE = new Set([429, 500, 502, 503]);

async function fetchWithRetry(url, maxRetries = 3) {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    const resp = await fetch(url, {
      headers: { "X-TheRundown-Key": API_KEY },
    });

    if (resp.ok) return resp.json();

    if (!RETRYABLE.has(resp.status) || attempt === maxRetries) {
      throw new Error(`API error ${resp.status}: ${await resp.text()}`);
    }

    let wait;
    if (resp.status === 429) {
      const retryAfter = resp.headers.get("Retry-After");
      wait = retryAfter ? Math.max(Number(retryAfter), 1) : 60;
    } else {
      wait = Math.min(2 ** attempt + Math.random(), 30);
    }

    console.log(`Retrying in ${wait.toFixed(1)}s (attempt ${attempt + 1}/${maxRetries})`);
    await new Promise((r) => setTimeout(r, wait * 1000));
  }
}

// Usage
const events = await fetchWithRetry(
  `${BASE}/sports/4/events/2026-02-26`
);

import os
import requests
import time
import random

API_KEY = os.environ["THERUNDOWN_API_KEY"]
BASE = "https://therundown.io/api/v2"
SENTINEL = 0.0001
RETRYABLE = {429, 500, 502, 503}

def api_request(path, params=None, max_retries=3):
    """Make an API request with retry logic. Returns parsed JSON."""
    url = f"{BASE}/{path.lstrip('/')}"

    for attempt in range(max_retries + 1):
        resp = requests.get(
            url,
            headers={"X-TheRundown-Key": API_KEY},
            params=params,
        )

        if resp.status_code == 200:
            return resp.json()

        if resp.status_code not in RETRYABLE or attempt == max_retries:
            resp.raise_for_status()

        if resp.status_code == 429:
            retry_after = resp.headers.get("Retry-After")
            wait = max(int(retry_after), 1) if retry_after else 60
        else:
            wait = min(2 ** attempt + random.uniform(0, 1), 30)

        time.sleep(wait)

def is_available(price_value):
    """Return True if the price is real (not the 0.0001 sentinel)."""
    return price_value is not None and price_value != SENTINEL

def get_main_line_prices(event, market_id, affiliate_id):
    """Extract the main-line price for each participant in a market."""
    results = []
    for market in event.get("markets", []):
        if market["market_id"] != market_id:
            continue
        for participant in market.get("participants", []):
            for line in participant.get("lines", []):
                price_obj = line.get("prices", {}).get(str(affiliate_id))
                if not price_obj or not price_obj.get("is_main_line"):
                    continue
                price = price_obj["price"]
                results.append({
                    "participant": participant["name"],
                    "line": line["value"],
                    "price": price if is_available(price) else None,
                    "available": is_available(price),
                })
    return results

# Usage
data = api_request("sports/4/events/2026-02-26", {"market_ids": "1,2,3"})
for event in data.get("events", []):
    spreads = get_main_line_prices(event, market_id=2, affiliate_id=19)
    for s in spreads:
        if s["available"]:
            print(f"{s['participant']}: {s['line']} ({s['price']})")
        else:
            print(f"{s['participant']}: off the board")

const API_KEY = process.env.THERUNDOWN_API_KEY;
if (!API_KEY) throw new Error("Set THERUNDOWN_API_KEY in the Node.js server environment");
const BASE = "https://therundown.io/api/v2";
const SENTINEL = 0.0001;
const RETRYABLE = new Set([429, 500, 502, 503]);

async function apiRequest(path, params = {}, maxRetries = 3) {
  const query = new URLSearchParams(params);
  const url = `${BASE}/${path.replace(/^\//, "")}?${query}`;

  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    const resp = await fetch(url, { headers: { "X-TheRundown-Key": API_KEY } });

    if (resp.ok) return resp.json();

    if (!RETRYABLE.has(resp.status) || attempt === maxRetries) {
      throw new Error(`API error ${resp.status}: ${await resp.text()}`);
    }

    let wait;
    if (resp.status === 429) {
      const retryAfter = resp.headers.get("Retry-After");
      wait = retryAfter ? Math.max(Number(retryAfter), 1) : 60;
    } else {
      wait = Math.min(2 ** attempt + Math.random(), 30);
    }

    await new Promise((r) => setTimeout(r, wait * 1000));
  }
}

function isAvailable(priceValue) {
  return priceValue != null && priceValue !== SENTINEL;
}

function getMainLinePrices(event, marketId, affiliateId) {
  const results = [];
  for (const market of event.markets || []) {
    if (market.market_id !== marketId) continue;
    for (const participant of market.participants || []) {
      for (const line of participant.lines || []) {
        const priceObj = line.prices?.[String(affiliateId)];
        if (!priceObj?.is_main_line) continue;
        results.push({
          participant: participant.name,
          line: line.value,
          price: isAvailable(priceObj.price) ? priceObj.price : null,
          available: isAvailable(priceObj.price),
        });
      }
    }
  }
  return results;
}

// Usage
const data = await apiRequest("sports/4/events/2026-02-26", {
  market_ids: "1,2,3",
});
for (const event of data.events || []) {
  const spreads = getMainLinePrices(event, 2, 19);
  for (const s of spreads) {
    if (s.available) {
      console.log(`${s.participant}: ${s.line} (${s.price})`);
    } else {
      console.log(`${s.participant}: off the board`);
    }
  }
}