MCP Server

The Model Context Protocol (MCP) is an open standard that lets AI-powered code editors connect to external tools and data sources. Instead of copying documentation into prompts or switching between your editor and a browser, MCP gives your AI assistant direct access to APIs, schemas, and reference material in real time.

The Lithic MCP server brings this capability to the Lithic Developer API. Once connected, your AI assistant can search Lithic documentation, inspect endpoint schemas, generate integration code, and execute live API requests, all from within your editor.

Lithic's MCP server works with any MCP-compatible client, including (but not limited to) Cursor, Claude Code, VS Code with GitHub Copilot, Windsurf / Devin Desktop, Cline, Claude Desktop, Claude.ai, ChatGPT, JetBrains IDEs, Gemini CLI, and Codex CLI.

Capabilities

Once connected, your AI coding assistant can:

• Search Lithic documentation: find guides, API references, and code examples by keyword
• Explore API endpoints: list all endpoints and inspect their request and response schemas
• Execute live API requests: call the Lithic API directly from your editor (requires a Lithic API key)
• Generate integration code: build Lithic integrations with real context from the API specification

Prerequisites

• An AI code editor or chat app that supports MCP (see supported clients below)
• A Lithic API key (authentication guide) (required for executing API requests; documentation search and exploration work without one)
• For sandbox testing, use a Sandbox API key to safely simulate transactions

Lithic MCP Server URL

Lithic hosts a remote MCP server at:

https://docs.lithic.com/mcp

This is a hosted server. No local installation, npm install, or Docker setup is required. Add the URL to your editor's MCP configuration and you're ready to go.

Store Your API Key in a .env File

To execute live API requests through the MCP server, your AI assistant needs access to your Lithic API key. The recommended approach is to store it in a .env file in your project root so your assistant can read it when making requests.

Create a .env file in your project directory:

# .env
LITHIC_API_KEY=your_sandbox_api_key_here

Replace your_sandbox_api_key_here with your actual key. You can find your Sandbox API key in the Lithic Dashboard.

# .gitignore
.env

Your AI assistant can then read the key from this file and include it as an Authorization header when using the execute-request tool. See Improving Tool Discovery with Custom Instructions for how to tell your assistant where to find the key.

Connect Your Editor or Chat App

Select your editor or chat app and follow the setup instructions. Each section includes the exact configuration or steps you need.

Cursor

To connect Lithic to Cursor, add the MCP server to your project-level config (.cursor/mcp.json) or global config (~/.cursor/mcp.json):

{
  "mcpServers": {
    "lithic": {
      "url": "https://docs.lithic.com/mcp"
    }
  }
}

You can also add it from Cursor's Customize page (opened from the sidebar), which manages MCP servers and edits the same mcp.json. In Cursor 3.9 and later, this replaced the older Settings > Features > MCP Servers screen.

Claude Code

Use the CLI to add the Lithic MCP server:

# Add to your current project
claude mcp add lithic --transport http https://docs.lithic.com/mcp

# Or add globally (available across all projects)
claude mcp add lithic --transport http --scope user https://docs.lithic.com/mcp

To share the configuration with your team, add a .mcp.json file to your project root instead:

{
  "mcpServers": {
    "lithic": {
      "type": "http",
      "url": "https://docs.lithic.com/mcp"
    }
  }
}

VS Code (GitHub Copilot)

To connect Lithic to VS Code with GitHub Copilot, add a .vscode/mcp.json file to your project:

{
  "servers": {
    "lithic": {
      "type": "http",
      "url": "https://docs.lithic.com/mcp"
    }
  }
}

Lithic MCP tools are available in Copilot Chat (Agent mode). Select "Agent" from the mode dropdown. MCP support is generally available in VS Code 1.102 and later. Copilot Chat is built into current versions of VS Code, so you only need to sign in with a GitHub account (the free Copilot tier works).

Windsurf (now Devin Desktop)

Windsurf was rebranded to Devin Desktop (Cognition, June 2026); existing installs update over the air. To connect Lithic, open Devin Settings > Cascade > MCP Servers, or edit ~/.codeium/windsurf/mcp_config.json directly. The config file path and keys are unchanged by the rebrand:

{
  "mcpServers": {
    "lithic": {
      "serverUrl": "https://docs.lithic.com/mcp"
    }
  }
}

Cline

To connect Lithic to Cline, click the MCP Servers icon in the Cline panel, open the Configure tab, then click Configure MCP Servers and add:

{
  "mcpServers": {
    "lithic": {
      "type": "streamableHttp",
      "url": "https://docs.lithic.com/mcp",
      "autoApprove": [],
      "disabled": false
    }
  }
}

