> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dodopayments.com/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP Server

> Enable AI assistants to interact with the Dodo Payments API through Code Mode—a high-performance architecture for seamless payment operations and subscription management.

## Overview

The Model Context Protocol (MCP) is an open standard that enables AI applications to securely connect to external data sources and APIs. The Dodo Payments MCP Server provides AI assistants like Claude, Cursor, and other MCP-compatible clients with structured access to your payment infrastructure.

The Dodo Payments MCP Server uses the **Code Mode** architecture. Instead of exposing hundreds of individual tools for every API endpoint, Code Mode enables AI agents to write and execute TypeScript code against the Dodo Payments SDK in an isolated sandbox environment.

### 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 provides your AI agent with exactly two tools:

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

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

<Tip>
  Using Code Mode, agents can chain multiple API calls, handle conditional logic, and perform calculations without requiring multiple round-trips to the LLM.
</Tip>

### Quick Setup

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

<Tabs>
  <Tab title="Agent Plugin (recommended)">
    Das [Dodo Agent Plugin](/developer-resources/build-with-ai-coding-agents) installiert sowohl MCP-Server als auch alle acht Skills in einem Schritt für Claude Code, Codex CLI, Cursor und OpenCode. Siehe den [AI Coding Agents Guide](/developer-resources/build-with-ai-coding-agents) für installationsspezifische Kommandos.

    Wenn Ihr Agent nicht in dieser Liste enthalten ist, verwenden Sie die untenstehenden Tabs, um den MCP-Server direkt zu konfigurieren.
  </Tab>

  <Tab title="Cursor">
    Hinzufügen zu `~/.cursor/mcp.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "dodopayments": {
          "command": "npx",
          "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
        }
      }
    }
    ```
  </Tab>

  <Tab title="Claude Desktop">
    Zu Ihrer Claude Desktop-Konfiguration hinzufügen:

    ```json theme={null}
    {
      "mcpServers": {
        "dodopayments": {
          "command": "npx",
          "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
        }
      }
    }
    ```

    Konfigurationsdatei-Standorte:

    * **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
    * **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
    * **Linux**: `~/.config/Claude/claude_desktop_config.json`
  </Tab>

  <Tab title="Windsurf">
    Hinzufügen zu `~/.codeium/windsurf/mcp_config.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "dodopayments": {
          "command": "npx",
          "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
        }
      }
    }
    ```
  </Tab>

  <Tab title="Claude Code">
    Ausführen in Ihrem Terminal:

    ```bash theme={null}
    claude mcp add dodopayments -- npx -y mcp-remote@latest https://mcp.dodopayments.com/sse
    ```
  </Tab>
</Tabs>

<Note>
  Benötigt Node.js 18 oder höher. Der Remote-Server verwendet OAuth zur Authentifizierung — Sie werden aufgefordert, Ihren API-Schlüssel einzugeben und Ihre Umgebung bei der ersten Verbindung auszuwählen.
</Note>

## Dodo Knowledge MCP

Zusätzlich zum Dodo Payments MCP Server (für die Ausführung von API-Operationen), bieten wir **Dodo Knowledge MCP** — einen semantischen Suchserver, der KI-Assistenten sofortigen Zugriff auf die Dodo Payments-Dokumentation und Wissensdatenbank gewährt.

