Retrieve championship details

Use when you already have a championship_id and want the full championship record. Use the expanded parameter to include the organizer and game inline in a single call.

Endpoint: GET /championships/{championship_id}

Parameters:

• championship_id (path, str, required): The id of the championship

• expanded (query, list[str] | None): List of entity names to expand in request

Returns: Championship details

Retrieve all matches of a championship

Use to page through matches of a known championship. For a flat list of finished-match results (winners only) use getChampionshipResults.

Endpoint: GET /championships/{championship_id}/matches

Parameters:

• championship_id (path, str, required): The id of the championship

• type (query, str | None): Kind of matches to return. Can be all(default), upcoming, ongoing or past One of: 'all', 'upcoming', 'ongoing', 'past'.

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Matches list

Retrieve all results of a championship

Use when you only care about the final results of a championship's matches. For live/upcoming match details use getChampionshipMatches.

Endpoint: GET /championships/{championship_id}/results

Parameters:

• championship_id (path, str, required): The id of the championship

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Championship results

Retrieve all subscriptions of a championship

Use to list the teams or players that subscribed to a championship (registrations). Not for hub members - use getHubMembers for that.

Endpoint: GET /championships/{championship_id}/subscriptions

Parameters:

• championship_id (path, str, required): The id of the championship

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 10)): The number of items to return

Returns: Subscriptions list

Retrieve all championships of a game

Use when listing all championships for a given game, optionally filtered by status (upcoming/ongoing/past). For free-text search by championship name use searchChampionships instead.

Endpoint: GET /championships

Parameters:

• game (query, str, required): The id of the game

• type (query, str | None): Kind of matches to return. Can be all(default), upcoming, ongoing or past One of: 'all', 'upcoming', 'ongoing', 'past'.

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 10)): The number of items to return

Returns: Championships list

Retrieve details of all games on FACEIT

Use to enumerate every game supported on FACEIT (CS2, Dota 2, LoL, etc.). Often the first step to discover valid game_id values for other tools.

Endpoint: GET /games

Parameters:

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Games list

Retrieve game details

Use to fetch the canonical record for one game by its game_id (string slug). Call getParentGame if the id points to a region-specific variant and you want the parent.

Endpoint: GET /games/{game_id}

Parameters:

• game_id (path, str, required): The id of the game

Returns: Game detail

Retrieve details of all matchmakings of a game on FACEIT

Use to list the matchmaking queues a game exposes. Drill down with getMatchmaking for details about a single matchmaking.

Endpoint: GET /games/{gameId}/matchmakings

Parameters:

• game_id (path, str, required): The id of the game

• region (query, str | None): The region of the matchmakings

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Matchmakings list

Retrieve the details of the parent game, if the game is region-specific

Use when the game_id is a region-specific variant (e.g. a regional CS2 pool) and you want the canonical parent game.

Endpoint: GET /games/{game_id}/parent

Parameters:

• game_id (path, str, required): The id of the game

Returns: Game detail

Retrieve queue bans on FACEIT

Use to list the map/region/etc. bans currently active on a queue.

Endpoint: GET /games/{game_id}/queues/{queue_id}/bans

Parameters:

• game_id (path, str, required): The id of the game

• queue_id (path, str, required): The id of the queue

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Bans list

Retrieve details of a queue on FACEIT

Use when you already have a queue_id and want its configuration and current state.

Endpoint: GET /games/{game_id}/queues/{queue_id}

Parameters:

• game_id (path, str, required): The id of the game

• queue_id (path, str, required): The id of the queue

Returns: Queue

Retrieve queues by filters on FACEIT

Use to list queues for a game with arbitrary entity filters. If you already know the region use getQueuesByRegion; if you know the queue_id use getQueueById.

Endpoint: GET /games/{game_id}/queues

Parameters:

• game_id (path, str, required): The id of the game

• entity_type (query, str, required): The type of the entity

• entity_id (query, str, required): The id of the entity

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 20)): The number of items to return

Returns: Queues list

Retrieve queues by region on FACEIT

Use to list queues available in a specific region of a game (e.g. EU, NA). Pick getQueuesByEntityFilters instead when filtering by non-region entities.

Endpoint: GET /games/{game_id}/regions/{region_id}/queues

Parameters:

• game_id (path, str, required): The id of the game