Claude Desktop

To connect Lithic to Claude Desktop, use Custom Connectors:

1. Open Settings (Cmd+, on macOS, Ctrl+, on Windows), then select Connectors
2. Click "Add custom connector"
3. Enter a name (for example, Lithic) and the MCP server URL: https://docs.lithic.com/mcp
4. Leave the OAuth fields blank (this server needs no authentication) and click "Add"

Custom connectors are the recommended way to add remote MCP servers in Claude Desktop. No restart is required; enable the connector in a chat with the "+" button. If the connector doesn't appear after you add it, fully quitting and relaunching Claude Desktop (closing the window is not enough) is a known fix.

Claude.ai (Web)

To connect Lithic to Claude.ai, use the Connectors feature (currently in beta). Available on all plans (Free users are limited to one custom connector).

1. Open Customize > Connectors
2. Click "+", then "Add custom connector"
3. Enter a name (for example, Lithic) and the MCP server URL: https://docs.lithic.com/mcp
4. Leave the OAuth fields blank and click "Add" (no credentials are needed for this server)

To use the connector in a conversation, click the "+" button at the bottom of the chat input, select "Connectors", and enable the Lithic connector. You can toggle connectors on and off per conversation.

JetBrains IDEs

To connect Lithic to JetBrains IDEs (IntelliJ IDEA, PyCharm, WebStorm, and others), open Settings > Tools > AI Assistant > Model Context Protocol (MCP) and add a new server:

• Transport: Streamable HTTP (choose this over the legacy SSE option)
• URL: https://docs.lithic.com/mcp

Set the server level (global or current project), click Apply, and check the Status column to confirm it connects. Requires JetBrains IDE version 2025.1 or later with the AI Assistant plugin enabled.

ChatGPT

To connect Lithic to ChatGPT, use MCP through Developer Mode. Available to Plus, Pro, Business, Enterprise, and Education accounts on the web.

Step 1: Enable Developer Mode

1. Open Settings > Security and login
2. Toggle Developer mode on

On Business, Enterprise, and Education workspaces, an admin must allow Developer Mode before the toggle appears.

Step 2: Add the Lithic connector

1. Open Settings > Plugins, or go directly to chatgpt.com/plugins
2. Click "+" to create a new developer-mode app and fill in the fields:
   • Name: Lithic
   • Description: Search Lithic API documentation, explore endpoints, and execute API requests
   • MCP Server URL: https://docs.lithic.com/mcp
   • Authentication: No Authentication
3. Click "Create"

Step 3: Enable per conversation

Developer-mode apps are not automatically active. In each new conversation:

1. Click "+" near the message composer, then "More", then select "Developer mode"
2. Select the Lithic app for that conversation

Gemini CLI

To connect Lithic to Gemini CLI, use the gemini mcp add command with the HTTP transport:

# Add for the current project
gemini mcp add --transport http lithic https://docs.lithic.com/mcp

# Or add for all projects
gemini mcp add --transport http --scope user lithic https://docs.lithic.com/mcp

Alternatively, edit ~/.gemini/settings.json (user scope) or .gemini/settings.json (project scope) directly:

{
  "mcpServers": {
    "lithic": {
      "httpUrl": "https://docs.lithic.com/mcp"
    }
  }
}

Run /mcp list inside Gemini CLI to confirm lithic is connected.

Codex CLI

To connect Lithic to Codex CLI, add the server to your Codex configuration. Edit ~/.codex/config.toml (all projects) or <project>/.codex/config.toml:

[mcp_servers.lithic]
url = "https://docs.lithic.com/mcp"

Type /mcp inside an interactive Codex session to confirm lithic is connected.

Verify Your Setup

After configuring your editor or chat app, open a new chat and try one of these prompts:

• "How do I create a card in the Lithic Sandbox?"
• "Show me the request body for creating an authorization rule."
• "What endpoints are available for transaction management?"
• "Simulate a transaction in the Lithic Sandbox."

Your assistant should respond with accurate, up-to-date information pulled directly from the Lithic API documentation and endpoint schemas.

Troubleshooting

MCP server not appearing in my editor

• Double-check that the URL is exactly https://docs.lithic.com/mcp with no trailing slash
• In Claude Desktop, if the connector doesn't appear after you add it, fully quit and relaunch the app (closing the window is not enough)
• In Cursor, try toggling the server off and on from the Customize page
• In Claude.ai or Claude Desktop, if adding the connector shows a sign-in or registration error even though this server needs no authentication, remove and re-add it; if that doesn't help, use the mcp-remote fallback described under Claude Desktop

