Skip to main content
Glama

LeetCode MCP Server

NPM Version Chinese Doc NPM Downloads GitHub License LeetCode MCP Server on Glama Stars Docs

The LeetCode MCP Server is a Model Context Protocol (MCP) server that provides seamless integration with LeetCode APIs, enabling advanced automation and intelligent interaction with LeetCode's programming problems, contests, solutions, and user data.

๐Ÿ‘‰ Explore Interactive Documentation & Configurator (GitHub Pages)

Features

  • ๐ŸŒ Multi-site Support: Support both leetcode.com (Global) and leetcode.cn (China) platforms

  • ๐Ÿ”Œ Dual Transport Modes: Run as a stdio process (default) or as a Streamable HTTP server for web-based integrations

  • ๐Ÿ“Š Problem Data Retrieval: Obtain detailed problem descriptions, constraints, examples, official editorials, and user-submitted solutions

  • ๐Ÿ’ป Starter Code Snippets: Extract exact language boilerplate code (get_code_snippet) for 20+ supported languages

  • ๐ŸŽฒ Random Problem Practice: Pick random problems (get_random_problem) filtered by difficulty or tags

  • ๐Ÿ† Contest Schedules & Tracking: Query upcoming Weekly/Biweekly contest schedules (get_upcoming_contests) and user contest rankings

  • ๐Ÿ’ฌ MCP Prompts: First-class prompt workflows for non-spoiler progressive hints (get_hint), problem breakdown (explain_problem), code review (code_review), and mock interviews (mock_interview)

  • ๐Ÿ‘ค User Data Access: Retrieve user profiles, submission history, and contest performance

  • ๐Ÿ”’ Private Data Access: Create and query user notes, manage problem lists, track problem-solving progress, and analyze submission details (AC/WA analysis)

  • ๐Ÿ” Advanced Search Capabilities: Filter problems by tags, difficulty levels, categories, and keywords

  • ๐Ÿ“… Daily Challenge Access: Easily access daily challenge problems

Related MCP server: LeetCode MCP Server

Prerequisites

  1. Node.js (v20.x or above)

  2. (Optional) LeetCode session cookie for authenticated API access

Installation

# Install from npm
npm install @iamrudhresh/mcp-server-leetcode -g

# Run with Global site configuration (stdio transport, default)
npx -y @iamrudhresh/mcp-server-leetcode --site global

# Run with authentication (for accessing private data)
npx -y @iamrudhresh/mcp-server-leetcode --site global --session <YOUR_LEETCODE_SESSION_COOKIE>

# Run as a Streamable HTTP server
npx -y @iamrudhresh/mcp-server-leetcode --transport http --port 3000 --site global

Alternatively, you can clone the repository and run it locally:

# Clone the repository
git clone https://github.com/iamrudhresh/mcp-server-leetcode.git

# Navigate to the project directory
cd leetcode-mcp-server

# Build the project
npm install && npm run build

# Run the server (stdio transport)
node build/index.js --site global

# Or run as a Streamable HTTP server
node build/index.js --transport http --port 3000 --site global

Usage

The server supports two transport modes:

Transport

Description

stdio (default)

Standard input/output transport for local MCP clients

http

Streamable HTTP transport for web-based integrations and remote access

Command-Line Options

Option

Alias

Default

Description

--site

-s

global

LeetCode API site: global (leetcode.com) or cn (leetcode.cn)

--session

-c

โ€”

LeetCode session cookie for authenticated requests

--transport

-t

stdio

Transport mode: stdio or http

--port

โ€”

3000

HTTP server port (Streamable HTTP only)

--host

โ€”

127.0.0.1

HTTP server host (Streamable HTTP only)

--endpoint

โ€”

/mcp

HTTP endpoint path (Streamable HTTP only)

MCP Client Configuration (stdio)

Add the following server entry to your MCP client configuration file:

Option 1: Using Environment Variables

