GameScorekeeper

Overview

Welcome to the GameScorekeeper API documentation

This document is intended as a guide and look-up reference for developers creating apps and sites powered by the GameScorekeeper APIs.

The GameScorekeeper APIs provide data from Esports matches. There are currently two APIs available that a user or app can connect to in order to retrieve data:

  • REST API: The REST API provides access to all data on past and future fixtures, for example final results of matches already played and start times of scheduled matches.
  • Live Data API: The live API makes it possible to establish live WebSocket connections with the GameScorekeeper data platform to retrieve real-time results and stats from fixtures currently being played.

Connecting to the APIs requires an authentication token, which is obtained by creating an account with GameScorekeeper. Please contact us at sales@gamescorekeeper.com to create an account.

Terminology

Timestamps

All timestamps are Unix-timestamps in milliseconds.

Sport

A sport is an Esport, ie. a video game, supported by the GameScorekeeper data platform.

Examples

  • Counter-Strike: Global Offensive
  • Heroes of the Storm
  • Dota 2
  • League of Legends

Competition

A competition is a group of fixtures. Competitions includes both tournaments, where matches are usually played at the same venue over a short time span, and leagues, where matches can be played over a longer time span in a range of geographical locations.

Examples

  • Blast Pro Series 2017
  • HGC Spring 2018
  • The International 2017
  • 2018 NA LCS Spring Split

Fixture

A fixture, also known as a match, represents a series of one or more games played between two or more participants.

A fixture is part of a competition.

Each fixture has a scheduled start time. This is the planned start time for the fixture according to the fixture organiser. Actual start time may differ from the scheduled start time.

Examples

  • Astralis vs North in Blast Pro Series 2017
  • Fnatic vs Misfits in HGC Spring 2018
  • Team Liquid vs Invictus Gaming in The International 2017
  • Cloud9 vs Counter Logic Gaming in 2018 NA LCS Spring Split

Participant

A participant represents a team, player or other entity participating in a fixture. Though participants are most commonly esports teams, some sports and events feature 1v1 matches and national, regional or all-star teams.

Participants may have individual handicaps in any given fixture.

Examples

  • Team Liquid
  • Life
  • Brazil
  • All-Stars West

REST API https://api.gamescorekeeper.com

The REST API is used to retrieve upcoming and completed fixtures. Use Authorization : Bearer <Your Token> in the header of a request. A missing or invalid authorization header will result in a status 401.

The base URL for all REST API requests is https://api.gamescorekeeper.com. Each endpoints lists its path as part of the header.

Get Fixture /v1/fixtures/{id}

Get a specific fixture by ID.

Parameters

Path Parameters

fixtureId
The fixture ID.
long

Responses

Response Schema

id
The fixture ID.
integer
tie
Whether this fixture ended as a tie. Optional.
boolean
winnerId
ID of the winning participant. Optional.
integer
status
Valid values: Scheduled, Started, Ended, Cancelled.
string
format
name
The name of the format
string
FormatDTO
competition
id
The id of the competition
integer
name
The name of the competition
string
CompetitionDTO
scheduledStartTime
Timestamp for when this fixture is scheduled to start.
timestamp
startTime
Timestamp for when this fixture actually started. Can be null.
timestamp
endTime
Timestamp for when this fixture ended. Can be null.
timestamp
sport
alias
The id of the sport
integer
name
The name of the sport
string
SportSummaryDTO
participants
id
The id of the participant.
integer
name
The name of the participant.
string
score
Current score for this participant in the fixture - including handicap.
integer
scoreWithoutHandicap
Current score for this participant in the fixture - not including handicap.
integer
handicap
The handicap of the participant in this specific fixture. Is added to scoreWithoutHandicap to determine final score.
integer
Array of ParticipantDTO
links
rel
The link relation. Allowed values: liveapi.
integer
link
A URI pointing to the relation.
uri
Array of LinkDTO
maps
A list of objects with data for each map played in the fixture. Map schema is game specific, see below. Can be null.
Array of maps

Map Schemas

CSGO Map

status
Status of the map. Valid values: Live, Ended
string
endTime
Timestamp for when the map ended. Can be null.
timestamp
mapName
Name of the map.
string
winnerId
ID of the participant that won the map. Can be null.
long
mapNumber
The map's number in within the fixture.
integer
startTime
Timestamp for when the map was started.
timestamp
roundScores
id
ID of the participant.
long
roundsWon
How many rounds the participant has won in this map.
int
Array of RoundScore

