espn-odds-scraper 0.2.0__tar.gz

espn_odds_scraper-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Oronto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

espn_odds_scraper-0.2.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: espn_odds_scraper
+Version: 0.2.0
+Summary: A package for scraping historical and live MLB odds from ESPN's public API
+Author-email: Oronto <vile319@gmail.com>
+Project-URL: Homepage, https://github.com/Oronto/espn_odds_scraper
+Project-URL: Bug Tracker, https://github.com/Oronto/espn_odds_scraper/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.0.0
+Requires-Dist: requests>=2.0.0
+Requires-Dist: MLB-StatsAPI>=1.0.0
+Dynamic: license-file
+
+# espn_odds_scraper
+
+Scrape historical and live MLB odds from ESPN's public (undocumented) API. No API key, no Selenium — plain JSON requests.
+
+Successor to `mlb_odds_scraper` (OddsPortal/Selenium based). ESPN carries per-book odds (DraftKings, FanDuel, Caesars, MGM, Bet365, ...; older seasons carry BOVADA, 5Dimes, etc.), moneyline + run line + total in a single request per game, and timestamped line-movement history on its consensus feed.
+
+**Coverage:** solid from ~2015 onward. Earlier seasons exist but are degraded (moneylines often missing).
+
+## Install
+
+```bash
+pip install espn_odds_scraper
+```
+
+## Usage
+
+```python
+from espn_odds_scraper import scrape_espn_mlb, scrape_espn_mlb_years
+
+# One day, every book — one row per game x sportsbook
+df = scrape_espn_mlb("2023-07-14")
+
+# Date range, only certain books
+df = scrape_espn_mlb("2023-07-01", "2023-07-31", providers=["DraftKings", "FanDuel"])
+
+# With full timestamped line movement (opt-in, ~3 extra requests per game)
+odds, movement = scrape_espn_mlb("2023-07-14", include_history=True)
+
+# Whole seasons
+df = scrape_espn_mlb_years(2018, 2024)
+```
+
+### Odds DataFrame columns
+
+`game_id, game_datetime (UTC), status, completed, home_team_abbr, away_team_abbr, home_team_name, away_team_name, home_team_espn_id, away_team_espn_id, home_score, away_score, provider_id, provider, home_ml, away_ml, spread (home line), home_spread_odds, away_spread_odds, total, over_odds, under_odds, open_* (8 cols), close_* (8 cols), moneyline_winner, spread_winner`
+
+For completed games, per-book odds are the lines frozen at game time — effectively **closing lines**. In-game "Live Odds" feeds are dropped by default (`exclude_live=False` to keep them).
+
+### Opening / closing lines & line movement
+
+ESPN's data comes in two eras:
+
+- **2024+ (ESPN BET / DraftKings era):** each book carries real `open_*` and `close_*` snapshots (moneyline, spread + prices, total + prices) directly in the odds row — no extra requests. Fewer books, though (often just one).
+- **≤2023 (multi-book era):** `open_*`/`close_*` are empty (ESPN stored junk there), but full **timestamped line movement** exists on the consensus feed:
+
+```python
+from espn_odds_scraper import fetch_line_history, get_open_close
+
+movement = fetch_line_history("401472391")   # timestamped rows per market
+oc = get_open_close(movement)                # one row per market: open_* and close_*
+```
+
+Movement rows: `game_id, market (moneyline/spread/total), line_date (UTC), away_odds, home_odds, over_odds, under_odds, line`. First row per market is the opener, last is the closer. ESPN dropped this feed after the 2023 season.
+
+### Drop-in compatibility with mlb_odds_scraper
+
+```python
+from espn_odds_scraper import to_legacy_format, clean_game_data
+
+legacy = to_legacy_format(df)  # game_date, game_datetime, home_team/away_team
+                               # (statsapi ids), home_odds/away_odds, scores, abbrs
+merged = clean_game_data(cleaned_schedule, legacy)  # same merge helper as before
+```
+
+## Request footprint
+
+- 1 request per day (schedule + scores)
+- 1 request per game (all books, all markets)
+- optional: 3 requests per game (line movement)
+
+A full season is roughly 2,600 requests without history. Requests run through a thread pool (`max_workers=8` by default). Be polite; this is an undocumented API.
+
+## License
+
+MIT

espn_odds_scraper-0.2.0/README.md