{
  "mcpServers": {
    "leetcode": {
      "command": "npx",
      "args": ["-y", "@iamrudhresh/mcp-server-leetcode"],
      "env": {
        "LEETCODE_SITE": "global",
        "LEETCODE_SESSION": "<YOUR_LEETCODE_SESSION_COOKIE>"
      }
    }
  }
}

Option 2: Using Command Line Arguments

{
  "mcpServers": {
    "leetcode": {
      "command": "npx",
      "args": [
        "-y",
        "@iamrudhresh/mcp-server-leetcode",
        "--site",
        "global",
        "--session",
        "<YOUR_LEETCODE_SESSION_COOKIE>"
      ]
    }
  }
}

For LeetCode China site, modify the --site parameter to cn.

NOTE

The exact configuration file location and JSON structure may vary by MCP client. Some clients use an mcp.servers wrapper or a type field โ€” refer to your client's documentation and adapt the example accordingly.

MCP Client Configuration (Streamable HTTP)

First, start the server in HTTP mode:

npx -y @iamrudhresh/mcp-server-leetcode --transport http --port 3000 --site global

Then connect your MCP client to the running server:

{
  "mcpServers": {
    "leetcode": {
      "type": "http",
      "url": "http://127.0.0.1:3000/mcp"
    }
  }
}

To use authenticated endpoints, pass the session cookie when starting the server:

npx -y @iamrudhresh/mcp-server-leetcode --transport http --port 3000 --site global --session <YOUR_LEETCODE_SESSION_COOKIE>
NOTE

Some MCP clients use"type": "http" or "type": "streamableHttp" alongside the url field. Refer to your client's documentation for the exact HTTP transport configuration format.

TIP

The server supports the following optional environment variables:

  • LEETCODE_SITE: LeetCode API endpoint (global or cn, default: global)

  • LEETCODE_SESSION: LeetCode session cookie for authenticated API access (default: empty)

  • LEETCODE_TRANSPORT: Transport mode (stdio or http, default: stdio)

  • LEETCODE_HTTP_PORT: HTTP server port when using Streamable HTTP (default: 3000)

  • LEETCODE_HTTP_HOST: HTTP server host when using Streamable HTTP (default: 127.0.0.1)

  • LEETCODE_HTTP_ENDPOINT: HTTP endpoint path when using Streamable HTTP (default: /mcp)

Priority Note: Command-line arguments take precedence over environment variables when both are specified. For example:

  • If LEETCODE_SITE=cn is set but you run leetcode-mcp-server --site global, the server will use global.

  • If LEETCODE_SESSION exists but you provide --session "new_cookie", the command-line session value will be used.

Available Tools

Problems

Tool

Global

CN

Auth Required

Description

get_daily_challenge

โœ…

โœ…

โŒ

Retrieves today's LeetCode Daily Challenge problem

get_problem

โœ…

โœ…

โŒ

Retrieves details for a specific LeetCode problem

search_problems

โœ…

โœ…

โŒ

Searches for LeetCode problems with multiple filter criteria

get_code_snippet

โœ…

โœ…

โŒ

Extracts language-specific boilerplate starter code

get_random_problem

โœ…

โœ…

โŒ

Selects a random problem filtered by difficulty or tags

Contests

Tool

Global

CN

Auth Required

Description

get_upcoming_contests

โœ…

โœ…

โŒ

Retrieves upcoming Weekly & Biweekly contest schedule & URLs

get_user_contest_ranking

โœ…

โœ…

โŒ

Obtains contest ranking statistics for a user

Prompts

Prompt

Description

explain_problem

Step-by-step intuitive explanation breaking down problem constraints, patterns, and edge cases

get_hint

Progressive, non-spoiler hints (Level 1: Intuition, Level 2: Data Structure, Level 3: Pseudocode)

code_review

Evaluates submitted code for time/space complexity, correctness, edge cases, and style

mock_interview

Simulates an interactive technical coding interview in a senior FAANG interviewer persona

Users

Tool

Global

