Connecting your March Madness dashboard to live data

You've built the command center and added efficiency metrics, but there's one problem: the data is fake.

Simulated games are great for development, but when tip-off happens, you want real scores flowing through your dashboard. This is exactly what Deephaven is designed for: swap out the data source, and everything downstream — your queries, your analytics, your dashboard — just works.

Same queries, same dashboard, real data.

Catch up on the series:

Part 1: Data-driven bracket picks — historical analysis and value picks.

Part 2: Real-time March Madness analytics — build the live command center.

Part 3: Understanding upsets — win probability and efficiency metrics.

Tip

New to Deephaven? Try the live demo or get started with Community Core — it's free and takes about 5 minutes.

Choosing a data source

In Part 2 and Part 3 of this blog series, we built a complete analytics dashboard — upset detection, scoring runs, bracket damage tracking, win probability. All of it powered by simulated data. The simulation was useful for development, but now we need the real thing.

Several APIs provide live sports data. Here's what matters for March Madness:

API	Scores	Odds/Win Prob	Free Tier	Auth
The Odds API	✓	✓	500 req/month	API key
ESPN (unofficial)	✓	✗	Unlimited	None
Sportradar	✓	✓	Trial only	API key

We'll use The Odds API — it has a generous free tier, clean JSON responses, and includes win probabilities from major sportsbooks (which are more accurate than any model you'll build in an afternoon).

Getting started with The Odds API

Sign up at the-odds-api.com (free tier works fine).
Copy your API key from the dashboard.
Store it as an environment variable — never commit keys to git.

Set the environment variable, then start Deephaven:

export ODDS_API_KEY="your-key-here"
docker run -e ODDS_API_KEY -p 10000:10000 ghcr.io/deephaven/server:latest

In your Python code, retrieve it with:

import os

API_KEY = os.environ.get("ODDS_API_KEY")

Caution

Never commit API keys to git. If you accidentally commit a key, rotate it immediately on the Odds API dashboard.

Fetching live scores

With your API key ready, let's see what real tournament data looks like. The Odds API returns scores for in-progress and completed games:

import urllib.request
import json


def fetch_live_scores():
    """Fetch current NCAA basketball scores from The Odds API."""
    url = (
        f"https://api.the-odds-api.com/v4/sports/basketball_ncaab/scores/"
        f"?apiKey={API_KEY}&daysFrom=1"
    )

    with urllib.request.urlopen(url) as response:
        data = json.loads(response.read().decode())

    return data

The response includes game IDs, team names, scores, and completion status — everything you need for your scoreboard.

Creating a ticking table from API data

Here's where everything comes together. Remember the simulated live_scoreboard table from Part 2? We're about to replace it with real data — and the beautiful part is that none of your downstream queries need to change.

We'll use a function-generated table to poll the API and produce a ticking table:

from deephaven import new_table, function_generated_table
from deephaven.column import string_col, int_col, bool_col
import urllib.request
import json
import os

API_KEY = os.environ.get("ODDS_API_KEY")


def fetch_scores():
    """Fetch live scores and return as a Deephaven table."""
    url = (
        f"https://api.the-odds-api.com/v4/sports/basketball_ncaab/scores/"
        f"?apiKey={API_KEY}&daysFrom=1"
    )

    try:
        with urllib.request.urlopen(url) as response:
            games = json.loads(response.read().decode())
    except Exception as e:
        print(f"API error: {e}")
        games = []

    # Parse into column lists
    game_ids, team1s, score1s, team2s, score2s, is_complete = [], [], [], [], [], []
    for game in games:
        if game.get("scores") and len(game["scores"]) == 2:
            game_ids.append(game["id"])
            team1s.append(game["home_team"])
            score1s.append(int(game["scores"][0]["score"]))
            team2s.append(game["away_team"])
            score2s.append(int(game["scores"][1]["score"]))
            is_complete.append(game.get("completed", False))

    return new_table(
        [
            string_col("GameID", game_ids),
            string_col("Team1", team1s),
            int_col("Score1", score1s),
            string_col("Team2", team2s),
            int_col("Score2", score2s),
            bool_col("IsComplete", is_complete),
        ]
    )


# Create a ticking table that refreshes every 5 minutes
# Free tier: 500 req/month ≈ 16/day — use sparingly!
live_scores = function_generated_table(
    table_generator=fetch_scores,
    refresh_interval_ms=5 * 60 * 1000,  # 5 minutes
)

The live_scores table showing real NCAA basketball game data

That's it. live_scores now updates every 5 minutes with real tournament data. Once you join in seed data (covered in "Putting it together" below), you're watching real upsets unfold.

Note

The free tier allows ~16 requests per day. A 5-minute refresh works for casual monitoring. For faster updates during games, consider a paid tier or use the caching strategy below to maximize your budget.

Adding win probabilities from odds

Remember the win probability model from Part 3? We built our own based on seed matchups and game state. But there's an easier way: let the sportsbooks do the math for you.

