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.

Dodo Knowledge MCP

Neben dem Dodo Payments MCP Server (zum Ausführen von API-Operationen) bieten wir Dodo Knowledge MCP an - einen semantischen Suchserver, der KI-Assistenten sofortigen Zugriff auf die Dokumentation und Wissensdatenbank von Dodo Payments ermöglicht.
Built with ContextMCP.ai: Dodo Knowledge MCP wird von ContextMCP betrieben, was eine schnelle semantische Suche in unserer Dokumentation mithilfe von Vektor-Embeddings ermöglicht.

Was ist Dodo Knowledge MCP?

Dodo Knowledge MCP ist ein Remote-MCP-Server, der Folgendes bietet:
  • Semantische Dokumentationssuche: Finden Sie relevante Dokumentation mit natürlichen Sprachabfragen
  • Kontextuelle Antworten: KI-Assistenten erhalten genaue, aktuelle Informationen über Dodo Payments
  • Null Einrichtung: Keine API-Schlüssel oder lokale Installation erforderlich - einfach verbinden und Abfragen starten

Schnelle Einrichtung

Verbinden Sie sich mit Dodo Knowledge MCP in Ihrem KI-Client:
Fügen Sie hinzu zu ~/.cursor/mcp.json:
{
  "mcpServers": {
    "dodo-knowledge": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://knowledge.dodopayments.com/mcp"]
    }
  }
}
Erfordert Node.js 18 oder höher. Das mcp-remote Paket verwaltet die Verbindung zum Remote-MCP-Server.

Verwendung beider MCP-Server zusammen

Für das beste KI-unterstützte Entwicklungserlebnis empfehlen wir die Verwendung beider MCP-Server:
ServerZweckAnwendungsfall
Dodo Knowledge MCPDokumentationssuche”Wie gehe ich mit Webhooks um?”, “Welche Zahlungsmethoden werden unterstützt?”
Dodo Payments MCPAPI-OperationenZahlungen erstellen, Abonnements verwalten, Rückerstattungen bearbeiten
{
  "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"]
    }
  }
}
Mit beiden Servern konfiguriert, kann Ihr KI-Assistent zuerst die Dokumentation durchsuchen, um zu verstehen, wie man eine Funktion implementiert, und dann die tatsächlichen API-Aufrufe ausführen - alles in einem einzigen Gespräch.

Fehlerbehebung Knowledge MCP

Wenn Sie auf Verbindungsprobleme stoßen:
  1. MCP-Authentifizierungscache leeren: rm -rf ~/.mcp-auth
  2. Starten Sie Ihre Client-Anwendung neu
  3. Überprüfen Sie die Client-Protokolle auf Fehlermeldungen
  4. Überprüfen Sie die Node.js-Version: Erfordert Node.js 18+

Knowledge MCP Server

Greifen Sie auf die Konfigurationsseite von Dodo Knowledge MCP zu

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 zu https://mcp.dodopayments.com in Ihrem Browser.
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-Fluss 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 Testmodus-Schlüssel während der Entwicklung.
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 neueste 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 auf 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

Cursor-Einstellungen öffnen

Navigieren Sie zu Cursor-Einstellungen > Features > 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 mithilfe von Umgebungsvariablen.
VariableBeschreibungErforderlich
DODO_PAYMENTS_API_KEYIhr Dodo Payments API-SchlüsselJa
DODO_PAYMENTS_WEBHOOK_KEYIhr Webhook-SignierschlüsselNein
DODO_PAYMENTS_ENVIRONMENTSetzen Sie auf live_mode für die ProduktionNein

Remote Ausführen

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

Sobald bereitgestellt, können sich Clients über die Server-URL verbinden:
{
  "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-Fähigkeiten

Verschiedene MCP-Clients unterstützen unterschiedliche Ebenen 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 Fähigkeitskonfiguration

Für Clients, die oben nicht aufgeführt sind, konfigurieren Sie die Fähigkeiten 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-Vereinigungstypen
  • valid-json - Korrekte JSON-String-Argumentanalyse
  • refs - Unterstützung für $ref-Zeiger in Schemata
  • unions - Unterstützung für Vereinigungstypen (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 schreibgeschützte oder schreibbare Operationen 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

Tools 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 Tools ein- oder ausschließen

Feinabstimmung, welche einzelnen Tools 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 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 gleichzeitige Laden aller Tools den Kontextbereich der KI überfordern. Der dynamische Tools-Modus bietet eine effizientere Alternative.
npx dodopayments-mcp --tools=dynamic
Im dynamischen Modus ersetzen drei Meta-Tools einzelne API-Tools:
  1. list_api_endpoints - Entdeckt verfügbare Methoden mit optionaler Filterung
  2. get_api_endpoint_schema - Holt detailliertes Schema für eine bestimmte Methode
  3. invoke_api_endpoint - Führt eine Methode mit den entsprechenden Parametern aus
Dynamische Tools werden 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] 
});

Sicherheitsbestimmungen

Schützen Sie Ihre API-Anmeldeinformationen und gewährleisten Sie sichere Integrationen.
Geben Sie niemals Anmeldeinformationen in die Versionskontrolle einSpeichern 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 immer Testmodus-API-Schlüssel während der Entwicklung, 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-ServerBeim Remote-Deployment 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 NetzwerkzugriffKonfigurieren Sie Firewall-Regeln, um zu beschränken, welche Clients sich mit Ihrem MCP-Server verbinden können.

Fehlerbehebung

Ü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://test.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 ausführliches Logging 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 UmgebungsvariableÜberprüfen Sie, ob 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 von FähigkeitenEinige Clients unterstützen nicht alle Funktionen des JSON-Schemas. Verwenden Sie --describe-capabilities um zu verstehen, was unterstützt wird.

Ressourcen