stat-api-com · Schema

DFSSlatesContestOwnership_DfsSlateContestOwnershipResponse

SportsDataAPIDFSFantasy

Properties

Name Type Description
_metadata object Where the values come from, and on a gated answer the plan that opens the rest.
access object What this caller sees.
across object The biggest contests side by side (the tool's Across contests tab).
as_of stringnull The newest write time of the served rows (ISO 8601, UTC). Null when no rows are served.
compare objectnull The values of the compare contest (`?compare=`, default `default_compare`), the same shape as `contest`. Null when the slate has no cash contest and none is asked.
contest objectnull The values of the selected contest (`?contest=`, default `default_contest`). Null without a contest.
contests array The lobby, the biggest prize pool first, then the largest max_entries, then the lowest id. With DFS access every contest of the slate with learned rows (no qualifier, no cancelled contest). Without it
default_compare integernull The contest each value compares with (Frank 2026-10-01): the biggest cash game (contest_type 1), by prize pool, then max_entries, then id. Null when the slate has no cash contest.
default_contest integernull The contest the tool opens on (Frank 2026-10-01): the biggest prize pool, the first of `contests`. Null without a contest.
default_group stringnull The group key the tool opened first before the lobby (Frank 2026-10-01, the largest GPP): the GPP group whose representative contest comes first by the representative order (paid, then the largest max
groups array The contest groups, cash first, then single-entry GPP, then multi-entry GPP, each by size tier. DFS access only; empty without it.
model stringnull The learned model label of the served rows (`stats.ownership_model`, e.g. single_hgb@19d12bd6d309). Null when no rows are served.
players array The players, highest peak total first (all with DFS access, else the 5 featured players or the 5-row preview). The order is the same for every caller, so the first 5 of a Pro answer are the featured p
reason stringnull Why `contests` and `groups` are empty (an in-game format, no STAT_API_LATEST source for the format, no learned rows yet, or a slate of another league than NFL, which this board does not serve). Null w
slate object The slate.
source string The projection source of every value (always STAT_API_LATEST).
View JSON Schema on GitHub

JSON Schema

stat-api-com-dfsslates-contest-ownership-dfs-slate-contest-ownership-response-schema.json Raw ↑
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://artifacts.apis.io/stat-api-com/json-schema/stat-api-com-dfsslates-contest-ownership-dfs-slate-contest-ownership-response-schema.json",
  "title": "DFSSlatesContestOwnership_DfsSlateContestOwnershipResponse",
  "x-generated": "2026-10-31",
  "x-method": "derived",
  "x-generator": "derive-json-schema.py",
  "x-source": "openapi/stat-api-com-openapi.json#/components/schemas/DFSSlatesContestOwnership_DfsSlateContestOwnershipResponse",
  "properties": {
    "_metadata": {
      "description": "Where the values come from, and on a gated answer the plan that opens the rest.",
      "properties": {
        "contest_ownership": {
          "description": "persisted (the stored rows of the learned model) when contests are served, else null.",
          "enum": [
            "persisted"
          ],
          "type": [
            "string",
            "null"
          ]
        },
        "message": {
          "description": "Sent only when players or contests are held back - what the plan opens.",
          "type": [
            "string",
            "null"
          ]
        },
        "required_tier": {
          "description": "Sent only when players or contests are held back - pro.",
          "type": [
            "string",
            "null"
          ]
        },
        "total_actual_records": {
          "description": "Sent only when players or contests are held back - the players on the board.",
          "format": "int64",
          "type": [
            "integer",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "access": {
      "description": "What this caller sees.",
      "properties": {
        "plan": {
          "description": "pro (every contest and player), primetime (every contest and player for every caller, on a TNF or MNF game's single-game slate), featured (the free contests with the 5 featured players, on a pre-game single-game slate) or preview (the free contests with 5 players).",
          "enum": [
            "pro",
            "primetime",
            "featured",
            "preview"
          ],
          "type": "string"
        },
        "players_shown": {
          "description": "Players in `players`.",
          "format": "int64",
          "type": "integer"
        },
        "players_total": {
          "description": "Players on the board.",
          "format": "int64",
          "type": "integer"
        }
      },
      "required": [
        "plan",
        "players_total",
        "players_shown"
      ],
      "type": "object"
    },
    "across": {
      "description": "The biggest contests side by side (the tool's Across contests tab).",
      "properties": {
        "contest_ids": {
          "description": "The contests in lobby order. With DFS access the 5 biggest GPP contests and the 5 biggest cash games (the page's three filters); without it the free contests, so the ids of `contests`.",
          "items": {
            "format": "int64",
            "type": "integer"
          },
          "type": "array"
        },
        "seats": {
          "description": "On a slate with boost seats: contest id to player id to seat (MVP, STAR, PRO, FLEX) to its share, for the same contests and players as `values`. Empty on any other slate.",
          "type": "object"
        },
        "values": {
          "description": "Contest id to player id to [captain_pct, flex_pct], for the open contests of `contest_ids` and the shown players with a value. A locked contest is left out.",
          "type": "object"
        }
      },
      "required": [
        "contest_ids",
        "values",
        "seats"
      ],
      "type": "object"
    },
    "as_of": {
      "description": "The newest write time of the served rows (ISO 8601, UTC). Null when no rows are served.",
      "type": [
        "string",
        "null"
      ]
    },
    "compare": {
      "description": "The values of the compare contest (`?compare=`, default `default_compare`), the same shape as `contest`. Null when the slate has no cash contest and none is asked.",
      "properties": {
        "actual_status": {
          "description": "The contest's actual ownership: `served` when its players carry it; `pro_required` when the caller's plan does not open the results of this contest (a marquee contest's are free to everyone); else the reason of GET /api/v1/dfs/contests/{contest_id}/ownership (`contest_not_final`, `league_not_computed`, `no_lineups`, `actuals_not_recomputed`). Null before the slate is final, and on a locked contest.",
          "type": [
            "string",
            "null"
          ]
        },
        "id": {
          "description": "dfs.contests id.",
          "format": "int64",
          "type": "integer"
        },
        "locked": {
          "description": "True when this caller may not see the contest's values. A locked contest sends no player and no position total.",
          "type": "boolean"
        },
        "players": {
          "description": "The shown players (all with DFS access, else the 5 featured players or the 5-row preview) with a value in the contest, the highest total first. Empty when locked.",
          "items": {
            "properties": {
              "actual_captain_pct": {
                "description": "After the contest is final: the field's actual captain (CPT or MVP) ownership of the player in this contest, in percent (GET /api/v1/dfs/contests/{contest_id}/ownership x 100; 0 when no lineup used the seat). Null on a classic contest, and while `actual_status` is not `served`.",
                "format": "double",
                "type": [
                  "number",
                  "null"
                ]
              },
              "actual_flex_pct": {
                "description": "After the contest is final: the field's actual FLEX ownership in percent; on a classic contest the player's one actual ownership. Null while `actual_status` is not `served`.",
                "format": "double",
                "type": [
                  "number",
                  "null"
                ]
              },
              "actual_total_pct": {
                "description": "After the contest is final: the field's actual ownership of the player in any seat, in percent. Null while `actual_status` is not `served`.",
                "format": "double",
                "type": [
                  "number",
                  "null"
                ]
              },
              "captain_pct": {
                "description": "Captain ownership in the contest, in percent (the stored projected_ownership of the captain row x 100).",
                "format": "double",
                "type": [
                  "number",
                  "null"
                ]
              },
              "captain_rank": {
                "description": "Rank of the captain ownership among all players of the contest (1 = most owned; ties share a rank).",
                "format": "int64",
                "type": [
                  "integer",
                  "null"
                ]
              },
              "captain_rate": {
                "description": "captain_pct / total_pct (0-1). Null when the total is 0 or a value is missing.",
                "format": "double",
                "type": [
                  "number",
                  "null"
                ]
              },
              "flex_pct": {
                "description": "FLEX ownership in the contest, in percent.",
                "format": "double",
                "type": [
                  "number",
                  "null"
                ]
              },
              "flex_rank": {
                "description": "Rank of the FLEX ownership among all players of the contest.",
                "format": "int64",
                "type": [
                  "integer",
                  "null"
                ]
              },
              "player_id": {
                "description": "nfl.players id (the `player_id` of `players`).",
                "format": "int64",
                "type": [
                  "integer",
                  "null"
                ]
              },
              "seats": {
                "description": "On a slate with boost seats (FanDuel's old single game: MVP 2x, STAR 1.5x, PRO 1.2x and FLEX), one entry per seat. Empty on any other slate.",
                "items": {
                  "properties": {
                    "pct": {
                      "description": "The seat's share, in percent. Null when the player has no row for the seat.",
                      "format": "double",
                      "type": [
                        "number",
                        "null"
                      ]
                    },
                    "seat": {
                      "description": "The seat (MVP, STAR, PRO or FLEX).",
                      "type": "string"
                    }
                  },
                  "required": [
                    "seat"
                  ],
                  "type": "object"
                },
                "type": "array"
              },
              "total_pct": {
                "description": "captain_pct + flex_pct, plus the STAR and PRO seats on a slate with boost seats (the sum of `seats`).",
                "format": "double",
                "type": [
                  "number",
                  "null"
                ]
              }
            },
            "required": [
              "seats"
            ],
            "type": "object"
          },
          "type": "array"
        },
        "position_totals": {
          "description": "The contest's ownership summed by real position over every player of the contest (also the players not shown), in percent. Captain sums to about 100, FLEX to about 100 x flex_seats. Both maps are empty when locked.",
          "properties": {
            "captain": {
              "description": "Real position (QB, RB, WR, TE, K, DST, D) to the sum of its captain ownership.",
              "type": "object"
            },
            "flex": {
              "description": "Real position to the sum of its FLEX ownership.",
              "type": "object"
            },
            "seats": {
              "description": "On a slate with boost seats: seat (MVP, STAR, PRO, FLEX) to real position to the sum of its share. Empty on any other slate.",
              "type": "object"
            }
          },
          "required": [
            "captain",
            "flex",
            "seats"
          ],
          "type": "object"
        },
        "reason": {
          "description": "Why the contest is locked, and the plan that opens it. Null when it is open.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "required": [
        "id",
        "locked",
        "players",
        "position_totals"
      ],
      "type": [
        "object",
        "null"
      ]
    },
    "contest": {
      "description": "The values of the selected contest (`?contest=`, default `default_contest`). Null without a contest.",
      "properties": {
        "actual_status": {
          "description": "The contest's actual ownership: `served` when its players carry it; `pro_required` when the caller's plan does not open the results of this contest (a marquee contest's are free to everyone); else the reason of GET /api/v1/dfs/contests/{contest_id}/ownership (`contest_not_final`, `league_not_computed`, `no_lineups`, `actuals_not_recomputed`). Null before the slate is final, and on a locked contest.",
          "type": [
            "string",
            "null"
          ]
        },
        "id": {
          "description": "dfs.contests id.",
          "format": "int64",
          "type": "integer"
        },
        "locked": {
          "description": "True when this caller may not see the contest's values. A locked contest sends no player and no position total.",
          "type": "boolean"
        },
        "players": {
          "description": "The shown players (all with DFS access, else the 5 featured players or the 5-row preview) with a value in the contest, the highest total first. Empty when locked.",
          "items": {
            "properties": {
              "actual_captain_pct": {
                "description": "After the contest is final: the field's actual captain (CPT or MVP) ownership of the player in this contest, in percent (GET /api/v1/dfs/contests/{contest_id}/ownership x 100; 0 when no lineup used the seat). Null on a classic contest, and while `actual_status` is not `served`.",
                "format": "double",
                "type": [
                  "number",
                  "null"
                ]
              },
              "actual_flex_pct": {
                "description": "After the contest is final: the field's actual FLEX ownership in percent; on a classic contest the player's one actual ownership. Null while `actual_status` is not `served`.",
                "format": "double",
                "type": [
                  "number",
                  "null"
                ]
              },
              "actual_total_pct": {
                "description": "After the contest is final: the field's actual ownership of the player in any seat, in percent. Null while `actual_status` is not `served`.",
                "format": "double",
                "type": [
                  "number",
                  "null"
                ]
              },
              "captain_pct": {
                "description": "Captain ownership in the contest, in percent (the stored projected_ownership of the captain row x 100).",
                "format": "double",
                "type": [
                  "number",
                  "null"
                ]
              },
              "captain_rank": {
                "description": "Rank of the captain ownership among all players of the contest (1 = most owned; ties share a rank).",
                "format": "int64",
                "type": [
                  "integer",
                  "null"
                ]
              },
              "captain_rate": {
                "description": "captain_pct / total_pct (0-1). Null when the total is 0 or a value is missing.",
                "format": "double",
                "type": [
                  "number",
                  "null"
                ]
              },
              "flex_pct": {
                "description": "FLEX ownership in the contest, in percent.",
                "format": "double",
                "type": [
                  "number",
                  "null"
                ]
              },
              "flex_rank": {
                "description": "Rank of the FLEX ownership among all players of the contest.",
                "format": "int64",
                "type": [
                  "integer",
                  "null"
                ]
              },
              "player_id": {
                "description": "nfl.players id (the `player_id` of `players`).",
                "format": "int64",
                "type": [
                  "integer",
                  "null"
                ]
              },
              "seats": {
                "description": "On a slate with boost seats (FanDuel's old single game: MVP 2x, STAR 1.5x, PRO 1.2x and FLEX), one entry per seat. Empty on any other slate.",
                "items": {
                  "properties": {
                    "pct": {
                      "description": "The seat's share, in percent. Null when the player has no row for the seat.",
                      "format": "double",
                      "type": [
                        "number",
                        "null"
                      ]
                    },
                    "seat": {
                      "description": "The seat (MVP, STAR, PRO or FLEX).",
                      "type": "string"
                    }
                  },
                  "required": [
                    "seat"
                  ],
                  "type": "object"
                },
                "type": "array"
              },
              "total_pct": {
                "description": "captain_pct + flex_pct, plus the STAR and PRO seats on a slate with boost seats (the sum of `seats`).",
                "format": "double",
                "type": [
                  "number",
                  "null"
                ]
              }
            },
            "required": [
              "seats"
            ],
            "type": "object"
          },
          "type": "array"
        },
        "position_totals": {
          "description": "The contest's ownership summed by real position over every player of the contest (also the players not shown), in percent. Captain sums to about 100, FLEX to about 100 x flex_seats. Both maps are empty when locked.",
          "properties": {
            "captain": {
              "description": "Real position (QB, RB, WR, TE, K, DST, D) to the sum of its captain ownership.",
              "type": "object"
            },
            "flex": {
              "description": "Real position to the sum of its FLEX ownership.",
              "type": "object"
            },
            "seats": {
              "description": "On a slate with boost seats: seat (MVP, STAR, PRO, FLEX) to real position to the sum of its share. Empty on any other slate.",
              "type": "object"
            }
          },
          "required": [
            "captain",
            "flex",
            "seats"
          ],
          "type": "object"
        },
        "reason": {
          "description": "Why the contest is locked, and the plan that opens it. Null when it is open.",
          "type": [
            "string",
            "null"
          ]
        }
      },
      "required": [
        "id",
        "locked",
        "players",
        "position_totals"
      ],
      "type": [
        "object",
        "null"
      ]
    },
    "contests": {
      "description": "The lobby, the biggest prize pool first, then the largest max_entries, then the lowest id. With DFS access every contest of the slate with learned rows (no qualifier, no cancelled contest). Without it only the free contests: the 5 biggest prize pools of the slate, in the same order. The page filters them All, Cash or GPP and shows 5 of each with DFS access.",
      "items": {
        "properties": {
          "entries": {
            "description": "Entries (entry_count) when last read.",
            "format": "int64",
            "type": "integer"
          },
          "entry_fee": {
            "description": "Entry fee, in dollars.",
            "format": "double",
            "type": "number"
          },
          "entry_type": {
            "description": "GPP only: single_entry (max_entries_per_user 1) or multi_entry. Null for cash.",
            "enum": [
              "single_entry",
              "multi_entry"
            ],
            "type": [
              "string",
              "null"
            ]
          },
          "external_id": {
            "description": "Operator contest ID.",
            "format": "int64",
            "type": "integer"
          },
          "group": {
            "description": "The key of the contest's group in `groups`.",
            "type": "string"
          },
          "id": {
            "description": "dfs.contests id (the `contest` and `compare` parameter).",
            "format": "int64",
            "type": "integer"
          },
          "kind": {
            "description": "cash (contest_type 1) or gpp, the same rule as the groups.",
            "enum": [
              "cash",
              "gpp"
            ],
            "type": "string"
          },
          "max_entries": {
            "description": "Maximum entries.",
            "format": "int64",
            "type": "integer"
          },
          "max_entries_per_user": {
            "description": "Maximum entries per user.",
            "format": "int64",
            "type": "integer"
          },
          "name": {
            "description": "Contest name.",
            "type": "string"
          },
          "open": {
            "description": "True when this caller may see the contest's values. Always true, since a caller without DFS access gets only the free contests.",
            "type": "boolean"
          },
          "prize_pool": {
            "description": "Prize pool, in dollars.",
            "format": "double",
            "type": "number"
          },
          "prize_rank": {
            "description": "The contest's place among every contest of the slate (1 = the biggest prize pool). A caller without DFS access sees the ranks of the free contests, 1-5 always among them.",
            "format": "int64",
            "type": "integer"
          },
          "same_terms": {
            "description": "How many other contests of the slate share the model's contest terms (archetype, max_entries, entry fee, max entries per user), so the same values.",
            "format": "int64",
            "type": "integer"
          },
          "tier": {
            "description": "Size tier by max_entries (the tiers of the groups).",
            "enum": [
              "2",
              "3-100",
              "101-1k",
              "1k-10k",
              "10k-100k",
              "100k+"
            ],
            "type": "string"
          }
        },
        "required": [
          "id",
          "external_id",
          "name",
          "prize_pool",
          "entry_fee",
          "entries",
          "max_entries",
          "max_entries_per_user",
          "kind",
          "tier",
          "group",
          "prize_rank",
          "same_terms",
          "open"
        ],
        "type": "object"
      },
      "type": "array"
    },
    "default_compare": {
      "description": "The contest each value compares with (Frank 2026-10-01): the biggest cash game (contest_type 1), by prize pool, then max_entries, then id. Null when the slate has no cash contest.",
      "format": "int64",
      "type": [
        "integer",
        "null"
      ]
    },
    "default_contest": {
      "description": "The contest the tool opens on (Frank 2026-10-01): the biggest prize pool, the first of `contests`. Null without a contest.",
      "format": "int64",
      "type": [
        "integer",
        "null"
      ]
    },
    "default_group": {
      "description": "The group key the tool opened first before the lobby (Frank 2026-10-01, the largest GPP): the GPP group whose representative contest comes first by the representative order (paid, then the largest max_entries, then entries, prize pool, id). Null without a GPP group.",
      "type": [
        "string",
        "null"
      ]
    },
    "groups": {
      "description": "The contest groups, cash first, then single-entry GPP, then multi-entry GPP, each by size tier. DFS access only; empty without it.",
      "items": {
        "properties": {
          "contest": {
            "description": "The representative contest, whose stored values the group shows: paid first, then the largest max_entries, then the most entries, then the largest prize pool, then the lowest id.",
            "properties": {
              "archetype": {
                "description": "The stored contest_archetype of its rows, else the model's rule.",
                "enum": [
                  "cash",
                  "gpp_single_entry",
                  "gpp_small_field",
                  "gpp_mme",
                  "baseline"
                ],
                "type": "string"
              },
              "contest_id": {
                "description": "dfs.contests id.",
                "format": "int64",
                "type": "integer"
              },
              "entries": {
                "description": "Entries (entry_count) when last read.",
                "format": "int64",
                "type": "integer"
              },
              "entry_fee_cents": {
                "description": "Entry fee in cents.",
                "format": "int64",
                "type": "integer"
              },
              "external_id": {
                "description": "Operator contest ID.",
                "format": "int64",
                "type": "integer"
              },
              "max_entries": {
                "description": "Maximum entries (the model's size feature).",
                "format": "int64",
                "type": "integer"
              },
              "max_entries_per_user": {
                "description": "Maximum entries per user.",
                "format": "int64",
                "type": "integer"
              },
              "name": {
                "description": "Contest name.",
                "type": "string"
              },
              "prize_pool_cents": {
                "description": "Prize pool in cents.",
                "format": "int64",
                "type": "integer"
              }
            },
            "required": [
              "contest_id",
              "external_id",
              "name",
              "entries",
              "max_entries",
              "max_entries_per_user",
              "entry_fee_cents",
              "prize_pool_cents",
              "archetype"
            ],
            "type": "object"
          },
          "contest_count": {
            "description": "Contests of the slate in this group that have learned rows.",
            "format": "int64",
            "type": "integer"
          },
          "entry_type": {
            "description": "GPP only: single_entry (max_entries_per_user 1) or multi_entry. Null for cash.",
            "enum": [
              "single_entry",
              "multi_entry"
            ],
            "type": [
              "string",
              "null"
            ]
          },
          "key": {
            "description": "The group key: kind, entry type (GPP only) and size tier, e.g. cash:3-100, gpp:single_entry:1k-10k, gpp:multi_entry:100k+.",
            "type": "string"
          },
          "kind": {
            "description": "cash or gpp, as the operator labels the contest (Frank 2026-10-01): contest_type 1 is cash, every other type gpp. A DraftKings Triple Up (contest_type 0) is gpp, although the model's archetype calls it cash. Only a contest without a contest_type falls back to the model's name rule (Double Up, 50/50, H2H, Triple Up).",
            "enum": [
              "cash",
              "gpp"
            ],
            "type": "string"
          },
          "position_totals": {
            "description": "The group's ownership summed by real position, captain and FLEX apart, over every player of the representative contest (also the players a preview does not list). Captain sums to about 100, FLEX to about 100 x flex_seats.",
            "items": {
              "properties": {
                "captain_pct": {
                  "description": "Sum of the captain ownership, in percent.",
                  "format": "double",
                  "type": "number"
                },
                "flex_pct": {
                  "description": "Sum of the FLEX ownership, in percent.",
                  "format": "double",
                  "type": "number"
                },
                "position": {
                  "description": "Real position (QB, RB, WR, TE, K, DST on DraftKings, D on FanDuel).",
                  "type": "string"
                },
                "seats": {
                  "description": "On a slate with boost seats, each seat's sum (MVP, STAR, PRO, FLEX). Empty on any other slate.",
                  "items": {
                    "properties": {
                      "pct": {
                        "description": "The seat's share, in percent. Null when the player has no row for the seat.",
                        "format": "double",
                        "type": [
                          "number",
                          "null"
                        ]
                      },
                      "seat": {
                        "description": "The seat (MVP, STAR, PRO or FLEX).",
                        "type": "string"
                      }
                    },
                    "required": [
                      "seat"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                }
              },
              "required": [
                "position",
                "captain_pct",
                "flex_pct",
                "seats"
              ],
              "type": "object"
            },
            "type": "array"
          },
          "size_tier": {
            "description": "Size tier by max_entries.",
            "enum": [
              "2",
              "3-100",
              "101-1k",
              "1k-10k",
              "10k-100k",
              "100k+"
            ],
            "type": "string"
          }
        },
        "required": [
          "key",
          "kind",
          "size_tier",
          "contest_count",
          "contest",
          "position_totals"
        ],
        "type": "object"
      },
      "type": "array"
    },
    "model": {
      "description": "The learned model label of the served rows (`stats.ownership_model`, e.g. single_hgb@19d12bd6d309). Null when no rows are served.",
      "type": [
        "string",
        "null"
      ]
    },
    "players": {
      "description": "The players, highest peak total first (all with DFS access, else the 5 featured players or the 5-row preview). The order is the same for every caller, so the first 5 of a Pro answer are the featured players.",
      "items": {
        "properties": {
          "actual": {
            "description": "The player's actual result, once the stats services hold one (null before his game).",
            "properties": {
              "fantasy_pts": {
                "description": "The fantasy points he scored on the slate's scoring (GET /api/v1/dfs/player_stats `fantasy_pts` of his FLEX row).",
                "format": "double",
                "type": [
                  "number",
                  "null"
                ]
              },
              "minutes": {
                "description": "The minutes he played, on an NBA slate (GET /api/v1/nba/game_player_stats `minutes`). Null on NFL.",
                "format": "double",
                "type": [
                  "number",
                  "null"
                ]
              }
            },
            "type": [
              "object",
              "null"
            ]
          },
          "by_group": {
            "description": "The player's values in each group, in the order of `groups`. Empty without DFS access.",
            "items": {
              "properties": {
                "captain_pct": {
                  "description": "Captain ownership in the representative contest, in percent (the stored projected_ownership of the captain row x 100).",
                  "format": "double",
                  "type": [
                    "number",
                    "null"
                  ]
                },
                "captain_rank": {
                  "description": "Rank of the captain ownership among all players of the group (1 = most owned; ties share a rank).",
                  "format": "int64",
                  "type": [
                    "integer",
                    "null"
                  ]
                },
                "captain_rate": {
                  "description": "captain_pct / total_pct (0-1). Null when the total is 0 or a value is missing.",
                  "format": "double",
                  "type": [
                    "number",
                    "null"
                  ]
                },
                "flex_pct": {
                  "description": "FLEX ownership in the representative contest, in percent.",
                  "format": "double",
                  "type": [
                    "number",
                    "null"
                  ]
                },
                "flex_rank": {
                  "description": "Rank of the FLEX ownership among all players of the group.",
                  "format": "int64",
                  "type": [
                    "integer",
                    "null"
                  ]
                },
                "key": {
        

# --- truncated at 32 KB (48 KB total) ---
# Full source: https://artifacts.apis.io/stat-api-com/json-schema/stat-api-com-dfsslates-contest-ownership-dfs-slate-contest-ownership-response-schema.json

Work with this as data

Every JSON Schema here is available over the APIs.io API and to AI agents over MCP.

MCP server

One button, every client — Claude, Cursor, VS Code and the rest.

https://apis.io/mcp

Tools for schemas

4 MCP tools reach this
  • find_json_schemasBrowse and filter every JSON Schema in the catalog.
  • apis_io_searchSTART HERE — APIs, providers and tags for one query, each with its total.
  • resolveTurn a domain, URL or GitHub org into the provider it belongs to.
  • find_cohortsEvery scored population of providers in the catalog.
All 92 tools →

Call it yourself

curl for this page
This JSON Schema
curl "https://apis.io/api/v1/json-schemas/stat-api-com-dfsslates-contest-ownership-dfs-slate-contest-ownership-response"
All schemas
curl "https://apis.io/api/v1/json-schemas?limit=25"

Discovery needs no key. Ratings and market analysis are Pro.

Get an API key

Free tier, no form to fill in. Signing in shares your email address with us — we store it to create your key and to recognise you if you sign in with another provider. See our Privacy Policy and Terms.

A second provider on the same verified email joins the account you already have.