Zum Hauptinhalt springen

Übersicht

Das Model Context Protocol (MCP) ist ein offener Standard, der es KI-Anwendungen ermöglicht, sicher mit externen Datenquellen und APIs zu verbinden. Der Dodo Payments MCP Server bietet KI-Assistenten wie Claude, Cursor und anderen MCP-kompatiblen Clients strukturierten Zugriff auf Ihre Zahlungsinfrastruktur. Der Dodo Payments MCP-Server ist mit Stainless erstellt und verwendet die Code Mode-Architektur, die es KI-Agenten ermöglicht, TypeScript-Code gegen das Dodo Payments SDK in einer isolierten Sandbox-Umgebung zu schreiben und auszuführen.

Hauptfunktionen

  • Zahlungsoperationen: Zahlungen und Rückerstattungen erstellen, abrufen und verwalten
  • Abonnementverwaltung: Wiederkehrende Abrechnungen, Upgrades und Stornierungen verwalten
  • Kundenverwaltung: Kundendaten und Portalzugang verwalten
  • Produktkatalog: Produkte, Preise und Rabatte erstellen und aktualisieren
  • Lizenzverwaltung: Softwarelizenzen aktivieren, validieren und verwalten
  • Nutzungsbasierte Abrechnung: Abrechnungen für gemessene Nutzung verfolgen und erstellen

Wie Code Mode funktioniert

Der Dodo Payments MCP-Server verwendet Code Mode und bietet Ihrem KI-Agenten zwei leistungsstarke Werkzeuge:
  1. Docs Search Tool: Dokumentation über die Dodo Payments API und SDK abfragen, um verfügbare Operationen und Parameter zu verstehen
  2. Code Execution Tool: TypeScript-Code gegen das SDK schreiben, der in einer sicheren Sandbox-Umgebung ohne Web- oder Dateisystemzugriff ausgeführt wird
Diese Architektur ermöglicht es KI-Agenten, komplexe, mehrstufige Zahlungsoperationen deterministisch und wiederholbar durchzuführen.
Mit Code Mode können Agenten mehrere API-Aufrufe verketten, bedingte Logik handhaben und Berechnungen durchführen – alles in einem einzigen Toolaufruf.

Installation

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

Remote MCP-Server (Empfohlen)

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

Zugriff auf den Remote-Server

Navigieren Sie in Ihrem Browser zu https://mcp.dodopayments.com.
2

Konfigurieren Sie Ihren 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:
{
  "mcpServers": {
    "dodopayments_api": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
    }
  }
}
3

Authentifizieren und konfigurieren

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
Halten Sie Ihren API-Schlüssel sicher. Verwenden Sie während der Entwicklung Testmodus-Schlüssel.
4

Einrichtung abschließen

Klicken Sie auf Anmelden und Genehmigen, um die Verbindung zu autorisieren.
Sobald Sie verbunden sind, kann Ihr KI-Assistent im Auftrag von Ihnen mit der Dodo Payments API interagieren.

NPM-Paket

Installieren und führen Sie den MCP-Server lokal mit NPM aus.
# 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
Verwenden Sie @latest, um immer die aktuellste Version abzurufen, oder fixieren Sie eine bestimmte Version wie @1.0.0 für Stabilität.

Docker

Führen Sie den MCP-Server in einer containerisierten Umgebung für konsistente Bereitstellung aus.
# 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
Docker-Images sind im GitHub Container Registry verfügbar.

Client-Konfiguration

