Which integrations are available for this server?

Provides tools for querying players, matches, hubs, tournaments, and more from the FACEIT Data API v4, enabling AI agents to interact with the FACEIT esports platform.

How do I use faceit-mcp?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@faceit-mcp find information about player 's1mple'" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

faceit-mcp

by sebazai

Overview Schema Source Related Servers Discussions Admin

Python

Remote

faceit-mcp

Give your AI assistant typed, first-class access to the FACEIT platform.

An MCP server that maps the FACEIT Data API v4 to a curated set of tools—so agents can query players, matches, hubs, tournaments, and more with clear, disambiguated intent.

Features

Full API coverage — All 64 GET endpoints from the official Swagger spec, generated into per-tag Python modules and registered with FastMCP.
Agent-friendly tool design — Every tool carries an enriched description with “use this when / prefer that when” hints so models pick the right call among similar names (for example searchPlayers vs getPlayerFromLookup vs getPlayer, or lifetime vs per-match player stats).
Typed request surfaces — Tool parameters are generated from the spec with accurate Python annotations (paths, query strings, enums, and pagination limits).
Production-ready HTTP — Async httpx client with bearer auth, timeouts, and structured errors tuned for LLM-facing messages (401 / 403 / 404 / 429 / 503).
Reproducible codegen — Tools are generated from swagger.json via scripts/generate_tools.py; committed output means the server runs without the spec at runtime.

Related MCP server: copamind-mcp

Requirements

Python 3.10+ (tested on 3.11)
A server-side FACEIT API key from developers.faceit.com (My Apps → API Keys → Server-side)

Installation

From PyPI

Ideal for dev containers, CI, and machines where you do not need a git clone:

pip install faceit-mcp

With uv:

uv tool install faceit-mcp

Run once without a global install (also suitable for Cursor):

uvx faceit-mcp

From source (contributors)

python3 -m venv .venv
source .venv/bin/activate
pip install -e .

With uv (this repo ships an uv.lock):

uv venv && source .venv/bin/activate
uv pip install -e .

Configuration

Copy the example env file and set your key:

cp .env.example .env
# Edit .env and set FACEIT_API_KEY=...

Variable	Required	Default	Description
`FACEIT_API_KEY`	yes	—	Server-side key (sent as `Authorization: Bearer …`).
`FACEIT_API_BASE_URL`	no	`https://open.faceit.com/data/v4`	Override for testing or staging.
`FACEIT_API_TIMEOUT`	no	`30`	HTTP timeout in seconds.

Run (stdio)

This server uses stdio transport (JSON-RPC over stdin/stdout). Cursor, Claude Desktop, or the MCP Inspector spawn the process and attach to that pipe. If you run faceit-mcp in a normal shell with no client, it will appear idle because it is waiting for MCP messages, not printing a REPL.

faceit-mcp
# equivalent:
python -m faceit_mcp

Quick smoke test (no HTTP; verifies all tools register):

FACEIT_API_KEY=placeholder python -c "
import asyncio
from faceit_mcp.server import mcp
tools = asyncio.run(mcp.list_tools())
assert len(tools) == 64, len(tools)
print('OK', len(tools))
"

Try it with the MCP Inspector

The MCP Inspector is a browser UI for exploring and calling a live MCP server. The mcp[cli] dependency provides mcp dev, which launches the Inspector and connects to this server over stdio.

Prerequisites

Node.js on PATH (Inspector is loaded via npx; see the Inspector repo for supported versions)
uv on PATH (used by mcp dev for an isolated env)
FACEIT_API_KEY available to the server (e.g. via .env at the repo root, loaded by config.py)

Launch (venv active so mcp resolves):

source .venv/bin/activate
mcp dev src/faceit_mcp/server.py:mcp --with-editable .

Or call the binary directly:

./.venv/bin/mcp dev src/faceit_mcp/server.py:mcp --with-editable .

What happens