Example /v1/fixtures/2

    List Fixtures /v1/fixtures?query

    Gets all fixtures fitting the parameters specified.

    Parameters

    Query Parameters

    sport
    The alias of the sport to filter on (use the List Sports endpoint to get alias').
    Optional; includes all sports if missing.
    string
    competitionId
    The ID of the competition to filter on (use the List Competitions endpoint to get IDs).
    Optional; includes all competitions if missing.
    string
    from
    The start of the period to return fixtures for.
    The value can either be a Unix timestamp in milliseconds or a string of the form yyyy-mm-dd (e.g. 2017-12-31 = Dec. 31 2017).
    Optional; defaults to midnight today in UTC.
    string or number
    to
    The end of the period to return fixtures for.
    The value can either be a Unix timestamp in milliseconds or a string of the form yyyy-mm-dd (e.g. 2017-12-31 = Dec. 31 2017).
    Optional; defaults to midnight tomorrow in UTC.
    string or integer
    page
    The page to start from.
    Optional; defaults to 1.
    integer
    pageCount
    Number of results per page.
    Optional; defaults to 200.
    integer
    status
    Status of the fixtures to return.
    Optional; Valid values: Scheduled, Started, Ended, Cancelled.
    string

    Responses

    Response Schema

    fixtures
    A list of fixtures matching the search criteria.
    id
    The id of the fixture.
    integer
    tie
    Whether this fixture ended as a tie. Optional.
    boolean
    winnerId
    ID of the winning participant. Optional.
    integer
    status
    Valid values: Scheduled, Started, Ended, Cancelled.
    string
    format
    name
    Name of the format
    string
    competition
    CompetitionSummaryDTO
    id
    ID of the competition.
    integer
    name
    Name of the competition.
    string
    scheduledStartTime
    Timestamp for when this fixture is scheduled to start.
    timestamp
    startTime
    Timestamp for when this fixture actually started.
    timestamp
    endTime
    Timestamp for when this fixture ended.
    timestamp
    sport
    SportSummaryDTO
    alias
    Alias uniquely identifying the sport.
    integer
    name
    Name of the sport.
    string
    participants
    id
    The id of the participant.
    integer
    name
    The name of the participant.
    string
    score
    Current score for this participant in the fixture - including handicap.
    integer
    scoreWithoutHandicap
    Current score for this participant in the fixture - not including handicap.
    integer
    handicap
    The handicap of the participant in this specific fixture. Is added to scoreWithoutHandicap to determine final score.
    integer
    Array of ParticipantDTO
    links
    rel
    The link relation. Allowed values: liveapi.
    integer
    link
    A URI pointing to the relation.
    uri
    Array of LinkDTO
    Array of FixtureDTO
    totalCount
    The total number of fixtures matching the query.
    integer

    Example /v1/fixtures?page=1&pageCount=2

      List Sports /v1/sports

      Gets all supported sports.

      Responses

      Response Schema

      sports
      SportDTO
      name
      Name of the sport.
      string
      alias
      Alias of the sport.
      string

      Example /v1/sports

        List Competitions /v1/competitions?query

        Gets all competitions or optinally all competition for a given sport.

        Query Parameters

        sport
        The sport alias to filter on.
        string

        Responses

        Response Schema

        competitions
        Array of CompetitionDTO
        id
        ID of the competition.
        integer
        name
        Name of the competition.
        string
        sportAlias
        Alias of the sport this competition is held for.
        string
        startDate
        The timestamp for when the competition starts. Can be null.
        timestamp
        endDate
        The timestamp for when the competition ends. Can be null.
        timestamp

        Example /v1/competitions?sport=HotS

          Live Data API wss://api.gamescorekeeper.com/v1/liveapi/{fixtureId}

          The Live Data API uses WebSockets to push live data to clients. Each connection to the API can deliver data for one specific fixture.

          URIs for Live Data WebSockets are based on fixture IDs as such:

              wss://host/v1/liveapi/<fixtureId>
                                  

          When connecting to the WebSocket, after having authenticated, all events from the start of the fixture are sent. This means that connecting late will not result in a loss of information, only its delay.

          Protocol

          The protocol of the Live Data API is simple. Data is sent in “messages” with the following structure:

              {
                  "type": "<the type of message being sent>",
                  "payload"?: <object>
              }

          The types are explained below along with a description of the specific payloads.

          The time in timestamp is when the message was originally generated. This means that the timestamp of a specific message will be the same regardless of when you connect to the WebSocket.

          Authentication

          When connecting to a Live Data WebSocket you will receive an authentication message like this:

              {
                  "type": "auth"
              }

          And to authenticate you must respond with your token like this:

              {
                  "token": "<your bearer token>"
              }

          The bearer token to use is the same as when connecting to the REST API.

          Once authenticated you will begin receiving messages representing game data for the specified fixture once it starts. No data is received for an unstarted fixture.

          Example

          • {
          • "type": "auth"
          • }

          Fixture Started

          Frames with type fixture_started represent that the fixture has begun:

              {
                  "type": "fixture_started",
                  "payload": {
                      "snapshotNumber": <integer>,
                      "fixtureId": <integer>,
                      "timestamp": <timestamp>,
                      "participants": [
                          {
                              "id": <integer>
                          },
                          {
                              "id": <integer>
                          }
                      ],
                  }
              }
              

          Example

            Property Changed

            Frames with type property_changed represent that one or more in-game properties have changed. Which properties depend entirely on the game, and can be anything from number of kills, team level or amount of gold to whether or not a tower has been taken over or if a (de)buff is applied. The format is as follows:

                {
                    "type": "property_changed",
                    "payload": {
                        "changes": {
                            <partial game-specific object>
                        }
                        "snapshotNumber": <integer>,
                        "fixtureId": <integer>,
                        "timestamp": <timestamp>
                    }
                }
            

            Example (HotS property changed)

              Score Changed

              Frames with type score_changed indicate that the overall score for the fixture has changed. While the specific meaning of the score is game specific the format is the same:

                  {
                      "type": "score_changed",
                      "payload": {
                          "scores": [
                              {
                                  "participantId": <id>,
                                  "score": <integer>
                              }
                          ],
                          "snapshotNumber": <integer>
                      },
                      "timestamp": <timestamp>
                  }
                                  

              Example

                Occurrence

                Frames with type occurrence represent that some discreet in-game event occurred. This might be one player killing another or the destruction of a tower. The game-specific progression of fixtures will also be announced via occurrences.

                E.g. HotS fixtures consist of a number of "games" and this will be announced via game_started and game_ended occurrences that are unique for HotS. CS:GO fixtures, on the other hand, consist of a number of "maps" themselves consisting of a number of "rounds", which again is announced via map_started/ended and round_started/ended occurrences.

                The data for these specific occurrences is described in detail in the sections relating to the specific games supported.

                Overall the structure of an occurrence message is as such:

                    {
                        "type": "occurrence",
                        "payload": {
                            "name": "<name of occurrence, e.g. game_started>",
                            "timestamp": <timestamp>,
                            "fixtureId": <integer>,
                            <occurrence specific properties>,
                            "snapshotNumber": <integer>
                        },
                    }
                

                Note that occurrences with the same name may occur in different games. E.g. players kill each other in both HotS and CS:GO and the associated occurrence will be named "kill" in both games but contain different data.

                Example (bomb exploded in CS:GO)

                  Fixture Ended

                  Once the entire fixture has been played the fixture_ended message is sent containing the final score and the winner (or indication of being tied).

                      {
                          "type": "fixture_ended",
                          "payload": {
                              "timestamp": <timestamp>,
                              "fixtureId": <integer>
                              "winnerId"?: <id>,
                              "scores": [
                                  {
                                      "participantId": <id>,
                                      "score": <score as integer>
                                  },
                                  {
                                      "participantId": <id>,
                                      "score": <score as integer>
                                  }
                              ],
                              "isTie": <boolean>,
                              "snapshotNumber": <integer>
                          }
                      }
                                      

                  The property winnerId can be null if the fixture ended in a tie.

                  Example

                    Counter-Strike Global Offensive (CS:GO) Live Data API

                    A fixture in CS:GO is made up of one or more games. Each game is played on a specific map and consists of a number of rounds. Games are usually played as best of 30 rounds, which means that the actual number of rounds played can vary from game to game. Game ties are allowed at some CS:GO events, while other events add additional rounds in case of a tie.

                    The score of a fixture is the number of games a team has won in that fixture.

                    Map Started

                    A map started occurrence is sent when a Map (game) starts. It contains the name of the map being played along with the map-number in the series.

                    Properties

                    mapName
                    The name of the map being played on.
                    string
                    mapNumber
                    1st map of a fixture is mapNumber 1, second is 2 etc.
                    integer
                    participants
                    Array of participants.
                    id
                    Id of the participant.
                    string

                    Example

                      Map Ended

                      A map ended occurrence is sent when a Map (game) has been decided. Either because a winner has been found, or in tournaments that allows ties, because the map was tied.

                      Properties

                      mapNumber
                      1st map of a fixture is mapNumber 1, second is 2 etc.
                      integer
                      winnerId
                      The participantId of the team who won the map. May be null.
                      string
                      tie
                      True if the map ended as a tie.
                      boolean
                      participants
                      Array of participants.
                      id
                      Id of the participant.
                      string
                      score
                      Fixture score (number of maps won) of the participant.
                      integer
                      roundsWon
                      The final round score of the participant for this map.
                      integer

                      Example

                        Round Started

                        In CS:GO, a map is played over a series of up to 30 rounds or more (if it goes to overtime). When a new round starts a round started event is sent as an occurrence.

                        Properties

                        mapNumber
                        1st map of a fixture is mapNumber 1, second is 2 etc.
                        integer
                        roundNumber
                        The round being played in the current map.
                        integer

                        Example

                          Round Ended

                          When a round is concluded an occurrence with "round_ended" is sent. The round ended occurrences summarizes how many rounds each participant has won.

                          Properties

                          mapNumber
                          1st map of a fixture is mapNumber 1, second is 2 etc.
                          integer
                          winnerId
                          The ID of the participant that won the round.
                          string
                          participants
                          Array of participants.
                          id
                          Id of the participant.
                          string
                          roundsWon
                          Number of rounds won so far in the current map
                          integer

                          Example

                            Round Voided

                            When a round is restarted or otherwise nullified an occurrence with "round_voided" is sent. This occurrence indicates that all events between the last round_started and the round_voided were not officially part of the match.

                            Example

                              Half Started

                              A half started occurrence is sent when a half has started which is at the start of a map and every time the teams switch sides (at the start of round 16 and during overtime).

                              Properties

                              participants
                              Array of participants.
                              id
                              Id of the participant.
                              string
                              side
                              Side of the participant for this half. CT or Terrorist.
                              string

                              Example

                                Half Ended

                                A half ended occurrence is sent when a half has ended and the teams will switch sides, or the map is over.

                                Example

                                  Half Voided

                                  When a half is restarted or otherwise nullified an occurrence with "half_voided" is sent. This occurrence indicates that all events between the last half_started and the half_voided were not officially part of the match.

                                  Example

                                    Kill

                                    A kill Occurrence is sent when a kill is detected.

                                    Properties

                                    killer
                                    player
                                    id
                                    The GameScorekeeper ID of the player who performed the kill.
                                    string
                                    name
                                    The name of the killer.
                                    string
                                    side
                                    The side the killer plays for. "CT" or "TERRORIST".
                                    string
                                    teamId
                                    The GameScorekeeper ID of the team the killer plays for.
                                    string
                                    victim
                                    player
                                    id
                                    The GameScorekeeper ID of the player who was killed.
                                    string
                                    name
                                    The name of the victim.
                                    string
                                    side
                                    The side the victim plays for. "CT" or "TERRORIST".
                                    string
                                    teamId
                                    The GameScorekeeper ID of the team the victim plays for.
                                    string
                                    weapon
                                    The weapon used to perform the kill.
                                    string
                                    headshot
                                    Whether the kill was a headshot or not.
                                    boolean
                                    roundNumber
                                    The round in which the kill happened.
                                    integer

                                    Example

                                      Bomb Planted

                                      A Bomb Planted Occurrence is sent when the bomb is planted.

                                      Properties

                                      planterId
                                      The GameScorekeeper ID of the player who planted the bomb.
                                      string
                                      planterName
                                      The name of the player who planted the bomb.
                                      string
                                      roundNumber
                                      The round in which the bomb plant happened.
                                      integer
                                      sourceTeamId
                                      The GameScorekeeper ID of the team who planted the bomb.
                                      string
                                      targetTeamId
                                      The GameScorekeeper ID of the team who had the bomb planted against them.
                                      string
                                      timestamp
                                      The actual time the bomb was planted.
                                      timestamp

                                      Example

                                        Bomb Defused

                                        A Bomb Defused Occurrence is sent when the bomb is planted.

                                        Properties

                                        name
                                        The name of the occurrence: "bomb_defused"
                                        string
                                        defuserId
                                        The GameScorekeeper ID of the player who defused the bomb.
                                        string
                                        defuserName
                                        The name of the player who defused the bomb.
                                        string
                                        roundNumber
                                        The round in which the bomb defuse happened.
                                        integer
                                        sourceTeamId
                                        The GameScorekeeper ID of the team who defused the bomb.
                                        string
                                        targetTeamId
                                        The GameScorekeeper ID of the team whose bomb was defused.
                                        string
                                        timestamp
                                        The actual time the bomb was defused.
                                        timestamp

                                        Example

                                          Bomb Exploded

                                          A Bomb Exploded Occurrence is sent when the bomb explodes.

                                          Properties

                                          name
                                          The name of the occurrence: "bomb_exploded"
                                          string
                                          timestamp
                                          The actual time the bomb exploded.
                                          timestamp
                                          roundNumber
                                          The round in which the bomb explode happened.
                                          integer
                                          sourceTeamId
                                          The GameScorekeeper ID of the team who successfully had the bomb explode.
                                          string
                                          targetTeamId
                                          The GameScorekeeper ID of the team who failed to defuse the bomb in time.
                                          string

                                          Example

                                            Heroes of the Storm (HotS) Live Data API

                                            A Heroes of the Storm fixture is made up of a number of games. Each game is played on a specific map (also known as a battleground).

                                            The score of a fixture is the number of games a team has won in that fixture.

                                            Game Started

                                            The game started occurrence contains information on the battleground (map) and side and color of the participants.

                                            Properties

                                            gameNumber
                                            integer
                                            1st game in a series is gameNumber 1, second is 2 etc.
                                            mapName
                                            string
                                            The name of the map this game is played on.
                                            participants
                                            Array of participants.
                                            id
                                            Id of the participant.
                                            string
                                            side
                                            Side of the participant. left or right.
                                            string
                                            color
                                            Color of the participant.
                                            string

                                            Example

                                              Property Changed

                                              Properties for Heroes of the Storm are grouped into "Global Properties" and "Participant Properties". Participant properties are properties that are tied to a specific participant, such as level, while Global Properties are not, such as gameTime.

                                              Global properties

                                              Some properties are general and have no special path prefix.

                                              Properties

                                              gameTime
                                              The in-game time in seconds. It is the time as reported by the game, not the amount of wall clock time elapsed since the fixture started. Game time may be negative.
                                              integer

                                              Participant properties

                                              Changes to participants are reflected in the participants object where each key is the id of a participant which had changes to their properties.

                                              Properties

                                              level
                                              The current level of the team. 1.4 means that the team is level 1 and 40% of the way to level 2.
                                              float
                                              kills
                                              The amount of kills the team has
                                              integer
                                              core
                                              currentHealth
                                              Current health of the core. Percentage can be calculated by taken currentHealth / maxHealth
                                              integer
                                              maxHealth
                                              Maximum health of the core
                                              integer
                                              currentShield
                                              A number representing the amount of shield on the core
                                              float
                                              maxShield
                                              The maximum value possible for core shield.
                                              float
                                              towers
                                              current
                                              The amount of towers the team currently has
                                              integer
                                              start
                                              The amount of towers the team starts with.
                                              integer

                                              Example

                                                Game Ended

                                                A game ended occurrence is sent when a winner is detected in a game. The winnerId refers to the ID of the participant who won the game.

                                                Properties

                                                gameNumber
                                                integer
                                                1st game in a series is gameNumber 1, second is 2 etc.
                                                winnerId
                                                The participantId of the team who won the map. May be null.
                                                integer
                                                participants
                                                Array of participants.
                                                id
                                                Id of the participant.
                                                string
                                                score
                                                Fixture score (number of games won) of the participant.
                                                integer

                                                Example

                                                  Dota2 Live Data API

                                                  A Dota2 fixture is made up of a number of games.

                                                  The score of a fixture is the number of games a team has won in that fixture.

                                                  Game Started

                                                  The game started occurrence contains information on the side of the participants (radiant/dire).

                                                  Properties

                                                  gameNumber
                                                  integer
                                                  1st game in a series is gameNumber 1, second is 2 etc.
                                                  participants
                                                  Array of participants.
                                                  id
                                                  Id of the participant.
                                                  string
                                                  side
                                                  Side of the participant. Can be dire or radiant.
                                                  string

                                                  Example

                                                    Property Changed

                                                    Currently we don't send property changed messages for Dota2.

                                                    Game Ended

                                                    A game ended occurrence is sent when a winner is detected in a game. The winnerId refers to the ID of the participant who won the game.

                                                    Properties

                                                    gameNumber
                                                    integer
                                                    1st game in a series is gameNumber 1, second is 2 etc.
                                                    winnerId
                                                    The participantId of the team who won the map. May be null.
                                                    string
                                                    winningSide
                                                    The side (either radiant or dire) of the winning team.
                                                    string
                                                    participants
                                                    Array of participants.
                                                    id
                                                    Id of the participant.
                                                    string
                                                    score
                                                    Fixture score (number of games won) of the participant.
                                                    integer

                                                    Example

                                                    League of Legends Live Data API

                                                    A LoL fixture is made up of a number of games.

                                                    The score of a fixture is the number of games a team has won in that fixture.

                                                    Game Started

                                                    The game started occurrence contains information on the side of the participants (blue/red).

                                                    Properties

                                                    gameNumber
                                                    integer
                                                    1st game in a series is gameNumber 1, second is 2 etc.
                                                    participants
                                                    Array of participants.
                                                    id
                                                    Id of the participant.
                                                    string
                                                    side
                                                    The side of the participant. Can be blue or red.
                                                    string

                                                    Example

                                                      Property Changed

                                                      Properties for League of Legends are grouped into "Global Properties" and "Participant Properties". Participant properties are properties that are tied to a specific participant, such as level, while Global Properties are not, such as gameTime.

                                                      Global properties

                                                      Some properties are general and have no special path prefix.

                                                      Properties

                                                      gameTime
                                                      The in-game time in milliseconds. It is the time as reported by the game, not the amount of wall clock time elapsed since the fixture started.
                                                      integer

                                                      Participant properties

                                                      Changes to participants are reflected in the participants object where each key is the id of a participant which had changes to their properties

                                                      Properties

                                                      baronsKilled
                                                      Number of barons the team has killed
                                                      integer
                                                      dragonsKilled
                                                      Number of dragons the team has killed
                                                      integer
                                                      inhibitorsKilled
                                                      Number of inhibitors the team has destroyed
                                                      integer
                                                      towersKilled
                                                      Number of towers the team has destroyed
                                                      integer
                                                      color
                                                      The color of the team
                                                      string
                                                      firstBlood
                                                      Whether or not the team has gotten first blood
                                                      boolean
                                                      playerStats
                                                      object
                                                      player1
                                                      Properties specific to the participant's top laner (see PlayerStats below)
                                                      PlayerStats
                                                      player2
                                                      Properties specific to the participant's jungler (see PlayerStats below)
                                                      PlayerStats
                                                      player3
                                                      Properties specific to the participant's mid laner (see PlayerStats below)
                                                      PlayerStats
                                                      player4
                                                      Properties specific to the participant's ADC (see PlayerStats below)
                                                      PlayerStats
                                                      player5
                                                      Properties specific to the participant's support (see PlayerStats below)
                                                      PlayerStats

                                                      PlayerStats Property

                                                      summonerName
                                                      In-game name (including team alias) of the player.
                                                      string
                                                      championName
                                                      Slug name of the champion the player is playing.
                                                      string
                                                      championId
                                                      Riot ID of the champion.
                                                      integer
                                                      level
                                                      Player level.
                                                      integer
                                                      kills
                                                      Number of kills.
                                                      integer
                                                      assists
                                                      Number of assists.
                                                      integer
                                                      deaths
                                                      Number of deaths.
                                                      integer
                                                      creepScore
                                                      Creep Score (Also known as 'CS'). The number of minions and monsters killed
                                                      integer
                                                      currentGold
                                                      Current gold available to spend.
                                                      integer
                                                      totalGold
                                                      Total gold earned so far in the game.
                                                      integer
                                                      health
                                                      Current health.
                                                      integer
                                                      maxHealth
                                                      Maximum health.
                                                      integer
                                                      power
                                                      Current power (Mana/energy/rage etc.)
                                                      integer
                                                      maxPower
                                                      Maximum power (Mana/energy/rage etc.)
                                                      integer
                                                      attackDamage
                                                      Attack damage. The amount of base damage (before mitigation/multipliers) that the player does with auto attacks.
                                                      integer
                                                      abilityPower
                                                      Ability power. Amplifies the damage of some player abilities.
                                                      integer
                                                      armor
                                                      Armor. Mitigates physical damage received.
                                                      integer
                                                      magicResist
                                                      Magic resist. Mitigates magical damage received.
                                                      integer
                                                      attackSpeed
                                                      Attack speed. Increases rate of auto attacks.
                                                      integer
                                                      movementSpeed
                                                      Movement speed. The amount of in-game units (distance) the player can move per second.
                                                      integer
                                                      armorPen
                                                      Armor penetration. The amount of flat armor the player ignores on enemies when doing physical damage.
                                                      integer
                                                      magicPen
                                                      Magic penetration. The amount of flat magic resist the player ignores on enemies when doing magical damage.
                                                      integer
                                                      armorPenPercent
                                                      Armor penetration percentage. The percentage of armor the player ignores on enemies when doing physical damage.
                                                      integer
                                                      magicPenPercent
                                                      Magic penetration percentage. The percentage of magic resist the player ignores on enemies when doing magical damage.
                                                      integer
                                                      spellVamp
                                                      Spell vamp. Percentage of damage caused by abilities and active that is healed as health.
                                                      integer
                                                      lifesteal
                                                      Life steal. Percentage of damage caused by auto attacks is healed as health.
                                                      integer
                                                      tenacity
                                                      Tenacity (Crowd-control reduction). Reduces the duration of crowd control effects (Stun, slow, root etc.) by this percentage.
                                                      integer
                                                      healthRegen
                                                      Health regeneration (also known as HP10). The amount of health naturally restored over 10 seconds
                                                      integer
                                                      powerRegen
                                                      Power regeneration (also known as MP10). The amount of power naturally restored over 10 seconds
                                                      integer
                                                      xp
                                                      Total amount of xp accrued in the game
                                                      integer
                                                      wardsPlaced
                                                      Amount of wards placed in the game.
                                                      integer
                                                      wardsKilled
                                                      Amount of wards destroyed in the game.
                                                      integer
                                                      summonersSpell1
                                                      ID of the player's first summoner spell.
                                                      integer
                                                      summonersSpell2
                                                      ID of the player's second summoner spell.
                                                      integer
                                                      x
                                                      X-coordinate of the player's position on the map (0 o 14820)
                                                      integer
                                                      y
                                                      Y-coordinate of the player's position on the map (0 o 14820)
                                                      integer
                                                      totalDmg
                                                      Total damage dealt to champions, minions and monsters.
                                                      integer
                                                      magicDmg
                                                      Total magical damage dealt to champions, minions and monsters.
                                                      integer
                                                      physicalDmg
                                                      Total physical damage dealt to champions, minions and monsters.
                                                      integer
                                                      trueDmg
                                                      Total true damage dealt to champions, minions and monsters.
                                                      integer
                                                      totalChampionDmg
                                                      Total damage dealt to champions
                                                      integer
                                                      magicChampionDmg
                                                      Total magical damage dealt to champions
                                                      integer
                                                      physicalChampionDmg
                                                      Total physical damage dealt to champions
                                                      integer
                                                      trueChampionDmg
                                                      Total true damage dealt to champions
                                                      integer
                                                      items
                                                      List of IDs of items the player possesses
                                                      array
                                                      skills
                                                      Object where the keys represent the level the player selected a skill, and the value denotes which skill was leveled up (1: Q, 2: W, 3: E, 4: R)
                                                      object
                                                      doubleKills
                                                      Number of double-kills the player has done
                                                      integer
                                                      tripleKills
                                                      Number of triple-kills the player has done
                                                      integer
                                                      quadraKills
                                                      Number of quadra-kills the player has done
                                                      integer
                                                      pentaKills
                                                      Number of penta-kills the player has done
                                                      integer

                                                      Example

                                                        Game Ended

                                                        A game ended occurrence is sent when a winner is detected in a game. The winnerId refers to the ID of the participant who won the game.

                                                        Properties

                                                        gameNumber
                                                        integer
                                                        1st game in a series is gameNumber 1, second is 2 etc.
                                                        winnerId
                                                        The participantId of the team who won the map. May be null.
                                                        string
                                                        participants
                                                        Array of participants.
                                                        id
                                                        Id of the participant.
                                                        string
                                                        score
                                                        Fixture score (number of games won) of the participant.
                                                        integer

                                                        Example