Konfigurieren Sie den Dodo Payments MCP-Server in Ihrem bevorzugten KI-Client.
Richten Sie den Dodo Payments MCP-Server in Cursor ein, um konversationellen Zugriff auf Ihre Zahlungsdaten zu ermöglichen.Ein-Klick-InstallationVerwenden Sie die Schaltfläche unten, um den MCP-Server direkt in Cursor zu installieren:[Zu Cursor hinzufügen](https://cursor.com/en-US/install-mcp?name=dodopayments-mcp&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsImRvZG9wYXltZW50cy1tY3AiXSwiZW52Ijp7IkRPRE9fUEFZTUVOVFNfQVBJX0tFWSI6IlNldCB5b3VyIERPRE9fUEFZTUVOVFNfQVBJX0tFWSBoZXJlLiIsIkRPRE9fUEFZTUVOVFNfV0VCSE9PS19LRVkiOiJTZXQgeW91ciBET0RPX1BBWU1FTlRTX1dFQkhPT0tfS0VZIGhlcmUuIn19)Nach dem Klicken setzen Sie Ihre Umgebungsvariablen in Cursors mcp.json über Cursor-Einstellungen > Tools & MCP > Neuer MCP-Server.Manuelle Konfiguration
1

Öffnen Sie die Cursor-Einstellungen

Navigieren Sie zu Cursor-Einstellungen > Funktionen > Model Context Protocol oder drücken Sie Cmd/Ctrl + Shift + P und suchen Sie nach “MCP-Einstellungen”.
2

Konfiguration bearbeiten

Klicken Sie auf Konfiguration bearbeiten, um die mcp_config.json Datei zu öffnen.
3

Dodo Payments-Konfiguration hinzufügen

Wählen Sie eine der folgenden Konfigurationen:Remote-Server (Empfohlen)
{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
    }
  }
}
Lokales NPX
{
  "mcpServers": {
    "dodopayments": {
      "command": "npx",
      "args": ["-y", "dodopayments-mcp@latest"],
      "env": {
        "DODO_PAYMENTS_API_KEY": "dodo_test_...",
        "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
      }
    }
  }
}
4

Speichern und neu starten

Speichern Sie die Konfigurationsdatei und starten Sie Cursor neu.
Überprüfen Sie die Verbindung, indem Sie den KI-Assistenten nach Ihren Dodo Payments-Daten fragen.

Umgebungsvariablen

Konfigurieren Sie das Verhalten des MCP-Servers mit Umgebungsvariablen.
VariableBeschreibungErforderlich
DODO_PAYMENTS_API_KEYIhr Dodo Payments API-SchlüsselJa
DODO_PAYMENTS_WEBHOOK_KEYIhr Webhook-SignierschlüsselNein
DODO_PAYMENTS_ENVIRONMENTSetzen Sie live_mode für die ProduktionNein

Remote Ausführung

Setzen Sie den MCP-Server als Remote-HTTP-Server für webbasierte Clients oder agentische Workflows ein.
# 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

Nach der Bereitstellung können Clients über die Server-URL eine Verbindung herstellen:
{
  "mcpServers": {
    "dodopayments_api": {
      "url": "http://localhost:3000",
      "headers": {
        "Authorization": "Bearer your_api_key"
      }
    }
  }
}

Autorisierungsheader

Der Remote-Server akzeptiert die Authentifizierung über die folgenden Header:
HeaderBeschreibung
AuthorizationBearer-Token-Authentifizierung
x-dodo-payments-api-keyDirekter API-Schlüssel-Header

Client-Funktionen

Verschiedene MCP-Clients unterstützen unterschiedliche Funktionen der MCP-Spezifikation. Der Server kann die Tool-Schemas automatisch anpassen, um diese Einschränkungen zu umgehen.
# Auto-detect client (default)
npx dodopayments-mcp --client=infer

# Configure for specific clients
npx dodopayments-mcp --client=cursor
npx dodopayments-mcp --client=claude
npx dodopayments-mcp --client=claude-code
npx dodopayments-mcp --client=openai-agents

Verfügbare Client-Presets

ClientBeschreibung
inferAutomatische Erkennung des Clients (Standard)
cursorCursor-Editor
claudeClaude AI Web oder Desktop
claude-codeClaude Code CLI
openai-agentsOpenAI-Agentenplattform

Manuelle Funktionskonfiguration

Für Clients, die nicht oben aufgeführt sind, konfigurieren Sie die Funktionen manuell:
# Disable $ref pointer support and set max tool name length
npx dodopayments-mcp --no-capability=refs --capability=tool-name-length=40
Verfügbare Funktionen:
  • top-level-unions - Unterstützung für Top-Level-Unionstypen
  • valid-json - Korrekte JSON-String-Argumentanalyse
  • refs - Unterstützung für $ref-Zeiger in Schemas
  • unions - Unterstützung für Unionstypen (anyOf)
  • formats - Unterstützung für Formatvalidierungen
  • tool-name-length=N - Maximale Länge des Toolnamens
