Chapter 22: Betting Market Analysis

Understanding the most efficient prediction market in sports

Introduction

NFL betting markets represent one of the most efficient prediction systems in existence. Billions of dollars flow through these markets each week, with sophisticated bettors, syndicates, and algorithms competing to find edges. The result is a collective forecast that's remarkably difficult to beat.

This chapter explores betting markets not as gambling advice, but as an analytical framework. Understanding how markets work, what prices mean, and how to evaluate predictions against market efficiency provides essential context for anyone building NFL prediction models.

Learning Objectives

By the end of this chapter, you will be able to:

1. Interpret point spreads, moneylines, and totals
2. Convert between different odds formats
3. Explain the concept of market efficiency in sports betting
4. Calculate the break-even win rate at various odds
5. Evaluate model performance against market benchmarks
6. Understand how line movement reflects information flow
7. Apply closing line value as a performance metric
8. Recognize the limitations of using betting data in analysis

Part 1: Understanding Betting Markets

The Three Primary Markets

Point Spreads (Against the Spread / ATS):

The point spread equalizes the contest by giving points to the underdog:

Kansas City Chiefs -7.0 (-110)
Buffalo Bills +7.0 (-110)

This means: - Chiefs must win by more than 7 to "cover" - Bills cover if they win outright or lose by less than 7 - Exactly 7 is a "push" (tie)—bets returned

Moneylines:

Straight win/loss bets with varying payouts:

Kansas City Chiefs -280
Buffalo Bills +230

This means: - Bet $280 on Chiefs to win $100 - Bet $100 on Bills to win $230

Totals (Over/Under):

Betting on combined points:

Total: 51.5
Over -110
Under -110

Bet on whether the combined score exceeds or falls short of 51.5.

Converting Odds

def american_to_implied_probability(american_odds: int) -> float:
    """
    Convert American odds to implied probability.

    Positive odds (underdog): probability = 100 / (odds + 100)
    Negative odds (favorite): probability = |odds| / (|odds| + 100)
    """
    if american_odds > 0:
        return 100 / (american_odds + 100)
    else:
        return abs(american_odds) / (abs(american_odds) + 100)


def american_to_decimal(american_odds: int) -> float:
    """Convert American odds to decimal odds."""
    if american_odds > 0:
        return (american_odds / 100) + 1
    else:
        return (100 / abs(american_odds)) + 1


def implied_probability_to_american(prob: float) -> int:
    """Convert probability to American odds."""
    if prob >= 0.5:
        return int(-100 * prob / (1 - prob))
    else:
        return int(100 * (1 - prob) / prob)


def spread_to_probability(spread: float, std: float = 13.5) -> float:
    """
    Convert point spread to implied win probability.

    Uses normal distribution with NFL's typical std of ~13.5 points.
    """
    from scipy import stats
    return 1 - stats.norm.cdf(spread / std)

The Vig (Vigorish)

Sportsbooks don't offer fair odds—they take a commission:

Standard: -110 on both sides
You risk $110 to win $100

This creates the vig or juice:

• Implied probability at -110: 52.38%
• Both sides at -110 implies 104.76% total
• The extra 4.76% is the vig

def calculate_vig(odds1: int, odds2: int) -> float:
    """
    Calculate the vig (overround) in a two-way market.

    Returns the vig as a percentage.
    """
    prob1 = american_to_implied_probability(odds1)
    prob2 = american_to_implied_probability(odds2)
    return (prob1 + prob2 - 1) * 100


def remove_vig(odds1: int, odds2: int) -> Tuple[float, float]:
    """
    Calculate vig-free (fair) probabilities.

    Distributes the overround proportionally.
    """
    prob1 = american_to_implied_probability(odds1)
    prob2 = american_to_implied_probability(odds2)
    total = prob1 + prob2

    return prob1 / total, prob2 / total

Part 2: Market Efficiency

What Is Market Efficiency?

A market is "efficient" when prices reflect all available information. In an efficient betting market:

1. Prices are unbiased: The spread accurately predicts the median outcome
2. No systematic edges exist: You can't consistently beat the market with public information
3. Information is rapidly incorporated: News quickly moves lines