• region_id (path, str, required): The id of the region

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 20)): The number of items to return

Returns: Queues list

Retrieve hub details

Use when you already have a hub_id. Use the expanded parameter to inline the organizer and game records in one call. For fuzzy name search use searchHubs.

Endpoint: GET /hubs/{hub_id}

Parameters:

• hub_id (path, str, required): The id of the hub

• expanded (query, list[str] | None): List of entity names to expand in request

Returns: Hub details

Retrieve all matches of a hub

Use to list a hub's matches (upcoming/ongoing/past). For hub members use getHubMembers, for hub leaderboards use getHubLeaderboards.

Endpoint: GET /hubs/{hub_id}/matches

Parameters:

• hub_id (path, str, required): The id of the hub

• type (query, str | None): Kind of matches to return. Can be all(default), upcoming, ongoing or past One of: 'all', 'upcoming', 'ongoing', 'past'.

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Matches list

Retrieve all members of a hub

Use to list the players that belong to a hub, optionally filtered by role. For ranking of members use getHubRanking.

Endpoint: GET /hubs/{hub_id}/members

Parameters:

• hub_id (path, str, required): The id of the hub

• offset (query, int | None (min 0, max 1000)): The starting item position

• limit (query, int | None (min 1, max 50)): The number of items to return

Returns: Members list

Retrieve all roles members can have in a hub

Use to list the roles that members of a hub can hold (admin, member, etc.).

Endpoint: GET /hubs/{hub_id}/roles

Parameters:

• hub_id (path, str, required): The id of the hub

• offset (query, int | None (min 0, max 1000)): The starting item position

• limit (query, int | None (min 1, max 50)): The number of items to return

Returns: Roles list

Retrieve rules of a hub

Use to read the rules document attached to a hub.

Endpoint: GET /hubs/{hub_id}/rules

Parameters:

• hub_id (path, str, required): The id of the hub

Returns: Rules details

Retrieve statistics of a hub

Use to fetch aggregate hub-wide statistics (matches played, top players, etc.).

Endpoint: GET /hubs/{hub_id}/stats

Parameters:

• hub_id (path, str, required): The id of the hub

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Hub stats

Retrieve group ranking of a championship

Use when you have a championship_id and a group number and want the full ordered ranking of that group.

Endpoint: GET /leaderboards/championships/{championship_id}/groups/{group}

Parameters:

• championship_id (path, str, required): The id of the championship

• group (path, int, required): A group of the championship

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Championship ranking

Retrieve all leaderboards of a championship

Use to list all leaderboards (groups / stages) inside a championship. For a specific group's ranking use getChampionshipGroupRanking.

Endpoint: GET /leaderboards/championships/{championship_id}

Parameters:

• championship_id (path, str, required): The id of the championship

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Leaderboards list

Retrieve all leaderboards of a hub

Use to list all leaderboards attached to a hub. For a specific named ranking use getHubRanking (all-time) or getHubSeasonRanking (per season).

Endpoint: GET /leaderboards/hubs/{hub_id}

Parameters:

• hub_id (path, str, required): The id of the hub

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Leaderboards list

Retrieve all time ranking of a hub

Use for the hub's all-time ranking across every season. Use getHubSeasonRanking for a specific season.

Endpoint: GET /leaderboards/hubs/{hub_id}/general

Parameters:

• hub_id (path, str, required): The id of the hub

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Hub ranking

Retrieve seasonal ranking of a hub

Use for the ranking of a hub for one specific season number. Use getHubRanking for all-time.

Endpoint: GET /leaderboards/hubs/{hub_id}/seasons/{season}

Parameters:

• hub_id (path, str, required): The id of the hub

• season (path, int, required): A season of the hub

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Hub ranking

Retrieve ranking from a leaderboard id

Use when you already have a leaderboard_id (from getChampionshipLeaderboards or getHubLeaderboards) and want its ranking.

Endpoint: GET /leaderboards/{leaderboard_id}

Parameters:

• leaderboard_id (path, str, required): The id of the leaderboard

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Competition ranking

Retrieve a players ranking in a leaderboard

Use to look up where a single player sits on a specific leaderboard. Returns the entry with position and score rather than the whole board.

Endpoint: GET /leaderboards/{leaderboard_id}/players/{player_id}

Parameters:

• leaderboard_id (path, str, required): The id of the leaderboard

