draftkingsapi 0.1.0__tar.gz

draftkingsapi-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 draftkingsapi.com
+
+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.

draftkingsapi-0.1.0/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: draftkingsapi
+Version: 0.1.0
+Summary: Python client for draftkingsapi.com: DraftKings Pick6 lines and line history, DFS salaries, sportsbook odds and box scores. Independent, not affiliated with DraftKings.
+License: MIT
+Project-URL: Repository, https://github.com/draftkingsapi/draftkingsapi-python
+Project-URL: Issues, https://github.com/draftkingsapi/draftkingsapi-python/issues
+Project-URL: Homepage, https://draftkingsapi.com
+Project-URL: Documentation, https://draftkingsapi.com/docs
+Project-URL: OpenAPI, https://draftkingsapi.com/openapi.json
+Project-URL: Status, https://draftkingsapi.com/status
+Keywords: draftkings,pick6,dfs,sportsbook,odds,sports-data,api-client
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# draftkingsapi (Python)
+
+Python client for [draftkingsapi.com](https://draftkingsapi.com): DraftKings Pick6 lines and line history,
+DFS salaries, contests and slates, sportsbook odds and price history, and box scores. Standard library only,
+no dependencies, typed.
+
+draftkingsapi.com is an independent API. It is not affiliated with or endorsed by DraftKings. "DraftKings" is a
+trademark of its owner and is used here only to describe the data.
+
+```bash
+pip install draftkingsapi
+```
+
+## No key needed
+
+The keyless feeds are delayed and capped, cost no credits, and need no account:
+
+```python
+from draftkingsapi import Client
+
+dk = Client()  # reads DRAFTKINGS_API_KEY if set; keyless calls never send it
+
+board = dk.public_board(league="nba", limit=3)
+for prop in board["props"]:
+    print(prop["player"], prop["stat"], prop["line"], prop["more_multiplier"])
+
+games = dk.public_sportsbook(league="nfl", limit=2)
+for game in games["games"]:
+    print(game["away"], "at", game["home"], [(m["market"], m["side"], m["line"], m["american"]) for m in game["markets"]])
+
+moves = dk.public_line_moves(market="pick6", limit=5)
+costs = dk.credit_costs()            # credits per endpoint
+status = dk.status()                 # measured collection status
+sample = dk.demo("odds", limit=1)    # frozen sample rows, for the response shape only
+```
+
+Output of the first loop, run on 15 Nov 2026 (live data, so yours will differ; a prop with no current line prints None):
+
+```text
+Giannis Antetokounmpo Points 32.5 0.8
+Cade Cunningham Points 30.5 1
+Bam Adebayo Points None None
+```
+
+## With a key
+
+Get a free key (100 credits a month, no card) at https://draftkingsapi.com/sign-up, then:
+
+```bash
+export DRAFTKINGS_API_KEY=dk_...
+```
+
+```python
+from draftkingsapi import Client
+
+dk = Client(user_request="Build a prop screen from current Pick6 lines")
+
+lines = dk.pick6_projections(sport="NBA", limit=100)
+history = dk.pick6_line_history(lines["data"][0]["pickable_id"], change_type="line_move")
+odds = dk.odds(sport="NFL", market="moneyline")
+salaries = dk.dfs_players(sport="NFL", format="csv")      # CSV text
+box = dk.stats_player_games("NBA", 2026, limit=50)
+edges = dk.ev(league="nba", min_edge=2)
+```
+
+`user_request` is optional: one plain sentence about the task, sent as `X-User-Request`. Never put personal data in it.
+
+### Pagination
+
+List routes return `pagination.has_more` with a cursor. `paginate()` follows it with a page budget, so a loop cannot
+spend your whole allowance:
+
+```python
+for row in dk.paginate(dk.odds, sport="NBA", max_pages=5):
+    ...
+```
+
+It follows `next_cursor` (sent back as `cursor`), `next` on the stats routes and `next_after` on the change feeds
+(both sent back as `after`).
+
+### Errors
+
+Every non-2xx response raises a subclass of `DraftKingsAPIError` with the API's own message:
+
+| Status | Exception | What to do |
+| --- | --- | --- |
+| 400 | `InvalidRequestError` | `e.error["query_help"]` often has a corrected example |
+| 401 | `AuthenticationError` | missing or wrong key; raised before any request when a keyed method has no key |
+| 402 | `PaymentRequiredError` | `e.error["upgrade_url"]` |
+| 404 | `NotFoundError` | `e.error["closest_endpoints"]` |
+| 429 | `RateLimitError` | wait `e.retry_after` seconds; if `e.error["limit"] == "month"`, stop retrying |
+| 503 | `DatasetUnavailableError` | dataset temporarily unavailable; not charged, retry later |
+
+```python
+from draftkingsapi import Client, RateLimitError
+
+try:
+    Client().odds(sport="NFL")
+except RateLimitError as e:
+    print("retry in", e.retry_after, "seconds:", e.message)
+```
+
+## Methods
+
+Keyless: `public_board`, `public_sportsbook`, `public_line_moves`, `demo(dataset)`, `credit_costs`, `directory`,
+`status`, `history_coverage`.
+
+Keyed: `coverage`, `events`, `odds`, `history`, `pick6_projections`, `pick6_history`, `pick6_line_history`,
+`projections`, `changes`, `dfs_sports`, `dfs_contests`, `dfs_slates`, `dfs_players`, `dfs_changes`, `compare`,
+`compare_books`, `ev`, `arbitrage`, `stats_games`, `stats_player_games`, `stats_team_games`, `context_games`,
+`context_player_stats`, `context_team_stats`, `sportsbook_scopes`, `sportsbook_snapshot`, `stream_snapshot`.
+
+Optional filters are keyword arguments, passed through unchanged. Every route's parameters are in the
+[OpenAPI document](https://draftkingsapi.com/openapi.json) and the [docs](https://draftkingsapi.com/docs).
+Not wrapped: the server-sent event stream, the native sportsbook WebSocket, and account, billing and sign-up routes.
+
+## Plans
+
+Free 100 credits a month, Developer $49, Production $149, Scale $499 a month. Credits per endpoint:
+`Client().credit_costs()` or https://draftkingsapi.com/api/v1/credit-costs.
+
+## Tests
+
+```bash
+python -m unittest discover -s tests            # mocked, no network
+DRAFTKINGS_LIVE=1 python -m unittest tests.test_live -v   # live keyless endpoints, no key, no credits
+```
+
+MIT License.

draftkingsapi-0.1.0/README.md

@@ -0,0 +1,129 @@
+# draftkingsapi (Python)
+
+Python client for [draftkingsapi.com](https://draftkingsapi.com): DraftKings Pick6 lines and line history,
+DFS salaries, contests and slates, sportsbook odds and price history, and box scores. Standard library only,
+no dependencies, typed.
+
+draftkingsapi.com is an independent API. It is not affiliated with or endorsed by DraftKings. "DraftKings" is a
+trademark of its owner and is used here only to describe the data.
+
+```bash
+pip install draftkingsapi
+```
+
+## No key needed
+
+The keyless feeds are delayed and capped, cost no credits, and need no account:
+
+```python
+from draftkingsapi import Client
+
+dk = Client()  # reads DRAFTKINGS_API_KEY if set; keyless calls never send it
+
+board = dk.public_board(league="nba", limit=3)
+for prop in board["props"]:
+    print(prop["player"], prop["stat"], prop["line"], prop["more_multiplier"])
+
+games = dk.public_sportsbook(league="nfl", limit=2)
+for game in games["games"]:
+    print(game["away"], "at", game["home"], [(m["market"], m["side"], m["line"], m["american"]) for m in game["markets"]])
+
+moves = dk.public_line_moves(market="pick6", limit=5)
+costs = dk.credit_costs()            # credits per endpoint
+status = dk.status()                 # measured collection status
+sample = dk.demo("odds", limit=1)    # frozen sample rows, for the response shape only
+```
+
+Output of the first loop, run on 15 Nov 2026 (live data, so yours will differ; a prop with no current line prints None):
+
+```text
+Giannis Antetokounmpo Points 32.5 0.8
+Cade Cunningham Points 30.5 1
+Bam Adebayo Points None None
+```
+
+## With a key
+
+Get a free key (100 credits a month, no card) at https://draftkingsapi.com/sign-up, then:
+
+```bash
+export DRAFTKINGS_API_KEY=dk_...
+```
+
+```python
+from draftkingsapi import Client
+
+dk = Client(user_request="Build a prop screen from current Pick6 lines")
+
+lines = dk.pick6_projections(sport="NBA", limit=100)
+history = dk.pick6_line_history(lines["data"][0]["pickable_id"], change_type="line_move")
+odds = dk.odds(sport="NFL", market="moneyline")
+salaries = dk.dfs_players(sport="NFL", format="csv")      # CSV text
+box = dk.stats_player_games("NBA", 2026, limit=50)
+edges = dk.ev(league="nba", min_edge=2)
+```
+
+`user_request` is optional: one plain sentence about the task, sent as `X-User-Request`. Never put personal data in it.
+
+### Pagination
+
+List routes return `pagination.has_more` with a cursor. `paginate()` follows it with a page budget, so a loop cannot
+spend your whole allowance:
+
+```python
+for row in dk.paginate(dk.odds, sport="NBA", max_pages=5):
+    ...
+```
+
+It follows `next_cursor` (sent back as `cursor`), `next` on the stats routes and `next_after` on the change feeds
+(both sent back as `after`).
+
+### Errors
+
+Every non-2xx response raises a subclass of `DraftKingsAPIError` with the API's own message:
+
+| Status | Exception | What to do |
+| --- | --- | --- |
+| 400 | `InvalidRequestError` | `e.error["query_help"]` often has a corrected example |
+| 401 | `AuthenticationError` | missing or wrong key; raised before any request when a keyed method has no key |
+| 402 | `PaymentRequiredError` | `e.error["upgrade_url"]` |
+| 404 | `NotFoundError` | `e.error["closest_endpoints"]` |
+| 429 | `RateLimitError` | wait `e.retry_after` seconds; if `e.error["limit"] == "month"`, stop retrying |
+| 503 | `DatasetUnavailableError` | dataset temporarily unavailable; not charged, retry later |
+
+```python
+from draftkingsapi import Client, RateLimitError
+
+try:
+    Client().odds(sport="NFL")
+except RateLimitError as e:
+    print("retry in", e.retry_after, "seconds:", e.message)
+```
+
+## Methods
+
+Keyless: `public_board`, `public_sportsbook`, `public_line_moves`, `demo(dataset)`, `credit_costs`, `directory`,
+`status`, `history_coverage`.
+
+Keyed: `coverage`, `events`, `odds`, `history`, `pick6_projections`, `pick6_history`, `pick6_line_history`,
+`projections`, `changes`, `dfs_sports`, `dfs_contests`, `dfs_slates`, `dfs_players`, `dfs_changes`, `compare`,
+`compare_books`, `ev`, `arbitrage`, `stats_games`, `stats_player_games`, `stats_team_games`, `context_games`,
+`context_player_stats`, `context_team_stats`, `sportsbook_scopes`, `sportsbook_snapshot`, `stream_snapshot`.
+
+Optional filters are keyword arguments, passed through unchanged. Every route's parameters are in the
+[OpenAPI document](https://draftkingsapi.com/openapi.json) and the [docs](https://draftkingsapi.com/docs).
+Not wrapped: the server-sent event stream, the native sportsbook WebSocket, and account, billing and sign-up routes.
+
+## Plans
+
+Free 100 credits a month, Developer $49, Production $149, Scale $499 a month. Credits per endpoint:
+`Client().credit_costs()` or https://draftkingsapi.com/api/v1/credit-costs.
+
+## Tests
+
+```bash
+python -m unittest discover -s tests            # mocked, no network
+DRAFTKINGS_LIVE=1 python -m unittest tests.test_live -v   # live keyless endpoints, no key, no credits
+```
+
+MIT License.

draftkingsapi-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "draftkingsapi"
+version = "0.1.0"
+description = "Python client for draftkingsapi.com: DraftKings Pick6 lines and line history, DFS salaries, sportsbook odds and box scores. Independent, not affiliated with DraftKings."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+dependencies = []
+keywords = ["draftkings", "pick6", "dfs", "sportsbook", "odds", "sports-data", "api-client"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Typing :: Typed",
+  "Topic :: Software Development :: Libraries",
+]
+
+[project.urls]
+Repository = "https://github.com/draftkingsapi/draftkingsapi-python"
+Issues = "https://github.com/draftkingsapi/draftkingsapi-python/issues"
+Homepage = "https://draftkingsapi.com"
+Documentation = "https://draftkingsapi.com/docs"
+OpenAPI = "https://draftkingsapi.com/openapi.json"
+Status = "https://draftkingsapi.com/status"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+draftkingsapi = ["py.typed"]

draftkingsapi-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

draftkingsapi-0.1.0/src/draftkingsapi/__init__.py

@@ -0,0 +1,31 @@
+"""Python client for draftkingsapi.com, an independent DraftKings data API (not affiliated with DraftKings)."""
+
+from ._version import __version__
+from .client import DEFAULT_BASE_URL, DEMO_DATASETS, DraftKingsAPI, Response
+from .errors import (
+    AuthenticationError,
+    DatasetUnavailableError,
+    DraftKingsAPIError,
+    InvalidRequestError,
+    NotFoundError,
+    PaymentRequiredError,
+    RateLimitError,
+)
+
+Client = DraftKingsAPI
+
+__all__ = [
+    "__version__",
+    "Client",
+    "DraftKingsAPI",
+    "DEFAULT_BASE_URL",
+    "DEMO_DATASETS",
+    "Response",
+    "DraftKingsAPIError",
+    "InvalidRequestError",
+    "AuthenticationError",
+    "PaymentRequiredError",
+    "NotFoundError",
+    "RateLimitError",
+    "DatasetUnavailableError",
+]

draftkingsapi-0.1.0/src/draftkingsapi/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

draftkingsapi-0.1.0/src/draftkingsapi/client.py

@@ -0,0 +1,334 @@
+"""Typed client for the draftkingsapi.com REST API. Standard library only.
+
+draftkingsapi.com is an independent API, not affiliated with or endorsed by DraftKings.
+"""
+
+import json
+import os
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Callable, Dict, Iterator, Mapping, Optional, Union
+
+from ._version import __version__
+from .errors import SIGN_UP_URL, AuthenticationError, DraftKingsAPIError, error_for
+
+DEFAULT_BASE_URL = "https://draftkingsapi.com"
+
+JSON = Dict[str, Any]
+Params = Mapping[str, Any]
+
+DEMO_DATASETS = (
+    "pick6",
+    "dfs",
+    "events",
+    "odds",
+    "history",
+    "pick6-history",
+    "coverage",
+    "stats-games",
+    "stats-player-games",
+    "stats-team-games",
+)
+
+Transport = Callable[[urllib.request.Request, float], "Response"]
+
+
+class Response:
+    """What a transport returns: status, headers (lower-case keys) and raw body bytes."""
+
+    def __init__(self, status: int, headers: Mapping[str, str], body: bytes) -> None:
+        self.status = status
+        self.headers = {k.lower(): v for k, v in headers.items()}
+        self.body = body
+
+
+def _urllib_transport(request: urllib.request.Request, timeout: float) -> Response:
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as res:
+            return Response(res.status, dict(res.headers.items()), res.read())
+    except urllib.error.HTTPError as e:
+        return Response(e.code, dict(e.headers.items()) if e.headers else {}, e.read() or b"")
+
+
+def _clean(params: Optional[Params]) -> Dict[str, str]:
+    out: Dict[str, str] = {}
+    for key, value in (params or {}).items():
+        if value is None:
+            continue
+        if isinstance(value, bool):
+            value = "true" if value else "false"
+        out[key] = str(value)
+    return out
+
+
+class DraftKingsAPI:
+    """Client for https://draftkingsapi.com/api/v1.
+
+    Args:
+        api_key: your key (``dk_...``). Defaults to the ``DRAFTKINGS_API_KEY`` environment variable.
+            Keyless methods (``public_*``, ``demo``, ``credit_costs``, ``status``) work without one.
+        base_url: override for testing.
+        timeout: seconds per request.
+        user_request: optional one-sentence task sent as ``X-User-Request`` on every call, which
+            the API uses to improve its answers. Never put anything personal in it.
+        transport: injectable HTTP function, used by the tests.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        *,
+        base_url: Optional[str] = None,
+        timeout: float = 30.0,
+        user_request: Optional[str] = None,
+        transport: Optional[Transport] = None,
+    ) -> None:
+        self.api_key = api_key if api_key is not None else os.environ.get("DRAFTKINGS_API_KEY") or None
+        self.base_url = (base_url or os.environ.get("DRAFTKINGS_API_BASE") or DEFAULT_BASE_URL).rstrip("/")
+        self.timeout = timeout
+        self.user_request = user_request
+        self._transport = transport or _urllib_transport
+        self.last_headers: Dict[str, str] = {}
+
+    # ------------------------------------------------------------------ core
+
+    def request(self, path: str, params: Optional[Params] = None, *, keyed: bool = True) -> Union[JSON, str]:
+        """GET ``path`` (``/api/v1/...``) and return decoded JSON, or text for ``format=csv``.
+
+        Raises a subclass of :class:`DraftKingsAPIError` on any non-2xx response.
+        """
+        if keyed and not self.api_key:
+            raise AuthenticationError(
+                f"This endpoint needs an API key. Set DRAFTKINGS_API_KEY or pass api_key=. "
+                f"Free key, no card: {SIGN_UP_URL}",
+                status=401,
+                error_type="missing_api_key",
+            )
+        query = urllib.parse.urlencode(_clean(params))
+        url = f"{self.base_url}{path}" + (f"?{query}" if query else "")
+        headers = {"Accept": "application/json", "User-Agent": f"draftkingsapi-python/{__version__}"}
+        if keyed and self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        if self.user_request:
+            headers["X-User-Request"] = urllib.parse.quote(self.user_request[:500], safe=" ,.:;!?'()-")
+        req = urllib.request.Request(url, headers=headers, method="GET")
+        try:
+            res = self._transport(req, self.timeout)
+        except (urllib.error.URLError, OSError) as e:
+            raise DraftKingsAPIError(f"Could not reach {self.base_url}: {e}") from e
+        self.last_headers = dict(res.headers)
+        text = res.body.decode("utf-8", errors="replace")
+        is_json = "json" in res.headers.get("content-type", "") or text[:1] in "{["
+        body: Any = text
+        if is_json and text:
+            try:
+                body = json.loads(text)
+            except ValueError:
+                body = text
+        if res.status >= 400:
+            retry = res.headers.get("retry-after")
+            raise error_for(res.status, body, int(retry) if retry and retry.isdigit() else None)
+        return body
+
+    def _get(self, path: str, params: Optional[Params] = None, keyed: bool = True) -> Any:
+        return self.request(path, params, keyed=keyed)
+
+    def paginate(
+        self,
+        method: Callable[..., Any],
+        *,
+        max_pages: int = 10,
+        **params: Any,
+    ) -> Iterator[JSON]:
+        """Yield rows across pages of any list method, with a page budget so a loop cannot drain your credits.
+
+        Follows ``pagination.next_cursor`` (sent back as ``cursor``), ``pagination.next`` (stats routes,
+        sent back as ``after``) or ``pagination.next_after`` (change feeds, sent back as ``after``).
+
+            for row in client.paginate(client.pick6_projections, sport="NBA", max_pages=3):
+                ...
+        """
+        params = dict(params)
+        params.pop("offset", None)  # cursor and offset cannot be combined
+        for _ in range(max(1, max_pages)):
+            page = method(**params)
+            if not isinstance(page, dict):
+                raise TypeError("paginate() needs JSON pages; do not pass format='csv'")
+            rows = page.get("data")
+            if isinstance(rows, list):
+                yield from rows
+            elif rows is not None:
+                yield rows
+            pagination = page.get("pagination") or {}
+            if not pagination.get("has_more") or not rows:
+                return
+            if pagination.get("next_cursor"):
+                params["cursor"] = pagination["next_cursor"]
+            elif pagination.get("next"):
+                params["after"] = pagination["next"]
+            elif pagination.get("next_after") not in (None, ""):
+                params["after"] = pagination["next_after"]
+            else:
+                return
+
+    # -------------------------------------------------------- keyless routes
+
+    def public_board(self, league: Optional[str] = None, limit: Optional[int] = None) -> JSON:
+        """Delayed, capped Pick6 board plus recent line moves. No key, no credits.
+
+        league: nfl, nba, nhl, cfb, cbb, soccer, mlb, ufc, cs or lol.
+        """
+        return self._get("/api/v1/public/board", {"league": league, "limit": limit}, keyed=False)
+
+    def public_sportsbook(self, league: Optional[str] = None, limit: Optional[int] = None) -> JSON:
+        """Sportsbook mainlines (moneyline, spread, total). No key, no credits.
+
+        league: nfl, nba, nhl, cfb, cbb, mlb, epl or mls.
+        """
+        return self._get("/api/v1/public/sportsbook", {"league": league, "limit": limit}, keyed=False)
+
+    def public_line_moves(
+        self, league: Optional[str] = None, limit: Optional[int] = None, market: Optional[str] = None
+    ) -> JSON:
+        """Recent Pick6 and sportsbook line moves. market: all, pick6 or sportsbook. No key."""
+        return self._get(
+            "/api/v1/public/line-moves", {"league": league, "limit": limit, "market": market}, keyed=False
+        )
+
+    def demo(self, dataset: str = "pick6", limit: Optional[int] = None, sport: Optional[str] = None) -> JSON:
+        """Frozen sample rows to learn a response shape. No key. Never use them as data.
+
+        dataset: one of :data:`DEMO_DATASETS`.
+        """
+        if dataset not in DEMO_DATASETS:
+            raise ValueError(f"dataset must be one of {', '.join(DEMO_DATASETS)}")
+        return self._get(f"/api/v1/demo/{dataset}", {"limit": limit, "sport": sport}, keyed=False)
+
+    def credit_costs(self, path: Optional[str] = None, rows: Optional[int] = None) -> JSON:
+        """Credits each endpoint costs. No key, no credits."""
+        return self._get("/api/v1/credit-costs", {"path": path, "rows": rows}, keyed=False)
+
+    def directory(self) -> JSON:
+        """Every route, the OpenAPI URL and docs. No key."""
+        return self._get("/api/v1", keyed=False)
+
+    def status(self) -> JSON:
+        """Measured collection status (jobs, workers, dataset freshness). No key."""
+        return self._get("/status.json", keyed=False)
+
+    def history_coverage(self) -> JSON:
+        """Start dates and capture counts of stored history by league. No key."""
+        return self._get("/history-coverage.json", keyed=False)
+
+    # ---------------------------------------------------------- keyed routes
+    # Optional filters are passed through as keyword arguments; see https://draftkingsapi.com/docs
+    # or https://draftkingsapi.com/openapi.json for each route's parameters.
+
+    def coverage(self) -> JSON:
+        """Live coverage of every dataset for your key."""
+        return self._get("/api/v1/coverage")
+
+    def events(self, **params: Any) -> Any:
+        """Sportsbook events. Filters: sport, event_id, status, search, start_after, start_before, limit, cursor, format."""
+        return self._get("/api/v1/events", params)
+
+    def odds(self, **params: Any) -> Any:
+        """Current sportsbook odds. Filters: sport, event_id, market, status, view, fresh_only, limit, cursor, format."""
+        return self._get("/api/v1/odds", params)
+
+    def history(self, **params: Any) -> Any:
+        """Stored sportsbook price history. Filters: sport, event_id, offer_id, market, limit, cursor, format."""
+        return self._get("/api/v1/history", params)
+
+    def pick6_projections(self, **params: Any) -> Any:
+        """Current Pick6 lines. Filters: sport, stat, team, search, status, pickable_id, view, limit, cursor, format."""
+        return self._get("/api/v1/pick6/projections", params)
+
+    def pick6_history(self, **params: Any) -> Any:
+        """Pick6 change feed. Filters: sport, stat, pickable_id, after, limit, cursor, format."""
+        return self._get("/api/v1/pick6/history", params)
+
+    def pick6_line_history(self, pickable_id: str, **params: Any) -> JSON:
+        """Recorded moves for one Pick6 prop. Filters: stat, pick_group_id, change_type, limit, cursor."""
+        return self._get("/api/v1/pick6/line-history", {"pickable_id": pickable_id, **params})
+
+    def projections(self, **params: Any) -> Any:
+        """Alias route of :meth:`pick6_projections`."""
+        return self._get("/api/v1/projections", params)
+
+    def changes(self, **params: Any) -> Any:
+        """Every Pick6 line change after your cursor. Filters: after, sport, stat, limit, cursor."""
+        return self._get("/api/v1/changes", params)
+
+    def dfs_sports(self, **params: Any) -> Any:
+        """DFS sports in the lobby."""
+        return self._get("/api/v1/dfs/sports", params)
+
+    def dfs_contests(self, **params: Any) -> Any:
+        """DFS contests. Filters: sport, slate_id, limit, cursor, format."""
+        return self._get("/api/v1/dfs/contests", params)
+
+    def dfs_slates(self, **params: Any) -> Any:
+        """DFS slates. Filters: sport, slate_id, limit, cursor, format."""
+        return self._get("/api/v1/dfs/slates", params)
+
+    def dfs_players(self, **params: Any) -> Any:
+        """DFS players with salaries. Filters: sport, slate_id, team, search, view, limit, cursor, format."""
+        return self._get("/api/v1/dfs/players", params)
+
+    def dfs_changes(self, **params: Any) -> JSON:
+        """DFS lobby changes. Filters: after, sport, kind, change, slate_id, limit."""
+        return self._get("/api/v1/dfs/changes", params)
+
+    def compare(self, **params: Any) -> JSON:
+        """Pick6 lines against DraftKings Sportsbook lines. Filters: sport, stat, player, min_gap, sort, limit, offset."""
+        return self._get("/api/v1/compare", params)
+
+    def compare_books(self, **params: Any) -> JSON:
+        """Lines across books. Filters: league, market_type, player, team, stat, with_fair, min_ev, sort, limit, offset."""
+        return self._get("/api/v1/compare/books", params)
+
+    def ev(self, **params: Any) -> JSON:
+        """Positive expected value prices. Filters: league, market_type, book, player, min_edge, min_prob, sort, limit."""
+        return self._get("/api/v1/ev", params)
+
+    def arbitrage(self, **params: Any) -> JSON:
+        """Arbitrage and middles. Filters: type, league, market_type, book, min_profit, limit, offset."""
+        return self._get("/api/v1/arbitrage", params)
+
+    def stats_games(self, sport: str, season: int, **params: Any) -> JSON:
+        """Game results. sport: NBA, NFL, NHL, NCAAF, NCAAB, MLB or WNBA. Filters: event_id, completed, from, to, limit, after."""
+        return self._get("/api/v1/stats/games", {"sport": sport, "season": season, **params})
+
+    def stats_player_games(self, sport: str, season: int, **params: Any) -> JSON:
+        """Player box scores. Filters: athlete_id, team_id, event_id, completed, from, to, limit, after."""
+        return self._get("/api/v1/stats/player-games", {"sport": sport, "season": season, **params})
+
+    def stats_team_games(self, sport: str, season: int, **params: Any) -> JSON:
+        """Team box scores. Filters: team_id, event_id, completed, from, to, limit, after."""
+        return self._get("/api/v1/stats/team-games", {"sport": sport, "season": season, **params})
+
+    def context_games(self, **params: Any) -> Any:
+        """Game context joined to lines. Filters: sport, event_id, athlete_id, limit, cursor, format."""
+        return self._get("/api/v1/context/games", params)
+
+    def context_player_stats(self, **params: Any) -> Any:
+        """Player stat context. Filters: sport, event_id, athlete_id, limit, cursor, format."""
+        return self._get("/api/v1/context/player-stats", params)
+
+    def context_team_stats(self, **params: Any) -> Any:
+        """Team stat context. Filters: sport, event_id, limit, cursor, format."""
+        return self._get("/api/v1/context/team-stats", params)
+
+    def sportsbook_scopes(self) -> JSON:
+        """Native sportsbook scopes you can snapshot."""
+        return self._get("/api/v1/sportsbook/scopes")
+
+    def sportsbook_snapshot(self, scope: str) -> JSON:
+        """Snapshot of one native sportsbook scope (from :meth:`sportsbook_scopes`)."""
+        return self._get("/api/v1/sportsbook/snapshot", {"scope": scope})
+
+    def stream_snapshot(self, sport: Optional[str] = None) -> JSON:
+        """Current state that the server-sent event stream continues from."""
+        return self._get("/api/v1/stream/snapshot", {"sport": sport})

draftkingsapi-0.1.0/src/draftkingsapi/errors.py

@@ -0,0 +1,88 @@
+"""Exceptions raised by the draftkingsapi client.
+
+Every API error carries the HTTP status and the API's own error JSON, which looks like
+``{"error": {"code": 401, "type": "missing_api_key", "message": "..."}}``.
+"""
+
+from typing import Any, Dict, Optional
+
+SIGN_UP_URL = "https://draftkingsapi.com/sign-up"
+
+
+class DraftKingsAPIError(Exception):
+    """Any non-2xx response, or a transport failure (status 0)."""
+
+    def __init__(
+        self,
+        message: str,
+        status: int = 0,
+        error_type: Optional[str] = None,
+        body: Optional[Dict[str, Any]] = None,
+        retry_after: Optional[int] = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.error_type = error_type
+        self.body = body or {}
+        self.retry_after = retry_after
+
+    @property
+    def error(self) -> Dict[str, Any]:
+        """The ``error`` object from the response body, or an empty dict."""
+        value = self.body.get("error") if isinstance(self.body, dict) else None
+        return value if isinstance(value, dict) else {}
+
+    def __str__(self) -> str:
+        prefix = f"HTTP {self.status}" if self.status else "Request failed"
+        kind = f" {self.error_type}" if self.error_type else ""
+        return f"{prefix}{kind}: {self.message}"
+
+
+class InvalidRequestError(DraftKingsAPIError):
+    """400: a query parameter was rejected. ``error['query_help']`` often has a corrected example."""
+
+
+class AuthenticationError(DraftKingsAPIError):
+    """401: the API key is missing or invalid. Free keys: https://draftkingsapi.com/sign-up"""
+
+
+class PaymentRequiredError(DraftKingsAPIError):
+    """402: the request needs a paid plan. ``error['upgrade_url']`` opens checkout."""
+
+
+class NotFoundError(DraftKingsAPIError):
+    """404: unknown route or record. ``error['closest_endpoints']`` lists real routes."""
+
+
+class RateLimitError(DraftKingsAPIError):
+    """429: a minute, day or month limit was reached. Not charged.
+
+    ``retry_after`` is the Retry-After header in seconds. On a monthly limit, stop retrying:
+    ``error['limit'] == 'month'``.
+    """
+
+
+class DatasetUnavailableError(DraftKingsAPIError):
+    """503: the dataset is temporarily unavailable. Not charged; retry after ``retry_after``."""
+
+
+_BY_STATUS = {
+    400: InvalidRequestError,
+    401: AuthenticationError,
+    402: PaymentRequiredError,
+    404: NotFoundError,
+    429: RateLimitError,
+    503: DatasetUnavailableError,
+}
+
+
+def error_for(status: int, body: Any, retry_after: Optional[int]) -> DraftKingsAPIError:
+    """Build the matching exception from a status code and decoded body (dict or text)."""
+    data: Dict[str, Any] = body if isinstance(body, dict) else {}
+    err = data.get("error") if isinstance(data.get("error"), dict) else {}
+    message = err.get("message") or (body if isinstance(body, str) and body else f"HTTP {status}")
+    if retry_after is None and isinstance(err.get("retry_after_seconds"), int):
+        retry_after = err["retry_after_seconds"]
+    cls = _BY_STATUS.get(status, DraftKingsAPIError)
+    return cls(str(message)[:2000], status=status, error_type=err.get("type"), body=data, retry_after=retry_after)

draftkingsapi-0.1.0/src/draftkingsapi.egg-info/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: draftkingsapi
+Version: 0.1.0
+Summary: Python client for draftkingsapi.com: DraftKings Pick6 lines and line history, DFS salaries, sportsbook odds and box scores. Independent, not affiliated with DraftKings.
+License: MIT
+Project-URL: Repository, https://github.com/draftkingsapi/draftkingsapi-python
+Project-URL: Issues, https://github.com/draftkingsapi/draftkingsapi-python/issues
+Project-URL: Homepage, https://draftkingsapi.com
+Project-URL: Documentation, https://draftkingsapi.com/docs
+Project-URL: OpenAPI, https://draftkingsapi.com/openapi.json
+Project-URL: Status, https://draftkingsapi.com/status
+Keywords: draftkings,pick6,dfs,sportsbook,odds,sports-data,api-client
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# draftkingsapi (Python)
+
+Python client for [draftkingsapi.com](https://draftkingsapi.com): DraftKings Pick6 lines and line history,
+DFS salaries, contests and slates, sportsbook odds and price history, and box scores. Standard library only,
+no dependencies, typed.
+
+draftkingsapi.com is an independent API. It is not affiliated with or endorsed by DraftKings. "DraftKings" is a
+trademark of its owner and is used here only to describe the data.
+
+```bash
+pip install draftkingsapi
+```
+
+## No key needed
+
+The keyless feeds are delayed and capped, cost no credits, and need no account:
+
+```python
+from draftkingsapi import Client
+
+dk = Client()  # reads DRAFTKINGS_API_KEY if set; keyless calls never send it
+
+board = dk.public_board(league="nba", limit=3)
+for prop in board["props"]:
+    print(prop["player"], prop["stat"], prop["line"], prop["more_multiplier"])
+
+games = dk.public_sportsbook(league="nfl", limit=2)
+for game in games["games"]:
+    print(game["away"], "at", game["home"], [(m["market"], m["side"], m["line"], m["american"]) for m in game["markets"]])
+
+moves = dk.public_line_moves(market="pick6", limit=5)
+costs = dk.credit_costs()            # credits per endpoint
+status = dk.status()                 # measured collection status
+sample = dk.demo("odds", limit=1)    # frozen sample rows, for the response shape only
+```
+
+Output of the first loop, run on 15 Nov 2026 (live data, so yours will differ; a prop with no current line prints None):
+
+```text
+Giannis Antetokounmpo Points 32.5 0.8
+Cade Cunningham Points 30.5 1
+Bam Adebayo Points None None
+```
+
+## With a key
+
+Get a free key (100 credits a month, no card) at https://draftkingsapi.com/sign-up, then:
+
+```bash
+export DRAFTKINGS_API_KEY=dk_...
+```
+
+```python
+from draftkingsapi import Client
+
+dk = Client(user_request="Build a prop screen from current Pick6 lines")
+
+lines = dk.pick6_projections(sport="NBA", limit=100)
+history = dk.pick6_line_history(lines["data"][0]["pickable_id"], change_type="line_move")
+odds = dk.odds(sport="NFL", market="moneyline")
+salaries = dk.dfs_players(sport="NFL", format="csv")      # CSV text
+box = dk.stats_player_games("NBA", 2026, limit=50)
+edges = dk.ev(league="nba", min_edge=2)
+```
+
+`user_request` is optional: one plain sentence about the task, sent as `X-User-Request`. Never put personal data in it.
+
+### Pagination
+
+List routes return `pagination.has_more` with a cursor. `paginate()` follows it with a page budget, so a loop cannot
+spend your whole allowance:
+
+```python
+for row in dk.paginate(dk.odds, sport="NBA", max_pages=5):
+    ...
+```
+
+It follows `next_cursor` (sent back as `cursor`), `next` on the stats routes and `next_after` on the change feeds
+(both sent back as `after`).
+
+### Errors
+
+Every non-2xx response raises a subclass of `DraftKingsAPIError` with the API's own message:
+
+| Status | Exception | What to do |
+| --- | --- | --- |
+| 400 | `InvalidRequestError` | `e.error["query_help"]` often has a corrected example |
+| 401 | `AuthenticationError` | missing or wrong key; raised before any request when a keyed method has no key |
+| 402 | `PaymentRequiredError` | `e.error["upgrade_url"]` |
+| 404 | `NotFoundError` | `e.error["closest_endpoints"]` |
+| 429 | `RateLimitError` | wait `e.retry_after` seconds; if `e.error["limit"] == "month"`, stop retrying |
+| 503 | `DatasetUnavailableError` | dataset temporarily unavailable; not charged, retry later |
+
+```python
+from draftkingsapi import Client, RateLimitError
+
+try:
+    Client().odds(sport="NFL")
+except RateLimitError as e:
+    print("retry in", e.retry_after, "seconds:", e.message)
+```
+
+## Methods
+
+Keyless: `public_board`, `public_sportsbook`, `public_line_moves`, `demo(dataset)`, `credit_costs`, `directory`,
+`status`, `history_coverage`.
+
+Keyed: `coverage`, `events`, `odds`, `history`, `pick6_projections`, `pick6_history`, `pick6_line_history`,
+`projections`, `changes`, `dfs_sports`, `dfs_contests`, `dfs_slates`, `dfs_players`, `dfs_changes`, `compare`,
+`compare_books`, `ev`, `arbitrage`, `stats_games`, `stats_player_games`, `stats_team_games`, `context_games`,
+`context_player_stats`, `context_team_stats`, `sportsbook_scopes`, `sportsbook_snapshot`, `stream_snapshot`.
+
+Optional filters are keyword arguments, passed through unchanged. Every route's parameters are in the
+[OpenAPI document](https://draftkingsapi.com/openapi.json) and the [docs](https://draftkingsapi.com/docs).
+Not wrapped: the server-sent event stream, the native sportsbook WebSocket, and account, billing and sign-up routes.
+
+## Plans
+
+Free 100 credits a month, Developer $49, Production $149, Scale $499 a month. Credits per endpoint:
+`Client().credit_costs()` or https://draftkingsapi.com/api/v1/credit-costs.
+
+## Tests
+
+```bash
+python -m unittest discover -s tests            # mocked, no network
+DRAFTKINGS_LIVE=1 python -m unittest tests.test_live -v   # live keyless endpoints, no key, no credits
+```
+
+MIT License.

draftkingsapi-0.1.0/src/draftkingsapi.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/draftkingsapi/__init__.py
+src/draftkingsapi/_version.py
+src/draftkingsapi/client.py
+src/draftkingsapi/errors.py
+src/draftkingsapi/py.typed
+src/draftkingsapi.egg-info/PKG-INFO
+src/draftkingsapi.egg-info/SOURCES.txt
+src/draftkingsapi.egg-info/dependency_links.txt
+src/draftkingsapi.egg-info/top_level.txt
+tests/test_client.py
+tests/test_live.py

draftkingsapi-0.1.0/src/draftkingsapi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

draftkingsapi-0.1.0/src/draftkingsapi.egg-info/top_level.txt

@@ -0,0 +1 @@
+draftkingsapi

draftkingsapi-0.1.0/tests/test_client.py

@@ -0,0 +1,169 @@
+"""Mocked tests: no network. Run with `python -m unittest discover -s tests` from packages/python."""
+
+import json
+import os
+import sys
+import unittest
+import urllib.parse
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
+
+from draftkingsapi import (  # noqa: E402
+    AuthenticationError,
+    DatasetUnavailableError,
+    DraftKingsAPI,
+    InvalidRequestError,
+    RateLimitError,
+    Response,
+)
+
+
+class FakeTransport:
+    def __init__(self, responses):
+        self.responses = list(responses)
+        self.requests = []
+
+    def __call__(self, request, timeout):
+        self.requests.append(request)
+        status, body, headers = self.responses.pop(0)
+        raw = body if isinstance(body, bytes) else json.dumps(body).encode()
+        base = {"Content-Type": "application/json"} if not isinstance(body, bytes) else {"Content-Type": "text/csv"}
+        base.update(headers or {})
+        return Response(status, base, raw)
+
+    def query(self, i=-1):
+        url = urllib.parse.urlparse(self.requests[i].full_url)
+        return url.path, dict(urllib.parse.parse_qsl(url.query))
+
+
+def client(responses, key="dk_test", **kw):
+    t = FakeTransport(responses)
+    return DraftKingsAPI(api_key=key, base_url="https://example.test", transport=t, **kw), t
+
+
+class KeylessTests(unittest.TestCase):
+    def test_public_board_sends_no_key(self):
+        c, t = client([(200, {"feed": "pick6-board", "props": []}, None)], key="dk_secret")
+        out = c.public_board(league="nba", limit=2)
+        self.assertEqual(out["feed"], "pick6-board")
+        path, q = t.query()
+        self.assertEqual(path, "/api/v1/public/board")
+        self.assertEqual(q, {"league": "nba", "limit": "2"})
+        self.assertIsNone(t.requests[0].get_header("Authorization"))
+
+    def test_keyless_without_key(self):
+        c, t = client([(200, {"data": []}, None)], key=None)
+        os.environ.pop("DRAFTKINGS_API_KEY", None)
+        c.api_key = None
+        c.demo("odds", limit=1)
+        self.assertEqual(t.query()[0], "/api/v1/demo/odds")
+
+    def test_demo_rejects_unknown_dataset(self):
+        c, _ = client([])
+        with self.assertRaises(ValueError):
+            c.demo("nope")
+
+    def test_status_and_coverage_paths(self):
+        c, t = client([(200, {"status": "ok"}, None), (200, {"page": "x"}, None), (200, {"data": []}, None)])
+        c.status()
+        self.assertEqual(t.query()[0], "/status.json")
+        c.history_coverage()
+        self.assertEqual(t.query()[0], "/history-coverage.json")
+        c.credit_costs(path="/api/v1/odds", rows=500)
+        self.assertEqual(t.query(), ("/api/v1/credit-costs", {"path": "/api/v1/odds", "rows": "500"}))
+
+
+class KeyedTests(unittest.TestCase):
+    def test_missing_key_raises_before_any_request(self):
+        c, t = client([], key=None)
+        c.api_key = None
+        with self.assertRaises(AuthenticationError) as ctx:
+            c.odds(sport="NFL")
+        self.assertIn("draftkingsapi.com/sign-up", str(ctx.exception))
+        self.assertEqual(t.requests, [])
+
+    def test_bearer_and_task_header(self):
+        c, t = client([(200, {"data": [], "pagination": {"has_more": False}}, None)], user_request="Build a prop screen")
+        c.pick6_projections(sport="NBA", fresh_only=True, view="compact")
+        req = t.requests[0]
+        self.assertEqual(req.get_header("Authorization"), "Bearer dk_test")
+        self.assertEqual(urllib.parse.unquote(req.get_header("X-user-request")), "Build a prop screen")
+        self.assertEqual(t.query()[1], {"sport": "NBA", "fresh_only": "true", "view": "compact"})
+
+    def test_required_args(self):
+        c, t = client([(200, {"data": []}, None), (200, {"data": []}, None), (200, {"data": {}}, None)])
+        c.pick6_line_history("123", change_type="line_move")
+        self.assertEqual(t.query(), ("/api/v1/pick6/line-history", {"pickable_id": "123", "change_type": "line_move"}))
+        c.stats_player_games("NBA", 2026, athlete_id="9")
+        self.assertEqual(t.query()[1], {"sport": "NBA", "season": "2026", "athlete_id": "9"})
+        c.sportsbook_snapshot("nba-props")
+        self.assertEqual(t.query(), ("/api/v1/sportsbook/snapshot", {"scope": "nba-props"}))
+
+    def test_csv_returns_text(self):
+        c, _ = client([(200, b"id,line\n1,20.5\n", None)])
+        out = c.dfs_players(sport="NFL", format="csv")
+        self.assertTrue(out.startswith("id,line"))
+
+
+class ErrorTests(unittest.TestCase):
+    def test_401_message(self):
+        body = {"error": {"code": 401, "type": "invalid_api_key", "message": "Invalid API key."}}
+        c, _ = client([(401, body, None)])
+        with self.assertRaises(AuthenticationError) as ctx:
+            c.odds()
+        self.assertEqual(ctx.exception.status, 401)
+        self.assertEqual(ctx.exception.error_type, "invalid_api_key")
+        self.assertEqual(ctx.exception.message, "Invalid API key.")
+
+    def test_429_retry_after(self):
+        body = {"error": {"code": 429, "type": "minute_rate_limited", "message": "Slow down.", "limit": "minute"}}
+        c, _ = client([(429, body, {"Retry-After": "12"})])
+        with self.assertRaises(RateLimitError) as ctx:
+            c.ev()
+        self.assertEqual(ctx.exception.retry_after, 12)
+        self.assertEqual(ctx.exception.error["limit"], "minute")
+
+    def test_503(self):
+        body = {"error": {"code": 503, "type": "service_unavailable", "message": "Dataset unavailable."}}
+        c, _ = client([(503, body, None)])
+        with self.assertRaises(DatasetUnavailableError):
+            c.public_board()
+
+    def test_400_query_help(self):
+        body = {"error": {"code": 400, "type": "invalid_query", "message": "Invalid input", "query_help": {"x": 1}}}
+        c, _ = client([(400, body, None)])
+        with self.assertRaises(InvalidRequestError) as ctx:
+            c.odds(limit=99999)
+        self.assertEqual(ctx.exception.error["query_help"], {"x": 1})
+
+
+class PaginationTests(unittest.TestCase):
+    def test_cursor_pages(self):
+        pages = [
+            (200, {"data": [1, 2], "pagination": {"has_more": True, "next_cursor": "c2"}}, None),
+            (200, {"data": [3], "pagination": {"has_more": False, "next_cursor": None}}, None),
+        ]
+        c, t = client(pages)
+        rows = list(c.paginate(c.odds, sport="NFL", offset=50))
+        self.assertEqual(rows, [1, 2, 3])
+        self.assertNotIn("offset", t.query(0)[1])
+        self.assertEqual(t.query(1)[1], {"sport": "NFL", "cursor": "c2"})
+
+    def test_stats_next(self):
+        pages = [
+            (200, {"data": ["a"], "pagination": {"has_more": True, "next": "k:1"}}, None),
+            (200, {"data": ["b"], "pagination": {"has_more": False, "next": None}}, None),
+        ]
+        c, t = client(pages)
+        self.assertEqual(list(c.paginate(c.stats_games, sport="NBA", season=2026)), ["a", "b"])
+        self.assertEqual(t.query(1)[1]["after"], "k:1")
+
+    def test_page_budget(self):
+        page = (200, {"data": [0], "pagination": {"has_more": True, "next_cursor": "x"}}, None)
+        c, t = client([page] * 5)
+        self.assertEqual(len(list(c.paginate(c.odds, max_pages=3))), 3)
+        self.assertEqual(len(t.requests), 3)
+
+
+if __name__ == "__main__":
+    unittest.main()

draftkingsapi-0.1.0/tests/test_live.py

@@ -0,0 +1,50 @@
+"""Opt-in live test against the keyless endpoints. Spends no credits and needs no key.
+
+    DRAFTKINGS_LIVE=1 python -m unittest tests.test_live -v
+"""
+
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
+
+from draftkingsapi import AuthenticationError, DraftKingsAPI  # noqa: E402
+
+LIVE = os.environ.get("DRAFTKINGS_LIVE") == "1"
+
+
+@unittest.skipUnless(LIVE, "set DRAFTKINGS_LIVE=1 to call the live keyless endpoints")
+class LiveKeyless(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.c = DraftKingsAPI(api_key="", user_request="Run the SDK live keyless test")
+        cls.c.api_key = None
+
+    def test_public_board(self):
+        out = self.c.public_board(league="nba", limit=2)
+        self.assertEqual(out["feed"], "pick6-board")
+        self.assertTrue(out["keyless"])
+        self.assertIsInstance(out["props"], list)
+
+    def test_public_sportsbook(self):
+        out = self.c.public_sportsbook(league="nfl", limit=2)
+        self.assertEqual(out["feed"], "sportsbook-mainlines")
+        self.assertIsInstance(out["games"], list)
+
+    def test_line_moves(self):
+        out = self.c.public_line_moves(limit=2)
+        self.assertEqual(out["feed"], "line-moves")
+
+    def test_demo_and_costs(self):
+        self.assertTrue(self.c.demo("pick6")["demo"]["sample"])
+        self.assertIsInstance(self.c.credit_costs()["data"], list)
+        self.assertIn("status", self.c.status())
+
+    def test_keyed_without_key_is_clear(self):
+        with self.assertRaises(AuthenticationError):
+            self.c.odds()
+
+
+if __name__ == "__main__":
+    unittest.main()