chesscom-mcp
Read-only access to Chess.com public data: profiles, stats, current games, game archives, titled players, leaderboards, and club information.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@chesscom-mcpshow me the stats for Hikaru Nakamura"
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.
chesscom-mcp
An MCP server over the Chess.com public data API. Read-only, and the upstream API needs no authentication — there is no token to manage and nothing to expire, which makes this the simplest of the set.
Runs over stdio and is registered in ~/.claude.json as chesscom.
Tools
Tool | Purpose |
| Public profile — name, title, country, followers, join date |
| Ratings and W/L/D per format (bullet, blitz, rapid, daily, puzzles) |
| Daily/correspondence games in progress; |
| Index of available monthly archive URLs for a player |
| Every game a player played in a given year/month, with PGNs |
| Usernames holding a given title (GM, IM, FM, …) |
| Current Chess.com leaderboards across all categories |
| Club profile by URL-ID |
| Clubs a given player belongs to |
Related MCP server: MCP Chess Server
Layout
src/client.js thin fetch wrapper over api.chess.com/pub, shared error handling
src/chess.js all nine tool registrations
src/index.js McpServer construction + stdio transportRunning it
npm ci
npm start # stdio server; expects an MCP client on the other endRegistered for Claude Code with:
claude mcp add chesscom -- node <path>/chesscom-mcp/src/index.jsTests
npm testRegistration plus the fetch wrapper's URL, headers and error handling, using a
stubbed fetch. No network calls, so it is safe in CI.
Notes
The upstream API is rate-limited but generous, and serves cached responses. Bursts of
chess_get_games_by_monthacross many months are the realistic way to hit a limit.Usernames are case-insensitive upstream but are URL-encoded here before use.
credentials/and.envare gitignored on principle even though this server has no secrets today — so that adding auth later can't leak one by accident.
Available Tools
9 toolschess_get_clubGet club detailsA
Details for a club, identified by its URL id (the slug in chess.com/club/).
| Name | Required | Description | Default |
|---|---|---|---|
| urlId | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It only states that it returns 'details', but does not disclose whether it is read-only, requires authentication, or any error behaviors (e.g., what happens if the club does not exist). This is insufficient for a tool with no annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence with no wasted words. It conveys the essential information efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (1 parameter, no output schema), the description is almost complete, but it lacks details about the return format or error cases. While sibling tools exist, no explicit distinctions are made. Annotations are absent, which would have helped.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With schema description coverage at 0%, the description adds meaning to the sole parameter 'urlId' by explaining it is 'the slug in chess.com/club/<url-id>'. This clarifies the expected format beyond the schema's type 'string'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description specifies a clear verb-resource combination ('Details for a club') and distinguishes from the sibling 'chess_get_clubs' (plural), which likely lists clubs. It also clarifies the identification method using the URL slug.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies that the tool should be used when you have a club's URL id, but it does not explicitly state when to use this tool over alternatives like 'chess_get_clubs' or exclude other use cases. No guidance on prerequisites or error handling.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
chess_get_clubsGet a player's clubsC
Clubs a given username belongs to.
| Name | Required | Description | Default |
|---|---|---|---|
| username | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It only says 'Clubs a given username belongs to,' omitting whether the operation is read-only, requires authentication, or behavior on missing usernames.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise (a short phrase), but it is not a complete sentence and lacks structure. It could be expanded slightly without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity (1 param, no output schema, no annotations), the description is incomplete. It does not explain what the output will be (e.g., list of club names or objects) or any error cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter 'username' has no schema description (0% coverage). The description merely restates it as 'a given username,' adding no additional meaning or format guidance.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Clubs a given username belongs to' clearly indicates the tool retrieves clubs for a specified username. The verb is implicit but understandable, and the resource is identified. It somewhat distinguishes from sibling 'chess_get_club' (singular vs plural) but doesn't explicitly differentiate.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like 'chess_get_club' or other siblings. No prerequisites or exclusions mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
chess_get_current_gamesGet in-progress daily gamesC
Daily (correspondence) games a player currently has in progress.
| Name | Required | Description | Default |
|---|---|---|---|
| username | Yes | ||
| onlyMyTurn | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must disclose behavior. It only states the tool returns current games, omitting details on response format, ordering, or effect of onlyMyTurn parameter. Lacks transparency for a read operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, very concise. However, over-conciseness leads to missing critical information. Could be restructured to front-load key details while maintaining brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, no annotations, and two parameters, the description is insufficient. Does not explain return structure, pagination, or how onlyMyTurn modifies results. Incomplete for effective tool usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 0% description coverage for parameters. Description only implies the username parameter via 'a player', but does not explain the onlyMyTurn parameter at all. Fails to compensate for missing schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States it returns 'daily (correspondence) games a player currently has in progress', clearly indicating verb and resource. Distinguishes from sibling tools like get_game_archives (historical) and get_games_by_month (monthly archives). However, 'daily games' could be more explicitly defined.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like get_games_by_month or get_game_archives. Does not mention that this is for current games only, nor explain the onlyMyTurn filter's role.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
chess_get_game_archivesList monthly game archive URLsB
List of monthly archive URLs available for a player, going back to when they started playing.
| Name | Required | Description | Default |
|---|---|---|---|
| username | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must cover behavior. It mentions 'list of URLs' but omits error cases, rate limits, or response format.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with no redundancy, front-loads the main action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Minimally adequate for a simple tool, but missing output structure detail (e.g., list of URLs vs dates) given no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Single parameter 'username' has no description in schema or description; lacking details like valid formats or requirements.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it lists monthly archive URLs for a player, distinguishing from sibling tools like chess_get_games_by_month that fetch games for a specific month.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use vs alternatives or prerequisites (e.g., player must exist). Sibling tools hint at sequential usage but not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
chess_get_games_by_monthGet games played in a given monthB
All games (rated + casual, all formats) a player completed in a specific year/month.
| Name | Required | Description | Default |
|---|---|---|---|
| year | Yes | ||
| month | Yes | ||
| username | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavioral traits. It mentions what is returned (all games) but fails to address authentication requirements, rate limits, pagination, or any side effects. Minimal disclosure for a mutation-free tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence (14 words) that front-loads the action. No unnecessary verbiage, but structure is minimal as it lacks bullet points or groupings for clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and 3 required parameters, the description is too brief. It does not explain what the return format is, whether results are paginated, or any error conditions. Incomplete for a tool with these characteristics.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Description offers no additional meaning beyond parameter names (username, year, month). With 0% schema description coverage, the description should provide format or constraints but does not. Parameters are left to be interpreted from names alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description explicitly states 'All games (rated + casual, all formats) a player completed in a specific year/month.' It clearly identifies the resource (games by month), the verb (get), and the scope (all formats, rated and casual), distinguishing it from siblings like chess_get_current_games (current games) and chess_get_game_archives (archives).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for historical game retrieval but provides no explicit guidance on when to use this tool versus alternatives, nor does it mention prerequisites or exclusions. Usage is implied but lacks clarity on appropriate contexts.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
chess_get_leaderboardsGet global leaderboardsB
Top players across daily/live formats and tactics/puzzle-rush leaderboards.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and the description only gives basic purpose. It fails to disclose behavioral traits such as authorization needs, rate limits, or return format.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that conveys the core purpose with no unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite low complexity (no parameters), the description lacks details about the structure of returned data, e.g., fields like rating or rank, leaving the agent guessing about the output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With no parameters and 100% schema coverage, the description adds no param details, but baseline for zero-param tools is 4. The description is clear about what is returned.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves top players across daily/live formats and tactics/puzzle-rush leaderboards, distinguishing it from sibling tools like profile or stats retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for getting leaderboard data but does not explicitly state when to use this over alternatives or provide exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
chess_get_profileGet Chess.com player profileB
Public profile info (name, title, country, followers, join date) for a Chess.com username.
| Name | Required | Description | Default |
|---|---|---|---|
| username | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description carries full burden. It states the tool returns public data, implying read-only behavior, but does not mention authentication, rate limits, or error handling conditions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence that is front-loaded with purpose. No unnecessary words. Could benefit from a second sentence for guidelines, but remains efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequately lists returned fields for a simple profile lookup, but lacks output schema or details on response format. Given no output schema and single parameter with 0% coverage, description is sufficient but not comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaning to the 'username' parameter by indicating it is a Chess.com username, but does not specify format, constraints, or validity checks. Schema coverage is 0%, so description partially compensates.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool retrieves public profile info (name, title, country, followers, join date) for a Chess.com username, and the purpose is distinct from sibling tools like chess_get_stats or chess_get_current_games.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. The description implies it is for basic profile info, but does not state when not to use it or suggest other tools for other purposes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
chess_get_statsGet Chess.com player statsB
Rating and win/loss/draw stats per game format (bullet, blitz, rapid, daily, puzzles) for a username.
| Name | Required | Description | Default |
|---|---|---|---|
| username | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavior. It mentions the output includes ratings and stats per format, but fails to indicate whether authentication is needed, error handling (e.g., invalid username), or any side effects. This is insufficient for a tool with no annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that conveys the core function without extraneous words. It is appropriately front-loaded but could be slightly more structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (1 param, no output schema), the description provides basic context. However, it omits details about the return format, error conditions, and any limitations, leaving gaps for the agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage for the single parameter 'username'. The description only says 'for a username', which adds no meaning beyond the field name. It does not specify format, constraints, or examples.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it retrieves rating and win/loss/draw stats per game format for a username. It uses specific resource (stats) and verbs (retrieve), and distinguishes from sibling tools like chess_get_profile and chess_get_current_games.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for getting player stats, but does not explicitly state when to use this tool versus alternatives, nor mention any prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
chess_get_titled_playersList titled playersA
Usernames of all players holding a given title (e.g. GM, IM, FM, WGM, NM).
| Name | Required | Description | Default |
|---|---|---|---|
| title | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It states output is usernames, but does not disclose if it's read-only, auth requirements, or rate limits. For a simple list, this is adequate but minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence efficiently states purpose and examples. No wasted words. Front-loaded with key action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given a single parameter and no output schema, the description covers the main purpose. Could be improved by specifying output format (e.g., array of strings) and any limitations, but is mostly complete for a simple lookup tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, description does not describe the parameter beyond examples. The enum schema already lists all values, so description adds marginal context by giving examples. Does not fully compensate for missing schema description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it returns usernames of players holding a given title, with examples. Verb 'list' and resource 'titled players' are specific. Distinguishes from sibling tools that deal with profiles, stats, games, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use vs alternatives. Purpose is implied but no when-not-to-use or alternative suggestions. However, sibling tools are distinct enough that context is partially clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
9 tool updates
v1.0.0- First observed
chess_get_club - First observed
chess_get_clubs - First observed
chess_get_current_games - First observed
chess_get_game_archives - First observed
chess_get_games_by_month - First observed
chess_get_leaderboards - First observed
chess_get_profile - First observed
chess_get_stats - First observed
chess_get_titled_players
TDQS
Each tool targets a distinct aspect of Chess.com data: titled players, leaderboards, profiles, stats, current games, archives, games by month, and clubs. No ambiguity.
All tools follow a consistent 'chess_get_<noun>' pattern in snake_case, making them predictable and easy to select.
9 tools is well-scoped for a chess server, covering player info, games, and clubs without excess or deficiency.
Covers most essential areas (profiles, stats, games, clubs), but misses puzzle/rush data and tournament info, which are minor gaps.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Chess.com MCP — wraps the Chess.com public API (free, no auth)
Lichess public API: players, ratings, eval, tablebase, opening explorer
Pedagogical chess intelligence for AI agents: explain positions and games for a target Elo.
Query your SEO data in plain language: rankings, audits, backlinks, competitors and AI visibility.
Related MCP Servers
- AlicenseBqualityBmaintenanceProvides access to Chess.com player data, game records, and public information through standardized MCP interfaces, allowing AI assistants to search and analyze chess information.1087MIT
- FlicenseBqualityDmaintenanceEnables interaction with Chess.com's public API to retrieve player profiles and statistics including rating history and performance metrics for any Chess.com username.2-
- AlicenseBqualityDmaintenanceProvides Chess.com player data integration, enabling AI assistants to fetch real-time chess player profiles and comprehensive statistics including ratings, game counts, and performance metrics from Chess.com's public API.2MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to explore player profiles, ratings, game archives, leaderboards, clubs, and puzzles via the Chess.com API.1MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/brettadams0/chesscom-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server