Dodo Payments MCP Server

Overview

The Model Context Protocol (MCP) is an open standard that lets AI applications connect to external data sources and APIs. The Dodo Payments MCP Server gives AI assistants like Claude, Cursor, and other MCP-compatible clients access to your payment infrastructure. The Dodo Payments MCP Server uses Code Mode architecture. Instead of exposing hundreds of individual tools for every API endpoint, Code Mode lets AI agents write and execute TypeScript code against the Dodo Payments SDK in an isolated sandbox.

Key Capabilities

Payment Operations — Create, retrieve, and manage payments and refunds
Subscription Management — Handle recurring billing, upgrades, and cancellations
Customer Administration — Manage customer data and portal access
Product Catalog — Create and update products, pricing, and discounts
License Management — Activate, validate, and manage software licenses
Usage-Based Billing — Track and bill for metered usage

How Code Mode Works

The Dodo Payments MCP Server gives your AI agent two tools:

Docs Search Tool — Queries documentation about the Dodo Payments API and SDK to understand available operations and parameters.
Code Execution Tool — Writes TypeScript code against the SDK that executes in a secure sandbox.

This architecture lets agents perform complex, multi-step operations in a single invocation. For example, an agent can list all active subscriptions, filter them by criteria, and apply a discount to each—all in one script.

Agents can chain multiple API calls, handle conditional logic, and perform calculations without round-tripping back to the LLM.

Quick Setup

Connect to the Dodo Payments MCP Server in your AI client:

Agent Plugin (recommended)
Cursor
Claude Desktop
Windsurf
Claude Code

The Dodo Agent Plugin installs both MCP servers and all seventeen skills in one step for Claude Code, Codex CLI, Cursor, VS Code / GitHub Copilot, Kiro, and OpenCode (OpenCode needs one extra skills.paths setting). Gemini CLI gets the two MCP servers only, since it has no agent-skill primitive. See the AI Coding Agents guide for per-agent install commands.If your agent isn’t in that list, use the tabs below to configure the MCP server directly.

Add to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/mcp"]
    }
  }
}

Add to your Claude Desktop configuration:

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/mcp"]
    }
  }
}

Configuration file locations:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json

Add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/mcp"]
    }
  }
}

Run in your terminal:

claude mcp add dodopayments -- npx -y mcp-remote@latest https://mcp.dodopayments.com/mcp

Requires Node.js 18 or higher. The remote server uses OAuth for authentication. On first connection, you’ll be prompted to enter your API key and select your environment.

Dodo Knowledge MCP

In addition to the Dodo Payments MCP Server (for executing API operations), we provide Dodo Knowledge MCP—a semantic search server that gives AI assistants instant access to Dodo Payments documentation.

Built with ContextMCP.ai: Dodo Knowledge MCP is powered by ContextMCP, enabling fast semantic search across our documentation using vector embeddings.

What is Dodo Knowledge MCP?

Dodo Knowledge MCP is a remote MCP server that provides semantic documentation search. Find relevant documentation using natural language queries, get accurate up-to-date information about Dodo Payments, and connect with no API keys or local installation required.

Quick Setup

Connect to Dodo Knowledge MCP in your AI client:

Cursor
Claude Desktop
Windsurf
Claude Code

Add to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "dodo-knowledge": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://knowledge.dodopayments.com/mcp"]
    }
  }
}

Add to your Claude Desktop configuration:

{
  "mcpServers": {
    "dodo-knowledge": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://knowledge.dodopayments.com/mcp"]
    }
  }
}

Configuration file locations:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json

Add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "dodo-knowledge": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://knowledge.dodopayments.com/mcp"]
    }
  }
}

Run in your terminal:

claude mcp add dodo-knowledge -- npx -y mcp-remote@latest https://knowledge.dodopayments.com/mcp

Requires Node.js 18 or higher. The mcp-remote package handles the connection to the remote MCP server.

Using Both MCP Servers Together

For the best AI-assisted development experience, use both MCP servers:

Server	Purpose	Use Case
Dodo Knowledge MCP	Documentation search	”How do I handle webhooks?”, “What payment methods are supported?”
Dodo Payments MCP	API operations	Create payments, manage subscriptions, handle refunds

{
  "mcpServers": {
    "dodo-knowledge": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://knowledge.dodopayments.com/mcp"]
    },
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/mcp"]
    }
  }
}

With both servers configured, your agent can search documentation to understand a feature, then execute the API calls to implement it—all in one conversation.

Troubleshooting Knowledge MCP

If you encounter connection issues, clear the MCP authentication cache with rm -rf ~/.mcp-auth, restart your client application, check client logs for error messages, and verify Node.js version (requires 18+).

Knowledge MCP Server