Evidence of NFL Market Efficiency

Historical Spread Performance:

The market achieves near-perfect 50/50 outcomes—exactly what you'd expect from efficient prices.

Point Spread as Predictor:

Spreads accurately reflect win probabilities.

Sources of Efficiency

1. Smart Money: Professional bettors and syndicates move lines with large bets based on sophisticated models.

2. Competition: Bookmakers compete, narrowing spreads to attract action.

3. Information Flow: Injury reports, weather, and other news are instantly priced in.

4. Market Size: NFL is the most bet-on sport in America—high liquidity enables efficiency.

Inefficiency Opportunities

Despite overall efficiency, potential edges exist:

class MarketInefficiencyScanner:
    """
    Identify potential market inefficiencies.

    Note: Most apparent inefficiencies disappear under closer examination.
    """

    def __init__(self):
        self.known_patterns = {
            'home_underdog': "Home underdogs historically slight edge ATS",
            'bye_week_coming': "Teams before bye weeks may be undervalued",
            'divisional_dog': "Division underdogs know opponent well",
            'reverse_line_movement': "Line moves opposite to betting %"
        }

    def check_home_underdog(self, home_team: str, spread: float) -> Dict:
        """
        Check for home underdog situation.

        Historical ATS edge for home underdogs: ~1-2%
        """
        if spread > 0:  # Home team is underdog
            return {
                'pattern': 'home_underdog',
                'description': f"{home_team} is home underdog at +{spread}",
                'historical_edge': '1-2% ATS above break-even',
                'caveat': 'Edge may be priced in by sharp markets'
            }
        return None

    def check_line_movement(self, opening: float, current: float,
                            public_pct: float) -> Dict:
        """
        Check for reverse line movement.

        If line moves opposite to public betting, sharp money may be involved.
        """
        line_moved_toward_underdog = current > opening
        public_on_favorite = public_pct > 55

        if line_moved_toward_underdog and public_on_favorite:
            return {
                'pattern': 'reverse_line_movement',
                'description': 'Line moved toward underdog despite public on favorite',
                'implication': 'Sharp money may be on underdog',
                'caveat': 'Public betting % data may be unreliable'
            }
        return None

Part 3: Evaluating Model Performance

Against-the-Spread (ATS) Records

The standard measure: how often does your model correctly predict ATS outcomes?

class ATSEvaluator:
    """
    Evaluate model performance against the spread.
    """

    def __init__(self, vig: float = 0.0476):
        """
        Initialize with standard vig.

        At -110/-110, vig is 4.76%.
        Break-even ATS rate is 52.38%.
        """
        self.vig = vig
        self.break_even = 1 / (2 - vig)  # 52.38%

    def evaluate(self, predictions: List[Dict],
                 results: List[Dict]) -> Dict:
        """
        Evaluate ATS performance.

        predictions: [{'game_id', 'pick': 'home'/'away', 'spread'}]
        results: [{'game_id', 'home_score', 'away_score', 'spread'}]
        """
        correct = 0
        pushes = 0
        total = 0

        for pred, result in zip(predictions, results):
            actual_margin = result['home_score'] - result['away_score']
            line = result['spread']

            if pred['pick'] == 'home':
                cover = actual_margin > -line
                push = actual_margin == -line
            else:
                cover = actual_margin < -line
                push = actual_margin == -line

            if push:
                pushes += 1
            else:
                total += 1
                if cover:
                    correct += 1

        win_rate = correct / total if total > 0 else 0
        roi = (win_rate * 1.909 - 1) * 100  # ROI at -110

        return {
            'games': total + pushes,
            'wins': correct,
            'losses': total - correct,
            'pushes': pushes,
            'win_rate': round(win_rate, 4),
            'vs_break_even': round(win_rate - self.break_even, 4),
            'roi': round(roi, 2),
            'significant': self._significance_test(correct, total)
        }

    def _significance_test(self, wins: int, total: int) -> Dict:
        """Test if record is significantly different from break-even."""
        from scipy import stats

        if total < 50:
            return {'significant': False, 'reason': 'Insufficient sample'}

        # One-sample proportion test against break-even
        observed_rate = wins / total
        se = np.sqrt(self.break_even * (1 - self.break_even) / total)
        z = (observed_rate - self.break_even) / se
        p_value = 2 * (1 - stats.norm.cdf(abs(z)))

        return {
            'significant': p_value < 0.05,
            'p_value': round(p_value, 4),
            'z_score': round(z, 2)
        }

