#!/usr/bin/env python3 """Put Pick6 rows, DFS salaries and sportsbook mainlines for one sport side by side as JSON lines. Independent service, not affiliated with or endorsed by DraftKings. No wagering. Run: python3 comparison-feed.py --sport NFL --stat "Receiving Yards" --max-requests 12 The three datasets mean different things. This feed never computes a mismatch, an edge or a pick. Pick6 entity_id matched DFS playerDkId in a 2026-11-03 sample. Treat that as an observation and report unmatched rows. Sportsbook rows have no player props, so they appear as separate game context. """ import argparse import hashlib import json import os import sys import time from datetime import datetime, timezone from pathlib import Path from urllib.error import HTTPError, URLError from urllib.parse import urlencode from urllib.request import Request, urlopen API_KEY = os.environ.get("DRAFTKINGS_API_KEY") BASE = os.environ.get("DRAFTKINGS_API_BASE", "https://draftkingsapi.com").rstrip("/") CACHE_DIR = Path(os.environ.get("DRAFTKINGS_CACHE_DIR", ".draftkings-cache")) # Collection targets five minutes. Polling faster spends quota without newer data. CACHE_TTL_SECONDS = 300 class ApiError(Exception): def __init__(self, status, message): super().__init__(f"HTTP {status}: {message}") self.status = status class Client: """Bounded client: a request budget, a timeout, a file cache and limited retries.""" def __init__(self, max_requests, use_cache=True): if not API_KEY: sys.exit("Set DRAFTKINGS_API_KEY in your environment. Create a key at https://draftkingsapi.com/dashboard") self.max_requests = max_requests self.requests = 0 self.use_cache = use_cache def get(self, path, **params): query = {k: v for k, v in params.items() if v is not None} url = f"{BASE}{path}?{urlencode(query)}" if query else f"{BASE}{path}" cached = self._read_cache(url) if cached is not None: return cached body = self._fetch(url) self._write_cache(url, body) return body def _fetch(self, url): for attempt in range(3): if self.requests >= self.max_requests: raise ApiError(0, f"Local budget of {self.max_requests} requests reached. Raise it deliberately.") self.requests += 1 request = Request(url, headers={"Authorization": f"Bearer {API_KEY}", "Accept": "application/json"}) try: with urlopen(request, timeout=20) as response: return json.load(response) except HTTPError as error: message = _error_message(error) can_retry = self.requests < self.max_requests if error.code == 429 and attempt == 0 and can_retry: # Minute limits reset at the next UTC minute. A second 429 usually means the monthly allowance. time.sleep(61 - datetime.now(timezone.utc).second) continue if error.code >= 500 and attempt < 2 and can_retry: time.sleep(2 ** attempt) continue raise ApiError(error.code, message) from None except (URLError, TimeoutError) as error: if attempt < 2 and self.requests < self.max_requests: time.sleep(2 ** attempt) continue raise ApiError(0, f"Network failure: {error}") from None raise ApiError(429, "Account request limit reached. Check the allowance in your dashboard.") def _cache_path(self, url): return CACHE_DIR / (hashlib.sha256(url.encode()).hexdigest() + ".json") def _read_cache(self, url): path = self._cache_path(url) if not self.use_cache or not path.exists() or time.time() - path.stat().st_mtime > CACHE_TTL_SECONDS: return None return json.loads(path.read_text()) def _write_cache(self, url, body): if self.use_cache: CACHE_DIR.mkdir(exist_ok=True) self._cache_path(url).write_text(json.dumps(body)) def _error_message(error): try: return json.load(error)["error"]["message"] except Exception: return error.reason DFS_SPORT = {"SOCCER": "SOC", "UFC": "MMA"} BOOK_SPORT = {"CFB": "NCAAF", "CBB": "NCAAB"} def pages(client, path, reserve, **params): offset = 0 while client.requests < client.max_requests - reserve: page = client.get(path, limit=100, offset=offset, **params) yield from page["data"] if not page["pagination"]["has_more"]: return offset += 100 def main(): parser = argparse.ArgumentParser() parser.add_argument("--sport", required=True) parser.add_argument("--stat") parser.add_argument("--max-requests", type=int, default=12) args = parser.parse_args() client = Client(max_requests=args.max_requests) # Reserve budget so each dataset gets a turn. pick6 = list(pages(client, "/api/v1/pick6/projections", 6, sport=args.sport, stat=args.stat)) salaries = {} for row in pages(client, "/api/v1/dfs/players", 2, sport=DFS_SPORT.get(args.sport, args.sport)): data = row.get("data") or {} salaries.setdefault(str(data.get("playerDkId")), []).append({"draftable_id": data.get("draftableId"), "slate_id": row.get("slate_id"), "salary": data.get("salary"), "roster_slot_id": data.get("rosterSlotId")}) book = list(pages(client, "/api/v1/odds", 0, sport=BOOK_SPORT.get(args.sport, args.sport))) matched = unmatched = 0 for row in pick6: if row.get("is_paused"): continue entity = (row.get("entities") or [{}])[0] dfs = salaries.get(str(entity.get("entity_id")), []) matched, unmatched = matched + bool(dfs), unmatched + (not dfs) print(json.dumps({"kind": "pick6_row", "player": entity.get("full_name"), "entity_id": entity.get("entity_id"), "stat": row.get("stat"), "target_value": row.get("target_value"), "selections": row.get("selections"), "observed_at": row.get("observed_at"), "stale": row.get("stale"), "dfs_draftables": dfs})) for row in book: print(json.dumps({"kind": "sportsbook_mainline", "event_id": row["event_id"], "market": row["market"], "side": row["side"], "line": row["line"], "american": row["american"], "event_status": row["event_status"], "observed_at": row["observed_at"], "stale": row["stale"]})) print(json.dumps({"requests": client.requests, "pick6_rows": len(pick6), "with_dfs_match": matched, "without_dfs_match": unmatched, "sportsbook_rows": len(book)}), file=sys.stderr) if __name__ == "__main__": try: main() except ApiError as error: sys.exit(str(error))