Access the Dodo Knowledge MCP configuration page

Installation

Choose the installation method that fits your workflow.

Remote MCP Server (Recommended)

Access the hosted MCP server without local setup or installation.

Access the remote server

Navigate to https://mcp.dodopayments.com in your browser.

Configure your MCP client

Copy the provided JSON configuration for your specific client. For Cursor or Claude Desktop, add this to your MCP settings:

{
  "mcpServers": {
    "dodopayments_api": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/mcp"]
    }
  }
}

Authenticate and configure

The OAuth flow will prompt you to:

Enter your Dodo Payments API key
Select your environment (test or live)
Choose your MCP client type

Keep your API key secure. Use test mode keys during development.

Complete setup

Click Login and Approve to authorize the connection.

Once connected, your AI assistant can interact with the Dodo Payments API on your behalf.

NPM Package

Install and run the MCP server locally.

The local server runs your code in a Deno sandbox. Install Deno 2.8 or earlier and make sure deno is on your PATH; the sandbox fails to start on Deno 2.9 and later. Local code execution works on macOS and Linux only. On Windows, use the remote server or run the local server under WSL2.

NPX (No Installation)
MCP Client Configuration

# Set your environment variables
export DODO_PAYMENTS_API_KEY="dodo_test_..."
export DODO_PAYMENTS_WEBHOOK_KEY="your_webhook_key"
export DODO_PAYMENTS_ENVIRONMENT="test_mode"

# Run the latest version
npx -y dodopayments-mcp@latest

{
  "mcpServers": {
    "dodopayments_api": {
      "command": "npx",
      "args": ["-y", "dodopayments-mcp@latest"],
      "env": {
        "DODO_PAYMENTS_API_KEY": "dodo_test_...",
        "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key",
        "DODO_PAYMENTS_ENVIRONMENT": "test_mode"
      }
    }
  }
}

Use @latest to always pull the most recent version, or pin to a specific version like @2.51.0 for stability.

Docker

Run the MCP server in a container.

# Pull the latest image
docker pull ghcr.io/dodopayments/mcp:latest

# Run the container (-i keeps stdin open for the stdio transport)
docker run -i -e DODO_PAYMENTS_API_KEY="dodo_test_..." \
  -e DODO_PAYMENTS_WEBHOOK_KEY="your_webhook_key" \
  -e DODO_PAYMENTS_ENVIRONMENT="test_mode" \
  ghcr.io/dodopayments/mcp:latest

Docker images are available on GitHub Container Registry.

Client Configuration

Configure the Dodo Payments MCP server in your preferred AI client.

Set up the Dodo Payments MCP server in Cursor to enable conversational access to your payments data.One-Click InstallUse the button below to install the MCP server directly in Cursor:

After clicking, set your environment variables in Cursor’s mcp.json via Cursor Settings > Tools & MCP > New MCP Server.Manual Configuration

Open Cursor settings

Navigate to Cursor Settings > Tools & MCP or press Cmd/Ctrl + Shift + P and search for “MCP Settings”.

Edit configuration

Click New MCP Server to open the mcp.json file.

Add Dodo Payments configuration

Choose one of the following configurations:Remote Server (Recommended)

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/mcp"]
    }
  }
}

Local NPX

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "dodopayments-mcp@latest"],
      "env": {
        "DODO_PAYMENTS_API_KEY": "dodo_test_...",
        "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
      }
    }
  }
}

Save and restart

Save the configuration file and restart Cursor.

Verify the connection by asking the AI assistant about your Dodo Payments data.

Set up the Dodo Payments MCP server in Claude Desktop to enable conversational access to your payments data.

Locate configuration file

Find the Claude Desktop configuration file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json

Edit configuration

Open the file in a text editor and add the Dodo Payments configuration:Remote Server (Recommended)

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/mcp"]
    }
  }
}

Local NPX

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "dodopayments-mcp@latest"],
      "env": {
        "DODO_PAYMENTS_API_KEY": "dodo_test_...",
        "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
      }
    }
  }
}

Restart Claude Desktop

Close and reopen Claude Desktop for the changes to take effect.

Look for the 🔌 icon in Claude Desktop to confirm the MCP server is connected.

Set up the Dodo Payments MCP server in Claude Code CLI.Run the following command in your terminal:

claude mcp add --transport stdio dodopayments_api \
  --env DODO_PAYMENTS_API_KEY="dodo_test_..." \
  DODO_PAYMENTS_WEBHOOK_KEY="your_webhook_key" \
  -- npx -y dodopayments-mcp

The configuration will be stored in your home directory’s .claude.json file.

Claude Code automatically picks up environment variables from your shell, so you can also export them before running the command.

