LeetCode MCP Server

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.

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

• 👤 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 @jinzcdev/leetcode-mcp-server -g

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

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

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

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

# Clone the repository
git clone https://github.com/jinzcdev/leetcode-mcp-server.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:

Command-Line Options

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", "@jinzcdev/leetcode-mcp-server"],
      "env": {
        "LEETCODE_SITE": "global",
        "LEETCODE_SESSION": "<YOUR_LEETCODE_SESSION_COOKIE>"
      }
    }
  }
}

Option 2: Using Command Line Arguments

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

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

MCP Client Configuration (Streamable HTTP)

First, start the server in HTTP mode:

npx -y @jinzcdev/leetcode-mcp-server --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 @jinzcdev/leetcode-mcp-server --transport http --port 3000 --site global --session <YOUR_LEETCODE_SESSION_COOKIE>

Available Tools

Problems

Users

Submissions

Notes

Problem Lists

Solutions

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