Führen Sie npx dodopayments-mcp --describe-capabilities für detaillierte Informationen zu den Funktionen aus.

Tool-Filterung

Steuern Sie, welche API-Operationen Ihrem KI-Assistenten zur Verfügung stehen, um die Leistung zu optimieren und die Sicherheit zu gewährleisten.

Nach Operationstyp filtern

Zugriff auf Lese- oder Schreiboperationen einschränken.
# Only expose read operations (GET requests)
npx dodopayments-mcp --operation=read

# Only expose write operations (POST, PUT, DELETE)
npx dodopayments-mcp --operation=write
Verwenden Sie --operation=read während der Entwicklung, um versehentliche Änderungen an Ihren Daten zu verhindern.

Nach Ressource filtern

Werkzeuge auf bestimmte API-Ressourcen beschränken.
# Only expose payment-related tools
npx dodopayments-mcp --resource=payments

# Expose multiple resources
npx dodopayments-mcp --resource=payments --resource=customers

# Use wildcards for resource groups
npx dodopayments-mcp --resource=subscription*

Bestimmte Werkzeuge ein- oder ausschließen

Feinabstimmung, welche einzelnen Werkzeuge verfügbar sind.
# Include only specific tools
npx dodopayments-mcp --tool=create_payments --tool=list_payments

# Exclude specific tools
npx dodopayments-mcp --no-tool=delete_products

# Disable the docs search tool
npx dodopayments-mcp --no-tools=docs

# List all available tools
npx dodopayments-mcp --list

Filter kombinieren

Wenden Sie mehrere Filter gleichzeitig für eine präzise Kontrolle an.
# Only payment and subscription read operations
npx dodopayments-mcp --operation=read --resource=payments --resource=subscriptions

URL-Abfrageparameterfilterung (Remote-Server)

Bei Verwendung des Remote-Servers Filter über URL-Abfrageparameter anwenden:
https://mcp.dodopayments.com/?operation=read
https://mcp.dodopayments.com/?resource=payments

Dynamischer Tools-Modus

Für große APIs kann das Laden aller Tools auf einmal das Kontextfenster der KI überfordern. Der dynamische Tools-Modus bietet eine effizientere Alternative.
npx dodopayments-mcp --tools=dynamic
Im dynamischen Modus ersetzen drei Meta-Tools die einzelnen API-Tools:
  1. list_api_endpoints - Entdeckt verfügbare Methoden mit optionaler Filterung
  2. get_api_endpoint_schema - Holt detaillierte Schema für eine bestimmte Methode
  3. invoke_api_endpoint - Führt jede Methode mit den entsprechenden Parametern aus
Dynamische Tools sind automatisch für APIs mit mehr als 50 Methoden aktiviert. Überschreiben Sie mit --tools=all, um alle Tools einzuschließen.
# Use both dynamic tools and specific resources
npx dodopayments-mcp --tools=dynamic --resource=payments

Erweiterte Nutzung

Programmatische Integration

Erstellen Sie benutzerdefinierte MCP-Server oder erweitern Sie den vorhandenen programmatisch.
import { server, endpoints, init } from "dodopayments-mcp/server";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

// Initialize with all default endpoints
init({ server, endpoints });

// Start the server
const transport = new StdioServerTransport();
await server.connect(transport);

Entwicklung benutzerdefinierter Tools

Erweitern Sie den MCP-Server mit Ihren eigenen Tools und Geschäftslogik.
import { server, init } from "dodopayments-mcp/server";
import createPayments from "dodopayments-mcp/tools/payments/create-payments";
import { zodToJsonSchema } from "zod-to-json-schema";
import { z } from "zod";

// Define a custom tool
const customTool = {
  tool: {
    name: 'calculate_payment_total',
    description: 'Calculate payment total with tax and fees',
    inputSchema: zodToJsonSchema(
      z.object({
        amount: z.number().describe('Base amount in cents'),
        tax_rate: z.number().describe('Tax rate as decimal'),
      })
    ),
  },
  handler: async (client, args) => {
    const total = args.amount * (1 + args.tax_rate);
    return {
      content: [{
        type: 'text',
        text: JSON.stringify({ total, currency: 'usd' }),
      }],
    };
  },
};