CN

Auth Required

Description

get_user_profile

โœ…

โœ…

โŒ

Retrieves profile information for a LeetCode user

get_user_contest_ranking

โœ…

โœ…

โŒ

Obtains contest ranking statistics for a user

get_recent_ac_submissions

โœ…

โœ…

โŒ

Retrieves a user's recent accepted submissions

get_recent_submissions

โœ…

โŒ

โŒ

Retrieves a user's recent submissions history

get_user_status

โœ…

โœ…

โœ…

Retrieves current user's current status

get_problem_submission_report

โœ…

โœ…

โœ…

Provides detailed submission analysis for a specific problem

get_problem_progress

โœ…

โœ…

โœ…

Retrieves current user's problem-solving progress

get_all_submissions

โœ…

โœ…

โœ…

Retrieves current user's submission history

Submissions

Tool

Global

CN

Auth Required

Description

run_code

โœ…

โœ…

โœ…

Runs code for a problem and polls /check/ until finished

submit_solution

โœ…

โœ…

โœ…

Submits code for a problem and polls /check/ until finished

Notes

Tool

Global

CN

Auth Required

Description

search_notes

โŒ

โœ…

โœ…

Searches for user notes with filtering options

get_note

โŒ

โœ…

โœ…

Retrieves notes for a specific problem by question ID

create_note

โŒ

โœ…

โœ…

Creates a new note for a specific problem

update_note

โŒ

โœ…

โœ…

Updates an existing note with new content

Problem Lists

Tool

Global

CN

Auth Required

Description

list_problem_lists

โœ…

โœ…

โœ…

Lists the current user's problem lists (favorites)

get_problem_list

โœ…

โœ…

โœ…

Retrieves a problem list's metadata and its questions

create_problem_list

โœ…

โœ…

โœ…

Creates a new problem list, optionally with initial problems

update_problem_list

โœ…

โœ…

โœ…

Renames a problem list, edits its description or visibility

add_problems_to_list

โœ…

โœ…

โœ…

Adds problems to a problem list by slug or problem number

remove_problems_from_list

โœ…

โœ…

โœ…

Removes problems from a problem list

reorder_problem_list

โœ…

โœ…

โœ…

Reorders the problems inside a problem list

Solutions

Tool

Global

CN

Auth Required

Description

list_problem_solutions

โœ…

โœ…

โŒ

Retrieves a list of community solutions for a specific problem

get_problem_solution

โœ…

โœ…

โŒ

Retrieves the complete content of a specific solution

Tool Parameters

Problems

  • get_daily_challenge - Retrieves today's LeetCode Daily Challenge problem with complete details

    • No parameters required

  • get_problem - Retrieves details about a specific LeetCode problem

    • titleSlug: The URL slug/identifier of the problem (string, required)

  • search_problems - Searches for LeetCode problems based on multiple filter criteria

    • category: Problem category filter (string, optional, default: "all-code-essentials")

    • tags: List of topic tags to filter problems by (string[], optional)

    • difficulty: Problem difficulty level filter (enum: "EASY", "MEDIUM", "HARD", optional)

    • searchKeywords: Keywords to search in problem titles and descriptions (string, optional)

    • limit: Maximum number of problems to return (number, optional, default: 10)

    • offset: Number of problems to skip (number, optional)