Set up the Dodo Payments MCP server in VS Code.One-Click InstallOpen VS CodeAfter clicking, set your environment variables in VS Code’s mcp.json via Command Palette > MCP: Open User Configuration.Manual Configuration

Open MCP configuration

Open the Command Palette (Cmd/Ctrl + Shift + P) and search for “MCP: Open User Configuration”.

Add server configuration

Add the Dodo Payments MCP server:

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "dodopayments-mcp@latest"],
      "env": {
        "DODO_PAYMENTS_API_KEY": "dodo_test_...",
        "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
      }
    }
  }
}

Reload window

Reload VS Code (Cmd/Ctrl + Shift + P > “Reload Window”) to activate the MCP server.

Set up the Dodo Payments MCP server in Cline (VS Code) to enable conversational access to your payments data.

Open Cline settings

Locate the Cline configuration file:

macOS: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
Windows: %APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json
Linux: ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json

Configure MCP server

Add the Dodo Payments MCP server configuration:

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "dodopayments-mcp@latest"],
      "env": {
        "DODO_PAYMENTS_API_KEY": "dodo_test_...",
        "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
      }
    }
  }
}

Reload VS Code

Reload the VS Code window (Cmd/Ctrl + Shift + P > “Reload Window”) to activate the MCP server connection.

Set up the Dodo Payments MCP server in Zed to enable conversational access to your payments data.

Open Zed settings

Navigate to Settings > Assistant > Model Context Protocol.

Add server configuration

Add the following configuration:

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "dodopayments-mcp@latest"],
      "env": {
        "DODO_PAYMENTS_API_KEY": "dodo_test_...",
        "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
      }
    }
  }
}

Save and verify

Save the configuration. The MCP server should now be available in Zed’s AI assistant.

Set up the Dodo Payments MCP server in other MCP-compatible clients.Remote Server (Recommended)

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/mcp"]
    }
  }
}

Local NPX

{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "dodopayments-mcp@latest"],
      "env": {
        "DODO_PAYMENTS_API_KEY": "dodo_test_...",
        "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
      }
    }
  }
}

Visit modelcontextprotocol.io/clients for a complete list of MCP-compatible clients and their configuration methods.

Environment Variables

Configure the MCP server behavior using environment variables.

Variable	Description	Required
`DODO_PAYMENTS_API_KEY`	Your Dodo Payments API key	Yes
`DODO_PAYMENTS_WEBHOOK_KEY`	Your webhook signing key	No
`DODO_PAYMENTS_ENVIRONMENT`	`live_mode` or `test_mode`; defaults to `live_mode`	No

Running Remotely

Deploy the MCP server as a remote HTTP server for web-based clients or agentic workflows.

# Start as remote server
npx -y dodopayments-mcp --transport=http

# Specify a custom port
npx -y dodopayments-mcp --transport=http --port=3000

Remote Server Configuration

Once deployed, clients can connect using the server URL:

{
  "mcpServers": {
    "dodopayments_api": {
      "url": "http://localhost:3000",
      "headers": {
        "Authorization": "Bearer your_api_key"
      }
    }
  }
}

Authorization Headers

The remote server accepts authentication via the following headers:

Header	Purpose
`Authorization`	Bearer token authentication
`x-dodo-payments-api-key`	Direct API key header

Security Best Practices

Code Mode provides inherent security by executing code in a sandboxed environment and injecting API keys server-side. Follow these best practices to protect your credentials.

API Key Management

Never commit credentials to version control. Store API keys in environment variables or secure secret management systems:

# Use environment variables
export DODO_PAYMENTS_API_KEY="dodo_test_..."

# Use a .env file (add to .gitignore)
echo "DODO_PAYMENTS_API_KEY=dodo_test_..." > .env

Rotate keys regularly by generating new API keys periodically and revoking old ones through your Dodo Payments dashboard. Always use test mode API keys during development to avoid affecting production data.

Access Control

When deploying remotely, always require authentication via the Authorization header or x-dodo-payments-api-key header.

Network Security

Always deploy remote MCP servers behind HTTPS endpoints. Protect against abuse by implementing rate limits at both the MCP server and API levels. Configure firewall rules to limit which clients can connect to your MCP server.

Troubleshooting

Connection issues

Verify your API key is correctly set and has the necessary permissions:

# Test your API key
curl -H "Authorization: Bearer dodo_test_..." \
  https://test.dodopayments.com/payments

Check that you can reach the Dodo Payments API endpoints. Enable verbose logging in your MCP client to diagnose connection problems.

Authentication errors

Ensure you’re using test keys with test endpoints and live keys with production endpoints. Verify DODO_PAYMENTS_ENVIRONMENT is set correctly (live_mode for production). If issues persist, generate a new API key through your dashboard.

Tool execution failures