Closing Line Value (CLV)

CLV measures whether your predictions beat the closing line—the final line before kickoff:

class ClosingLineValue:
    """
    Calculate Closing Line Value (CLV).

    CLV = (Opening line - Closing line) when you bet with line movement
    CLV is the best predictor of long-term betting success.
    """

    def calculate_clv(self, bet_line: float, closing_line: float,
                      bet_side: str = 'home') -> Dict:
        """
        Calculate CLV for a single bet.

        Args:
            bet_line: The line when you placed the bet
            closing_line: The final line before kickoff
            bet_side: 'home' or 'away'

        Returns:
            CLV in points and approximate percentage edge
        """
        if bet_side == 'home':
            # Betting home team
            clv_points = bet_line - closing_line
        else:
            # Betting away team
            clv_points = closing_line - bet_line

        # Approximate: each point of CLV = ~3% edge
        clv_percentage = clv_points * 3

        return {
            'bet_line': bet_line,
            'closing_line': closing_line,
            'clv_points': round(clv_points, 1),
            'clv_percentage': round(clv_percentage, 1),
            'edge': 'positive' if clv_points > 0 else 'negative' if clv_points < 0 else 'neutral'
        }

    def aggregate_clv(self, bets: List[Dict]) -> Dict:
        """
        Calculate aggregate CLV across multiple bets.

        bets: [{'bet_line', 'closing_line', 'bet_side'}]
        """
        clv_points = []

        for bet in bets:
            result = self.calculate_clv(
                bet['bet_line'],
                bet['closing_line'],
                bet['bet_side']
            )
            clv_points.append(result['clv_points'])

        return {
            'n_bets': len(bets),
            'mean_clv': round(np.mean(clv_points), 2),
            'total_clv': round(sum(clv_points), 1),
            'positive_clv_pct': round(np.mean([c > 0 for c in clv_points]) * 100, 1),
            'expected_long_term': 'profitable' if np.mean(clv_points) > 0 else 'unprofitable'
        }

The CLV Paradox

Why CLV matters more than actual results:

1. Results are noisy: Any given bet can win or lose regardless of edge
2. CLV is signal: Consistently beating closing lines indicates skill
3. Long-term convergence: Positive CLV bettors profit over time; negative CLV bettors lose

Part 4: Market-Derived Predictions

Using Market Prices as Predictions

Market lines are themselves predictions—often the best available:

class MarketDerivedPredictions:
    """
    Extract predictions from market prices.

    The market consensus is a strong baseline for any model.
    """

    def __init__(self, home_field_advantage: float = 2.5):
        self.hfa = home_field_advantage

    def line_to_predictions(self, spread: float,
                            total: float,
                            home_ml: int,
                            away_ml: int) -> Dict:
        """
        Convert market lines to predictions.

        Args:
            spread: Point spread (negative = home favored)
            total: Over/under total points
            home_ml: Home team moneyline
            away_ml: Away team moneyline
        """
        # Win probability from moneyline
        home_prob, away_prob = remove_vig(home_ml, away_ml)

        # Expected margin from spread
        expected_margin = -spread

        # Expected scores from spread and total
        # Home expected = (total + margin) / 2
        # Away expected = (total - margin) / 2
        home_expected = (total + expected_margin) / 2
        away_expected = (total - expected_margin) / 2

        # Implied team strength (neutral field)
        home_rating = expected_margin - self.hfa

        return {
            'home_win_prob': round(home_prob, 3),
            'away_win_prob': round(away_prob, 3),
            'expected_margin': round(expected_margin, 1),
            'expected_home_score': round(home_expected, 1),
            'expected_away_score': round(away_expected, 1),
            'implied_total': total,
            'implied_home_rating': round(home_rating, 1),
            'spread_confidence': self._spread_confidence(spread)
        }

    def _spread_confidence(self, spread: float) -> str:
        """Assess spread confidence level."""
        abs_spread = abs(spread)
        if abs_spread <= 3:
            return "Low - close game expected"
        elif abs_spread <= 7:
            return "Medium - clear favorite"
        elif abs_spread <= 14:
            return "High - significant mismatch"
        else:
            return "Very high - major mismatch"


