Building Your Own Shipping-Price Dashboard

Install Dependencies

fredapi wraps the FRED REST API and returns pandas DataFrames. yfinance pulls Yahoo Finance data. matplotlib handles charting. requests is for GDELT API calls.

fred_data.py

from fredapi import Fred
import pandas as pd

FRED_API_KEY = "YOUR_KEY_HERE"  # Replace with your free API key
fred = Fred(api_key=FRED_API_KEY)

# Define the series we care about
series_ids = {
    "cpi_all":      "CPIAUCSL",    # CPI All Items (monthly)
    "cpi_energy":   "CPIENGSL",    # CPI Energy (monthly)
    "cpi_food":     "CPIFABSL",    # CPI Food at Home (monthly)
    "ppi_all":      "PPIACO",      # PPI All Commodities (monthly)
    "import_price": "IR",          # Import Price Index (monthly)
    "brent":        "DCOILBRENTEU",# Brent Crude (daily)
    "wti":          "DCOILWTICO",  # WTI Crude (daily)
    "gas_price":    "GASREGW",     # Retail Gas Price (weekly)
}

START_DATE = "2020-01-01"

def pull_fred_data():
    """Pull all FRED series into a single DataFrame."""
    frames = {}
    for name, sid in series_ids.items():
        print(f"  Fetching {name} ({sid})...")
        s = fred.get_series(sid, observation_start=START_DATE)
        s.name = name
        frames[name] = s

    # Resample everything to daily, forward-fill monthly/weekly
    df = pd.DataFrame(frames)
    df.index = pd.to_datetime(df.index)
    df = df.resample("D").last().ffill()

    # Compute year-over-year percent changes for price indices
    for col in ["cpi_all", "cpi_energy", "cpi_food", "ppi_all", "import_price"]:
        df[f"{col}_yoy"] = df[col].pct_change(periods=365) * 100

    return df

if __name__ == "__main__":
    df = pull_fred_data()
    print(f"FRED data: {len(df)} rows, {df.columns.tolist()}")
    print(df.tail())

yfinance_data.py

import yfinance as yf
import pandas as pd

# Tickers relevant to shipping-price analysis
tickers = {
    "bdi":    "^BDI",     # Baltic Dry Index (availability varies)
    "crude":  "CL=F",     # WTI Crude Futures
    "nat_gas":"NG=F",     # Natural Gas Futures
    "wheat":  "ZW=F",     # CBOT Wheat Futures
    "corn":   "ZC=F",     # CBOT Corn Futures
    "usd":    "DX-Y.NYB", # US Dollar Index
    "zim":    "ZIM",      # ZIM Integrated Shipping
    "danaos": "DAC",      # Danaos Corporation
    "maersk": "AMKBY",    # Maersk (OTC ADR)
}

START_DATE = "2020-01-01"

def pull_yfinance_data():
    """Pull closing prices for shipping-relevant tickers."""
    frames = {}
    for name, ticker in tickers.items():
        print(f"  Fetching {name} ({ticker})...")
        try:
            data = yf.download(ticker, start=START_DATE, progress=False)
            if len(data) > 0:
                frames[name] = data["Close"]
        except Exception as e:
            print(f"  Warning: {name} failed: {e}")

    df = pd.DataFrame(frames)
    df.index = pd.to_datetime(df.index)

    # Compute 30-day rolling returns
    for col in df.columns:
        df[f"{col}_30d_ret"] = df[col].pct_change(periods=30) * 100

    return df

if __name__ == "__main__":
    df = pull_yfinance_data()
    print(f"Yahoo Finance data: {len(df)} rows, {df.columns.tolist()}")
    print(df.tail())

gdelt_data.py

import requests
import pandas as pd
from datetime import datetime, timedelta

GDELT_DOC_URL = "https://api.gdeltproject.org/api/v2/doc/doc"

# Chokepoint keywords for monitoring
QUERIES = {
    "hormuz":   '"strait of hormuz" OR "hormuz tanker"',
    "suez":     '"suez canal" OR "suez blockage"',
    "red_sea":  '"red sea shipping" OR "houthi ship"',
    "panama":   '"panama canal" OR "panama drought"',
    "malacca":  '"malacca strait" OR "malacca shipping"',
}