// Initialize with custom tools
init({ 
  server, 
  endpoints: [createPayments, customTool] 
});

Sicherheitsbest Practices

Schützen Sie Ihre API-Anmeldeinformationen und gewährleisten Sie sichere Integrationen.
Geben Sie niemals Anmeldeinformationen in der Versionskontrolle anSpeichern Sie API-Schlüssel in Umgebungsvariablen oder sicheren Geheimnisverwaltungssystemen.
# 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
Drehen Sie Schlüssel regelmäßigGenerieren Sie regelmäßig neue API-Schlüssel und widerrufen Sie alte über Ihr Dodo Payments-Dashboard.Verwenden Sie Testschlüssel für die EntwicklungVerwenden Sie während der Entwicklung immer Testmodus-API-Schlüssel, um zu vermeiden, dass Produktionsdaten betroffen sind.
Wenden Sie Tool-Filterung in der Produktion anBeschränken Sie die exponierten Operationen auf das, was Ihr KI-Assistent benötigt.
# Production: read-only access
npx dodopayments-mcp --operation=read

# Development: full access
npx dodopayments-mcp
Implementieren Sie Authentifizierung für Remote-ServerBei der Bereitstellung im Remote-Modus ist immer eine Authentifizierung über den Authorization Header oder den x-dodo-payments-api-key Header erforderlich.Überwachen Sie die API-NutzungVerfolgen Sie die Aktivität des MCP-Servers über Ihr Dodo Payments-Dashboard und richten Sie Warnungen für ungewöhnliche Muster ein.
Verwenden Sie HTTPS für Remote-ServerSetzen Sie Remote-MCP-Server immer hinter HTTPS-Endpunkten ein.Implementieren Sie RatenbegrenzungSchützen Sie sich vor Missbrauch, indem Sie Ratenlimits sowohl auf MCP-Server- als auch auf API-Ebene implementieren.Beschränken Sie den NetzwerkzugangKonfigurieren Sie Firewall-Regeln, um zu beschränken, welche Clients eine Verbindung zu Ihrem MCP-Server herstellen können.

Fehlersuche

Überprüfen Sie Ihren API-SchlüsselStellen Sie sicher, dass Ihr API-Schlüssel korrekt gesetzt ist und die erforderlichen Berechtigungen hat.
# Test your API key
curl -H "Authorization: Bearer dodo_test_..." \
  https://api.dodopayments.com/payments
Überprüfen Sie Ihre NetzwerkverbindungStellen Sie sicher, dass Sie die Dodo Payments API-Endpunkte erreichen können.Überprüfen Sie die Client-ProtokolleAktivieren Sie das ausführliche Protokollieren in Ihrem MCP-Client, um Verbindungsprobleme zu diagnostizieren.
Bestätigen Sie die API-SchlüsselumgebungStellen Sie sicher, dass Sie Testschlüssel mit Testendpunkten und Live-Schlüssel mit Produktionsendpunkten verwenden.Überprüfen Sie die UmgebungsvariableStellen Sie sicher, dass DODO_PAYMENTS_ENVIRONMENT korrekt gesetzt ist (live_mode für die Produktion).Generieren Sie Anmeldeinformationen neuWenn Probleme weiterhin bestehen, generieren Sie einen neuen API-Schlüssel über Ihr Dashboard.
Validieren Sie EingabeparameterStellen Sie sicher, dass der KI-Assistent korrekt formatierte Parameter für jedes Tool bereitstellt.Überprüfen Sie FehlermeldungenÜberprüfen Sie die Fehlermeldung von der API für spezifische Hinweise darauf, was schiefgelaufen ist.Testen Sie direkt mit der APIÜberprüfen Sie, ob die Operation funktioniert, wenn Sie die Dodo Payments API direkt über curl oder Postman aufrufen.
Versuchen Sie ein anderes Client-PresetWenn Tools nicht richtig funktionieren, versuchen Sie, Ihren Client explizit anzugeben:
npx dodopayments-mcp --client=cursor
Überprüfen Sie die Unterstützung der FunktionenEinige Clients unterstützen nicht alle JSON-Schema-Funktionen. Verwenden Sie --describe-capabilities, um zu verstehen, was unterstützt wird.

Ressourcen