def compare_model_to_market(model_spread: float,
                             market_spread: float,
                             threshold: float = 2.0) -> Dict:
    """
    Compare model prediction to market line.

    Args:
        model_spread: Your model's predicted spread
        market_spread: The market spread
        threshold: Minimum difference to flag as disagreement

    Returns:
        Comparison analysis
    """
    difference = model_spread - market_spread

    if abs(difference) < threshold:
        assessment = "Agreement - model and market aligned"
        action = "No edge detected"
    elif difference > 0:
        # Model thinks home team is weaker than market
        assessment = f"Model favors away team by {difference:.1f} points more than market"
        action = "Potential value on away team"
    else:
        # Model thinks home team is stronger than market
        assessment = f"Model favors home team by {-difference:.1f} points more than market"
        action = "Potential value on home team"

    return {
        'model_spread': model_spread,
        'market_spread': market_spread,
        'difference': round(difference, 1),
        'assessment': assessment,
        'suggested_action': action,
        'warning': 'Market is usually right - proceed with caution'
    }

Part 5: Line Movement Analysis

Why Lines Move

Lines move for several reasons:

1. Information: Injuries, weather, or other news
2. Sharp money: Professional bettors placing large wagers
3. Public money: High volume from recreational bettors
4. Liability management: Bookmakers balancing exposure

Interpreting Movement

class LineMovementAnalyzer:
    """
    Analyze line movement patterns.
    """

    def analyze_movement(self, opening: float, current: float,
                          movements: List[Tuple[float, str]]) -> Dict:
        """
        Analyze line movement history.

        Args:
            opening: Opening spread
            current: Current spread
            movements: List of (spread, timestamp) tuples

        Returns:
            Movement analysis
        """
        total_movement = current - opening
        direction = "toward home" if total_movement < 0 else "toward away"

        # Categorize movement size
        abs_movement = abs(total_movement)
        if abs_movement < 0.5:
            magnitude = "minimal"
        elif abs_movement < 1.5:
            magnitude = "moderate"
        elif abs_movement < 3:
            magnitude = "significant"
        else:
            magnitude = "major"

        return {
            'opening': opening,
            'current': current,
            'total_movement': round(total_movement, 1),
            'direction': direction,
            'magnitude': magnitude,
            'n_moves': len(movements),
            'interpretation': self._interpret_movement(total_movement, magnitude)
        }

    def _interpret_movement(self, movement: float, magnitude: str) -> str:
        """Interpret what movement might mean."""
        if magnitude == "minimal":
            return "No significant information incorporated"
        elif magnitude == "moderate":
            return "Some sharp action or minor news incorporated"
        elif magnitude in ["significant", "major"]:
            if movement < 0:
                return "Strong money on home team - likely sharp action"
            else:
                return "Strong money on away team - likely sharp action"
        return "Unknown"

    def detect_steam_move(self, movements: List[Tuple[float, str]],
                           time_window: int = 5) -> bool:
        """
        Detect steam moves (rapid, coordinated line movement).

        Steam moves happen when sharp syndicates hit multiple books simultaneously.
        """
        if len(movements) < 2:
            return False

        # Check for rapid movement (simplified)
        for i in range(1, len(movements)):
            change = abs(movements[i][0] - movements[i-1][0])
            if change >= 1.0:  # 1+ point move
                return True

        return False

Part 6: Practical Applications

Building a Market-Aware Model

