# LazyEdge API reference > LazyEdge is a sports prediction market data platform. It prices NBA, NFL and MLB games with measured models, reads the live Kalshi and Polymarket order books, and publishes the model probability, the market price and the gap between them for every line it covers. People read the numbers in a web terminal; software reads them through a paid API at https://api.lazyedge.net/v1. LazyEdge publishes data and is not financial advice. ## Connecting - Base URL: https://api.lazyedge.net - Authentication: every request carries `Authorization: Bearer `. The WebSocket takes the key in its first message instead. - Keys: issued in the LazyEdge terminal under Settings, API Access. Issuing a key needs the Quant Node plan ($49.99) or 5+ Lazy Lions. - Rate limits per key, in requests per minute: recon 30, basic 60, pro 240, elite 1000. A request over the limit returns 429 with `Retry-After: 60`. - Tiers: each endpoint lists the minimum tier. "Any valid key" needs a key but no particular tier; "public" needs no key. - Errors: 401 for a missing, invalid or replaced key; 402 when the account behind the key has no active plan (the same key works again once it does); 403 when the key tier is below the endpoint minimum; 429 over the rate limit; 503 when data is unavailable. - Keys do not expire on a calendar: a key works while the account's plan is active. Issue, list and revoke keys at https://lazyedge.net/settings. - Agent guide: https://api.lazyedge.net/v1/skill is a markdown guide written to hand to an agent. - Browsable guide: https://lazyedge.net/api-docs Example: ``` curl -s "https://api.lazyedge.net/v1/nfl/edges?include_no_edge=true" \ -H "Authorization: Bearer $LAZYEDGE_API_KEY" ``` ## By function The same endpoints by what they do, across every sport; each is described under its sport below. - Slate and pregame edges: each game before the start, with our probability, the market price and the gap on every line. Endpoints: GET /v1/nfl/edges, GET /v1/nfl/board/{game_id}, GET /v1/mlb/edges, GET /v1/wc/edges, GET /v1/nba/games/today - Live in-game numbers: games in progress, repriced from the score and clock against the live book. Endpoints: GET /v1/nfl/live, GET /v1/nfl/live-plays, GET /v1/mlb/live, GET /v1/wc/live, GET /v1/nba/edges, GET /v1/nba/edges/{game_id}, WS /v1/nba/ws/edges - Ladders and order books: every rung of a game's spread ladder priced by our model, and the venues' books. Endpoints: GET /v1/nba/spread-ladder/{game_id}, GET /v1/nba/market/depth - Player props: our projection beside the venue line, pregame and in play. Endpoints: GET /v1/nfl/props, GET /v1/nfl/live-props - Injuries and teams: who is out and what the team ratings carry. Endpoints: GET /v1/nfl/injuries, GET /v1/nfl/teams, GET /v1/nba/injuries - Graded record and history: finished games graded against the final and the price, and past signals. Endpoints: GET /v1/nfl/results, GET /v1/nba/signals/history - Pick'em and $LAZY: the weekly contest, its standings, rewards and the token economy. Endpoints: GET /v1/lazy/economy, GET /v1/lazy/burns, GET /v1/lazy/leaderboard, GET /v1/lazy/rewards, GET /v1/lazy/contests, GET /v1/lazy/player/{ident}, GET /v1/lazy/picks - Account: the calling key's usage, rotation and billing. Endpoints: GET /v1/account/usage, POST /v1/account/rotate-key, POST /v1/billing/apply_promo - Guide: the agent guide, public with no key. Endpoints: GET /v1/skill ## NFL ### GET /v1/nfl/edges Tier: basic and above NFL pregame model against the market for every game in the current week. Parameters: - `season` (query, integer, optional): Season to return. Omit for the current season. - `week` (query, integer, optional): Week to return. Omit for the current week: the earliest week with a game still to play, or the latest once every game is final. - `min_edge_pp` (query, number, optional, default 0): Minimum absolute moneyline edge, in percentage points. - `include_no_edge` (query, boolean, optional, default false): Include games with no moneyline edge. With true, every game carries THE PLAY. - `all_weeks` (query, boolean, optional, default false): Every published week instead of the current one. Pass a season with it for one whole season. Returns: An array, one object per game, sorted by the absolute moneyline edge. Each carries `signal` (BUY_HOME, BUY_AWAY or NO_EDGE, the moneyline value side), `best_edge_pp` and `target_kalshi_ticker`; win probability and the fair American moneyline; the expected home margin with `margin_sigma`, and `exp_total` with `total_sigma`; the market spread in sportsbook convention (`spread_home`) and `total_line`; our P(over) and P(home cover) at those lines; the full `p_over_ladder` and `p_cover_ladder`; THE PLAY (`play_*`: lane, basis, side, line, our probability, the market probability, `play_edge_pp`, label and measured record); `driver` (QB, FINISHING or RATING: which part of the model put our margin away from the line, for the spread and moneyline); the model breakdown (`qb_edge_pts`, `hfa_scale`, `wx_pen`); the conditions (`stadium`, `roof`, `indoors`, `temp_f`, `wind_mph`, `wind_gust_mph`, `precip_prob` in percent, `precip_type`, `forecast_at` and `forecast_lead_h`, where `indoors` is true under a dome or a closed roof); and the Kalshi moneyline, spread and total tickers. Notes: `exp_margin` is a home margin (positive means the home side is favoured) while `spread_home` is in sportsbook convention (home favourite negative), so the two carry opposite signs by design. `market_p_home`, `spread_home` and `total_line` are the sportsbook consensus, not a venue price; the venue price behind THE PLAY is `play_market_p`, read off `play_venue`. `play_edge_pp` is in probability points; `best_edge_pp` is the older moneyline field. ### GET /v1/nfl/board/{game_id} Tier: basic and above Every lane for one NFL game (spread, total, moneyline and each player prop rung), ranked on one scale. Parameters: - `game_id` (path, string, required): nflverse game_id, for example 2026_01_NE_SEA. - `lane` (query, string, optional): One lane only: SPREAD, TOTAL, ML or PROP. - `ranked_only` (query, boolean, optional, default false): Drop the unranked rows (illiquid, role priced, no venue line). Returns: An object with `game_id`, `as_of` (when the board was published), `n_rows` and `rows`. Each row carries `lane`, `basis` (what the edge is measured against), `side`, a readable `ref`, `line`, `our_p`, `market_p`, `edge_pp` in probability points, `price_c`, `label`, `record` (what that lane measured on 2022 to 2025), `rank`, `is_top`, `n_ranked`, `ticker`, `venue`, `gap_pts` and `driver`, and prop rows add `player` and `stat`. Ranked rows come first by rank, then the unranked rows. Notes: `is_top` marks THE PLAY, the best ranked clean row on a main line, which is not always rank 1. Rows labelled ILLIQUID, ROLE_PRICED or UNPRICED are shown and never ranked. `driver` is QB, FINISHING or RATING on every spread and moneyline row of the game, Kalshi rungs included, and null on totals and props: it names the part of the model that put our margin away from the line, which is what splits a RATING_Q spread's record (2024 to 2025: 4+ point gaps driven by the QB or finishing covered 61%, by the unit ratings 39 to 49%). An unknown game_id returns 404. ### GET /v1/nfl/props Tier: basic and above NFL player props: our projection beside the venue line, for starters confirmed by the spine. Parameters: - `season` (query, integer, optional): Season filter. Omit for the current season. - `week` (query, integer, optional): Week filter. Omit for the current week, the one /v1/nfl/edges returns; with a game_id the game decides. - `game_id` (query, string, optional): One game only. - `stat` (query, string, optional): One stat only: pass_yds, rush_yds, rec_yds or receptions. - `with_line` (query, boolean, optional, default false): Only props a venue lists a line for. Returns: An array, one object per player and stat, sorted by game, team, player and stat. Each carries the identity (`prop_key`, `game_id`, `player`, `team`, `opponent`, `is_home`, `position`, `stat`, `basis`, `player_class`), our `projection` (the mean), `projection_median`, `proj_sigma`, `p_over` and `p_over_ladder`, fantasy points (`fpts_ppr`, `fpts_half`, `fpts_std`), and where a venue lists the prop its main `line`, `market_venue`, `market_ticker`, the ask on the over (`market_p_over`), our P(over) at that line (`our_p_over_line`), `venue_edge_pp` in probability points, every rung (`market_rungs`), the market fitted `market_median` and `market_sigma`, and `role_q`. Notes: The median is the number comparable with a line, since the mean carries the skew. `role_q` true means we and the venue disagree on the player role, a depth chart question rather than a price. ### GET /v1/nfl/live Tier: basic and above Every NFL game in progress: the live state and the live engine number. Parameters: none Returns: An array, one object per game in progress or at halftime. Each carries the game state (score, `quarter`, `clock`, `game_seconds_remaining`, `possession`, `down`, `distance`, `yardline_100`, `is_redzone`, `is_two_minute`, timeouts, `last_play`), the pregame reference numbers (`pregame_p_home_win`, `pregame_spread_home`, `pregame_total`), `model_source`, and `live`: the engine tick with win probability beside the incumbent number, projected margin and total with their spreads, the venue moneyline, spread and total with the age of each price, the edges, both full ladders (cover from -24 to +24 and over from 24 to 75, in half points), `qb_exit` and `injury_out`. Notes: `model_source` is `live` when the engine priced this tick, `pregame_only` when it has not, and `overtime` when the game is past regulation and no engine row that played the extra period exists; in both of the last two `live` is null and no edge is published. A served overtime row carries `overtime`, `ot_secs` (seconds left on the overtime clock) and `ot_poss_done` (overtime possessions completed), and its post-event read stays empty because that reaction was measured in regulation. An edge is null wherever the price behind it was stale. Pregame numbers freeze at kickoff. Empty outside game windows. ### GET /v1/nfl/live-props Tier: basic and above In-game player props for every NFL game in progress. Parameters: - `game_id` (query, string, optional): One live game only. Returns: An array, one object per player and stat in a game in progress. Each carries `current_value` (what he has now), `exp_rest` (the measured value of the snaps still to come), `projection` and `sigma` (the spread of the unplayed part only), `line` and `line_source` (the pregame line), our `p_over`, `pregame_proj`, `plays_left`, `availability`, and `absorbed` with `absorbed_from` when he inherits an absent teammate's volume. Where Kalshi lists the prop, the live book rides beside it: `ladder` (every rung with its `line`, `bid`, `ask`, `mid`, our probability `our`, `edge_pp`, `side`, `exec_edge_pp` at the price you would pay, and `thin` or `decided` where no edge is published), `book_line` (the rung the book prices nearest 50c) with `book_bid`, `book_ask`, `book_mid`, `book_our_p` and `book_edge_pp`, `best_line`, `best_side`, `best_edge_pp`, `best_exec_edge_pp` and `best_price` for the widest usable disagreement, `book_ts` (when the ladder was read) and `moved_sd` (how far the game has moved the projection, in pregame standard deviations). Notes: `availability` out means he went down and was not seen back; ESPN notes a return for about six exits in ten, so it is an inference and not a ruling. A rung carries an edge only when both sides are quoted within ten cents; thinner rungs are shown without one. The prop model has not yet been graded against live books. Empty outside game windows. ### GET /v1/nfl/live-plays Tier: basic and above Hot plays: the live edges that met the hot plays rule, across every NFL game in progress. Parameters: - `game_id` (query, string, optional): One live game only. - `include_props` (query, boolean, optional, default true): Include player props. - `limit` (query, integer, optional, default 50): Most plays to return, from 1 to 200. Returns: An object with `as_of`, `games_live`, `live_public`, `thresholds` and `plays`. Each play carries `market` (MONEYLINE, SPREAD, TOTAL or PROP), `selection`, `side`, `line`, `our_p` and `market_p` for that side, `edge_pp`, `price_age_s`, `matchup`, `score`, `clock`, `basis` (`live_engine` or `prop_model`), `graded`, `measured`, and `why`, the reason it is on the list. Props add `player`, `stat`, `our_line` (our projection), `book_line`, `price` (what you would pay) and `exec_edge_pp`. Notes: Game lines are listed when the engine edge clears the threshold against a fresh price within five minutes of a touchdown, field goal, turnover or big play; a standing disagreement with nothing happening is on /v1/nfl/live instead. The market under-reaction after a turnover, the one in-game edge that has been measured, is listed whenever the engine flags it and marked `measured`. A prop is listed only at the book's current line (the rung priced nearest 50c), only when that line is priced 25c to 75c, only on the side the game moved him (a projection that moved up lists the over, one that moved down the under, inherited volume the over, a ruling of out the under), with an edge still positive at the price you would pay, and at most three a game. Empty outside game windows. ### GET /v1/nfl/results Tier: recon and above The graded record: every finished NFL game, graded one game at a time. Parameters: - `season` (query, integer, optional): Season. Omit for the newest graded week. - `week` (query, integer, optional): Week. Omit for the newest graded week. - `game_id` (query, string, optional): One game in full, with every ledger row, in-game episode and graded prop. Returns: For a week, an object with `season`, `week`, `weeks` (every week with a graded game), `as_of`, `games` and `totals`. Each game carries the final score and `pregame` (our winner, spread and total calls against the final, with the lines and the market's pregame win probability), `the_play` (THE PLAY at the price it showed and its result), `ledger` (every pick staked at $5), and `live`, the in-game grade: `engine` (the live win probability's Brier score beside the incumbent model and the market, by quarter), `edges` and `hot` (every live edge episode and every hot play priced on its own contract, as a win rate held to the final beside the average price paid, and the return per contract after fees if sold 2, 5 or 15 minutes later), and `props` (the live projection's error against the final box score at kickoff and each quarter mark). `totals` combines the graded games. With `game_id`, one game with `episodes`, `props` and `ledger_rows` in full. Notes: The same payload as the public results page. Pregame calls and the ledger are graded by the model pipeline; the in-game grade comes from the prices our servers recorded during each game and covers regulation only. Returns are per $1 contract, net of the Kalshi fee. The ledger and THE PLAY stake every published pick at a flat $5, every game, with no filter: they grade the raw numbers in the open and are a measurement, not a strategy. A game appears the moment its first grade lands. ### GET /v1/nfl/injuries Tier: basic and above The NFL injury board: a five source consensus, one row per flagged player. Parameters: - `team` (query, string, optional): One team, for example SF. - `game_id` (query, string, optional): Both teams in one game. - `status` (query, string, optional): One status: OUT, DOUBTFUL, QUESTIONABLE, QUESTIONABLE_PRE, RESERVE or AVAILABLE. - `include_available` (query, boolean, optional, default false): Also list starters with no designation. Returns: An array of players. Each carries `team`, `player`, `position`, `status`, `severity` from 0 to 4, `p_play` (the measured chance he plays, applied once the official designation lands), `pre_report`, `conflict` (the sources disagree by two or more levels), `body_part`, `injury_detail`, return week estimates, each source's own status, `n_sources`, `chart_rank` and `is_starter`. Notes: This week's designations come first, worst first, then long term reserve. Starters with no designation are left out unless `include_available` is true. An unknown game_id returns 404. ### GET /v1/nfl/teams Tier: basic and above All 32 NFL team ratings and each team's quarterback exit input. Parameters: none Returns: An array of 32 teams. Each carries `pass_off`, `run_off`, `pass_def` and `run_def` (EPA per play above league), `finishing`, `hfa_scale`, the `starter` and his `qb_rating`, whether he moved teams this offseason, and the quarterback exit input: `qb1`, `qb2`, `qb2_rated` and `qb_backup_delta_pts`, the full game spread change if the starter leaves, with `qb_exit_generic_pts` for teams whose own number is null. Notes: A negative `qb_backup_delta_pts` means the team gets worse. The live engine applies it unscaled, and only once the exit holds: an out ruling, two full drives, eight backup dropbacks or five minutes with the backup in. ## MLB ### GET /v1/mlb/edges Tier: basic and above MLB daily slate: the model against the market for every game. Parameters: - `date` (query, string, optional): Slate date as YYYY-MM-DD. Defaults to today in US Eastern time. - `min_edge_pp` (query, number, optional, default 0): Minimum absolute moneyline edge, in percentage points. - `include_no_edge` (query, boolean, optional, default false): Include games with no moneyline signal. Returns: An array, one object per game, sorted by the absolute moneyline edge. Each carries `signal` (BUY_HOME, BUY_AWAY or NO_EDGE) and `best_edge_pp`; win probability, fair American moneylines and run lambdas; the Kalshi implied probability and the Kalshi and Polymarket edges; the measured totals board (`total_pick`, `main_line`, `market_total`, `our_total`, `our_p_over`, `market_p_over`, `total_edge_pp`, `total_seam`, `total_line_ok`, `sp_tbd`, `total_ladder`); the simulated P(over) by line (`p_over`); opener and bullpen game flags; the daily alpha pick (`alpha_*`); Kelly fractions (`kelly_ml_*`, `kelly_total_*`); starting pitchers with their wOBA; park and weather; and the Kalshi and Polymarket tickers. Notes: `total_seam` and `total_line_ok` together mark a measured totals edge on a tradeable line; with either false the totals fields are informational. `sp_tbd` true means the starter is unannounced or an opener, so the total is soft. ### GET /v1/mlb/live Tier: basic and above Every MLB game in progress, repriced by the live engine against the live Kalshi book. Parameters: none Returns: An array, one object per game in progress. Each carries `game_pk`, the teams, inning, half and score, `p_home_win`, the home and away tickers with their live mids, `market_source`, `ml_edge_pp` and `ml_signal_side`, `settlement_edge_pp`, `transient_edge_pp`, `single_kelly`, `sigma_p`, `portfolio_kelly`, `leverage`, `comeback_pct`, `p_over_live`, `projected_total`, `ou_line`, and `totals_ladder` (the liquid KXMLBTOTAL rungs with our P(over) at each line). Notes: A game whose feed has gone stale is skipped rather than priced. Empty when no game is in progress. ## World Cup ### GET /v1/wc/edges Tier: basic and above World Cup pregame 1X2 model against the de-vigged market, per match. Parameters: - `min_edge_pp` (query, number, optional, default 0): Minimum absolute edge, in percentage points. - `include_no_edge` (query, boolean, optional, default false): Include matches with no 1X2 signal. Returns: An array, one object per match, sorted by the absolute edge. Each carries `signal` (BUY_HOME, BUY_DRAW, BUY_AWAY or NO_EDGE), `best_edge_pp`, `target_kalshi_ticker` and `target_polymarket_event` for the signal side, the calibrated model 1X2 (`model_p_home`, `model_p_draw`, `model_p_away`), the de-vigged market (`mkt_p_home`, `mkt_p_draw`, `mkt_p_away`), the edge per outcome in percentage points (`edge_home_pp`, `edge_draw_pp`, `edge_away_pp`), the totals signal and edge when published (`ou_signal`, `ou_edge_pp`), and the Kalshi and Polymarket routing keys. Notes: A match whose Kalshi event is more than three days old is dropped, so a finished tournament returns an empty array. ### GET /v1/wc/live Tier: basic and above Every World Cup match in play, repriced off the current minute and score. Parameters: none Returns: An array, one object per match in play. Each carries `match_id`, `stage`, the teams, `minute`, goals and `status`, the pregame model 1X2 (`pregame_p_home`, `pregame_p_draw`, `pregame_p_away`), the live Kalshi book mid per outcome (`mkt_p_home`, `mkt_p_draw`, `mkt_p_away`, null before a book exists), and the live model (`p_home_win`, `p_draw`, `p_away_win`, `p_over`, `rem_frac`). Notes: Knockout stages collapse the draw. Empty until matches are in play. ## NBA ### GET /v1/nba/edges Tier: basic and above NBA live edge feed: the latest signal for each active game. Parameters: - `min_edge` (query, number, optional, default 0): Minimum absolute `edge_score`, in probability units (0.05 is five points). - `include_stale` (query, boolean, optional, default false): Include rows flagged stale (inference stalled on that game). Stale rows are suppressed by default. Returns: An array, one object per active game. Each carries the game state (teams, `period`, `clock`, score), the scheduled tip (`tip_time`, ISO 8601 UTC) and the game's Eastern date (`game_date`), `trade_signal` (BUY, SELL or HOLD), `target_side`, `target_kalshi_ticker` and `target_polymarket_id`, `our_prob`, `edge_score` (our probability minus the market mid), `kelly`, the Kalshi top of book (`kalshi_best_bid`, `kalshi_best_ask`, `kalshi_implied`), `edge_velocity`, `hawkes_flag`, `momentum_state`, `signal_stale` and `signal_age_s`, `dominance_score` and `dominance_components`, `computed_at_ms` and `timestamp`, the Kalshi and Polymarket routing keys, and the trailing team's comeback record from this spot: `comeback_trailing_team`, `comeback_deficit`, `comeback_win_prob`, `comeback_cover_prob`, `comeback_bucket` and `comeback_tier`; and the live line cover: `spread_fav_team`, `spread_fav_line`, `spread_fav_cover_prob`, `spread_dog_team`, `spread_dog_cover_prob`, `spread_trailing_team` and `spread_trailing_cover_prob`. Older path, still served: GET /v1/edges/live Notes: Before the tip a game's row reads `clock` PRE and `period` 0, and `tip_time` says when it starts. The comeback fields are filled from the third quarter on when a team trails by 5 or more, and are null otherwise. `comeback_win_prob` is how often a team in that spot went on to win; `comeback_cover_prob` is how often it got back within 3 points at some later moment. Both come from the play-by-play of 5,294 games, are the trailing team's figures, and are not part of `our_prob` or `edge_score`. The line cover is the engine's live chance that each side covers the pregame line (`spread_fav_team` must win by more than `spread_fav_line`), recomputed every play from the score and the engine's margin distribution for the rest of the game; `spread_trailing_cover_prob` is the team behind covering, null when level. It is filled all game when the game has a line; a whole-number line can push, so the two sides can sum to less than 1. ### GET /v1/nba/edges/{game_id} Tier: basic and above Edge time series for one NBA game, newest first. Parameters: - `game_id` (path, string, required): The game_id, as listed by /v1/nba/games/today. - `limit` (query, integer, optional, default 20): Rows to return, 1 to 100. Returns: An array of the same edge objects as /v1/nba/edges, newest first, with `edge_velocity` computed between consecutive rows. Older path, still served: GET /v1/edges/game/{game_id} Notes: These are historical rows, so the bid and ask fields carry the implied price rather than a live book. ### GET /v1/nba/games/today Tier: basic and above Today's NBA slate with every market identifier. Parameters: none Returns: An array, one object per game ordered by tip time: `game_id`, `game_date`, `home_team`, `away_team`, `tip_time`, `kalshi_home_ticker`, `kalshi_away_ticker`, `kalshi_event_prefix`, `polymarket_condition_id` and `polymarket_slug`. Older path, still served: GET /v1/games/today Notes: Today is the current US Eastern date. `kalshi_event_prefix` is the moneyline ticker without its team (KXNBAGAME-26OCT21ATLORL); swap KXNBAGAME for KXNBATOTAL or KXNBASPREAD to find the game's total and spread contracts. `polymarket_slug` is empty until the Polymarket book has quoted in the last 30 minutes. ### GET /v1/nba/spread-ladder/{game_id} Tier: basic and above Every rung of one NBA game's spread ladder, each priced against the model margin distribution. Parameters: - `game_id` (path, string, required): The game_id, as listed by /v1/nba/games/today. - `venue` (query, string, optional, default kalshi): kalshi or polymarket. Returns: An array of rungs, each with `ticker`, `team`, `line`, `model_prob` (the cover probability), `market_bid`, `market_ask`, `market_price`, `edge` (model minus market price), `side` (COVER or NOT_COVER), `depth_at_ask`, `best_edge` and `venue`. Older path, still served: GET /v1/spread-ladder/{game_id} Notes: `best_edge` marks the single rung with the largest edge. A venue other than kalshi or polymarket returns 400. Empty when no ladder is priced. ### GET /v1/nba/injuries Tier: basic and above The NBA injury report as of the latest poll, biggest usage first. Parameters: - `team` (query, string, optional): Team abbreviation filter. Returns: An array, one object per listed player, each with `player_name`, `team_abbr`, `status` (OUT, OUT_FOR_SEASON, DOUBTFUL, QUESTIONABLE, DAY_TO_DAY or SUSPENSION), `usage_share`, `pmm_impact`, `signal`, `source`, `comment` and `updated_at`. Older path, still served: GET /v1/injuries/live Notes: Every poll writes the whole league report, so a player who has returned is not listed. `usage_share` and `pmm_impact` are 0 where the model has no usage number for the player. ### GET /v1/nba/market/depth Tier: pro and above The current NBA order books on Polymarket or Kalshi, newest quote per contract. Parameters: - `exchange` (query, string, optional, default polymarket): polymarket or kalshi. - `game_id` (query, string, optional): Only this game's contracts, as listed by /v1/nba/games/today. - `limit` (query, integer, optional, default 50): Contracts returned, 1 to 500. Returns: An array, one object per contract, each with `condition_id` or `ticker`, `exchange`, `game_id`, `slug`, `best_bid`, `best_ask`, `mid_price`, `bid_depth_5`, `ask_depth_5`, `volume_24h` and `snapshot_time`. Older path, still served: GET /v1/market/depth Notes: Kalshi covers every NBA series (moneyline, totals, spreads, player points), depth in contracts across the top five levels; Polymarket depth is in shares. Books not quoted in the last 15 minutes are left out. ### GET /v1/nba/signals/history Tier: pro and above The engine's recent NBA BUY and SELL signals, newest first, paginated. Parameters: - `team` (query, string, optional): Team abbreviation, either side of the game. - `limit` (query, integer, optional, default 50): Rows per page, 1 to 500. - `offset` (query, integer, optional, default 0): Rows to skip. Returns: An object with `data`, `count`, `offset`, `limit` and `window`. Each `data` row carries `game_id`, `home_team`, `away_team`, `game_date`, `timestamp`, `period`, `clock`, `trade_signal`, `edge_score`, `our_prob`, `kalshi_implied`, `kelly` and `score_margin`. Older path, still served: GET /v1/signals/history Notes: The recent record, about the last day: the engine's rows are kept that long. `edge_score` is a probability, as on /v1/nba/edges (0.034 is 3.4 points). ### WS /v1/nba/ws/edges Tier: basic and above Live NBA edge stream over a WebSocket. Parameters: none Returns: `EDGE_UPDATE` messages with `type`, `edges`, `count` and `timestamp`, where `edges` holds the new live edge rows. The server polls every two seconds and sends a message only when new rows exist. Older path, still served: WS /v1/ws/edges Notes: Connect to wss://api.lazyedge.net/v1/nba/ws/edges and, within 10 seconds, send {"type": "AUTH", "key": ""}. The key travels in that message, not in a header. The text ping is answered with pong. Close codes: 4001 auth timeout, 4002 invalid auth message, 4003 auth service error, 4004 invalid key, 4005 tier below basic. ## $LAZY ### GET /v1/lazy/economy Tier: recon and above Snapshot of the $LAZY pick'em token economy. Parameters: none Returns: An object with `total_in`, `total_prizes`, `total_burned`, `total_rake`, `circulating_in_house`, `active_pot` and `updated_at`. Notes: Every figure derives from the one ledger. An empty economy returns true zeros. ### GET /v1/lazy/burns Tier: recon and above $LAZY burn history with a running total. Parameters: - `season` (query, integer, optional): Season filter. - `week` (query, integer, optional): Week filter. Returns: An object with `burns` (oldest first, each with `contest_id`, `season`, `week`, `amount_lazy`, `cumulative_lazy`, `status`, `tx_hash` and `at`), `total_burned_confirmed` and `total_burned_pending`. Notes: A burn without a `tx_hash` is `pending` and is not counted as confirmed. The running total and both totals cover every burn, whatever the filters. ### GET /v1/lazy/leaderboard Tier: recon and above Pick'em standings by week, season or all time. Parameters: - `scope` (query, string, optional, default season): week, season or alltime. - `season` (query, integer, optional): Season filter, for the week and season scopes. - `week` (query, integer, optional): Week filter, for the week scope. - `limit` (query, integer, optional, default 100): Rows to return, clamped to 1 to 500. Returns: An object with `scope` and `leaderboard`. Week rows carry `rank`, `player`, `display_name`, `points`, `correct`, `total`, `prize_lazy`, `season` and `week`; season rows carry `rank`, `player`, `display_name`, `total_points`, `weeks_played`, `weekly_wins` and `season`; alltime rows carry `player`, `display_name`, `total_points`, `weekly_wins`, `best_week_points`, `current_streak`, `longest_streak` and `lazy_won_total`. Notes: Week and season read off the entries, so a week still being played shows its points so far: week rows also carry `contest_id` and `final` (false while the contest is in play, when tied players share a rank), and season rows carry `live` (true while any of the player's contests is in play). A weekly win counts only once a contest settles. A player appears as `player`, a stable public reference, and a public name; no user id, email or wallet is included. An unrecognised scope reads as season. ### GET /v1/lazy/rewards Tier: recon and above Every pick'em reward: who won what, and whether it settled on chain. Parameters: - `season` (query, integer, optional): Season filter. - `contest_id` (query, integer, optional): Contest filter. - `status` (query, string, optional): Reward status filter, such as pending. Returns: An object with `rewards`, up to 500 newest first, each with `contest_id`, `season`, `player`, `display_name`, `rank`, `amount_lazy`, `status` and `paid_on_chain`. Notes: A pending reward has not paid out yet; `paid_on_chain` is true once it settled on chain. The transaction itself is not listed, because it names the winner's wallet. ### GET /v1/lazy/contests Tier: recon and above The pick'em contest schedule with pot, burn, prize configuration and entry count. Parameters: - `status` (query, string, optional): Contest status filter. - `season` (query, integer, optional): Season filter. Returns: An object with `contests`, up to 500 ordered by season and week descending, each with `id`, `season`, `week`, `season_type`, `format`, `status`, `entry_fee_lazy`, `pot_lazy`, `burned_lazy`, `burn_bps`, `rake_bps`, `prize` and `entries`. ### GET /v1/lazy/player/{ident} Tier: basic and above One pick'em player's public record: lifetime rollups, weekly history, $LAZY balance and ledger. Parameters: - `ident` (path, string, required): The player's public reference, the `player` field on the leaderboard, rewards and picks. Returns: An object with `player`, `display_name`, `lifetime` (total points, contests entered, weekly wins, best week, streaks, $LAZY won), `lazy_balance`, `weekly_history` and `ledger` (each movement with `delta_lazy`, `reason`, `ref`, `on_chain` and `at`). Notes: An unknown player returns 404. ### GET /v1/lazy/picks Tier: basic and above The field's picks for one contest, with the model probability at the time of each pick. Parameters: - `contest_id` (query, integer, required): The contest id. Returns: An object with `contest_id` and `picks`, each with `player`, `display_name`, `game_id`, `picked_side`, `confidence_rank`, `spread_at_pick`, `model_home_prob_at_pick`, `result` and `points_earned`. Notes: Picks stay sealed until the contest locks: before then the call returns 409, and an unknown contest returns 404. ## Account ### GET /v1/account/usage Tier: any valid key Usage for the calling key. Parameters: none Returns: An object with `key_prefix`, `tier`, `calls_today`, `rate_limit_per_min` and `created_at`. Notes: `calls_today` counts every authenticated call the key made since midnight US Eastern. `tier` and `rate_limit_per_min` are the ones the key works at now, which follow the plan on the account. ### POST /v1/account/rotate-key Tier: any valid key Rotate the calling key: a new key with the same tier and rate limit replaces it. Parameters: none Returns: An object with `api_key` (the new raw key), `new_key_id`, `rotated_from_key_id`, `expires_at` (null: the new key does not expire) and `previous_key_valid_until`. Notes: Keys do not expire on a calendar; they work while the account's plan is active. The old key keeps working for 24 hours so a running bot can switch without a gap, and the new key's raw value is returned only in this response. ### POST /v1/billing/apply_promo Tier: any valid key Apply a promo code to the subscription behind the calling key. Parameters: - `code` (body, string, required): Promo code, 2 to 50 characters, sent as a JSON body. Returns: An object with `success`, `discount_pct` and `message`. ## Guide ### GET /v1/skill Tier: public, no key The agent guide in markdown, written to hand to an agent: the endpoints, how to read the fields, and the conventions behind the numbers. Parameters: none Returns: The guide as text/markdown. Notes: Public, no key required. ## Frequently asked questions The answers on https://lazyedge.net/faq, in full. ### Getting started **What is LazyEdge?** A data terminal for sports prediction markets. For every NBA, NFL and MLB game we cover, our model's number sits beside the live price on Kalshi and Polymarket, before the game and while it is played. LazyEdge publishes data, not advice: it shows where our number and the market disagree, and every call is graded in public afterward. **Which sports are live?** The NBA, the NFL and MLB. Pick a sport from the sport switcher in the sidebar, or from the menu on a phone, and the navigation changes to that sport's screens. **Where should I start?** Open the Markets board for your sport. Each row is a game with the market price, our number and the gap between them. Click a game to open its full screen, where the live price, the ladders and the props sit together. **Is this financial advice?** No. LazyEdge is a research and data tool. Every probability, edge and sizing figure is a model output for information only. Prediction markets carry real financial risk, so never risk more than you can afford to lose. ### Plans and access **What does each plan include?** Quant Scout ($9.99 for seven days) and Observer Node ($29.99 a month, or a one time 30 days) open the full web terminal. The Quant Node ($49.99 a month) opens the web terminal and the API. Every plan covers every sport we run. **What can a free account see?** A free account plays the weekly NFL pick'em, reads the graded results and the blog, and manages its settings. The market screens need a plan, and a locked item in the navigation opens the plans page. **How do Lazy Lions holders get access?** Connect your wallet on the sign in page and sign one message. One Lazy Lion opens the full web terminal, and five or more open the API as well. Lions in wallets linked to your Lazy Lions profile count toward the total, and the holding is checked again every 30 days. **Who can use the API?** The API comes with the Quant Node plan ($49.99) or with five or more Lazy Lions. Quant Scout and Observer Node are web terminal plans and do not include it. ### Reading the numbers **What is the edge?** Our probability minus the market price, in percentage points. A price of 45 cents reads as 45 percent, so if our number is 52 percent the edge is +7 points. A positive edge means the contract costs less than our number says it is worth; a negative edge means it costs more. **What is fair value?** The price our model puts on a contract: its probability of paying out, written in cents. A fair value of 62 cents means our model gives the outcome a 62 percent chance. **Why is a number green or yellow?** The color shows how far apart our number and the market are. Green is a bigger gap, yellow a smaller one, and grey means little or no gap. On the NFL board, a spread or total turns yellow when our number is 1 point away from the line and green at 2.5 points, and a moneyline turns yellow at 2 percentage points and green at 5. The color only measures the size of the gap. It does not say who will win and it is not a recommendation, so read it together with the label beside it. **Is THE PLAY a recommendation?** No. THE PLAY is the row where our number sits furthest from the market on a main line for that game. For example, if the total line is 42.5 and our model projects 50 points, our number sits on the over side, which means 43 or more points in the game. The label beside it says what kind of gap it is, and what you do with the number is your call. **What do PRICE_GAP, RATING_Q and LEAN mean?** They say what kind of gap a row is. PRICE_GAP means our probability is at least 3 points above the price you would pay on the exchange, on a tight quote. RATING_Q means our number and the sportsbooks are far apart, 5 or more points on a total or 4 or more on a spread: a warning that our team ratings see the game very differently, not a play, and those rows have mostly graded worse, especially totals. LEAN is a smaller gap and NONE is little or no gap. TAIL_RUNG is a line away from the main line, and ROLE_Q is a prop where we read the player's role differently from the market. **Do the edges include fees?** The edge is the raw gap between our number and the price. Kalshi charges a fee of 0.07 times P times (1 minus P) per contract, about 1.75 cents at a 50 cent price and less toward either end, rounded up on the whole order. Where a screen shows net expected value, the fee is already taken out. **What does MODEL PENDING mean?** Our model has not priced that game yet, usually because the morning lines have not landed. Until it does, the screen leaves the fair value and the edge blank rather than show a placeholder. **What do the other status labels mean?** NO PRICE means the market has no live quote. LIVE BOOK PENDING means the book is not yet tracking that game, so no edge is shown against it. WAITING ON INJ REPORT marks a player who was on last week's injury report while this week's report is not out. ROLE QUESTION marks a prop where our model and the market read the player's role differently, which is a depth chart question and not a price. **What is the Kelly figure?** A sizing reference from the Kelly criterion: the share of a bankroll that the edge at that price would support. The terminal always shows a scaled down fraction of the full Kelly figure (the parlay builder shows a quarter of it). It describes the edge; it is not a recommendation to trade. ### Live games **How often do the live numbers update?** The market prices stream from Kalshi and Polymarket as they change. The NBA engine reprices on every play, the NFL engine about every ten seconds, and the MLB model about every 30 seconds. A price that has gone stale is marked and is never used for an edge. **What are the ladders?** Kalshi lists a game's spread and total as a ladder of lines, one contract per line. The ladder panels price every line with our probability beside the market's, so the gap shows on whichever line sits furthest from our number. **What are the player props?** Each player's projection beside the market line for points, rebounds, yards or receptions. During a game the projection updates from what the player has so far plus the rest of the game, and a flag marks a player whose live projection has crossed his line. **Do the buttons place trades?** No. A BUY or TRADE button opens that market on Kalshi or Polymarket in a new tab. Nothing is ever placed for you. ### The api and bots **What does the API carry?** The same numbers as the terminal: our number for every game, the exchange price beside it, how old that price is, the spread and total ladders, props and the graded results, for the NBA, the NFL and MLB. Every endpoint is listed at lazyedge.net/api-docs. **How do I get a key?** With the Quant Node plan or five or more Lazy Lions, open Settings, then API Access, and issue a key. Send it as Authorization: Bearer followed by the key on every request. The key is shown once, so store it safely. **Can a bot trade from the feed on its own?** Yes. Point your bot at the API, give it your own rules, and it can act on Kalshi or Polymarket while you do something else. A plain guide for AI agents is at lazyedge.net/llms.txt. **My bot only uses PRICE_GAP rows and sees none. Where are they?** Read every row of /v1/nfl/board/{game_id} and keep the ones whose label is PRICE_GAP. Two fields look similar and are not the same: signal on /v1/nfl/edges is the moneyline against the sportsbooks, and play_label names only the single headline row for each game. A bot that reads either one sees far fewer price gaps than the board carries. ### Results and pick'em **Where is the record?** Every call is graded in public after the game, misses included, at lazyedge.net/results. In play, our live number is graded against the Kalshi price at the same moment. **What is the Brier score?** A measure of how close a probability came to what happened: the average squared gap between the forecast and the result. Lower is closer. A coin flip at 50 percent scores 0.25 on every game. **What is the pick'em?** A weekly NFL contest. The free contest is open to everyone, and a paid pool is entered with $LAZY. Picks lock at each game's kickoff, and the standings are on the leaderboard.