@@ -0,0 +1,75 @@
+# espn_odds_scraper
+
+Scrape historical and live MLB odds from ESPN's public (undocumented) API. No API key, no Selenium — plain JSON requests.
+
+Successor to `mlb_odds_scraper` (OddsPortal/Selenium based). ESPN carries per-book odds (DraftKings, FanDuel, Caesars, MGM, Bet365, ...; older seasons carry BOVADA, 5Dimes, etc.), moneyline + run line + total in a single request per game, and timestamped line-movement history on its consensus feed.
+
+**Coverage:** solid from ~2015 onward. Earlier seasons exist but are degraded (moneylines often missing).
+
+## Install
+
+```bash
+pip install espn_odds_scraper
+```
+
+## Usage
+
+```python
+from espn_odds_scraper import scrape_espn_mlb, scrape_espn_mlb_years
+
+# One day, every book — one row per game x sportsbook
+df = scrape_espn_mlb("2023-07-14")
+
+# Date range, only certain books
+df = scrape_espn_mlb("2023-07-01", "2023-07-31", providers=["DraftKings", "FanDuel"])
+
+# With full timestamped line movement (opt-in, ~3 extra requests per game)
+odds, movement = scrape_espn_mlb("2023-07-14", include_history=True)
+
+# Whole seasons
+df = scrape_espn_mlb_years(2018, 2024)
+```
+
+### Odds DataFrame columns
+
+`game_id, game_datetime (UTC), status, completed, home_team_abbr, away_team_abbr, home_team_name, away_team_name, home_team_espn_id, away_team_espn_id, home_score, away_score, provider_id, provider, home_ml, away_ml, spread (home line), home_spread_odds, away_spread_odds, total, over_odds, under_odds, open_* (8 cols), close_* (8 cols), moneyline_winner, spread_winner`
+
+For completed games, per-book odds are the lines frozen at game time — effectively **closing lines**. In-game "Live Odds" feeds are dropped by default (`exclude_live=False` to keep them).
+
+### Opening / closing lines & line movement
+
+ESPN's data comes in two eras:
+
+- **2024+ (ESPN BET / DraftKings era):** each book carries real `open_*` and `close_*` snapshots (moneyline, spread + prices, total + prices) directly in the odds row — no extra requests. Fewer books, though (often just one).
+- **≤2023 (multi-book era):** `open_*`/`close_*` are empty (ESPN stored junk there), but full **timestamped line movement** exists on the consensus feed:
+
+```python
+from espn_odds_scraper import fetch_line_history, get_open_close
+
+movement = fetch_line_history("401472391")   # timestamped rows per market
+oc = get_open_close(movement)                # one row per market: open_* and close_*
+```
+
+Movement rows: `game_id, market (moneyline/spread/total), line_date (UTC), away_odds, home_odds, over_odds, under_odds, line`. First row per market is the opener, last is the closer. ESPN dropped this feed after the 2023 season.
+
+### Drop-in compatibility with mlb_odds_scraper
+
+```python
+from espn_odds_scraper import to_legacy_format, clean_game_data
+
+legacy = to_legacy_format(df)  # game_date, game_datetime, home_team/away_team
+                               # (statsapi ids), home_odds/away_odds, scores, abbrs
+merged = clean_game_data(cleaned_schedule, legacy)  # same merge helper as before
+```
+
+## Request footprint
+
+- 1 request per day (schedule + scores)
+- 1 request per game (all books, all markets)
+- optional: 3 requests per game (line movement)
+
+A full season is roughly 2,600 requests without history. Requests run through a thread pool (`max_workers=8` by default). Be polite; this is an undocumented API.
+
+## License
+
+MIT

espn_odds_scraper-0.2.0/espn_odds_scraper/__init__.py

@@ -0,0 +1,35 @@
+"""ESPN MLB odds scraper package."""
+
+from .scraper import (
+    scrape_espn_mlb,
+    scrape_espn_mlb_years,
+    get_games,
+    get_odds,
+    fetch_line_history,
+    get_open_close,
+    to_legacy_format,
+    clean_game_data,
+)
+from .pipeline import (
+    scrape,
+    scrape_line_movement,
+    add_game_ids,
+    get_mlb_team_map,
+)
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "scrape",
+    "scrape_line_movement",
+    "add_game_ids",
+    "get_mlb_team_map",
+    "scrape_espn_mlb",
+    "scrape_espn_mlb_years",
+    "get_games",
+    "get_odds",
+    "fetch_line_history",
+    "get_open_close",
+    "to_legacy_format",
+    "clean_game_data",
+]