def fetch_gdelt_tone(query, timespan="90d", max_records=250):
    """Fetch articles and return daily average tone."""
    params = {
        "query": query,
        "mode": "TimelineTone",
        "timespan": timespan,
        "format": "json",
    }
    try:
        resp = requests.get(GDELT_DOC_URL, params=params, timeout=30)
        data = resp.json()
        if "timeline" not in data:
            return pd.Series(dtype=float)
        # Parse the timeline response
        rows = []
        for series in data["timeline"]:
            for point in series.get("data", []):
                date = datetime.strptime(point["date"], "%Y%m%dT%H%M%SZ")
                rows.append({"date": date.date(), "tone": point["value"]})
        if not rows:
            return pd.Series(dtype=float)
        df = pd.DataFrame(rows).groupby("date")["tone"].mean()
        df.index = pd.to_datetime(df.index)
        return df
    except Exception as e:
        print(f"  GDELT error for query: {e}")
        return pd.Series(dtype=float)

def pull_gdelt_data():
    """Pull tone timelines for all chokepoint queries."""
    frames = {}
    for name, query in QUERIES.items():
        print(f"  Fetching GDELT tone: {name}...")
        tone = fetch_gdelt_tone(query)
        if len(tone) > 0:
            frames[f"tone_{name}"] = tone
    df = pd.DataFrame(frames)
    df.index = pd.to_datetime(df.index)
    return df

if __name__ == "__main__":
    df = pull_gdelt_data()
    print(f"GDELT data: {len(df)} rows, {df.columns.tolist()}")
    print(df.tail())

merge_data.py

import pandas as pd
from fred_data import pull_fred_data
from yfinance_data import pull_yfinance_data
from gdelt_data import pull_gdelt_data

def build_merged_dataset():
    """Merge all three data sources on a daily index."""
    print("Pulling FRED data...")
    fred_df = pull_fred_data()

    print("Pulling Yahoo Finance data...")
    yf_df = pull_yfinance_data()

    print("Pulling GDELT data...")
    gdelt_df = pull_gdelt_data()

    # Merge on date index
    merged = fred_df.join(yf_df, how="outer").join(gdelt_df, how="outer")

    # Forward-fill gaps (weekends, holidays)
    merged = merged.ffill()

    # Drop rows where key columns are all NaN
    key_cols = ["cpi_all", "brent", "crude"]
    merged = merged.dropna(subset=key_cols, how="all")

    print(f"Merged dataset: {len(merged)} rows, {len(merged.columns)} columns")
    return merged

if __name__ == "__main__":
    df = build_merged_dataset()
    df.to_csv("shipping_price_data.csv")
    print("Saved to shipping_price_data.csv")

correlations.py

import pandas as pd
import matplotlib.pyplot as plt
from merge_data import build_merged_dataset

def compute_correlations(df, window=90):
    """Compute rolling correlations between shipping and price metrics."""
    pairs = [
        ("brent",       "cpi_energy_yoy", "Brent Crude vs CPI Energy (YoY)"),
        ("crude",       "ppi_all_yoy",    "WTI Futures vs PPI All (YoY)"),
        ("crude",       "cpi_all_yoy",    "WTI Futures vs CPI All (YoY)"),
        ("nat_gas",     "cpi_energy_yoy", "Natural Gas vs CPI Energy (YoY)"),
        ("gas_price",   "cpi_all_yoy",    "Retail Gas vs CPI All (YoY)"),
    ]

    results = {}
    for col_a, col_b, label in pairs:
        if col_a in df.columns and col_b in df.columns:
            corr = df[col_a].rolling(window).corr(df[col_b])
            results[label] = corr

    return pd.DataFrame(results)

def plot_rolling_correlations(corr_df, window=90):
    """Plot rolling correlations over time."""
    fig, ax = plt.subplots(figsize=(12, 6))
    for col in corr_df.columns:
        ax.plot(corr_df.index, corr_df[col], label=col, linewidth=1.2)

    ax.set_title(f"Rolling {window}-Day Correlations: Shipping vs. Price Indicators")
    ax.set_ylabel("Pearson Correlation")
    ax.set_xlabel("Date")
    ax.axhline(y=0, color="gray", linestyle="--", linewidth=0.5)
    ax.legend(loc="lower left", fontsize=8)
    ax.set_ylim(-1, 1)
    plt.tight_layout()
    plt.savefig("rolling_correlations.png", dpi=150)
    plt.show()
    print("Saved rolling_correlations.png")

if __name__ == "__main__":
    df = build_merged_dataset()
    corr_df = compute_correlations(df, window=90)
    plot_rolling_correlations(corr_df, window=90)

dashboard.py

import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from merge_data import build_merged_dataset
from correlations import compute_correlations