uv creates a temporary environment and installs this project in editable mode.
The mcp instance in src/faceit_mcp/server.py loads.
The Inspector UI is served (typically http://localhost:6274/; proxy on :6277). Open the printed URL (includes MCP_PROXY_AUTH_TOKEN) or paste the token into the UI.

Smoke sequence in the UI

Connect (often automatic).
Open Tools — you should see all 64 faceit_* tools with full descriptions.
Try: faceit_getAllGames → faceit_searchPlayers (nickname: "s1mple") → faceit_getPlayer → faceit_getPlayerLifetimeStats / faceit_getPlayerRecentMatchStats to compare aggregates vs per-match stats.

Stop with Ctrl+C in the terminal.

Troubleshooting

401: Missing or invalid FACEIT_API_KEY — check .env or export the variable before mcp dev.
ImportError: attempted relative import with no known parent package: Use current server.py with absolute imports, or reinstall with pip install -e ..
EADDRINUSE on 6274/6277: Another Inspector is running — stop it or pkill -f '@modelcontextprotocol/inspector'.

Alternative: Inspector via `npx`

You can run the Inspector package directly; it spawns your server as a child process. Replace the Python path with your venv or use faceit-mcp if it is already on PATH:

npx @modelcontextprotocol/inspector -e FACEIT_API_KEY=YOUR_KEY_HERE -- /absolute/path/to/faceit-mcp/.venv/bin/python -m faceit_mcp

npx @modelcontextprotocol/inspector -e FACEIT_API_KEY=YOUR_KEY_HERE -- faceit-mcp

Open the URL printed in the terminal (it includes the proxy session token), then use Tools to list and call faceit_* tools.

Use in Cursor, Claude Desktop, or Claude Code

All of these clients use the same shape of stdio config: a command, optional args, and environment variables. The server does not open its own network port for MCP.

Cursor

Put this server in user MCP config only, not in the project’s .cursor/mcp.json. The FACEIT API key belongs in env next to the server entry; workspace files are easy to commit, share, or check into git by mistake. User config stays on your machine and keeps the secret out of the repo.

Open Cursor Settings → MCP (or edit the JSON manually).
Edit user config:
- macOS / Linux: ~/.cursor/mcp.json
- Windows: %USERPROFILE%\.cursor\mcp.json

Merge the faceit block into the existing mcpServers object if you already have other servers.

Recommended (PyPI) — uvx creates an isolated environment when Cursor starts the server:

{
  "mcpServers": {
    "faceit": {
      "command": "uvx",
      "args": ["faceit-mcp"],
      "env": {
        "FACEIT_API_KEY": "YOUR_KEY_HERE"
      }
    }
  }
}

If faceit-mcp is already on PATH:

{
  "mcpServers": {
    "faceit": {
      "command": "faceit-mcp",
      "env": {
        "FACEIT_API_KEY": "YOUR_KEY_HERE"
      }
    }
  }
}

Local clone — point command at the venv script:

{
  "mcpServers": {
    "faceit": {
      "command": "/absolute/path/to/faceit-mcp/.venv/bin/faceit-mcp",
      "env": {
        "FACEIT_API_KEY": "YOUR_KEY_HERE"
      }
    }
  }
}

Local uvx without PyPI:

{
  "mcpServers": {
    "faceit": {
      "command": "uvx",
      "args": ["--from", "/absolute/path/to/faceit-mcp", "faceit-mcp"],
      "env": { "FACEIT_API_KEY": "YOUR_KEY_HERE" }
    }
  }
}

After saving, enable the faceit server in the MCP panel if it is not already on. New chats in Agent mode can then use the FACEIT tools.

If you use a dev container or remote SSH, Cursor may resolve command on the remote side; still keep the entry in user mcp.json so the key is not stored in the project. See Cursor’s docs for how MCP runs in your setup.

Claude Desktop

Quit Claude Desktop completely.
Edit the MCP config file for your OS (create it if missing):
- macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
- Windows: %APPDATA%\Claude\claude_desktop_config.json
Merge a mcpServers entry with the same JSON shape as in the Cursor examples above (for example uvx + faceit-mcp and FACEIT_API_KEY in env).
Start Claude Desktop again; the FACEIT tools should appear under MCP for supported conversations.

Claude Code

Prefer user scope (or the equivalent global config) so FACEIT_API_KEY is not stored in a committed project file. Example:

claude mcp add --transport stdio --scope user --env FACEIT_API_KEY=YOUR_KEY_HERE faceit -- uvx faceit-mcp

--scope user keeps the definition (and env) in user config rather than a project .mcp.json you might commit. See Connect Claude Code to tools via MCP.

Development

Hand-written code: src/faceit_mcp/{server,client,config,errors}.py and src/faceit_mcp/__main__.py — safe to edit.
Generated code: everything under src/faceit_mcp/tools/ comes from scripts/generate_tools.py — do not edit by hand. See AGENTS.md for the full workflow (hints, overrides, regeneration, and the tool-count smoke test).
Setup: clone the repo, create a venv, pip install -e . or uv pip install -e ., copy .env.example to .env, set FACEIT_API_KEY.
Manual QA: run mcp dev src/faceit_mcp/server.py:mcp --with-editable . or the npx @modelcontextprotocol/inspector commands above and exercise a few tools against the real API.
Publishing / versioning: see Publishing to PyPI below.

There is no bundled pytest/ruff config yet; the smoke snippet in the Run (stdio) section above is the lightweight regression check documented in AGENTS.md.

Dev container (e.g. TypeScript repo)

Add Python to the container and install the MCP package once. Configure Cursor user ~/.cursor/mcp.json (not a tracked workspace file) with "command": "/opt/faceit-mcp/bin/faceit-mcp" or "faceit-mcp" once that binary is on PATH in the environment where Cursor launches MCP—same rule as above: do not put FACEIT_API_KEY in a project-level .cursor/mcp.json that could be committed.

Example .devcontainer/devcontainer.json fragment — a venv under /opt avoids Debian PEP 668 “externally managed environment” issues:

{
  "image": "mcr.microsoft.com/devcontainers/typescript-node:1-22-bookworm",
  "features": {
    "ghcr.io/devcontainers/features/python:1": {
      "version": "3.11"
    }
  },
  "postCreateCommand": "python3 -m venv /opt/faceit-mcp && /opt/faceit-mcp/bin/pip install -U pip faceit-mcp"
}

Supply FACEIT_API_KEY only in user Cursor MCP env, containerEnv, or a gitignored devcontainer.env — never commit real keys.

For MCP running inside the container, installing faceit-mcp in postCreateCommand is more reliable than assuming uvx on the host. Alternatively, keep a Node-only image and use uvx faceit-mcp if your setup launches MCP where Python is available.

Publishing to PyPI (maintainers)

PyPI account and an API token (or trusted publishing from GitHub).
Bump version in pyproject.toml for each release.
Build and upload:
```
uv build
UV_PUBLISH_TOKEN=pypi-xxxxxxxx uv publish
```
Or: python -m build and twine upload dist/*.
After the first upload, the PyPI-based Cursor snippets work for everyone.

Project on PyPI: faceit-mcp — if the name is taken, rename [project] name in pyproject.toml and update docs.

Tool catalogue (64 tools, 13 tags)

Tag	Count	Highlights
Championships	5	`getChampionships`, `getChampionshipMatches`, `getChampionshipResults`
Games	8	`getAllGames`, `getGame`, `getQueuesByEntityFilters`
Hubs	6	`getHub`, `getHubMatches`, `getHubMembers`
Leaderboards	7	`getHubRanking`, `getHubSeasonRanking`, `getChampionshipGroupRanking`
Leagues	3	`getLeagueById`, `getLeagueSeason`, `getPlayerForLeagueSeason`
Matches	2	`getMatch`, `getMatchStats`
Matchmakings	1	`getMatchmaking`
Organizers	6	`getOrganizer`, `getOrganizerChampionships`, `getOrganizerTournaments`
Players	9	`getPlayer`, `getPlayerFromLookup`, `getPlayerLifetimeStats`, `getPlayerRecentMatchStats`, `getPlayerHistory`
Rankings	2	`getGlobalRanking`, `getPlayerRanking`
Search	7	`searchPlayers`, `searchTeams`, `searchChampionships`, …
Teams	3	`getTeam`, `getTeamStats`, `getTeamTournaments`
Tournaments	5	`getTournament`, `getTournamentBrackets`, `getTournamentMatches`

Tools are registered with a faceit_ prefix, e.g. faceit_getPlayer. The two operations that shared getPlayerStats in Swagger are:

faceit_getPlayerLifetimeStats — career aggregates (GET /players/{player_id}/stats/{game_id})
faceit_getPlayerRecentMatchStats — paginated per-match stats (GET /players/{player_id}/games/{game_id}/stats)

Regenerating tools

Generated files under src/faceit_mcp/tools/ are committed and must not be edited by hand.

Place an updated swagger.json at the repo root (gitignored).
Adjust TAG_HINTS or OPERATION_OVERRIDES in scripts/generate_tools.py if needed.
Run:
```
python scripts/generate_tools.py
```
Commit the regenerated modules.

In Cursor you can use the /regenerate-tools command (see .cursor/commands/regenerate-tools.md).

Project layout

faceit-mcp/
├── pyproject.toml
├── uv.lock
├── swagger.json                       # gitignored; build-time input only
├── scripts/generate_tools.py          # swagger.json → tool modules
├── src/faceit_mcp/
│   ├── server.py                      # FastMCP app + stdio entrypoint
│   ├── client.py                      # httpx async client + auth + errors
│   ├── config.py                      # env-based settings
│   ├── errors.py                      # FaceitAPIError
│   └── tools/                         # GENERATED; committed
│       └── <one module per swagger tag>.py
├── AGENTS.md
└── .cursor/commands/regenerate-tools.md

License

The code in this repository is licensed under the terms in LICENSE. The FACEIT Data API, its Swagger specification, and API responses are the property of FACEIT LTD.

Available Tools

64 tools

faceit_getAllGamesA

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

Inputs: offset, limit.

faceit_getChampionshipA

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

Inputs: championship_id (required), expanded.

faceit_getChampionshipGroupRankingA

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

Inputs: championship_id (required), group (required), offset, limit.

faceit_getChampionshipLeaderboardsA

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

Inputs: championship_id (required), offset, limit.

faceit_getChampionshipMatchesA

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

Inputs: championship_id (required), type, offset, limit.

faceit_getChampionshipResultsA

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

Inputs: championship_id (required), offset, limit.

faceit_getChampionshipsA

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

Inputs: game (required), type, offset, limit.

faceit_getChampionshipSubscriptionsA

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

Inputs: championship_id (required), offset, limit.

faceit_getGameA

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

Inputs: game_id (required).

faceit_getGameMatchmakingsA

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

Inputs: game_id (required), region, offset, limit.

faceit_getGlobalRankingB

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

Inputs: game_id (required), region (required), country, offset, +1 more.

faceit_getHubA

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

Inputs: hub_id (required), expanded.

faceit_getHubLeaderboardsA

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

Inputs: hub_id (required), offset, limit.

faceit_getHubMatchesA

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

Inputs: hub_id (required), type, offset, limit.

faceit_getHubMembersA

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

Inputs: hub_id (required), offset, limit.

faceit_getHubRankingA

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

Inputs: hub_id (required), offset, limit.

faceit_getHubRolesA

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

Inputs: hub_id (required), offset, limit.

faceit_getHubRulesA

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

Inputs: hub_id (required).

faceit_getHubSeasonRankingA

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

Inputs: hub_id (required), season (required), offset, limit.

faceit_getHubStatsA

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

Inputs: hub_id (required), offset, limit.

faceit_getLeaderboardA

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

Inputs: leaderboard_id (required), offset, limit.

faceit_getLeagueByIdA

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

Inputs: league_id (required).

faceit_getLeagueSeasonB

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

Inputs: league_id (required), season_id (required).

faceit_getMatchA

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

Inputs: match_id (required).

faceit_getMatchmakingA

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

Inputs: matchmaking_id (required).

faceit_getMatchStatsA

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

Inputs: match_id (required).

faceit_getOrganizerA

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

Inputs: organizer_id (required).

faceit_getOrganizerByNameA

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

Inputs: name (required).

faceit_getOrganizerChampionshipsA

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

Inputs: organizer_id (required), published_only, offset, limit, +1 more.

faceit_getOrganizerGamesA

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

Inputs: organizer_id (required).

faceit_getOrganizerHubsA

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

Inputs: organizer_id (required), offset, limit.

faceit_getOrganizerTournamentsA

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

Inputs: organizer_id (required), type, offset, limit.

faceit_getParentGameA

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

Inputs: game_id (required).

faceit_getPlayerA

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

Inputs: player_id (required).

faceit_getPlayerBansA

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

Inputs: player_id (required), offset, limit.

faceit_getPlayerForLeagueSeasonB

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

Inputs: league_id (required), season_id (required), player_id (required).

faceit_getPlayerFromLookupA

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

Inputs: nickname, game, game_player_id.

faceit_getPlayerHistoryA

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

Inputs: player_id (required), game (required), from_, to, +2 more.

faceit_getPlayerHubsA

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

Inputs: player_id (required), offset, limit.

faceit_getPlayerLifetimeStatsA

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

Inputs: player_id (required), game_id (required).

faceit_getPlayerRankingA

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

Inputs: game_id (required), region (required), player_id (required), country, +1 more.

faceit_getPlayerRankingInLeaderboardA

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

Inputs: leaderboard_id (required), player_id (required).

faceit_getPlayerRecentMatchStatsA

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

Inputs: player_id (required), game_id (required), offset, limit, +2 more.

faceit_getPlayerTeamsA

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

Inputs: player_id (required), offset, limit.

faceit_getPlayerTournamentsA

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

Inputs: player_id (required), offset, limit.

faceit_getQueueBansA

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

Inputs: game_id (required), queue_id (required), offset, limit.

faceit_getQueueByIdA

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

Inputs: game_id (required), queue_id (required).

faceit_getQueuesByEntityFiltersA

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

Inputs: game_id (required), entity_type (required), entity_id (required), offset, +1 more.

faceit_getQueuesByRegionA

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

Inputs: game_id (required), region_id (required), offset, limit.

faceit_getTeamA

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

Inputs: team_id (required).

faceit_getTeamStatsA

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

Inputs: team_id (required), game_id (required).

faceit_getTeamTournamentsA

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

Inputs: team_id (required), offset, limit.

faceit_getTournamentA

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

Inputs: tournament_id (required), expanded.

faceit_getTournamentBracketsB

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

Inputs: tournament_id (required).

faceit_getTournamentMatchesA

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

Inputs: tournament_id (required), offset, limit.

faceit_getTournamentsListA

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

Inputs: game, region, offset, limit.

faceit_getTournamentTeamsA

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

Inputs: tournament_id (required), offset, limit.

faceit_searchChampionshipsA

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

Inputs: name (required), game, region, type, +2 more.

faceit_searchClansA

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

Inputs: name (required), game, region, offset, +1 more.

faceit_searchHubsA

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

Inputs: name (required), game, region, offset, +1 more.

faceit_searchOrganizersA

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

Inputs: name (required), offset, limit.

faceit_searchPlayersA

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

Inputs: nickname (required), game, country, offset, +1 more.

faceit_searchTeamsA

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

Inputs: nickname (required), game, offset, limit.

faceit_searchTournamentsA

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

Inputs: name (required), game, region, type, +2 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A3.6/5.0

Scored 2026-06-12 13:26 across 64 tools

Disambiguation4/5

Tools are largely distinct by entity (game, championship, hub, etc.) and action (get, search), with clear descriptions. Some overlap exists among ranking and leaderboard tools, but they are well-differentiated by parameters and context.

Naming Consistency5/5

All tools follow a consistent pattern of 'faceit_verb_noun' (e.g., getPlayer, searchHubs). No mixing of casing styles or redundant prefixes. This makes the tool surface predictable.

Tool Count2/5

64 tools is excessive for even a broad platform. While the FACEIT API covers many entities, the tool count overwhelms agents, with many niche tools (e.g., getChampionshipGroupRanking vs getLeaderboard) that could be combined.

Completeness3/5

The read-only coverage is fairly comprehensive across major entities (players, teams, matches, tournaments, hubs, championships), but there are notable gaps: no write operations, limited filtering on lists, and some missing endpoints like league season listing or live match data.

Maintenance

ActivityInactive

ResponsivenessOutdated data

Resources

Related MCP Connectors

Cralo
ai.cralo
Pay-per-use tool marketplace for AI agents. Search, price-check, and call APIs via MCP.
Agent Orchestration Developer Tools
1
https://mcp.cralo.ai/mcp
mcp
com.skopik
Your org's AI agents, tasks, runs, search, and brain files as MCP tools and resources.
Agent Orchestration Knowledge & Memory Search
2
https://api.skopik.com/mcp
mockmcpA
io.github.K-Cupples
Hosted MCP endpoint with realistic fake data for prototyping agents. 12 tools, no setup.
Developer Tools Testing & QA Tools
2
https://mockmcp.io/mcp
OneSchema MCP Server
co.oneschema
MCP server that lets AI assistants use all OneSchema features exposed via the public API.
Data Platforms App Automation
1
https://api.oneschema.co/mcp

Related MCP Servers

Relay
Agent Orchestration Developer Tools
adarshp14
A
license
Not graded
quality
D
maintenance
Enables AI agents to access a unified catalog of tools from various APIs (OpenAPI, GraphQL, MCP, Google Discovery) through the MCP protocol.
Updated 4 months ago (2026-06-29 06:34 UTC)
12 npm
MIT
copamind-mcp
Sports RAG Systems AI & Machine Learning
Phemassa
A
license
Not graded
quality
D
maintenance
Enables interaction with the CopaMind platform via MCP, exposing read-only and write tools for querying match predictions, Monte Carlo simulations, team rankings, and RAG-based explanations, all while maintaining full traceability and reproducibility.
Updated 4 months ago (2026-07-20 19:43 UTC)
1
MIT
fotmob-mcp
Sports Open Data Search
MoRocety
F
license
A
quality
B
maintenance
Enables querying FotMob football data including matches, match details, teams, leagues, players, and search through MCP-compatible LLM clients.
Updated 3 months ago (2026-08-21 17:29 UTC)
6
-
NBA MCP Server
Sports Open Data
SergioCastro02
A
license
A
quality
C
maintenance
Enables MCP-compatible LLM clients to access live NBA data, including stats, standings, rosters, scores, and box scores via callable tools.
Updated 3 months ago (2026-08-28 18:07 UTC)
9
MIT

faceit-mcp

Features

Requirements

Installation

From PyPI

From source (contributors)

Configuration

Run (stdio)

Try it with the MCP Inspector

Alternative: Inspector via npx

Use in Cursor, Claude Desktop, or Claude Code

Cursor

Claude Desktop

Claude Code

Development

Dev container (e.g. TypeScript repo)

Publishing to PyPI (maintainers)

Tool catalogue (64 tools, 13 tags)

Regenerating tools

Project layout

License

Available Tools

Tool Schema Changelog

TDQS

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

Relay

copamind-mcp

fotmob-mcp

NBA MCP Server

Alternative: Inspector via `npx`