Users

  • get_user_profile - Retrieves profile information about a LeetCode user

    • username: LeetCode username (string, required)

  • get_user_contest_ranking - Retrieves a user's contest ranking information

    • username: LeetCode username (string, required)

    • attended: Whether to include only the contests the user has participated in (boolean, optional, default: true)

  • get_recent_submissions - Retrieves a user's recent submissions on LeetCode Global

    • username: LeetCode username (string, required)

    • limit: Maximum number of submissions to return (number, optional, default: 10)

  • get_recent_ac_submissions - Retrieves a user's recent accepted submissions

    • username: LeetCode username (string, required)

    • limit: Maximum number of submissions to return (number, optional, default: 10)

  • get_user_status - Retrieves the current user's status

    • No parameters required

  • get_problem_submission_report - Retrieves detailed information about a specific submission

    • id: The numerical submission ID (number, required)

  • get_problem_progress - Retrieves the current user's problem-solving progress

    • offset: Number of questions to skip (number, optional, default: 0)

    • limit: Maximum number of questions to return (number, optional, default: 100)

    • questionStatus: Filter by question status (enum: "ATTEMPTED", "SOLVED", optional)

    • difficulty: Filter by difficulty levels (string[], optional)

  • get_all_submissions - Retrieves paginated list of user's submissions

    • limit: Maximum number of submissions to return (number, default: 20)

    • offset: Number of submissions to skip (number, default: 0)

    • questionSlug: Optional problem identifier (string, optional)

    • lang: Programming language filter (string, optional, CN only)

    • status: Submission status filter (enum: "AC", "WA", optional, CN only)

    • lastKey: Pagination token for retrieving next page (string, optional, CN only)

Submissions

  • run_code - Runs code for a specific problem and waits until finished (requires authentication)

    • titleSlug: The URL slug/identifier of the problem (string, required)

    • lang: Programming language (string enum, required)

    • typedCode: Source code to run (string, required)

    • dataInput: Custom input to run (string, optional)

    • timeoutMs: Polling timeout in milliseconds (number, optional, default: 120000)

    • pollIntervalMs: Polling interval in milliseconds (number, optional, default: 1500)

  • submit_solution - Submits code for a specific problem and waits until finished (requires authentication)

    • titleSlug: The URL slug/identifier of the problem (string, required)

    • lang: Programming language (string enum, required)

    • typedCode: Source code to submit (string, required)

    • timeoutMs: Polling timeout in milliseconds (number, optional, default: 120000)

    • pollIntervalMs: Polling interval in milliseconds (number, optional, default: 1500)

Notes

  • search_notes - Searches for user notes on LeetCode China

    • keyword: Search term to filter notes (string, optional)

    • limit: Maximum number of notes to return (number, optional, default: 10)

    • skip: Number of notes to skip (number, optional, default: 0)

    • orderBy: Sort order for returned notes (enum: "ASCENDING", "DESCENDING", optional, default: "DESCENDING")

  • get_note - Retrieves user notes for a specific LeetCode problem

    • questionId: The question ID of the LeetCode problem (string, required)

    • limit: Maximum number of notes to return (number, optional, default: 10)

    • skip: Number of notes to skip (number, optional, default: 0)

  • create_note - Creates a new note for a specific LeetCode problem

    • questionId: The question ID of the LeetCode problem (string, required)

    • content: The content of the note, supports markdown format (string, required)

    • summary: An optional short summary or title for the note (string, optional)

  • update_note - Updates an existing note with new content or summary

    • noteId: The ID of the note to update (string, required)

    • content: The new content for the note, supports markdown format (string, required)

    • summary: An optional new short summary or title for the note (string, optional)

Problem Lists