• player_id (path, str, required): The id of the player

Returns: Ranking of the player in the leaderboard

Retrieve details of a league of a matchmaking on FACEIT

Use to fetch a FACEIT league's configuration by its league_id.

Endpoint: GET /leagues/{league_id}

Parameters:

• league_id (path, str, required): The id of the league

Returns: League details

Retrieve details of a season of a league on FACEIT

Use to fetch one season of a league (standings, divisions, dates).

Endpoint: GET /leagues/{league_id}/seasons/{season_id}

Parameters:

• league_id (path, str, required): The id of the league

• season_id (path, int, required): The id of the season

Returns: Season details

Retrieve details of a player for a given league and season on FACEIT

Use to look up a single player's division/placement within one season of a league. Requires league_id, season_id, and player_id together.

Endpoint: GET /leagues/{league_id}/seasons/{season_id}/players/{player_id}

Parameters:

• league_id (path, str, required): The id of the league

• season_id (path, int, required): The id of the season

• player_id (path, str, required): The id of the player

Returns: Player details

Retrieve match details

Use to fetch the full record of one match by match_id (lobby, factions, results, voting, etc.). For per-round/player stats use getMatchStats.

Endpoint: GET /matches/{match_id}

Parameters:

• match_id (path, str, required): The id of the match

Returns: Match details

Retrieve statistics of a match

Use to fetch detailed statistics of a finished match (rounds, K/D/A per player, map, score). Returns empty/404 for matches that have not finished.

Endpoint: GET /matches/{match_id}/stats

Parameters:

• match_id (path, str, required): The id of the match

Returns: Match stats

Retrieve details of a matchmaking of a game on FACEIT

Use to fetch one matchmaking configuration by matchmaking_id. For the list of matchmakings belonging to a game use getGameMatchmakings.

Endpoint: GET /matchmakings/{matchmaking_id}

Parameters:

• matchmaking_id (path, str, required): The id of the matchmaking

Returns: Matchmaking

Retrieve organizer details

Use when you already have an organizer_id. For name-based lookup use getOrganizerByName, for fuzzy search use searchOrganizers.

Endpoint: GET /organizers/{organizer_id}

Parameters:

• organizer_id (path, str, required): The id of the organizer

Returns: Organizer details

Retrieve organizer details from name

Use when you only have an organizer name string and need the canonical organizer record (including organizer_id). For id-based lookup use getOrganizer.

Endpoint: GET /organizers

Parameters:

• name (query, str, required): The name of the organizer

Returns: Organizer details

Retrieve all championships of an organizer

Use to list championships run by a known organizer, optionally restricted to published ones.

Endpoint: GET /organizers/{organizer_id}/championships

Parameters:

• organizer_id (path, str, required): The id of the organizer

• published_only (query, bool | None): When set to true only published championships are retrieved

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

• sort (query, str | None): Sorting criteria for retrieved championships, supports +createdAt, -createdAt

Returns: Championships list

Retrieve all games an organizer is involved with

Use to list the games an organizer runs events for.

Endpoint: GET /organizers/{organizer_id}/games

Parameters:

• organizer_id (path, str, required): The id of the organizer

Returns: Games list

Retrieve all hubs of an organizer

Use to list hubs owned by a known organizer.

Endpoint: GET /organizers/{organizer_id}/hubs

Parameters:

• organizer_id (path, str, required): The id of the organizer

• offset (query, int | None (min 0, max 1000)): The starting item position

• limit (query, int | None (min 1, max 50)): The number of items to return

Returns: Hubs list

Retrieve all tournaments of an organizer

Use to list tournaments run by a known organizer, optionally filtered to past or upcoming.

Endpoint: GET /organizers/{organizer_id}/tournaments

Parameters:

• organizer_id (path, str, required): The id of the organizer

• type (query, str | None): Kind of tournament. Can be upcoming(default) or past One of: 'past', 'upcoming'.

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Tournaments list

Retrieve player details

Use when you already have the FACEIT player_id (UUID). For nickname or game-id lookup use getPlayerFromLookup; for fuzzy search use searchPlayers.

Endpoint: GET /players/{player_id}

Parameters:

• player_id (path, str, required): The id of the player

Returns: Player details

Retrieve all bans of a player

Use to list active and historical bans for a known player.

