--- title: "Contest standings with each entrant's entry count" method: GET path: "/api/v1/dfs/contests/{contest_id}/standings" tags: ["DFS"] --- # Contest standings with each entrant's entry count `GET /api/v1/dfs/contests/{contest_id}/standings` ## Request - Base URL: `https://api.stat-api.com` - URL: `https://api.stat-api.com/api/v1/dfs/contests/{contest_id}/standings` - Auth: HTTP bearer The contest's entries in finishing order, read from its lineup file: rank, username, points, payout, and how many entries the same user played. Two entries can share a rank; `row` is the 1-based position and is unique. `field` states what the field did (roster slots, pool size, C, the field's average lineup and the 3 chalk players), the same for every caller. Access (Frank 2026-09-27, the free flagship model; Frank 2026-10-18, top 100): each marquee contest (GET /api/v1/dfs/marquee: each week's NFL flagship contest, one per operator; each primetime night's single-game flagship, the biggest-prize guaranteed DraftKings pre-game Showdown contest of a Wednesday, Thursday or Monday night; and each NBA night's guaranteed contest with the biggest prize pool at an entry fee of $25 or less on each operator's main slate), free from season 2026 (NBA: from 2026-10-20), opens its first 100 standings rows to everyone, with or without a key (`access.plan = "flagship"`): those rows, and the full drill-down (every lineup, exposure row, name and value) of every user with an entry in them; no CSV. A row past 100 needs DFS access: such an answer carries the preview envelope `_metadata`, and a user with no entry in the first 100 rows answers `access.locked = true`, with or without a key. Any other contest needs a key or a login: no key answers 401 `key_required`. With a key but without DFS access, any other contest holds the first 5 rows, and only users with an entry in those rows open in the user lineups route (`open`). Such a capped answer carries the API's preview envelope `_metadata` (required_tier, message, total_actual_records), as every capped list does; a full answer carries none. CSV needs DFS access (402 otherwise). Each row also carries `stack`, the combo of that row's own lineup (a row is one lineup entry, not one user) on a classic NFL contest: QB, then the QB's teammates as WR, TE, RB (a count in front when more than 1, as 2WR), then BB for the bring-backs (2BB), joined by `/`, as QB/WR/RB/BB. It is null when the lineup has no stack and no bring-back, when a seat's position, team or game is unknown (never a partial answer), when the row is not open for the caller, in hide mode, and on every contest that is not a classic NFL contest. The row also carries `stack_team`, the team of that lineup's QB (the team the stack belongs to, such as DAL), set exactly when `stack` is set, and `bring_back_team`, the other team of the QB's game (such as PHI), set only when `stack` has a BB part. A page draws each team's logo from them. In the CSV the last three columns are `stack`, `stack_team` and `bring_back_team`. **202 Accepted (the lineup file is not loaded yet)**: A caller with a paid plan (not a trial key) who asks for a DraftKings contest that has started and has no lineup file gets `202` and no lineups, and the API queues a load of the file. A 202 costs no record. It carries `Retry-After` (seconds) and `Cache-Control: no-store`, and its body is JSON whatever `format` asks for: `{"status": "queued", "message": "The lineups of contest 196420231 are not loaded yet. A request to load them is queued. Expect them by the time in estimated_ready_at. Call again in 120 seconds.", "contest_id": 29647259, "external_id": 196420231, "requested_at": "2026-10-12T02:26:11Z", "estimated_ready_at": "2026-10-12T02:42:00Z", "retry_after_seconds": 120, "entry_count": 340}` `status` is `queued` (the loader will load the file; `estimated_ready_at` is the time to expect it) or `waiting_for_contest` (the contest has not finished; `estimated_ready_at` is then null). Call again after `retry_after_seconds`. A caller on a free plan, on a trial key or with no key never gets a 202: it keeps the answer it had before (a 200 with no lineups, or the preview). A contest that will never have a file answers `404` (`lineups_not_collected`: the loader does not collect lineups for this contest), `410` (`lineups_file_gone`: DraftKings no longer serves the file) or `503` (`lineups_not_loaded`: the loader gave up and support is informed), each in the usual error body. ## Path parameters - `contest_id` integer, required ## Query parameters - `limit` integer - `format` string - `from_row` integer - `user` string - `rank` integer ## Response `200` Contest standings with each entrant's entry count - DFSContestsStandingsDfsContestStandingsResponse - `_metadata` object, nullable: Sent only on a capped answer (fewer rows than exist for this caller): the plan that opens the rest. A full answer (DFS access, or a marquee contest of at most 100 entries) has no such key. A marquee contest of more than 100 entries carries it. - `message` string, required: What the plan opens. - `required_tier` string, required: pro. - `total_actual_records` integer, required: The contest's standings rows. - `access` object, required: What this caller may read. - `exposure_per_user` integer, nullable: Always null: no plan caps the exposure rows of an open user. - `exposure_total` integer, nullable: The user's exposure rows. Null on the standings route and when locked. - `full` boolean, required: True when every row and value is sent: DFS access only (a marquee contest stops at row 100). - `hidden_rows` integer, required: Exposure rows sent in hide mode (0 with DFS access and on the standings route). - `lineups_per_user` integer, nullable: Always null: no plan caps the lineups of an open user. - `lineups_total` integer, nullable: The user's lineups in the contest. Null on the standings route. - `locked` boolean, required: True when the plan withholds this response's exposure, lineup and seat rows. - `open_rows` integer, nullable: Standings rows whose users open: 5 on the Free plan, 100 on a marquee contest. Null with DFS access. - `plan` 'pro' | 'free' | 'flagship', required: "pro" with DFS access; "flagship" on a marquee contest for anyone else (GET /api/v1/dfs/marquee): the first 100 standings rows and every value of the users with an entry in them, no CSV; else "free" (the first 5 standings rows and hide mode). - `contest` object, required: The contest. - `contest_id` integer, required: Internal contest ID. - `date` string, nullable: Contest date (YYYY-MM-DD). - `entry_fee_cents` integer, required: Entry fee in cents. - `external_id` integer, required: Operator contest ID. - `game_type` string, nullable: Game type (classic or showdown). Null when the contest has no lineup file. - `has_lineups` boolean, required: False when the contest has no lineup file (the standings are empty). - `is_sampled` boolean, required: True when the lineup file holds a sample of the field. - `name` string, required: Contest name. - `operator` string, nullable: Operator name (DraftKings or FanDuel). - `paid_places` integer, nullable: Paid places. Null when the contest has no lineup file. - `prize_pool_cents` integer, required: Prize pool in cents. - `slate_id` integer, nullable: Internal slate ID. - `slate_name` string, nullable: Slate name. - `slots` string[], required: Roster slots in lineup order. - `sport` string, required: Sport code. - `stored_lineups` integer, required: Lineups stored in the lineup file (below total_entries in a sampled contest). - `total_entries` integer, required: Entries in the contest. - `field` object, nullable: What the field did, the same for every caller (the chalk is common knowledge). Null when the contest has no lineup file, or no stored lineup measured the field's ownership. - `avg_points_per_slot` number, double, required: C: the field's average points per roster slot = sum over the pool of (field_pct / 100 x fantasy_points), divided by roster_slots. A showdown player adds his flex share x base points and his captain share x captain points. - `chalk` object[], required: The 3 most-owned pool players, field_pct descending (a tie goes to the lower pool_id). - `fantasy_points` number, double, nullable: Fantasy points. Null when nothing measured them. - `field_pct` number, double, required: Share of the field's lineups with this player in percent. - `name` string, required: Player name. - `pool_id` integer, required: The player's ID in this contest's player pool. - `position` string, nullable: Position. Null when the pool row has no real position. - `salary` integer, nullable: Salary. Null when the operator price is unknown. - `team` string, required: Team abbreviation. - `field_avg_lineup` number, double, required: C x roster_slots: the field's average lineup points implied by ownership. - `players_owned` integer, required: Distinct pool players with a field share above 0 in any slot: the players the field actually used. - `pool_size` integer, required: Distinct players in the pool (a showdown player counts once). - `roster_slots` integer, required: Roster slots per lineup. - `from_row` integer, required: The row number (1-based) of the first standings row returned. - `returned` integer, required: Rows in this response. - `standings` object[], required: Entries in finishing order. - `bring_back_team` string, nullable: The team (such as PHI) of the bring-back seats of this row's own lineup: the other team of the QB's game. Set only when stack has a BB part. Null otherwise. - `open` boolean, required: True when this user opens in the user lineups route for this caller. - `payout_cents` integer, required: Payout in cents. - `points` number, double, required: Lineup fantasy points. - `rank` integer, required: Operator finishing rank (ties share a rank). - `row` integer, required: 1-based position in the standings (unique). - `stack` string, nullable: The combo of this row's own lineup: QB, then the QB's teammates as WR, TE, RB (a count in front when more than 1), then BB for the bring-backs, joined by /, as QB/WR/RB/BB or QB/2WR or QB/BB. Null when the lineup has no stack and no bring-back, when a seat's position, team or game is unknown, when the row is not open for this caller, in hide mode, and on every contest that is not a classic NFL contest. - `stack_team` string, nullable: The team (as in the pool, such as DAL) of the QB of this row's own lineup, the team the stack belongs to. Set exactly when stack is set. Null otherwise. - `user_best_rank` integer, nullable: The user's best rank in the contest. Null for user_unknown. - `user_entries` integer, nullable: The user's entries in the contest. Null for user_unknown. - `username` string, required: Entrant username. ## Other responses - `400`: Invalid contest ID; limit or format - `401`: No key, and not a free flagship (key_required): a free account opens every contest. The body names the contest (contest: contest_id, name, operator, date, total_entries, entry_fee_cents, prize_pool_cents; the public list's fields) and holds no standings, users or lineups - `402`: CSV requested without DFS access - `404`: Contest not found, or the loader does not collect lineups for this contest (lineups_not_collected). A contest without a lineup file answers 200 with has_lineups false, except for a caller with a paid plan on a DraftKings contest that has started (202, 404, 410 or 503, see the description) - `409`: The lineup file found belongs to a different operator contest - `410`: DraftKings no longer serves the lineup file of this contest (lineups_file_gone) - `503`: The loader gave up on the lineup file and support is informed (lineups_not_loaded, Retry-After 3600), or the request to load it could not be queued (lineups_request_failed, Retry-After 60) --- [API](https://skmtc.dev/stat-api/apis/sports-db-public-api.md) · [All operations](https://skmtc.dev/stat-api/apis/sports-db-public-api/llms.txt) · [OpenAPI document](https://skmtc.dev/stat-api/apis/sports-db-public-api/revisions/601ff9eaca3f?raw)