Problem lists are identified by their favoriteSlug, the path segment after /problem-list/ in the list URL.

  • list_problem_lists - Lists the current user's problem lists

    • includeCollected: Also return lists saved from other creators (boolean, optional, default: false)

  • get_problem_list - Retrieves a problem list's metadata and a page of its questions

    • favoriteSlug: The slug of the problem list (string, required)

    • limit: Maximum number of questions to return (number, optional, default: 50)

    • skip: Number of questions to skip (number, optional, default: 0)

    • searchKeyword: Keyword to filter questions by title (string, optional)

    • sortField: Sort field: CUSTOM (the order shown on the website), FRONTEND_ID, DIFFICULTY, AC_RATE, FREQUENCY or CONTEST_POINT (string, optional, default: CUSTOM)

    • sortOrder: ASCENDING or DESCENDING (string, optional, default: ASCENDING)

  • create_problem_list - Creates a new problem list

    • name: Display name of the list (string, required)

    • description: Description of the list (string, optional, default: "")

    • isPublic: Whether the list is publicly visible (boolean, optional, default: false)

    • questionSlugs: Problem slugs to add right after creation (string[], optional)

    • questionIds: Problem numbers to add right after creation, e.g. [1, 1143]; numbers that cannot be resolved are returned in unresolved ((string | number)[], optional)

  • update_problem_list - Renames a problem list, changes its description or toggles its visibility (at least one optional field is required)

    • favoriteSlug: The slug of the problem list (string, required)

    • name: New display name (string, optional)

    • description: New description (string, optional)

    • isPublic: New visibility (boolean, optional)

  • add_problems_to_list - Adds problems to a problem list (at least one of questionSlugs / questionIds is required; problems are appended in the given order, slugs first)

    • favoriteSlug: The slug of the problem list (string, required)

    • questionSlugs: Problem slugs to add, e.g. ["two-sum"] (string[], optional)

    • questionIds: Problem numbers to add, e.g. [1, 1143] or ["LCP 82"]; numbers that cannot be resolved are returned in unresolved ((string | number)[], optional)

  • remove_problems_from_list - Removes problems from a problem list

    • favoriteSlug: The slug of the problem list (string, required)

    • questionSlugs: Problem slugs to remove (string[], required)

  • reorder_problem_list - Reorders the problems inside a problem list (exactly one of sortField / questionSlugs is required; one problem is moved per request)

    • favoriteSlug: The slug of the problem list (string, required)

    • sortField: Sort the whole list by FRONTEND_ID, DIFFICULTY, AC_RATE, FREQUENCY or CONTEST_POINT (string, optional)

    • sortOrder: ASCENDING or DESCENDING (string, optional, default: ASCENDING)

    • questionSlugs: Problem slugs to move to the top, in this order; the remaining problems keep their relative order (string[], optional)

Solutions

  • list_problem_solutions - Retrieves a list of community solutions for a specific problem

    • questionSlug: The URL slug/identifier of the problem (string, required)

    • limit: Maximum number of solutions to return (number, optional, default: 10)

    • skip: Number of solutions to skip (number, optional)

    • userInput: Search term to filter solutions (string, optional)

    • tagSlugs: Array of tag identifiers to filter solutions (string[], optional, default: [])

    • orderBy: Sorting criteria for the returned solutions

      • Global: enum: "HOT", "MOST_RECENT", "MOST_VOTES", optional, default: "HOT"

      • CN: enum: "DEFAULT", "MOST_UPVOTE", "HOT", "NEWEST_TO_OLDEST", "OLDEST_TO_NEWEST", optional, default: "DEFAULT"

  • get_problem_solution - Retrieves the complete content of a specific solution

    • topicId: Unique topic ID of the solution (string, required, Global only)

    • slug: Unique slug/identifier of the solution (string, required, CN only)

Available Resources

Resource Name

Global

CN

Auth Required

Description

problem-categories

โœ…

โœ…

โŒ

A list of all problem classification categories

problem-tags

โœ…

โœ…

โŒ

A detailed collection of algorithmic and data structure tags

problem-langs

โœ…

โœ…

โŒ

A complete list of all supported programming languages

problem-detail

โœ…

โœ…

โŒ

Provides details about a specific problem

problem-solution

โœ…

โœ…

โŒ

Provides the complete content of a specific solution

Resource URIs

  • problem-categories - A list of all problem classification categories

    • URI: categories://problems/all

  • problem-tags - A detailed collection of algorithmic and data structure tags

    • URI: tags://problems/all

  • problem-langs - A complete list of all programming languages supported by LeetCode

    • URI: langs://problems/all

  • problem-detail - Provides details about a specific LeetCode problem

    • URI: problem://{titleSlug}

    • Parameters:

      • titleSlug: Problem identifier as it appears in the LeetCode URL

  • problem-solution - Provides the complete content of a specific solution

    • Global URI: solution://{topicId}

      • Parameters:

        • topicId: Unique topic ID of the solution

    • CN URI: solution://{slug}

      • Parameters:

        • slug: Unique slug/identifier of the solution