Ensure the AI assistant is providing correctly formatted parameters for each tool. Check the error response from the API for specific guidance on what went wrong. Verify the operation works when calling the Dodo Payments API directly via curl or Postman.

Why Code Mode

Traditional MCP implementations suffer from “tool proliferation,” where every API endpoint is exposed as a separate tool. Code Mode is better for several reasons:

LLMs Are Better at Writing Code Than Calling Tools

LLMs are trained on millions of lines of real-world code, so they naturally write scripts well. Tool-calling is often based on synthetic examples.

“Making an LLM perform tasks with tool calling is like putting Shakespeare through a month-long class in Mandarin and then asking him to write a play in it.” — Cloudflare

Eliminates Context Window Bloat

In traditional approaches, every tool definition consumes tokens before the conversation starts. Exposing 50+ tools can consume 55K–100K+ tokens. Anthropic found tool definitions could consume up to 134K tokens before optimization. Code Mode loads only 2 tool definitions (~1K tokens). The agent searches documentation on-demand. Anthropic’s Tool Search Tool preserved 95% of the context window, reducing overhead from 77K to 8.7K tokens.

Reduces Latency via Programmatic Orchestration

Traditional tool-calling requires a full model inference round-trip for every operation. If a task requires 20 API calls, that’s 20 round-trips. In Code Mode, the agent writes one script that executes all calls and returns only the final result. Anthropic observed a 37% reduction in tokens and improved accuracy (knowledge retrieval improved from 25.6% to 28.5%) using this approach.

More Secure by Design

Code Mode provides inherent security benefits:

No API keys in parameters — API keys are injected server-side and never exposed in tool parameters sent to the LLM.
Isolated sandbox — Code runs in a secure environment with no access to the network or host filesystem.
Controlled SDK — Only authorized SDK methods are available to the agent.

Scales to Any API Size

As an API grows, traditional MCP performance degrades because more tools must be loaded. Code Mode remains constant with 2 tools regardless of API surface area. Cloudflare collapsed over 2,500 API endpoints into 2 tools and ~1,000 tokens of context.

For more details, see the engineering blogs from Anthropic and Cloudflare, and the Programmatic Tool Calling documentation from Claude.

Resources

API Reference

Explore the complete Dodo Payments API documentation

MCP Protocol

Learn more about the Model Context Protocol standard

GitHub Repository

View the MCP server source code and contribute

NPM Package

Install the MCP server from NPM

Getting Started

Features

Integrate

Merchant of Record

Miscellaneous

Overview

Key Capabilities

How Code Mode Works

Quick Setup

Dodo Knowledge MCP

What is Dodo Knowledge MCP?

Quick Setup

Using Both MCP Servers Together

Troubleshooting Knowledge MCP

Knowledge MCP Server

Installation

Remote MCP Server (Recommended)

NPM Package

Docker

Client Configuration

Environment Variables

Running Remotely

Remote Server Configuration

Authorization Headers

Security Best Practices

Troubleshooting

Why Code Mode

LLMs Are Better at Writing Code Than Calling Tools

Eliminates Context Window Bloat

Reduces Latency via Programmatic Orchestration

More Secure by Design

Scales to Any API Size

Resources

API Reference

MCP Protocol

GitHub Repository

NPM Package

​Overview

​Key Capabilities

​How Code Mode Works

​Quick Setup

​Dodo Knowledge MCP

​What is Dodo Knowledge MCP?

​Quick Setup

​Using Both MCP Servers Together

​Troubleshooting Knowledge MCP

Knowledge MCP Server

​Installation

​Remote MCP Server (Recommended)

​NPM Package

​Docker

​Client Configuration

​Environment Variables

​Running Remotely

​Remote Server Configuration

​Authorization Headers

​Security Best Practices

​Troubleshooting

​Why Code Mode

​LLMs Are Better at Writing Code Than Calling Tools

​Eliminates Context Window Bloat

​Reduces Latency via Programmatic Orchestration

​More Secure by Design

​Scales to Any API Size

​Resources

API Reference

MCP Protocol

GitHub Repository

NPM Package

Overview

Key Capabilities

How Code Mode Works

Quick Setup

Dodo Knowledge MCP

What is Dodo Knowledge MCP?

Quick Setup

Using Both MCP Servers Together

Troubleshooting Knowledge MCP

Installation

Remote MCP Server (Recommended)

NPM Package

Docker

Client Configuration

Environment Variables

Running Remotely

Remote Server Configuration

Authorization Headers

Security Best Practices

Troubleshooting

Why Code Mode

LLMs Are Better at Writing Code Than Calling Tools

Eliminates Context Window Bloat

Reduces Latency via Programmatic Orchestration

More Secure by Design

Scales to Any API Size

Resources