class MarketAwarePredictor:
    """
    Prediction system that incorporates market information.

    Uses market lines as a baseline and adjusts based on model insights.
    """

    def __init__(self, model, market_weight: float = 0.3):
        """
        Initialize with base model and market weight.

        Args:
            model: Your prediction model
            market_weight: How much to weight market vs model (0-1)
        """
        self.model = model
        self.market_weight = market_weight

    def predict(self, game: Dict, market_spread: float) -> Dict:
        """
        Generate prediction blending model and market.
        """
        # Get model prediction
        model_pred = self.model.predict(
            game['home_team'],
            game['away_team']
        )
        model_spread = model_pred['predicted_spread']

        # Blend with market
        blended_spread = (
            (1 - self.market_weight) * model_spread +
            self.market_weight * market_spread
        )

        # Determine if there's value
        model_market_diff = model_spread - market_spread
        has_value = abs(model_market_diff) > 1.5  # 1.5 point threshold

        return {
            'model_spread': round(model_spread, 1),
            'market_spread': round(market_spread, 1),
            'blended_spread': round(blended_spread, 1),
            'model_market_diff': round(model_market_diff, 1),
            'has_potential_value': has_value,
            'value_side': 'home' if model_market_diff < -1.5 else 'away' if model_market_diff > 1.5 else None
        }

    def backtest(self, historical_games: pd.DataFrame) -> Dict:
        """
        Backtest the market-aware predictor.
        """
        results = {
            'model_only': {'correct': 0, 'total': 0},
            'market_only': {'correct': 0, 'total': 0},
            'blended': {'correct': 0, 'total': 0},
            'value_bets': {'correct': 0, 'total': 0}
        }

        for _, game in historical_games.iterrows():
            pred = self.predict(game, game['market_spread'])
            actual_margin = game['home_score'] - game['away_score']

            # Evaluate each approach
            model_pick = actual_margin > -pred['model_spread']
            market_pick = actual_margin > -pred['market_spread']
            blended_pick = actual_margin > -pred['blended_spread']

            results['model_only']['total'] += 1
            results['market_only']['total'] += 1
            results['blended']['total'] += 1

            if model_pick:
                results['model_only']['correct'] += 1
            if market_pick:
                results['market_only']['correct'] += 1
            if blended_pick:
                results['blended']['correct'] += 1

            # Value bets
            if pred['has_potential_value']:
                results['value_bets']['total'] += 1
                if pred['value_side'] == 'home' and actual_margin > -game['market_spread']:
                    results['value_bets']['correct'] += 1
                elif pred['value_side'] == 'away' and actual_margin < -game['market_spread']:
                    results['value_bets']['correct'] += 1

        # Calculate win rates
        for approach in results:
            if results[approach]['total'] > 0:
                results[approach]['win_rate'] = (
                    results[approach]['correct'] / results[approach]['total']
                )

        return results

Responsible Use of Betting Data

Legal Considerations: - Sports betting legality varies by jurisdiction - This chapter is educational, not gambling advice - Always comply with local laws

Analytical Use: - Betting data provides excellent prediction benchmarks - Market-derived ratings can supplement your models - Line movement reveals information flow

Risks: - Even skilled bettors lose most of the time - The house edge makes consistent profit extremely difficult - Past performance doesn't guarantee future results

Part 7: Advanced Topics

Market Microstructure

Understanding how betting markets actually function:

class MarketMicrostructure:
    """
    Understanding betting market mechanics.
    """

    def __init__(self):
        self.typical_limits = {
            'recreational': 500,      # Max bet for recreational books
            'mid_tier': 5000,         # Mid-tier sportsbooks
            'sharp': 20000,           # Sharp-friendly books
            'offshore': 50000+        # Some offshore books
        }

    def explain_price_discovery(self) -> Dict:
        """Explain how lines are set and move."""
        return {
            'opening_line': {
                'source': 'Market makers (Pinnacle, CRIS) or in-house models',
                'timing': 'Typically Sunday evening for next week',
                'uncertainty': 'Higher - limited information incorporated'
            },
            'early_week': {
                'activity': 'Sharp bettors look for mispriced lines',
                'movement': 'Lines adjust as smart money comes in',
                'opportunity': 'Highest potential edge, but hard to access'
            },
            'mid_week': {
                'activity': 'Public money begins flowing',
                'movement': 'Lines may move toward popular teams',
                'noise': 'Higher - public biases visible'
            },
            'closing_line': {
                'timing': 'Just before kickoff',
                'efficiency': 'Highest - all information incorporated',
                'benchmark': 'Best available prediction of game outcome'
            }
        }

    def calculate_hold_percentage(self, home_odds: int, away_odds: int) -> float:
        """
        Calculate the book's hold percentage.

        Lower hold = more competitive market = harder to beat.
        """
        prob_home = american_to_implied_probability(home_odds)
        prob_away = american_to_implied_probability(away_odds)
        return (prob_home + prob_away - 1) * 100