Authentication

User-specific data access requires LeetCode session authentication:

  1. Log in to LeetCode (Global or China site)

  2. Extract LEETCODE_SESSION cookie from browser developer tools

  3. Configure server with --session flag or LEETCODE_SESSION environment variable

Response Format

All tools return JSON-formatted responses with the following structure:

{
  "content": [
    {
      "type": "text",
      "text": "JSON_DATA_STRING"
    }
  ]
}

The JSON_DATA_STRING contains either the requested data or an error message for failed requests.

License

This project is licensed under the MIT License.

Available Tools

12 tools
get_code_snippetA

Retrieves starter boilerplate code for a problem in a specified programming language (read-only, no auth). Returns snippet, language, and method signatures as JSON. Use this when writing a solution and needing the exact starter template without fetching the full problem description.

Inputs: lang (required), titleSlug (required).

get_daily_challengeA

Retrieves today's Daily Challenge problem with full description (read-only, no auth). Returns problem details for the current date as JSON. Use get_problem when you know a specific titleSlug; use search_problems to discover problems by filters.

Inputs: no named parameters.

get_problemA

Retrieves a single LeetCode problem by titleSlug (read-only, no auth). Returns description, examples, constraints, and metadata as JSON. Use search_problems to find problems by keyword/tag/difficulty; use get_daily_challenge for today's featured problem.

Inputs: titleSlug (required).

get_problem_solutionA

Retrieves full content of a community solution article (read-only, no auth). Requires topicId from list_problem_solutions. Returns article text, author, and metadata as JSON. Use list_problem_solutions first to discover solutions and obtain topicId.

Inputs: topicId (required).

get_random_problemA

Picks a random LeetCode problem optionally filtered by difficulty, category, and topic tags (read-only, no auth). Returns randomly selected problem details as JSON. Useful for mock interview preparation or algorithmic practice.

Inputs: tags, category, difficulty.

get_recent_ac_submissionsA

Retrieves a user's recent accepted (AC) submissions (read-only, no auth). Available on both Global and CN. Use get_recent_submissions (Global only) to include failed attempts, or get_all_submissions (auth, current user) for full paginated history.

Inputs: username (required), limit.

get_recent_submissionsA

Retrieves a user's recent submission history on LeetCode Global (read-only, no auth). Includes both accepted and failed submissions. Global onlyโ€”not available on CN. Use get_recent_ac_submissions for accepted-only results, or get_all_submissions (auth, current user) for paginated full history with filters.

Inputs: username (required), limit.

get_upcoming_contestsA

Retrieves the schedule of upcoming LeetCode contests (read-only, no auth). Returns titles, slugs, start times (epoch & ISO), durations, and direct registration links as JSON. Use this to check upcoming Weekly or Biweekly contests.

Inputs: no named parameters.

get_user_contest_rankingA

Retrieves a user's contest ranking and participation history (read-only, no auth). Returns overall rating, ranking, and per-contest performance as JSON. Use get_user_profile for general stats and ranking; use this specifically for contest performance data.

Inputs: username (required), attended.

get_user_profileA

Retrieves any user's public profile by username (read-only, no auth). Returns ranking, avatar, bio, submission stats, and platform-specific progress. Use this to look up other users or public stats. Use get_user_status (requires auth) instead to verify the current session user's login stateโ€”not for looking up arbitrary users.

Inputs: username (required).

list_problem_solutionsA

Lists community solution articles for a problem (read-only, no auth). Returns metadata only (topicId)โ€”not full content. Use get_problem_solution with the returned topicId to read the full article. Do not call this when you already have a topicId and need the solution text.

Inputs: questionSlug (required), skip, limit, orderBy, +2 more.

search_problemsA