Endpoint: GET /players/{player_id}/bans

Parameters:

• player_id (path, str, required): The id of the player

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Bans of a user

Retrieve player details

Use when you have an exact nickname OR a game-specific id (Steam ID, Riot id, etc.) and want the canonical FACEIT player record in a single call. Prefer this over searchPlayers when the nickname is exact. Prefer getPlayer when you already have the player_id.

Endpoint: GET /players

Parameters:

• nickname (query, str | None): The nickname of the player on FACEIT

• game (query, str | None): A game on FACEIT

• game_player_id (query, str | None): The ID of a player on game's platform

Returns: Player details

Retrieve all matches of a player

Use to list matches a player has played across a time window (offset/limit, from/to UNIX seconds). Returns match metadata, not stats; pair with getMatchStats for per-match detail.

Endpoint: GET /players/{player_id}/history

Parameters:

• player_id (path, str, required): The id of the player

• game (query, str, required): A game on FACEIT

• from_ (query, int | None (min 0)): The timestamp (Unix time) as lower bound of the query. 1 month ago if not specified

• to (query, int | None (min 0)): The timestamp (Unix time) as higher bound of the query. Current timestamp if not specified

• offset (query, int | None (min 0, max 1000)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Player matches list

Retrieve all hubs of a player

Use to list hubs a player belongs to.

Endpoint: GET /players/{player_id}/hubs

Parameters:

• player_id (path, str, required): The id of the player

• offset (query, int | None (min 0, max 1000)): The starting item position

• limit (query, int | None (min 1, max 50)): The number of items to return

Returns: Hubs list

Retrieve lifetime aggregate statistics for a player in a specific game.

Use for a player's aggregated lifetime stats in a game (overall K/D, win rate, map-level totals). For per-match stats use getPlayerRecentMatchStats.

Endpoint: GET /players/{player_id}/stats/{game_id}

Parameters:

• player_id (path, str, required): The id of the player

• game_id (path, str, required): A game on FACEIT

Returns: Player stats

Retrieve paginated per-match statistics for a player in a specific game.

Use to page through a player's recent per-match stats for a game (returns one entry per match). For career totals use getPlayerLifetimeStats. For the timeline of matches without stats use getPlayerHistory.

Endpoint: GET /players/{player_id}/games/{game_id}/stats

Parameters:

• player_id (path, str, required): The id of the player

• game_id (path, str, required): A game on FACEIT

• offset (query, int | None (min 0, max 200)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

• from_ (query, int | None): Used to filter the dataset by date (minimum). Expected value is date ("items.stats.Match Finished At") in epoch milliseconds.

• to (query, int | None): Used to filter the dataset by date (maximum). Expected value is date ("items.stats.Match Finished At") in epoch milliseconds.

Returns: Player stats for matches

Retrieve all teams of a player

Use to list teams a player is a member of.

Endpoint: GET /players/{player_id}/teams

Parameters:

• player_id (path, str, required): The id of the player

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Teams of a user

Retrieve all tournaments of a player

Use to list tournaments a player has participated in.

Endpoint: GET /players/{player_id}/tournaments

Parameters:

• player_id (path, str, required): The id of the player

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Tournaments list

Retrieve global ranking of a game

Use for a page of the global game/region leaderboard. For where a specific player sits use getPlayerRanking (id) or pass player_id to this tool to center the page on them.

Endpoint: GET /rankings/games/{game_id}/regions/{region}

Parameters:

• game_id (path, str, required): The id of the game

• region (path, str, required): A region of a game

• country (query, str | None): A country code (ISO 3166-1)

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Ranking

Retrieve user position in the global ranking of a game

Use to fetch one player's position and nearby context on the global game/region ranking. For the full leaderboard use getGlobalRanking.

Endpoint: GET /rankings/games/{game_id}/regions/{region}/players/{player_id}

Parameters:

• game_id (path, str, required): The id of the game

• region (path, str, required): A region of a game

• player_id (path, str, required): The id of a player

• country (query, str | None): A country code (ISO 3166-1)

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Ranking

Search for championships

Use when you only have a (possibly partial) championship name. Switch to getChampionship once you have the id.

Endpoint: GET /search/championships

Parameters:

• name (query, str, required): The name of a championship on FACEIT

• game (query, str | None): A game on FACEIT

• region (query, str | None): A region of the game

• type (query, str | None): Kind of competitions to return One of: 'all', 'upcoming', 'ongoing', 'past'.

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: List of championship

Search for clans

Use when you only have a clan name. Returns clan records with ids.

Endpoint: GET /search/clans

Parameters:

• name (query, str, required): The name of a clan on FACEIT

• game (query, str | None): A game on FACEIT

• region (query, str | None): A region of the game

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: List of hub

Search for hubs

Use when you only have a (possibly partial) hub name. Switch to getHub once you have the hub_id.

Endpoint: GET /search/hubs

Parameters:

• name (query, str, required): The name of a hub on FACEIT

• game (query, str | None): A game on FACEIT

• region (query, str | None): A region of the game

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: List of hub

Search for organizers

Use for fuzzy organizer name search. For an exact name use getOrganizerByName; for id-based lookup use getOrganizer.

Endpoint: GET /search/organizers

Parameters:

• name (query, str, required): The name of a organizer on FACEIT

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: List of organizers

Search for players

Use for fuzzy nickname search. Prefer getPlayerFromLookup when the nickname is exact, or getPlayer when you already have the player_id.

Endpoint: GET /search/players

Parameters:

• nickname (query, str, required): The nickname of a player on FACEIT

• game (query, str | None): A game on FACEIT

• country (query, str | None): A country code (ISO 3166-1)

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: List of players

Search for teams

Use when you only have a (possibly partial) team name. Switch to getTeam once you have the team_id.

Endpoint: GET /search/teams

Parameters:

• nickname (query, str, required): The nickname of a team on FACEIT

• game (query, str | None): A game on FACEIT

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: List of teams

Search for tournaments

Use when you only have a (possibly partial) tournament name. Switch to getTournament once you have the tournament_id.

Endpoint: GET /search/tournaments

Parameters:

• name (query, str, required): The name of a tournament on FACEIT

• game (query, str | None): A game on FACEIT

• region (query, str | None): A region of the game

• type (query, str | None): Kind of competitions to return One of: 'all', 'upcoming', 'ongoing', 'past'.

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: List of tournament

Retrieve team details

Use when you already have the team_id and want the full team record.

Endpoint: GET /teams/{team_id}

Parameters:

• team_id (path, str, required): The id of the team

Returns: Team details

Retrieve statistics of a team

Use for a team's aggregated statistics in a specific game. Not for tournament-specific or match-specific stats.

Endpoint: GET /teams/{team_id}/stats/{game_id}

Parameters:

• team_id (path, str, required): The id of the team

• game_id (path, str, required): A game on FACEIT

Returns: Team stats

Retrieve tournaments of a team

Use to list tournaments that a team has participated in.

Endpoint: GET /teams/{team_id}/tournaments

Parameters:

• team_id (path, str, required): The id of the team

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Tournaments list

Retrieve tournament details

Use when you already have a tournament_id. Use the expanded parameter to inline the organizer and game in one call.

Endpoint: GET /tournaments/{tournament_id}

Parameters:

• tournament_id (path, str, required): The id of the tournament

• expanded (query, list[str] | None): List of entity names to expand in request

Returns: Tournament details

Retrieve brackets of a tournament

Use to fetch the bracket structure of a tournament (stages, matches, seeds).

Endpoint: GET /tournaments/{tournament_id}/brackets

Parameters:

• tournament_id (path, str, required): The id of the tournament

Returns: Rounds and matches list

Retrieve all matches of a tournament

Use to list all matches of a known tournament.

Endpoint: GET /tournaments/{tournament_id}/matches

Parameters:

• tournament_id (path, str, required): The id of the tournament

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Matches list

Retrieve all teams of a tournament

Use to list teams registered to a known tournament.

Endpoint: GET /tournaments/{tournament_id}/teams

Parameters:

• tournament_id (path, str, required): The id of the tournament

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Teams list

Retrieve tournaments v1 (no longer used)

DEPRECATED v1 tournaments list. Prefer searchTournaments, getOrganizerTournaments, or getTournament as appropriate.

Endpoint: GET /tournaments

Parameters:

• game (query, str | None): A game on FACEIT

• region (query, str | None): A region of the game

• offset (query, int | None (min 0)): The starting item position

• limit (query, int | None (min 1, max 100)): The number of items to return

Returns: Tournaments list