Tools aren't being used by my AI assistant

• Make sure you're in Agent mode (or Plan Mode in Cursor); this is required in Cursor, VS Code Copilot, and Claude Code
• In VS Code, confirm the "type": "http" field is present. It's required and easy to miss
• In Claude.ai, make sure the connector is enabled for the current conversation via the "+" button
• In ChatGPT, make sure Developer mode is active in the current conversation
• If your assistant ignores the tools even when connected, try adding custom instructions

API requests are failing

• The execute-request tool requires a valid Lithic API key. Documentation search and endpoint exploration work without one
• Use a Sandbox API key for testing to avoid affecting live data

Improving Tool Discovery with Custom Instructions

AI assistants automatically detect available MCP tools, but they don't always use them unprompted, especially if you have many MCP servers connected or if your question doesn't obviously match a tool name. Adding a short instruction to your editor's configuration can improve how reliably your assistant reaches for the Lithic tools.

Where to add instructions by client:

Example instruction to add:

When working with the Lithic API (cards, transactions, accounts, authorization rules,
payments, or webhooks), use the Lithic MCP tools to search documentation, explore
endpoints, and execute API requests. Use the Sandbox environment for testing.

When executing Lithic API requests, read the API key from the .env file
(LITHIC_API_KEY) and pass it as an Authorization header.

This is optional but recommended if you find your assistant isn't using the Lithic tools when it should be. For initial setup, see Connect Your Editor or Chat App.

Available MCP Tools

The Lithic MCP server exposes the following tools to your AI assistant:

Configuration Reference

A quick comparison of how each client handles MCP configuration:

Frequently Asked Questions

What is the Lithic MCP server?

The Lithic MCP server is a hosted service that connects AI code editors and chat apps to the Lithic Developer API using the Model Context Protocol standard. It lets your AI assistant search Lithic documentation, explore API endpoints, and execute live API requests from within your editor or chat interface.

Do I need a Lithic API key to use the MCP server?

Not for everything. Documentation search, endpoint exploration, and schema inspection all work without an API key. You only need a Lithic API key to execute live API requests using the execute-request tool.

Which AI tools support the Lithic MCP server?

Any tool that supports the Model Context Protocol. This includes Cursor, Claude Code, VS Code with GitHub Copilot, Windsurf / Devin Desktop, Cline, Claude Desktop, Claude.ai, ChatGPT, JetBrains IDEs, Gemini CLI, and Codex CLI. See Connect Your Editor or Chat App for setup instructions.

Do I need to install anything locally?

No. The Lithic MCP server is hosted at https://docs.lithic.com/mcp. You just add the URL to your editor's MCP configuration. No npm packages, Docker containers, or local server processes required.

Can I use this with the Lithic Sandbox?

Yes. Use a Sandbox API key when executing API requests to test against the Lithic Sandbox environment without affecting production data.

How do I use the Lithic API with AI coding tools?

Add the Lithic MCP server URL (https://docs.lithic.com/mcp) to your editor's MCP configuration. This gives your AI assistant direct access to Lithic's documentation, API endpoint schemas, and the ability to execute API requests. See Connect Your Editor for step-by-step setup instructions for each supported editor.

How do I connect Cursor to the Lithic API?

Add the Lithic MCP server URL to your Cursor configuration at .cursor/mcp.json. Once connected, Cursor's AI assistant can search Lithic docs, explore endpoints, and execute API requests directly in your editor. See the Cursor setup instructions for the exact configuration.

How do I use Lithic with Claude Code?

Run claude mcp add lithic --transport http https://docs.lithic.com/mcp to add the Lithic MCP server to Claude Code. Your assistant will then have access to all Lithic API documentation and endpoints. See the Claude Code setup instructions for details.

How do I connect VS Code Copilot to the Lithic API?

Add a .vscode/mcp.json file with the Lithic MCP server URL. Note that VS Code uses "servers" (not "mcpServers") and requires a "type": "http" field. See the VS Code setup instructions for the exact configuration.

Does Lithic work with Gemini CLI, Codex CLI, or JetBrains IDEs?

Yes. See the setup steps for Gemini CLI, Codex CLI, and JetBrains IDEs (IntelliJ, PyCharm, WebStorm, and others). Each connects to the same server URL (https://docs.lithic.com/mcp).

What is the Model Context Protocol (MCP)?

The Model Context Protocol is an open standard that allows AI assistants to connect to external tools and data sources. It provides a consistent way for code editors like Cursor, VS Code, and Claude Code to integrate with APIs and documentation. The Lithic MCP server implements this protocol so your AI assistant can work with the Lithic API natively.