Searches LeetCode problems by category, tags, difficulty, and keywords (read-only, no auth). Supports pagination via limit/offset. Returns matching problem list as JSON. Use get_problem when you already know the titleSlug; use this to browse or discover problems.

Inputs: tags, limit, offset, category, +2 more.

Tool Schema Changelog

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

Loading tool schema changelogโ€ฆ

    TDQS

    A4.1/5.0

    Scored across 12 tools

    Disambiguation4/5

    Most tools target a distinct resource+mode (problem fetch, search, random, daily challenge, solutions list vs. read, contest schedule vs. ranking, profile, submissions), and descriptions actively cross-reference siblings to steer selection. The only soft overlaps are get_recent_submissions vs. get_recent_ac_submissions and get_problem vs. get_random_problem/get_daily_challenge, but the descriptions spell out the boundaries. Minor deduction because descriptions reference tools not present in the set (get_user_status, get_all_submissions), which can muddy an agent's mental model.

    Naming Consistency5/5

    All 12 names are snake_case with a predictable verb_noun pattern using a small verb vocabulary (get_, list_, search_). Variants are distinguished by clear, consistent suffixes (get_recent_submissions vs. get_recent_ac_submissions). No mixed conventions anywhere.

    Tool Count5/5

    Twelve tools sit squarely in the well-scoped range, and each covers a discrete capability (problem retrieval, discovery, solutions, code snippets, contests, user stats, submissions). Nothing appears redundant enough to remove, and the surface is not bloated.

    Completeness4/5

    The read-only surface covers the core LeetCode workflows well: problem discovery/retrieval, solutions, starter code, contests, profiles, and submission history. Gaps are mostly ones the descriptions themselves advertise but do not deliver (get_user_status, paginated get_all_submissions with filters), plus no official editorial or CN-specific variants. These are workable but leave dead references in the descriptions.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    • Lichess MCP server for ChatGPT, Claude and any AI agent: accept team join request, send team update, create Arena tournament, create broadcast, import PGN to study and export games in your own Lichess account. Cotlet works in the account through your Cloud Browser, a real Chrome where you sign in to Lichess yourself; Cotlet does not store your password and you need no Lichess API key. About the official Lichess API: Lichess has a full, free REST API with personal and OAuth tokens, but no official MCP server (checked 17 Oct 2026). The API covers teams, Arena and Swiss tournaments, studies, broadcasts, challenges and game export, so the gap is a hosted, maintained MCP with no token to create, scope or revoke. Setup and FAQ: https://cotlet.dev/integrations/lichess-api-mcp-server

      https://cotlet.dev/mcp/v1/lichess
    • Automate any website: discover, run and create browser scripts that work behind logins.

      https://mcp.reduck.ai/mcp
    • Hacker News MCP server for ChatGPT, Claude and any AI agent: list upvoted items, list hidden items, list favorites, list my comment threads, get an item with its comments, favorite an item and hide an item in your own Hacker News account. Cotlet works in the account through your Cloud Browser, a real Chrome where you sign in to Hacker News yourself; Cotlet does not store your password and you need no Hacker News API key. About the official Hacker News API: Hacker News has an official API, but it is read-only and public (checked 28 Oct 2026). It returns items, users and the story lists. Setup and FAQ: https://cotlet.dev/integrations/hacker-news-api-mcp-server

    • Overleaf MCP server for ChatGPT, Claude and any AI agent: list projects, read file, edit file, compile project, add comment, reply to comment, accept tracked change and invite collaborator in your own Overleaf account. Cotlet works in the account through your Cloud Browser, a real Chrome where you sign in to Overleaf yourself; Cotlet does not store your password and you need no Overleaf API key. About the official Overleaf API: Overleaf has no public API to read or change existing projects (checked 5 Nov 2026). Its only API, Open in Overleaf, sends LaTeX in one direction to create a new project. Setup and FAQ: https://cotlet.dev/integrations/overleaf-api-mcp-server

    Related MCP Servers