espn_odds_scraper-0.2.0/espn_odds_scraper/pipeline.py

@@ -0,0 +1,453 @@
+"""STATSAPI V2 pipeline integration: sbr_odds-style output with MLB game_ids.
+
+Usage in Main.ipynb:
+
+    import espn_odds_scraper as espn
+
+    if update_espn_odds:
+        espn_odds = espn.scrape(fetch_start_date, fetch_end_date, engine)
+        pdu.to_sql_upsert(espn_odds, 'espn_odds', engine,
+                          ['game_id', 'sportsbook', 'odds_type'])
+
+    # one-time historical movement backfill (ESPN carries this <=2023 only):
+    # movement = espn.scrape_line_movement('2015-04-01', '2023-11-01', engine)
+    # pdu.to_sql_upsert(movement, 'espn_line_movement', engine,
+    #                   ['espn_game_id', 'market', 'timestamp'])
+"""
+
+import re
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Iterable
+
+import pandas as pd
+import requests
+
+from .scraper import (
+    CORE_BASE,
+    BET_TYPES,
+    HISTORY_PROVIDER_ID,
+    SCOREBOARD_URL,
+    _daterange,
+    _date_str,
+    _get_json,
+    _pick,
+    _to_num,
+)
+
+TEAM_NAME_ALIASES = {
+    "d-backs": "diamondbacks",
+    "diamondbacks": "diamondbacks",
+    "athletics": "athletics",
+    "a's": "athletics",
+    "oakland athletics": "athletics",
+}
+
+
+# ---------------------------------------------------------------------------
+# Schedule (includes venue) and per-book odds with open/current snapshots
+# ---------------------------------------------------------------------------
+
+def _get_games_pipeline(date):
+    data = _get_json(SCOREBOARD_URL, params={"dates": _date_str(date)})
+    if not data:
+        return []
+    games = []
+    for event in data.get("events", []):
+        try:
+            comp = event["competitions"][0]
+            status = comp.get("status", {}).get("type", {})
+            row = {
+                "espn_game_id": event["id"],
+                "game_datetime": event.get("date"),
+                "status": status.get("name", ""),
+                "completed": bool(status.get("completed", False)),
+                "venue": _pick(comp, "venue", "fullName") or "",
+            }
+            for side in comp.get("competitors", []):
+                prefix = "home" if side.get("homeAway") == "home" else "away"
+                team = side.get("team", {})
+                row[f"{prefix}_team"] = team.get("displayName", "")
+                row[f"{prefix}_team_short"] = team.get("abbreviation", "")
+                score = side.get("score", "")
+                row[f"{prefix}_score"] = (
+                    pd.to_numeric(score, errors="coerce") if score != "" else None
+                )
+            games.append(row)
+        except Exception as e:  # noqa: BLE001
+            print(f"Error parsing ESPN event on {date}: {e}")
+    return games
+
+
+def _parse_phase_flat(item, phase):
+    home = _pick(item, "homeTeamOdds", phase) or {}
+    away = _pick(item, "awayTeamOdds", phase) or {}
+    totals = item.get(phase) or {}
+    return {
+        "home_ml": _to_num(_pick(home, "moneyLine", "american")),
+        "away_ml": _to_num(_pick(away, "moneyLine", "american")),
+        "spread": _to_num(_pick(home, "pointSpread", "american")),
+        "home_spread_odds": _to_num(_pick(home, "spread", "american")),
+        "away_spread_odds": _to_num(_pick(away, "spread", "american")),
+        "total": _to_num(_pick(totals, "total", "american")),
+        "over_odds": _to_num(_pick(totals, "over", "american")),
+        "under_odds": _to_num(_pick(totals, "under", "american")),
+    }
+
+
+def _get_odds_pipeline(espn_game_id):
+    url = f"{CORE_BASE}/events/{espn_game_id}/competitions/{espn_game_id}/odds"
+    data = _get_json(url)
+    if not data:
+        return []
+    rows = []
+    for item in data.get("items", []):
+        try:
+            provider = item.get("provider", {})
+            cur = _parse_phase_flat(item, "current")
+            opn = _parse_phase_flat(item, "open")
+            if cur["home_ml"] is None:
+                cur["home_ml"] = _to_num(_pick(item, "homeTeamOdds", "moneyLine"))
+            if cur["away_ml"] is None:
+                cur["away_ml"] = _to_num(_pick(item, "awayTeamOdds", "moneyLine"))
+            if cur["total"] is None:
+                cur["total"] = _to_num(item.get("overUnder"))
+            if cur["over_odds"] is None:
+                cur["over_odds"] = _to_num(item.get("overOdds"))
+            if cur["under_odds"] is None:
+                cur["under_odds"] = _to_num(item.get("underOdds"))
+            rows.append(
+                {
+                    "espn_game_id": str(espn_game_id),
+                    "sportsbook": provider.get("name", ""),
+                    "sportsbook_id": provider.get("id", ""),
+                    "current": cur,
+                    "open": opn,
+                }
+            )
+        except Exception as e:  # noqa: BLE001
+            print(f"Error parsing odds for ESPN game {espn_game_id}: {e}")
+    return rows
+
+
+# ---------------------------------------------------------------------------
+# MLB game_id mapping (same approach as picktheodds_scraper.add_game_ids)
+# ---------------------------------------------------------------------------
+
+def _normalize_team_name(name: str) -> str:
+    normalized = re.sub(r"[^a-z0-9]+", " ", str(name).lower()).strip()
+    normalized = re.sub(r"\s+", " ", normalized)
+    return TEAM_NAME_ALIASES.get(normalized, normalized)
+
+
+def get_mlb_team_map() -> pd.DataFrame:
+    response = requests.get(
+        "https://statsapi.mlb.com/api/v1/teams?sportId=1", timeout=30
+    )
+    response.raise_for_status()
+    rows = []
+    for team in response.json().get("teams", []):
+        team_id = team.get("id")
+        names = {
+            team.get("name"),
+            team.get("teamName"),
+            team.get("clubName"),
+            team.get("shortName"),
+            team.get("abbreviation"),
+        }
+        for name in names:
+            if name:
+                rows.append(
+                    {"team_name_key": _normalize_team_name(name),
+                     "mlb_team_id": team_id}
+                )
+    return pd.DataFrame(rows).drop_duplicates("team_name_key")
+
+
+def add_game_ids(
+    espn_games: pd.DataFrame,
+    engine,
+    schedule_table: str = "cleaned_schedule",
+    tz: str = "US/Eastern",
+    tolerance_hrs: int = 12,
+) -> pd.DataFrame:
+    """Attach MLB statsapi game_id to ESPN games via the schedule table."""
+    if espn_games.empty or engine is None:
+        espn_games = espn_games.copy()
+        espn_games["game_id"] = None
+        return espn_games
+
+    try:
+        schedule = pd.read_sql_table(schedule_table, engine)
+    except ValueError:
+        schedule = pd.read_sql_table("processed_schedule", engine)
+
+    team_map = get_mlb_team_map()
+    espn_games = espn_games.copy()
+    espn_games["home_team_key"] = espn_games["home_team"].apply(_normalize_team_name)
+    espn_games["away_team_key"] = espn_games["away_team"].apply(_normalize_team_name)
+
+    espn_games = espn_games.merge(
+        team_map.rename(columns={"team_name_key": "home_team_key",
+                                 "mlb_team_id": "home_mlb_team_id"}),
+        on="home_team_key", how="left",
+    )
+    espn_games = espn_games.merge(
+        team_map.rename(columns={"team_name_key": "away_team_key",
+                                 "mlb_team_id": "away_mlb_team_id"}),
+        on="away_team_key", how="left",
+    )
+
+    schedule = schedule[
+        ["game_id", "game_datetime", "home_team", "away_team"]
+    ].copy()
+    schedule.rename(
+        columns={"home_team": "home_mlb_team_id", "away_team": "away_mlb_team_id"},
+        inplace=True,
+    )
+    schedule["merge_datetime"] = (
+        pd.to_datetime(schedule["game_datetime"], utc=True)
+        .dt.tz_convert(tz)
+        .dt.tz_localize(None)
+        .astype("datetime64[us]")
+    )
+    schedule = schedule.drop(columns=["game_datetime"]).sort_values("merge_datetime")
+
+    espn_games["merge_datetime"] = (
+        pd.to_datetime(espn_games["game_datetime"], utc=True)
+        .dt.tz_convert(tz)
+        .dt.tz_localize(None)
+        .astype("datetime64[us]")
+    )
+    espn_games.sort_values("merge_datetime", inplace=True)
+
+    espn_games = pd.merge_asof(
+        espn_games,
+        schedule,
+        on="merge_datetime",
+        by=["home_mlb_team_id", "away_mlb_team_id"],
+        direction="nearest",
+        tolerance=pd.Timedelta(f"{tolerance_hrs}hr"),
+    )
+    espn_games.drop(columns=["home_team_key", "away_team_key", "merge_datetime"],
+                    inplace=True)
+    espn_games["_has_game_id"] = espn_games["game_id"].notna()
+    espn_games.sort_values(["espn_game_id", "_has_game_id"],
+                           ascending=[True, False], inplace=True)
+    espn_games.drop_duplicates("espn_game_id", keep="first", inplace=True)
+    espn_games.drop(columns=["_has_game_id"], inplace=True)
+
+    mapped = espn_games["game_id"].notna().sum()
+    if mapped < len(espn_games):
+        missing = espn_games.loc[espn_games["game_id"].isna(), "game_datetime"]
+        missing_dates = sorted(pd.to_datetime(missing).dt.date.unique())
+        print(
+            f"Mapped {mapped}/{len(espn_games)} ESPN games to MLB game_id. "
+            f"Missing dates in {schedule_table}: {missing_dates[:5]}"
+        )
+    return espn_games
+
+
+# ---------------------------------------------------------------------------
+# Main entry point (sbr_odds-style long output)
+# ---------------------------------------------------------------------------
+
+ESPN_ODDS_COLUMNS = [
+    "game_id", "espn_game_id", "date", "game_datetime",
+    "away_team", "away_team_short", "home_team", "home_team_short",
+    "away_score", "home_score", "venue", "status",
+    "sportsbook", "sportsbook_id", "odds_type",
+    "opening_home_odds", "opening_away_odds", "opening_line",
+    "current_home_odds", "current_away_odds", "current_line",
+    "scraped_at",
+]
+
+
+def scrape(
+    start_date: str,
+    end_date: str,
+    engine=None,
+    odds_types: Iterable[str] = ("moneyline", "spread", "total"),
+    exclude_live: bool = True,
+    max_workers: int = 8,
+    schedule_table: str = "cleaned_schedule",
+) -> pd.DataFrame:
+    """Scrape ESPN MLB odds shaped like the sbr_odds table.
+
+    One row per game x sportsbook x odds_type. For totals, home = over and
+    away = under. 'current' odds are the closing line for completed games.
+    Opening odds are real from ~2024 onward; for <=2023 openers use
+    scrape_line_movement.
+
+    Upsert with keys ['game_id', 'sportsbook', 'odds_type'].
+    """
+    dates = _daterange(start_date, end_date)
+
+    games = []
+    with ThreadPoolExecutor(max_workers=max_workers) as pool:
+        for result in pool.map(_get_games_pipeline, dates):
+            games.extend(result)
+    print(f"Found {len(games)} ESPN games between {start_date} and {end_date}")
+    if not games:
+        return pd.DataFrame(columns=ESPN_ODDS_COLUMNS)
+
+    games_df = pd.DataFrame(games)
+    games_df = add_game_ids(games_df, engine, schedule_table=schedule_table)
+
+    odds_rows = []
+    ids = games_df["espn_game_id"].tolist()
+    with ThreadPoolExecutor(max_workers=max_workers) as pool:
+        futures = {pool.submit(_get_odds_pipeline, gid): gid for gid in ids}
+        for future in as_completed(futures):
+            odds_rows.extend(future.result())
+    print(f"Fetched odds for {len(ids)} games: {len(odds_rows)} book entries")
+
+    if exclude_live:
+        odds_rows = [
+            r for r in odds_rows if "live odds" not in r["sportsbook"].lower()
+        ]
+
+    games_idx = games_df.set_index("espn_game_id")
+    scraped_at = int(time.time())
+    rows = []
+    for entry in odds_rows:
+        gid = entry["espn_game_id"]
+        if gid not in games_idx.index:
+            continue
+        game = games_idx.loc[gid]
+        base = {
+            "game_id": game["game_id"],
+            "espn_game_id": gid,
+            "date": pd.to_datetime(game["game_datetime"], utc=True)
+            .tz_convert("US/Eastern").strftime("%Y-%m-%d"),
+            "game_datetime": game["game_datetime"],
+            "away_team": game["away_team"],
+            "away_team_short": game["away_team_short"],
+            "home_team": game["home_team"],
+            "home_team_short": game["home_team_short"],
+            "away_score": game["away_score"],
+            "home_score": game["home_score"],
+            "venue": game["venue"],
+            "status": game["status"],
+            "sportsbook": entry["sportsbook"],
+            "sportsbook_id": entry["sportsbook_id"],
+            "scraped_at": scraped_at,
+        }
+        cur, opn = entry["current"], entry["open"]
+        market_fields = {
+            "moneyline": {
+                "opening_home_odds": opn["home_ml"],
+                "opening_away_odds": opn["away_ml"],
+                "opening_line": None,
+                "current_home_odds": cur["home_ml"],
+                "current_away_odds": cur["away_ml"],
+                "current_line": None,
+            },
+            "spread": {
+                "opening_home_odds": opn["home_spread_odds"],
+                "opening_away_odds": opn["away_spread_odds"],
+                "opening_line": opn["spread"],
+                "current_home_odds": cur["home_spread_odds"],
+                "current_away_odds": cur["away_spread_odds"],
+                "current_line": cur["spread"],
+            },
+            # totals: home = over, away = under
+            "total": {
+                "opening_home_odds": opn["over_odds"],
+                "opening_away_odds": opn["under_odds"],
+                "opening_line": opn["total"],
+                "current_home_odds": cur["over_odds"],
+                "current_away_odds": cur["under_odds"],
+                "current_line": cur["total"],
+            },
+        }
+        for odds_type in odds_types:
+            fields = market_fields.get(odds_type)
+            if fields is None:
+                print(f"Unknown odds_type '{odds_type}', skipping")
+                continue
+            if all(v is None for v in fields.values()):
+                continue
+            rows.append({**base, "odds_type": odds_type, **fields})
+
+    result = pd.DataFrame(rows, columns=ESPN_ODDS_COLUMNS)
+    print(f"Built {len(result)} espn_odds rows.")
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Line movement for the pipeline (<=2023 only)
+# ---------------------------------------------------------------------------
+
+def _fetch_history_pipeline(espn_game_id, mlb_game_id=None,
+                            markets=("moneyline", "spread", "total")):
+    rows = []
+    for market in markets:
+        bet_type = BET_TYPES.get(market)
+        if bet_type is None:
+            continue
+        url = (
+            f"{CORE_BASE}/events/{espn_game_id}/competitions/{espn_game_id}"
+            f"/odds/{HISTORY_PROVIDER_ID}/history/{bet_type}/movement"
+        )
+        data = _get_json(url, params={"limit": 1000})
+        if not data:
+            continue
+        for item in data.get("items", []):
+            rows.append(
+                {
+                    "game_id": mlb_game_id,
+                    "espn_game_id": str(espn_game_id),
+                    "market": market,
+                    "timestamp": item.get("lineDate"),
+                    "away_odds": _to_num(item.get("awayOdds")),
+                    "home_odds": _to_num(item.get("homeOdds")),
+                    "over_odds": _to_num(item.get("overOdds")),
+                    "under_odds": _to_num(item.get("underOdds")),
+                    "line": item.get("line"),
+                }
+            )
+    df = pd.DataFrame(rows)
+    if not df.empty:
+        df = df.sort_values(["market", "timestamp"]).reset_index(drop=True)
+    return df
+
+
+def scrape_line_movement(
+    start_date: str,
+    end_date: str,
+    engine=None,
+    max_workers: int = 8,
+    schedule_table: str = "cleaned_schedule",
+) -> pd.DataFrame:
+    """Timestamped line movement for every game in the range (<=2023 only).
+
+    Upsert with keys ['espn_game_id', 'market', 'timestamp'].
+    """
+    dates = _daterange(start_date, end_date)
+    games = []
+    with ThreadPoolExecutor(max_workers=max_workers) as pool:
+        for result in pool.map(_get_games_pipeline, dates):
+            games.extend(result)
+    if not games:
+        return pd.DataFrame()
+    games_df = add_game_ids(pd.DataFrame(games), engine,
+                            schedule_table=schedule_table)
+
+    frames = []
+    pairs = list(zip(games_df["espn_game_id"], games_df["game_id"]))
+    print(f"Fetching line movement for {len(pairs)} games...")
+    with ThreadPoolExecutor(max_workers=max_workers) as pool:
+        futures = {
+            pool.submit(_fetch_history_pipeline, egid, gid): egid
+            for egid, gid in pairs
+        }
+        for future in as_completed(futures):
+            df = future.result()
+            if not df.empty:
+                frames.append(df)
+    movement = (
+        pd.concat(frames, ignore_index=True) if frames else pd.DataFrame()
+    )
+    print(f"Fetched {len(movement)} line-movement rows.")
+    return movement