The Odds API provides betting odds, which we can convert to implied win probabilities:

def fetch_odds():
    """Fetch live odds and convert to win probabilities."""
    url = (
        f"https://api.the-odds-api.com/v4/sports/basketball_ncaab/odds/"
        f"?apiKey={API_KEY}&regions=us&markets=h2h"
    )

    with urllib.request.urlopen(url) as response:
        games = json.loads(response.read().decode())

    rows = []
    for game in games:
        if game.get("bookmakers"):
            # Use first bookmaker's odds
            book = game["bookmakers"][0]
            for market in book.get("markets", []):
                if market["key"] == "h2h":
                    outcomes = market["outcomes"]
                    # Convert American odds to implied probability
                    for outcome in outcomes:
                        odds = outcome["price"]
                        if odds > 0:
                            prob = 100 / (odds + 100)
                        else:
                            prob = abs(odds) / (abs(odds) + 100)

                        rows.append(
                            {
                                "GameID": game["id"],
                                "Team": outcome["name"],
                                "WinProb": round(prob * 100, 1),
                            }
                        )
    return rows

These probabilities are derived from real money — millions of dollars wagered by people who care deeply about being right. It's a strong prior to have in your corner.

Rate limiting and caching

There's a catch with free APIs: they have limits. The Odds API allows 500 requests per month — about 16 per day. That's enough for casual monitoring, but you'll run out quickly when you're refreshing once a minute during a tight game.

Here's how to stretch your budget:

from datetime import datetime, timedelta

# Simple cache to avoid redundant API calls
_cache = {"data": None, "expires": None}


def fetch_with_cache(fetch_fn, ttl_seconds=60):
    """Cache API responses to reduce request count."""
    now = datetime.now()

    if _cache["data"] and _cache["expires"] and now < _cache["expires"]:
        return _cache["data"]

    data = fetch_fn()
    _cache["data"] = data
    _cache["expires"] = now + timedelta(seconds=ttl_seconds)
    return data

For tournament day with a paid tier, you might want:

1-minute refresh during games you're watching closely.
5-minute refresh for background monitoring.
Cache between calls — scores don't change that fast.

Putting it together

Let's step back and appreciate what just happened. You built a complete analytics dashboard with simulated data. Now, with about 50 lines of API code, you've connected it to real tournament feeds.

The scores endpoint gives you Team1, Score1, Team2, Score2, and IsComplete — enough for most analytics. One thing it doesn't include is seed numbers, which you need for true upset detection. The fix is a one-time join against a static seed lookup table:

# Seed lookup — update each year when brackets are set
seeds = new_table(
    [
        string_col(
            "Team",
            [
                "Duke",
                "Kentucky",
                "Baylor",
                "Arizona",
                "San Diego St",
                "Creighton",
                "Texas",
                "Memphis",
                "Vermont",
                "Montana St",
                "UC Santa Barbara",
                "Grand Canyon",
                "UAB",
                "New Mexico",
                "Xavier",
                "Florida Atlantic",
            ],
        ),
        int_col("Seed", [1, 2, 3, 4, 5, 6, 7, 8, 16, 15, 14, 13, 12, 11, 10, 9]),
    ]
)

# Join seeds for both teams
live_scores_seeded = live_scores.join(
    seeds, on=["Team1=Team"], joins=["Seed1=Seed"]
).join(seeds, on=["Team2=Team"], joins=["Seed2=Seed"])

Now the Part 2 upset detection works exactly as written:

upset_tracker = live_scores_seeded.update(
    [
        "Leader = Score1 > Score2 ? Team1 : (Score2 > Score1 ? Team2 : `Tied`)",
        "LeaderSeed = Score1 > Score2 ? Seed1 : (Score2 > Score1 ? Seed2 : 0)",
        "TrailerSeed = Score1 > Score2 ? Seed2 : (Score2 > Score1 ? Seed1 : 0)",
        "Margin = Math.abs(Score1 - Score2)",
        "IsUpset = LeaderSeed > TrailerSeed && Leader != `Tied`",
        "UpsetMagnitude = IsUpset ? (LeaderSeed - TrailerSeed) : 0",
        "UpsetLevel = UpsetMagnitude >= 8 ? `MAJOR UPSET` : (UpsetMagnitude >= 4 ? `Upset Alert` : (IsUpset ? `Minor upset` : `Chalk`))",
    ]
)

The upset_tracker table with Leader, Margin, and IsUpset columns

live_scores_seeded is now a direct substitute for the simulated scoreboard from Parts 2 and 3. Scoring runs, bracket damage tracking, win probability — all of those queries work unchanged.

Complete working script

from deephaven import new_table, function_generated_table
from deephaven.column import string_col, int_col, bool_col
import urllib.request
import json
import os

API_KEY = os.environ.get("ODDS_API_KEY")