def build_dashboard():
    df = build_merged_dataset()
    corr_df = compute_correlations(df, window=90)

    # Use last 365 days for display
    cutoff = df.index.max() - pd.Timedelta(days=365)
    df = df[df.index >= cutoff]
    corr_df = corr_df[corr_df.index >= cutoff]

    fig, axes = plt.subplots(2, 2, figsize=(14, 10))
    fig.suptitle("Shipping-Price Dashboard", fontsize=16, fontweight="bold")

    # Panel 1: Crude Oil vs CPI Energy
    ax1 = axes[0, 0]
    ax1.set_title("Brent Crude vs CPI Energy (YoY%)", fontsize=11)
    ax1.plot(df.index, df["brent"], color="#3b82f6", label="Brent ($/bbl)", linewidth=1)
    ax1_r = ax1.twinx()
    ax1_r.plot(df.index, df["cpi_energy_yoy"], color="#ef4444", label="CPI Energy YoY%", linewidth=1)
    ax1.set_ylabel("Brent ($/bbl)", color="#3b82f6")
    ax1_r.set_ylabel("CPI Energy YoY%", color="#ef4444")
    ax1.xaxis.set_major_formatter(mdates.DateFormatter("%b '%y"))

    # Panel 2: Rolling Correlations
    ax2 = axes[0, 1]
    ax2.set_title("90-Day Rolling Correlations", fontsize=11)
    for col in list(corr_df.columns)[:3]:
        ax2.plot(corr_df.index, corr_df[col], label=col, linewidth=1)
    ax2.axhline(y=0, color="gray", linestyle="--", linewidth=0.5)
    ax2.set_ylim(-1, 1)
    ax2.legend(fontsize=7, loc="lower left")
    ax2.xaxis.set_major_formatter(mdates.DateFormatter("%b '%y"))

    # Panel 3: Shipping Stocks as Freight Proxies
    ax3 = axes[1, 0]
    ax3.set_title("Shipping Stock 30-Day Returns (%)", fontsize=11)
    for col in ["zim_30d_ret", "danaos_30d_ret"]:
        if col in df.columns:
            ax3.plot(df.index, df[col], label=col.replace("_30d_ret",""), linewidth=1)
    ax3.axhline(y=0, color="gray", linestyle="--", linewidth=0.5)
    ax3.set_ylabel("30-Day Return (%)")
    ax3.legend(fontsize=8)
    ax3.xaxis.set_major_formatter(mdates.DateFormatter("%b '%y"))

    # Panel 4: GDELT Chokepoint Tone
    ax4 = axes[1, 1]
    ax4.set_title("GDELT Chokepoint Tone (7-Day Avg)", fontsize=11)
    for col in df.columns:
        if col.startswith("tone_"):
            label = col.replace("tone_", "").replace("_", " ").title()
            rolling = df[col].rolling(7).mean()
            ax4.plot(df.index, rolling, label=label, linewidth=1)
    ax4.axhline(y=0, color="gray", linestyle="--", linewidth=0.5)
    ax4.set_ylabel("Average Tone")
    ax4.legend(fontsize=7, loc="lower left")
    ax4.xaxis.set_major_formatter(mdates.DateFormatter("%b '%y"))

    plt.tight_layout()
    plt.savefig("shipping_dashboard.png", dpi=150, bbox_inches="tight")
    plt.show()
    print("Dashboard saved to shipping_dashboard.png")

if __name__ == "__main__":
    build_dashboard()

1. 1. Three free data sources cover the full pipeline. FRED provides the economic indicators (CPI, PPI, import prices). Yahoo Finance provides commodity prices and shipping stock proxies. GDELT provides geopolitical sentiment. Together, they cover the information chain from geopolitical event to consumer price impact.
2. 2. Mixed-frequency alignment is the hardest technical problem. Monthly CPI, weekly gas prices, daily oil prices, and 15-minute GDELT updates all need to land on a common time axis. Forward-filling is the standard approach but introduces artifacts. Be aware of the limitations.
3. 3. Rolling correlations reveal regime changes. The relationship between shipping metrics and consumer prices is not static. It tightens during disruptions and loosens during calm periods. A 90-day rolling window captures these shifts without excess noise.
4. 4. Multi-panel convergence is the signal. No single indicator is reliable in isolation. When GDELT tone drops, shipping stocks rally, oil rises, and correlations tighten simultaneously, the signal is strong. When panels disagree, investigate why.
5. 5. This is a learning tool, not a trading system. The dashboard demonstrates data pipeline mechanics. Production applications require cleaner data sources, proper backtesting, and risk management that goes far beyond a matplotlib chart.