<Info>
  **Erbaut mit [ContextMCP.ai](https://contextmcp.ai)**: Dodo Knowledge MCP wird von ContextMCP angetrieben und ermöglicht schnelle semantische Suche über unsere Dokumentation mit Hilfe von Vektor-Einbettungen.
</Info>

### Was ist Dodo Knowledge MCP?

Dodo Knowledge MCP ist ein Remote-MCP-Server, der Folgendes bietet:

* **Semantische Dokumentationssuche**: Finden Sie relevante Dokumentation mit Hilfe von natürlichen Sprachabfragen.
* **Kontextbezogene Antworten**: KI-Assistenten erhalten genaue, aktuelle Informationen über Dodo Payments.
* **Null Einrichtung**: Es sind keine API-Schlüssel oder lokale Installation erforderlich — einfach verbinden und Abfragen starten.

### Schnelle Einrichtung

Verbinden Sie Dodo Knowledge MCP in Ihrem KI-Client:

<Tabs>
  <Tab title="Cursor">
    Hinzufügen zu `~/.cursor/mcp.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "dodo-knowledge": {
          "command": "npx",
          "args": ["-y", "mcp-remote@latest", "https://knowledge.dodopayments.com/mcp"]
        }
      }
    }
    ```
  </Tab>

  <Tab title="Claude Desktop">
    Zu Ihrer Claude Desktop-Konfiguration hinzufügen:

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

    Konfigurationsdatei-Standorte:

    * **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
    * **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
    * **Linux**: `~/.config/Claude/claude_desktop_config.json`
  </Tab>

  <Tab title="Windsurf">
    Hinzufügen zu `~/.codeium/windsurf/mcp_config.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "dodo-knowledge": {
          "command": "npx",
          "args": ["-y", "mcp-remote@latest", "https://knowledge.dodopayments.com/mcp"]
        }
      }
    }
    ```
  </Tab>

  <Tab title="Claude Code">
    Ausführen in Ihrem Terminal:

    ```bash theme={null}
    claude mcp add dodo-knowledge -- npx -y mcp-remote@latest https://knowledge.dodopayments.com/mcp
    ```
  </Tab>
</Tabs>

<Note>
  Benötigt Node.js 18 oder höher. Das `mcp-remote` Paket verwaltet die Verbindung zum Remote-MCP-Server.
</Note>

### Beide MCP-Server gemeinsam verwenden

Für die beste KI-unterstützte Entwicklungserfahrung empfehlen wir die Verwendung beider MCP-Server:

| Server                 | Zweck               | Anwendungsfall                                                                 |
| ---------------------- | ------------------- | ------------------------------------------------------------------------------ |
| **Dodo Knowledge MCP** | Dokumentationssuche | "Wie gehe ich mit Webhooks um?", "Welche Zahlungsmethoden werden unterstützt?" |
| **Dodo Payments MCP**  | API-Operationen     | Zahlungen erstellen, Abonnements verwalten, Rückerstattungen bearbeiten        |

```json theme={null}
{
  "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/sse"]
    }
  }
}
```

<Tip>
  Mit beiden konfigurierten Servern kann Ihr KI-Assistent zuerst die Dokumentation durchsuchen, um zu verstehen, wie eine Funktion implementiert wird, und dann die tatsächlichen API-Aufrufe ausführen - alles in einem einzigen Gespräch.
</Tip>

### Fehlerbehebung bei Knowledge MCP

Wenn Sie Verbindungsprobleme haben:

1. **MCP-Authentifizierungs-Cache leeren**: `rm -rf ~/.mcp-auth`
2. **Ihre Client-Anwendung neu starten**
3. **Kundentools überprüfen** auf Fehlermeldungen
4. **Node.js-Version überprüfen**: Benötigt Node.js 18+

<Card title="Knowledge MCP Server" icon="book-open" href="https://knowledge.dodopayments.com">
  Auf die Dodo Knowledge MCP-Konfigurationsseite zugreifen
</Card>

## Installation

Wählen Sie die Installationsmethode, die am besten zu Ihrem Arbeitsablauf passt.

### Remote-MCP-Server (Empfohlen)

Zugriff auf den gehosteten MCP-Server ohne lokale Einrichtung oder Installation. Dies ist der schnellste Weg, um zu beginnen.

<Frame>
  <iframe className="w-full aspect-video rounded-md" src="https://www.youtube.com/embed/TxGgYxNmkT4" title="Using Dodo Payment's Remote MCP Server" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen />
</Frame>

<Steps>
  <Step title="Access the remote server">
    Navigieren Sie zu [https://mcp.dodopayments.com](https://mcp.dodopayments.com) in Ihrem Browser.
  </Step>

  <Step title="Configure your MCP client">
    Kopieren Sie die bereitgestellte JSON-Konfiguration für Ihren spezifischen Client. Für Cursor oder Claude Desktop fügen Sie dies zu Ihren MCP-Einstellungen hinzu:

    ```json theme={null}
    {
      "mcpServers": {
        "dodopayments_api": {
          "command": "npx",
          "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
        }
      }
    }
    ```
  </Step>

  <Step title="Authenticate and configure">
    Der OAuth-Flow fordert Sie auf:

    * Geben Sie Ihren Dodo Payments API-Schlüssel ein
    * Wählen Sie Ihre Umgebung (Test oder Live)
    * Wählen Sie Ihren MCP-Clienttyp

    <Warning>
      Halten Sie Ihren API-Schlüssel sicher. Verwenden Sie Testmodus-Schlüssel während der Entwicklung.
    </Warning>
  </Step>

  <Step title="Complete setup">
    Klicken Sie auf **Anmelden und Genehmigen**, um die Verbindung zu autorisieren.

    <Check>
      Sobald die Verbindung hergestellt ist, kann Ihr KI-Assistent mit der Dodo Payments API in Ihrem Namen interagieren.
    </Check>
  </Step>
</Steps>

### NPM-Paket

Installieren und führen Sie den MCP-Server lokal mit NPM aus.

<Tabs>
  <Tab title="NPX (No Installation)">
    ```bash theme={null}
    # Set your environment variables
    export DODO_PAYMENTS_API_KEY="dodo_test_..."
    export DODO_PAYMENTS_WEBHOOK_KEY="your_webhook_key"
    export DODO_PAYMENTS_ENVIRONMENT="live_mode"

    # Run the latest version
    npx -y dodopayments-mcp@latest
    ```
  </Tab>

  <Tab title="MCP Client Configuration">
    ```json theme={null}
    {
      "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": "live_mode"
          }
        }
      }
    }
    ```
  </Tab>
</Tabs>

<Tip>
  Verwenden Sie `@latest`, um immer die neueste Version zu holen, oder fixieren Sie auf eine bestimmte Version wie `@1.0.0` für Stabilität.
</Tip>

### Docker

Führen Sie den MCP-Server in einer containerisierten Umgebung für einen konsistenten Einsatz aus.

<CodeGroup>
  ```bash Docker theme={null}
  # Pull the latest image
  docker pull ghcr.io/dodopayments/mcp:latest

  # Run the container
  docker run -e DODO_PAYMENTS_API_KEY="dodo_test_..." \
    -e DODO_PAYMENTS_WEBHOOK_KEY="your_webhook_key" \
    -e DODO_PAYMENTS_ENVIRONMENT="live_mode" \
    ghcr.io/dodopayments/mcp:latest
  ```

  ```yaml Docker Compose theme={null}
  services:
    dodopayments-mcp:
      image: ghcr.io/dodopayments/mcp:latest
      environment:
        - DODO_PAYMENTS_API_KEY=dodo_test_...
        - DODO_PAYMENTS_WEBHOOK_KEY=your_webhook_key
        - DODO_PAYMENTS_ENVIRONMENT=live_mode
      restart: unless-stopped
  ```
</CodeGroup>

<Note>
  Docker-Images sind unter [GitHub Container Registry](https://github.com/orgs/dodopayments/packages/container/package/mcp) verfügbar.
</Note>

## Client-Konfiguration

Konfigurieren Sie den Dodo Payments MCP-Server in Ihrem bevorzugten KI-Client.

<Tabs>
  <Tab title="Cursor">
    Richten Sie den Dodo Payments MCP-Server in Cursor ein, um conversationalen Zugriff auf Ihre Zahlungsdaten zu ermöglichen.

    **Ein-Klick-Installation**

    Verwenden Sie den untenstehenden Button, um den MCP-Server direkt in Cursor zu installieren:

    \[

    ![Add to Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)

    ]\([https://cursor.com/en-US/install-mcp?name=dodopayments-mcp\&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsImRvZG9wYXltZW50cy1tY3AiXSwiZW52Ijp7IkRPRE9fUEFZTUVOVFNfQVBJX0tFWSI6IlNldCB5b3VyIERPRE9fUEFZTUVOVFNfQVBJX0tFWSBoZXJlLiIsIkRPRE9fUEFZTUVOVFNfV0VCSE9PS19LRVkiOiJTZXQgeW91ciBET0RPX1BBWU1FTlRTX1dFQkhPT0tfS0VZIGhlcmUuIn19](https://cursor.com/en-US/install-mcp?name=dodopayments-mcp\&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsImRvZG9wYXltZW50cy1tY3AiXSwiZW52Ijp7IkRPRE9fUEFZTUVOVFNfQVBJX0tFWSI6IlNldCB5b3VyIERPRE9fUEFZTUVOVFNfQVBJX0tFWSBoZXJlLiIsIkRPRE9fUEFZTUVOVFNfV0VCSE9PS19LRVkiOiJTZXQgeW91ciBET0RPX1BBWU1FTlRTX1dFQkhPT0tfS0VZIGhlcmUuIn19))

    Nach dem Klick setzen Sie Ihre Umgebungsvariablen in Cursors `mcp.json` über **Cursor Einstellungen** > **Tools & MCP** > **Neuer MCP-Server**.

    **Manuelle Konfiguration**

    <Steps>
      <Step title="Open Cursor settings">
        Navigieren Sie zu **Cursor Einstellungen** > **Funktionen** > **Model Context Protocol** oder drücken Sie `Cmd/Ctrl + Shift + P` und suchen Sie nach "MCP-Einstellungen".
      </Step>

      <Step title="Edit configuration">
        Klicken Sie auf **Konfiguration bearbeiten**, um die `mcp_config.json` Datei zu öffnen.
      </Step>

      <Step title="Add Dodo Payments configuration">
        Wählen Sie eine der folgenden Konfigurationen:

        **Remote-Server (Empfohlen)**

        ```json theme={null}
        {
          "mcpServers": {
            "dodopayments": {
              "command": "npx",
              "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
            }
          }
        }
        ```

        **Lokale NPX**

        ```json theme={null}
        {
          "mcpServers": {
            "dodopayments": {
              "command": "npx",
              "args": ["-y", "dodopayments-mcp@latest"],
              "env": {
                "DODO_PAYMENTS_API_KEY": "dodo_test_...",
                "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
              }
            }
          }
        }
        ```
      </Step>

      <Step title="Save and restart">
        Speichern Sie die Konfigurationsdatei und starten Sie Cursor neu.

        <Check>
          Überprüfen Sie die Verbindung, indem Sie den KI-Assistenten nach Ihren Dodo Payments-Daten fragen.
        </Check>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Claude Desktop">
    Richten Sie den Dodo Payments MCP-Server in Claude Desktop ein, um conversationalen Zugriff auf Ihre Zahlungsdaten zu ermöglichen.

    <Steps>
      <Step title="Locate configuration file">
        Suchen Sie die Claude Desktop-Konfigurationsdatei:

        * **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
        * **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
        * **Linux**: `~/.config/Claude/claude_desktop_config.json`
      </Step>

      <Step title="Edit configuration">
        Öffnen Sie die Datei in einem Texteditor und fügen Sie die Dodo Payments-Konfiguration hinzu:

        **Remote-Server (Empfohlen)**

        ```json theme={null}
        {
          "mcpServers": {
            "dodopayments": {
              "command": "npx",
              "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
            }
          }
        }
        ```

        **Lokale NPX**

        ```json theme={null}
        {
          "mcpServers": {
            "dodopayments": {
              "command": "npx",
              "args": ["-y", "dodopayments-mcp@latest"],
              "env": {
                "DODO_PAYMENTS_API_KEY": "dodo_test_...",
                "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
              }
            }
          }
        }
        ```
      </Step>

      <Step title="Restart Claude Desktop">
        Schließen und öffnen Sie Claude Desktop erneut, damit die Änderungen wirksam werden.

        <Tip>
          Suchen Sie nach dem 🔌-Symbol in Claude Desktop, um zu bestätigen, dass der MCP-Server verbunden ist.
        </Tip>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Claude Code">
    Richten Sie den Dodo Payments MCP-Server in Claude Code CLI ein.

    Führen Sie den folgenden Befehl in Ihrem Terminal aus:

    ```bash theme={null}
    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
    ```

    Die Konfiguration wird in der Datei `.claude.json` im Home-Verzeichnis gespeichert.

    <Tip>
      Claude Code übernimmt automatisch Umgebungsvariablen von Ihrer Shell, sodass Sie diese auch exportieren können, bevor Sie den Befehl ausführen.
    </Tip>
  </Tab>

  <Tab title="VS Code">
    Richten Sie den Dodo Payments MCP-Server in VS Code ein.

    **Ein-Klick-Installation**

    [Open VS Code](https://vscode.stainless.com/mcp/%7B%22name%22%3A%22dodopayments-mcp%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22dodopayments-mcp%22%5D%2C%22env%22%3A%7B%22DODO_PAYMENTS_API_KEY%22%3A%22Set%20your%20DODO_PAYMENTS_API_KEY%20here.%22%2C%22DODO_PAYMENTS_WEBHOOK_KEY%22%3A%22Set%20your%20DODO_PAYMENTS_WEBHOOK_KEY%20here.%22%7D%7D)

    Nach dem Klick setzen Sie Ihre Umgebungsvariablen in VS Codes `mcp.json` über **Befehlspalette** > **MCP: Open User Configuration**.

    **Manuelle Konfiguration**

    <Steps>
      <Step title="Open MCP configuration">
        Öffnen Sie die Befehlspalette (`Cmd/Ctrl + Shift + P`) und suchen Sie nach "MCP: Open User Configuration".
      </Step>

      <Step title="Add server configuration">
        Fügen Sie den Dodo Payments MCP-Server hinzu:

        ```json theme={null}
        {
          "mcpServers": {
            "dodopayments": {
              "command": "npx",
              "args": ["-y", "dodopayments-mcp@latest"],
              "env": {
                "DODO_PAYMENTS_API_KEY": "dodo_test_...",
                "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
              }
            }
          }
        }
        ```
      </Step>

      <Step title="Reload window">
        Laden Sie VS Code neu (`Cmd/Ctrl + Shift + P` > "Fenster neu laden"), um den MCP-Server zu aktivieren.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Cline (VS Code)">
    Richten Sie den Dodo Payments MCP-Server in Cline (VS Code) ein, um conversationalen Zugriff auf Ihre Zahlungsdaten zu ermöglichen.

    <Steps>
      <Step title="Open Cline settings">
        Suchen Sie die Cline-Konfigurationsdatei:

        * **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`
      </Step>

      <Step title="Configure MCP server">
        Fügen Sie die Dodo Payments MCP-Serverkonfiguration hinzu:

        ```json theme={null}
        {
          "mcpServers": {
            "dodopayments": {
              "command": "npx",
              "args": ["-y", "dodopayments-mcp@latest"],
              "env": {
                "DODO_PAYMENTS_API_KEY": "dodo_test_...",
                "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
              }
            }
          }
        }
        ```
      </Step>

      <Step title="Reload VS Code">
        Laden Sie das VS Code-Fenster neu (`Cmd/Ctrl + Shift + P` > "Fenster neu laden"), um die MCP-Serververbindung zu aktivieren.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Zed">
    Richten Sie den Dodo Payments MCP-Server in Zed ein, um conversationalen Zugriff auf Ihre Zahlungsdaten zu ermöglichen.

    <Steps>
      <Step title="Open Zed settings">
        Navigieren Sie zu **Einstellungen** > **Assistent** > **Model Context Protocol**.
      </Step>

      <Step title="Add server configuration">
        Fügen Sie die folgende Konfiguration hinzu:

        ```json theme={null}
        {
          "mcpServers": {
            "dodopayments": {
              "command": "npx",
              "args": ["-y", "dodopayments-mcp@latest"],
              "env": {
                "DODO_PAYMENTS_API_KEY": "dodo_test_...",
                "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
              }
            }
          }
        }
        ```
      </Step>

      <Step title="Save and verify">
        Speichern Sie die Konfiguration. Der MCP-Server sollte nun im KI-Assistenten von Zed verfügbar sein.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Other Clients">
    Richten Sie den Dodo Payments MCP-Server in anderen MCP-kompatiblen Clients ein.

    **Remote-Server (Empfohlen)**

    ```json theme={null}
    {
      "mcpServers": {
        "dodopayments": {
          "command": "npx",
          "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
        }
      }
    }
    ```

    **Lokale NPX**

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

    <Info>
      Besuchen Sie [modelcontextprotocol.io/clients](https://modelcontextprotocol.io/clients) für eine komplette Liste der MCP-kompatiblen Clients und ihre Konfigurationsmethoden.
    </Info>
  </Tab>
</Tabs>

## Umgebungsvariablen

Konfigurieren Sie das MCP-Server-Verhalten mit Umgebungsvariablen.

| Variable                    | Beschreibung                              | Erforderlich |
| --------------------------- | ----------------------------------------- | ------------ |
| `DODO_PAYMENTS_API_KEY`     | Ihr Dodo Payments API-Schlüssel           | Ja           |
| `DODO_PAYMENTS_WEBHOOK_KEY` | Ihr Webhook-Signierschlüssel              | Nein         |
| `DODO_PAYMENTS_ENVIRONMENT` | Setzen Sie auf `live_mode` für Produktion | Nein         |

## Remote ausführen

Setzen Sie den MCP-Server als Remote-HTTP-Server für webbasierte Clients oder agentische Workflows ein.

```bash theme={null}
# Start as remote server
npx -y dodopayments-mcp --transport=http

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

### Remote-Server-Konfiguration

Einmal bereitgestellt, können sich Clients mithilfe der Server-URL verbinden:

```json theme={null}
{
  "mcpServers": {
    "dodopayments_api": {
      "url": "http://localhost:3000",
      "headers": {
        "Authorization": "Bearer your_api_key"
      }
    }
  }
}
```

### Autorisierungsheader

Der Remote-Server akzeptiert Authentifizierung über die folgenden Header:

| Header                    | Beschreibung                   |
| ------------------------- | ------------------------------ |
| `Authorization`           | Bearer-Token-Authentifizierung |
| `x-dodo-payments-api-key` | Direkter API-Schlüssel-Header  |

## Sicherheitspraktiken

Code Mode bietet inhärente Sicherheit durch die Ausführung von Code in einer Sandbox-Umgebung und das injizieren von API-Schlüsseln serverseitig. Folgen Sie diesen zusätzlichen Best Practices, um Ihre Anmeldedaten zu schützen.

<AccordionGroup>
  <Accordion title="API Key Management">
    **Niemals Anmeldedaten in die Versionskontrolle einfügen**

    Speichern Sie API-Schlüssel in Umgebungsvariablen oder sicheren Geheimverwaltungssystemen.

    ```bash theme={null}
    # 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
    ```

    **Regelmäßiger Schlüsselwechsel**

    Generieren Sie regelmäßig neue API-Schlüssel und widerrufen Sie alte über Ihr Dodo Payments-Dashboard.

    **Verwenden Sie Testschlüssel für die Entwicklung**

    Verwenden Sie immer API-Schlüssel im Testmodus während der Entwicklung, um zu vermeiden, dass Produktionsdaten beeinflusst werden.
  </Accordion>

  <Accordion title="Access Control">
    **Implementieren Sie Authentifizierung für Remote-Server**

    Verlangen Sie bei Remote-Deployments immer eine Authentifizierung über den `Authorization` Header oder den `x-dodo-payments-api-key` Header.

    **API-Nutzung überwachen**

    Verfolgen Sie die Aktivitäten des MCP-Servers über Ihr Dodo Payments-Dashboard und richten Sie Alarme für ungewöhnliche Muster ein.
  </Accordion>

  <Accordion title="Network Security">
    **Verwenden Sie HTTPS für Remote-Server**

    Setzen Sie Remote-MCP-Server immer hinter HTTPS-Endpunkten ein.

    **Implementieren Sie Ratenbegrenzung**

    Schützen Sie sich vor Missbrauch, indem Sie Ratenbeschränkungen auf Server- und API-Ebene implementieren.

    **Eingeschränkter Netzwerkzugang**

    Konfigurieren Sie Firewall-Regeln, um einzuschränken, welche Clients auf Ihren MCP-Server zugreifen können.
  </Accordion>
</AccordionGroup>

## Fehlerbehebung

<AccordionGroup>
  <Accordion title="Connection issues">
    **Überprüfen Sie Ihren API-Schlüssel**

    Stellen Sie sicher, dass Ihr API-Schlüssel korrekt gesetzt ist und die notwendigen Berechtigungen hat.

    ```bash theme={null}
    # Test your API key
    curl -H "Authorization: Bearer dodo_test_..." \
      https://test.dodopayments.com/payments
    ```

    **Überprüfen Sie Ihre Netzwerkverbindung**

    Verifizieren Sie, dass Sie die Endpunkte der Dodo Payments API erreichen können.

    **Überprüfen Sie die Client-Logs**

    Aktivieren Sie ausführliches Logging in Ihrem MCP-Client, um Verbindungsprobleme zu diagnostizieren.
  </Accordion>

  <Accordion title="Authentication errors">
    **Bestätigen Sie die Umgebung des API-Schlüssels**

    Stellen Sie sicher, dass Sie Testschlüssel mit Testendpunkten und Live-Schlüssel mit Produktionsendpunkten verwenden.

    **Überprüfen Sie die Umgebungsvariable**

    Verifizieren Sie, dass `DODO_PAYMENTS_ENVIRONMENT` korrekt gesetzt ist (`live_mode` für Produktion).

    **Anmeldedaten neu generieren**

    Wenn Probleme weiterhin bestehen, generieren Sie einen neuen API-Schlüssel über Ihr Dashboard.
  </Accordion>

  <Accordion title="Tool execution failures">
    **Eingabeparameter validieren**

    Stellen Sie sicher, dass der KI-Assistent korrekt formatierte Parameter für jedes Tool bereitstellt.

    **Fehlermeldungen überprüfen**

    Überprüfen Sie die Fehlermeldung der API, um spezifische Hinweise darauf zu erhalten, was schiefgelaufen ist.

    **Direkt mit der API testen**

    Verifizieren Sie die Funktion, indem Sie die Dodo Payments API direkt über curl oder Postman aufrufen.
  </Accordion>
</AccordionGroup>

## Warum Code Mode

Traditionelle MCP-Implementierungen leiden oft unter "Tool Proliferation", bei der jeder API-Endpunkt als separates Tool exponiert wird. Code Mode ist eine überlegene Herangehensweise aus mehreren Gründen:

### LLMs sind besser im Schreiben von Code als im Aufrufen von Tools

LLMs wurden mit Millionen von Zeilen realer Codes trainiert, was sie natürlich kompetent im Schreiben von Skripten macht. Im Gegensatz dazu basiert das Aufrufen von Tools oft auf synthetischen Beispielen.

<Info>
  "Ein LLM dazu zu bringen, Aufgaben mit Tool-Aufrufen zu erledigen ist, wie Shakespeare in einem Monat Chinesisch-Unterricht zu geben und ihn dann zu bitten, ein Stück darin zu schreiben." — [Cloudflare](https://blog.cloudflare.com/code-mode/)
</Info>

### Eliminierung von Kontextfenster-Aufblähung

In einem traditionellen Ansatz verbraucht jede Tool-Definition Token, bevor das Gespräch überhaupt beginnt. Die Exposition von über 50 Tools kann leicht 55K–100K+ Token in Anspruch nehmen. Anthropic fand heraus, dass Tool-Definitionen bis zu 134K Token vor der Optimierung verbrauchen konnten.

Mit Code Mode werden nur 2 Tool-Definitionen geladen (\~1K Token). Der Agent sucht bei Bedarf nach der benötigten Dokumentation. Anthropics Tool-Such-Tool bewahrte 95 % des Kontextfensters, was die Overhead von 77K auf 8,7K Token reduzierte.

### Reduziert Latenz durch programmatische Orchestrierung

Traditionelles Tool-Aufrufen erfordert eine komplette Modell-Inferenz-Rundreise für jede einzelne Operation. Wenn eine Aufgabe 20 API-Aufrufe erfordert, sind das 20 Rundreisen. Im Code Mode schreibt der Agent ein Skript, das alle Aufrufe ausführt und nur das Endergebnis zurückgibt.

Anthropic beobachtete eine 37% Reduzierung der Token und verbesserte Genauigkeit (Wissensabruf verbesserte sich von 25,6% auf 28,5%) mit diesem programmatischen Ansatz.