Live Tennis API · Schema

PlayerStats

GET /players/{playerId}/stats (added 2026-10-22). `records` is PRO; `serve_return` is ULTRA and absent, not null, below ULTRA.

CompanySportsDataReal-TimeTennis

Properties

Name Type Description
player object
window object The window applied, UTC.
filters object
records object
serve_return object
meta object
View JSON Schema on GitHub

JSON Schema

livetennisapi-com-player-stats-schema.json Raw ↑
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://artifacts.apis.io/livetennisapi-com/json-schema/livetennisapi-com-player-stats-schema.json",
  "title": "PlayerStats",
  "description": "GET /players/{playerId}/stats (added 2026-10-22). `records` is PRO; `serve_return` is ULTRA and absent, not null, below ULTRA.",
  "x-generated": "2026-11-04",
  "x-method": "derived",
  "x-generator": "derive-json-schema.py",
  "x-source": "openapi/livetennisapi-com-players-api-openapi.yml#/components/schemas/PlayerStats",
  "type": "object",
  "properties": {
    "player": {
      "type": "object",
      "properties": {
        "id": {
          "type": "integer"
        },
        "name": {
          "type": "string"
        }
      }
    },
    "window": {
      "type": "object",
      "description": "The window applied, UTC.",
      "properties": {
        "from": {
          "type": "string",
          "format": "date-time"
        },
        "to": {
          "type": "string",
          "format": "date-time"
        }
      }
    },
    "filters": {
      "type": "object",
      "properties": {
        "surface": {
          "type": [
            "string",
            "null"
          ]
        },
        "level": {
          "type": [
            "string",
            "null"
          ]
        },
        "last": {
          "type": "integer"
        }
      }
    },
    "records": {
      "$ref": "#/$defs/PlayerRecords"
    },
    "serve_return": {
      "$ref": "#/$defs/PlayerServeReturn"
    },
    "meta": {
      "type": "object",
      "properties": {
        "generated_at": {
          "type": "string",
          "format": "date-time"
        },
        "note": {
          "type": "string",
          "description": "States what the aggregates are computed from and where the 1968–2022 equivalent lives."
        }
      }
    }
  },
  "$defs": {
    "PlayerPlayedRecord": {
      "type": "object",
      "properties": {
        "played": {
          "type": "integer"
        },
        "won": {
          "type": "integer"
        },
        "lost": {
          "type": "integer"
        },
        "win_pct": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    },
    "PlayerRecentMatch": {
      "type": "object",
      "properties": {
        "match_id": {
          "type": "integer"
        },
        "date": {
          "type": [
            "string",
            "null"
          ],
          "format": "date"
        },
        "scheduled_time": {
          "type": [
            "string",
            "null"
          ],
          "format": "date-time"
        },
        "tournament_id": {
          "type": [
            "string",
            "null"
          ]
        },
        "tournament": {
          "type": [
            "string",
            "null"
          ]
        },
        "round": {
          "type": [
            "string",
            "null"
          ]
        },
        "round_code": {
          "type": [
            "string",
            "null"
          ]
        },
        "surface": {
          "type": [
            "string",
            "null"
          ]
        },
        "indoor": {
          "type": [
            "boolean",
            "null"
          ]
        },
        "level": {
          "type": [
            "string",
            "null"
          ]
        },
        "opponent": {
          "type": [
            "object",
            "null"
          ],
          "description": "The other side of the match. `name` is null when the opponent id is not on the roster read. The whole object is null when the match row holds no opponent id.",
          "properties": {
            "id": {
              "type": "integer"
            },
            "name": {
              "type": [
                "string",
                "null"
              ]
            }
          }
        },
        "won": {
          "type": "boolean"
        },
        "outcome": {
          "type": "string",
          "enum": [
            "completed",
            "retired",
            "walkover",
            "default"
          ]
        },
        "score": {
          "type": [
            "object",
            "null"
          ],
          "description": "The final score turned round to this player — sets [player, opponent], games [[player per set], [opponent per set]] — from the row the match object serves. Null when no score row is held.",
          "properties": {
            "sets": {
              "type": "array",
              "items": {
                "type": [
                  "integer",
                  "null"
                ]
              }
            },
            "games": {
              "type": "array",
              "description": "The per-set lists through the match object's own projection, exactly as `GET /matches/{matchId}` serves them: a deciding match tiebreak the row keeps in `points` is rendered into the deciding-set games slot (since 2026-10-22; before that the stored lists were read raw). Otherwise passed through as held and not re-validated. A side whose list is unreadable is `[]`. The values are integers in practice, but nothing on this path coerces them, so decode each one as a nullable integer.",
              "items": {
                "type": "array",
                "items": {
                  "type": [
                    "integer",
                    "null"
                  ]
                }
              }
            }
          }
        }
      }
    },
    "PlayerRecords": {
      "type": "object",
      "description": "The results-based record (PRO). W/L blocks count matches with a published winner and an outcome of completed, retired, walkover or default.",
      "properties": {
        "overall": {
          "$ref": "#/$defs/PlayerWinLoss"
        },
        "last_12_months": {
          "description": "W/L over the 365 days ending at the window's `to`, whatever `from` says. With the default window it equals `overall`. With an older `to` it is the year before that date, and it can count matches that fall outside a narrower `from`. `surface` and `level` filters apply to it as to every block.",
          "allOf": [
            {
              "$ref": "#/$defs/PlayerWinLoss"
            }
          ]
        },
        "by_surface": {
          "type": "object",
          "description": "Keyed hard, clay, grass, unknown — the match surface.",
          "additionalProperties": {
            "$ref": "#/$defs/PlayerWinLoss"
          }
        },
        "by_venue": {
          "type": "object",
          "description": "Keyed indoor, outdoor, unknown — the match indoor flag.",
          "additionalProperties": {
            "$ref": "#/$defs/PlayerWinLoss"
          }
        },
        "by_level": {
          "type": "object",
          "description": "Keyed by the match tour (atp, wta, challenger, itf, juniors) or unknown.",
          "additionalProperties": {
            "$ref": "#/$defs/PlayerWinLoss"
          }
        },
        "by_season": {
          "type": "object",
          "description": "Keyed by the UTC calendar year of the scheduled start.",
          "additionalProperties": {
            "$ref": "#/$defs/PlayerWinLoss"
          }
        },
        "sets": {
          "type": "object",
          "description": "Over completed matches whose final score is complete and legal and agrees with the published winner. Retirements, walkovers, defaults and incomplete scores are counted out by name in sample.excluded.",
          "properties": {
            "sample": {
              "type": "object",
              "properties": {
                "matches": {
                  "type": "integer"
                },
                "excluded": {
                  "type": "object",
                  "properties": {
                    "retired": {
                      "type": "integer"
                    },
                    "walkover": {
                      "type": "integer"
                    },
                    "default": {
                      "type": "integer"
                    },
                    "score_incomplete": {
                      "type": "integer"
                    }
                  }
                }
              }
            },
            "tiebreaks": {
              "$ref": "#/$defs/PlayerPlayedRecord"
            },
            "deciding_sets": {
              "$ref": "#/$defs/PlayerPlayedRecord"
            },
            "after_winning_first_set": {
              "$ref": "#/$defs/PlayerSplitRecord"
            },
            "after_losing_first_set": {
              "$ref": "#/$defs/PlayerSplitRecord"
            },
            "comebacks": {
              "type": "object",
              "description": "Matches in which the player lost at least one set, and how many of them they won.",
              "properties": {
                "matches_lost_a_set": {
                  "type": "integer"
                },
                "won": {
                  "type": "integer"
                },
                "win_pct": {
                  "type": [
                    "number",
                    "null"
                  ]
                }
              }
            },
            "sets": {
              "type": "object",
              "properties": {
                "won": {
                  "type": "integer"
                },
                "lost": {
                  "type": "integer"
                },
                "win_pct": {
                  "type": [
                    "number",
                    "null"
                  ]
                }
              }
            }
          }
        },
        "withdrawals": {
          "type": "object",
          "description": "Per outcome, matches this player did not finish (given) and matches the opponent did not finish (received).",
          "properties": {
            "retired": {
              "$ref": "#/$defs/PlayerWithdrawalCount"
            },
            "walkover": {
              "$ref": "#/$defs/PlayerWithdrawalCount"
            },
            "default": {
              "$ref": "#/$defs/PlayerWithdrawalCount"
            }
          }
        },
        "excluded": {
          "type": "object",
          "description": "Matches in the window left out of every record, by reason.",
          "properties": {
            "not_singles": {
              "type": "integer"
            },
            "unresolved": {
              "type": "integer"
            },
            "abandoned": {
              "type": "integer"
            },
            "no_published_winner": {
              "type": "integer"
            }
          }
        },
        "recent": {
          "type": "array",
          "description": "The last `last` matches in the window, newest first.",
          "items": {
            "$ref": "#/$defs/PlayerRecentMatch"
          }
        }
      }
    },
    "PlayerServeReturn": {
      "type": "object",
      "description": "ULTRA only; absent below. Measured per-match statistics summed over the player's completed matches in the window. Each field carries the matches it was summed over.",
      "properties": {
        "matches": {
          "type": "integer"
        },
        "matches_with_stats": {
          "type": "integer",
          "description": "Matches whose measured statistics reach the final (the `freshness.measured.complete` judgement of GET /matches/{matchId}/statistics: the stamped per-set games against the served final, set by set, a deciding match tiebreak written as its points in one and as one game in the other counted as the same set). Only these matches are summed."
        },
        "matches_incomplete": {
          "type": "integer",
          "description": "Matches whose measured statistics are held but stop short of the final, or cannot be judged against it. Left out of every sum."
        },
        "serve": {
          "type": "object",
          "properties": {
            "aces": {
              "$ref": "#/$defs/PlayerStatCount"
            },
            "double_faults": {
              "$ref": "#/$defs/PlayerStatCount"
            },
            "first_serve_in": {
              "$ref": "#/$defs/PlayerStatRatio"
            },
            "first_serve_points_won": {
              "$ref": "#/$defs/PlayerStatRatio"
            },
            "second_serve_points_won": {
              "$ref": "#/$defs/PlayerStatRatio"
            },
            "service_games_won": {
              "$ref": "#/$defs/PlayerStatRatio"
            },
            "break_points_saved": {
              "$ref": "#/$defs/PlayerStatRatio"
            }
          }
        },
        "return": {
          "type": "object",
          "properties": {
            "first_serve_return_points_won": {
              "$ref": "#/$defs/PlayerStatRatio"
            },
            "second_serve_return_points_won": {
              "$ref": "#/$defs/PlayerStatRatio"
            },
            "return_games_won": {
              "$ref": "#/$defs/PlayerStatRatio"
            },
            "break_points_converted": {
              "$ref": "#/$defs/PlayerStatRatio"
            }
          }
        }
      }
    },
    "PlayerSplitRecord": {
      "type": "object",
      "properties": {
        "matches": {
          "type": "integer"
        },
        "won": {
          "type": "integer"
        },
        "lost": {
          "type": "integer"
        },
        "win_pct": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    },
    "PlayerStatCount": {
      "type": "object",
      "description": "A summed count. `total` and `per_match` are null with matches 0 when no match carried the field.",
      "properties": {
        "total": {
          "type": [
            "integer",
            "null"
          ]
        },
        "matches": {
          "type": "integer"
        },
        "per_match": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    },
    "PlayerStatRatio": {
      "type": "object",
      "description": "A sum of numerators over a sum of denominators. All null with matches 0 when no match carried the field.",
      "properties": {
        "numerator": {
          "type": [
            "integer",
            "null"
          ]
        },
        "denominator": {
          "type": [
            "integer",
            "null"
          ]
        },
        "pct": {
          "type": [
            "number",
            "null"
          ]
        },
        "matches": {
          "type": "integer"
        }
      }
    },
    "PlayerWinLoss": {
      "type": "object",
      "properties": {
        "matches": {
          "type": "integer"
        },
        "wins": {
          "type": "integer"
        },
        "losses": {
          "type": "integer"
        },
        "win_pct": {
          "type": [
            "number",
            "null"
          ],
          "description": "Percent with one decimal; null when matches is 0."
        }
      }
    },
    "PlayerWithdrawalCount": {
      "type": "object",
      "properties": {
        "given": {
          "type": "integer"
        },
        "received": {
          "type": "integer"
        }
      }
    }
  }
}

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/livetennisapi-com-player-stats"
All schemas
curl "https://apis.io/api/v1/json-schemas?limit=25"

Calls without X-API-Key need no key. Calls with it need a paid plan — get a key.

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.