class SharpVsPublicMoney:
    """
    Analyze differences between sharp and public betting patterns.
    """

    def __init__(self):
        self.public_biases = {
            'favorites': 'Public tends to bet on favorites',
            'home_teams': 'Public slightly favors home teams',
            'popular_teams': 'Cowboys, Patriots, etc. get excess action',
            'overs': 'Public prefers betting overs',
            'recent_performance': 'Public overweights recent results'
        }

    def interpret_betting_splits(self, public_pct: float,
                                  money_pct: float) -> Dict:
        """
        Interpret the difference between ticket count and money percentage.

        If public bets 70% on home but only 55% of money is on home,
        sharp money is likely on away.
        """
        ticket_money_diff = public_pct - money_pct

        if ticket_money_diff > 10:
            interpretation = "Sharp money appears to be opposite of public"
            sharp_side = "away" if public_pct > 50 else "home"
        elif ticket_money_diff < -10:
            interpretation = "Sharp money appears to be with public"
            sharp_side = "home" if public_pct > 50 else "away"
        else:
            interpretation = "No clear sharp vs public divergence"
            sharp_side = "unclear"

        return {
            'public_ticket_pct': public_pct,
            'money_pct': money_pct,
            'difference': round(ticket_money_diff, 1),
            'interpretation': interpretation,
            'implied_sharp_side': sharp_side,
            'caveat': 'Betting percentages are estimates and may be unreliable'
        }

Summary

Betting markets provide the most rigorous test for prediction models. Key takeaways:

1. Market Efficiency: NFL betting markets are highly efficient; beating them consistently is extremely difficult
2. Benchmark Value: Market lines serve as excellent prediction benchmarks
3. CLV Matters: Closing line value is the best predictor of long-term success
4. Information Flow: Line movement reveals how information is incorporated
5. Model Integration: Market data can supplement (not replace) your models

For analysts, betting markets offer valuable tools even without placing bets: - Use market lines as a prediction baseline - Compare model outputs to market consensus - Track CLV as a skill metric - Understand what information moves markets

Key Equations Reference

American Odds to Probability:

For positive odds: $P = \frac{100}{odds + 100}$

For negative odds: $P = \frac{|odds|}{|odds| + 100}$

Break-Even Win Rate at -110: $$WR_{break-even} = \frac{110}{110 + 100} = 52.38\%$$

Expected Value: $$EV = (Win\% \times Payout) - (Loss\% \times Stake)$$

Closing Line Value: $$CLV = Line_{bet} - Line_{close}$$

Looking Ahead

This concludes Part 4: Predictive Modeling. You now have the tools to build, evaluate, and refine NFL prediction systems.

Part 5 Preview: Next, we'll explore Advanced Topics—including player tracking data, advanced EPA analysis, and building comprehensive analytics dashboards.

Chapter Summary

Betting markets represent the gold standard for NFL prediction. Understanding how these markets work—from the mechanics of odds to the concept of closing line value—provides essential context for any serious analyst.

The key insight: if your model can consistently beat the closing line, you've built something valuable. If it can't, the market remains the best available prediction. This humility about market efficiency should inform how we evaluate all prediction systems.

For practitioners, betting data offers rich analytical possibilities beyond gambling: benchmarking models, understanding information flow, and incorporating market wisdom into predictions. Used responsibly, market analysis strengthens any NFL analytics toolkit.