def fetch_scores():
    """Fetch live scores and return as a Deephaven table."""
    url = (
        f"https://api.the-odds-api.com/v4/sports/basketball_ncaab/scores/"
        f"?apiKey={API_KEY}&daysFrom=1"
    )

    try:
        with urllib.request.urlopen(url) as response:
            games = json.loads(response.read().decode())
    except Exception as e:
        print(f"API error: {e}")
        games = []

    game_ids, team1s, score1s, team2s, score2s, is_complete = [], [], [], [], [], []
    for game in games:
        if game.get("scores") and len(game["scores"]) == 2:
            game_ids.append(game["id"])
            team1s.append(game["home_team"])
            score1s.append(int(game["scores"][0]["score"]))
            team2s.append(game["away_team"])
            score2s.append(int(game["scores"][1]["score"]))
            is_complete.append(game.get("completed", False))

    return new_table(
        [
            string_col("GameID", game_ids),
            string_col("Team1", team1s),
            int_col("Score1", score1s),
            string_col("Team2", team2s),
            int_col("Score2", score2s),
            bool_col("IsComplete", is_complete),
        ]
    )


# Ticking table that refreshes every 5 minutes
live_scores = function_generated_table(
    table_generator=fetch_scores,
    refresh_interval_ms=5 * 60 * 1000,
)

# --- Seed lookup (update each year when brackets are set) ---
seeds = new_table(
    [
        string_col(
            "Team",
            [
                "Duke",
                "Kentucky",
                "Baylor",
                "Arizona",
                "San Diego St",
                "Creighton",
                "Texas",
                "Memphis",
                "Vermont",
                "Montana St",
                "UC Santa Barbara",
                "Grand Canyon",
                "UAB",
                "New Mexico",
                "Xavier",
                "Florida Atlantic",
            ],
        ),
        int_col("Seed", [1, 2, 3, 4, 5, 6, 7, 8, 16, 15, 14, 13, 12, 11, 10, 9]),
    ]
)

live_scores_seeded = live_scores.join(
    seeds, on=["Team1=Team"], joins=["Seed1=Seed"]
).join(seeds, on=["Team2=Team"], joins=["Seed2=Seed"])

# --- Part 2 queries: Upset tracking ---
upset_tracker = live_scores_seeded.update(
    [
        "Leader = Score1 > Score2 ? Team1 : (Score2 > Score1 ? Team2 : `Tied`)",
        "LeaderSeed = Score1 > Score2 ? Seed1 : (Score2 > Score1 ? Seed2 : 0)",
        "TrailerSeed = Score1 > Score2 ? Seed2 : (Score2 > Score1 ? Seed1 : 0)",
        "Margin = Math.abs(Score1 - Score2)",
        "IsUpset = LeaderSeed > TrailerSeed && Leader != `Tied`",
        "UpsetMagnitude = IsUpset ? (LeaderSeed - TrailerSeed) : 0",
        "UpsetLevel = UpsetMagnitude >= 8 ? `MAJOR UPSET` : (UpsetMagnitude >= 4 ? `Upset Alert` : (IsUpset ? `Minor upset` : `Chalk`))",
    ]
)

# Filter to only in-progress upsets
active_upsets = upset_tracker.where("IsUpset && !IsComplete")

# --- Part 3 queries: Win probability ---
# Simple model based on margin (without game clock data)
# Each point of margin ≈ 3-4% win probability shift
win_probability = live_scores.where("!IsComplete").update(
    [
        "Margin = Score1 - Score2",
        "WinProb1 = Math.min(0.95, Math.max(0.05, 0.5 + Margin * 0.035))",
        "WinProb2 = 1.0 - WinProb1",
        "WinPct1 = (int)(WinProb1 * 100)",
        "WinPct2 = (int)(WinProb2 * 100)",
    ]
)

# --- Build a simple dashboard view ---
from deephaven import ui


@ui.component
def march_madness_command_center():
    return ui.flex(
        ui.heading("March Madness Command Center", level=2),
        ui.table(live_scores),
        ui.table(upset_tracker),
        ui.table(win_probability),
        direction="column",
        gap="size-200",
    )


command_center = march_madness_command_center()

Note

No games right now? The active_upsets and win_probability tables will be empty outside of game times. During the tournament, games typically run Thursday–Sunday afternoons and evenings (ET).

The power of Deephaven's declarative approach: you describe what you want, not how to compute it. Swap the data source, and everything downstream updates automatically.

Swap the data source, keep the queries.

What's next

You now have a complete, production-ready March Madness analytics stack:

Pre-tournament analysis — historical data for bracket picks.
Real-time tracking — live upset detection and bracket damage.
Contextual metrics — efficiency and win probability.
Live data integration — real tournament feeds.

The same architecture works for any sport, any data source. NFL, NBA, soccer — if you can get the data, Deephaven can analyze it in real time.

Ready to build? Get started with Deephaven Community Core — free, open source, and built for exactly this.

Questions? Find us on Slack.

Part 4 of the March Madness series: Swap simulation for real tournament feeds