> ## 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.

# Mit KI-Coding-Agenten entwickeln

> Verwenden Sie das Dodo Agent Plugin, um Integrationen mit Claude Code, Codex CLI, Cursor und OpenCode zu erstellen — MCP-Server und Skills in einer Installation.

Das Dodo Agent Plugin verbindet zwei MCP-Server und acht Integrationsfähigkeiten mit Ihrem KI-Coding-Agenten in einer einzigen Installation. Es funktioniert mit **Claude Code**, **Codex CLI**, **Cursor** und **OpenCode** — und die MCP-Server und Skills CLI funktionieren mit jedem MCP-kompatiblen Client.

<Info>
  **Drei Primitiven, ein Plugin.** Das Agent Plugin bündelt alles, was Sie brauchen:

  * **API MCP Server** — Live-Zugriff auf Zahlungen, Abonnements, Kunden, Produkte, Rückerstattungen, Lizenzen und Nutzung. Authentifiziert über Browser-OAuth (keine lokalen Schlüssel erforderlich).
  * **Knowledge MCP Server** — Semantische Suche über die gesamte Dodo Payments-Dokumentation. Keine Anmeldeinformationen erforderlich.
  * **Acht Agent Skills** — Spickzettel, die Ihr Agent bei Bedarf für Checkout, Abonnements, Webhooks, nutzungsabhängige Abrechnung, kreditbasierte Abrechnung, Lizenzschlüssel, BillingSDK und Best Practices lädt.
</Info>

## Plugin installieren

Wählen Sie unten Ihren Coding-Agenten aus. Die Installation fügt automatisch beide MCP-Server und alle acht Skills hinzu.

<AccordionGroup>
  <Accordion title="Claude Code" defaultOpen>
    Installation aus dem Marketplace:

    ```bash theme={null}
    claude plugins marketplace add dodopayments/dodo-agent-plugin
    claude plugins install dodopayments@dodopayments
    ```

    Der API MCP Server verwendet standardmäßig Browser-OAuth — keine Schlüssel erforderlich zur Installationszeit. Beim ersten Aufruf eines Dodo-Tools durch Ihren Agenten werden Sie aufgefordert, sich anzumelden.

    <Card title="Dodo Agent Plugin on GitHub" icon="github" href="https://github.com/dodopayments/dodo-agent-plugin">
      Quellcode, Konfigurationsoptionen und Anweisungen zur lokalen Entwicklung
    </Card>
  </Accordion>

  <Accordion title="Codex CLI">
    Codex installiert Plugins in zwei Schritten: Zuerst den Marktplatz über Ihr Terminal registrieren, dann das Plugin innerhalb der Codex TUI installieren.

    <Steps>
      <Step title="Register the marketplace">
        ```bash theme={null}
        codex plugin marketplace add dodopayments/dodo-agent-plugin
        ```
      </Step>

      <Step title="Install from the Codex TUI">
        Öffnen Sie Codex und führen Sie den `/plugins` Slash-Befehl aus:

        ```bash theme={null}
        codex
        ```

        Geben Sie dann `/plugins` ein, wechseln Sie zum **Dodo Payments** Marktplatz, wählen Sie das Plugin **dodopayments** und wählen Sie **Plugin installieren**.
      </Step>
    </Steps>

    Sowohl MCP-Server als auch alle acht Skills werden automatisch registriert, sobald das Plugin installiert ist.

    <Note>
      Codex CLI hat keinen `codex plugin install` Unterbefehl — die Plugin-Installation erfolgt immer über den in-TUI `/plugins` Flow. Siehe die [offiziellen Codex Plugins-Dokumentation](https://developers.openai.com/codex/plugins).
    </Note>

    Wenn Sie den Marktplatz zuvor hinzugefügt haben und das Plugin nicht unter `/plugins` erscheint, aktualisieren Sie es:

    ```bash theme={null}
    codex plugin marketplace upgrade dodopayments
    ```
  </Accordion>

  <Accordion title="Cursor">
    Manuelle Installation — klonen Sie das Repository in das lokale Plugins-Verzeichnis von Cursor:

    ```bash theme={null}
    git clone https://github.com/dodopayments/dodo-agent-plugin.git ~/.cursor/plugins/local/dodo-agent-plugin
    ```

    Starten Sie Cursor neu. Das Plugin lädt Skills von `.claude/skills/` (über die Claude Code-Kompatibilitätsschicht von Cursor) und MCP-Server von `.mcp.json`.

    <Info>
      Cursor-Marktplatz-Unterstützung ist in Arbeit. Vorerst verwenden Sie die oben beschriebene manuelle Installation.
    </Info>
  </Accordion>

  <Accordion title="OpenCode">
    OpenCode wird über npm verteilt. Fügen Sie das Plugin zu Ihrem `opencode.json` hinzu:

    ```json theme={null}
    {
      "$schema": "https://opencode.ai/config.json",
      "plugin": ["@dodopayments/opencode-plugin"]
    }
    ```

    Starten Sie OpenCode neu. Beide MCP-Server (`dodopayments-api`, `dodo-knowledge`) werden über den Konfigurationshook des Plugins automatisch registriert, und die acht Skills werden automatisch aus dem installierten Paket ermittelt. Kein manueller `mcp` Block erforderlich.
  </Accordion>
</AccordionGroup>

<Info>
  Verwenden Sie einen anderen Agenten? Die [MCP Server](/developer-resources/mcp-server) und [Agent Skills](/developer-resources/agent-skills) Anleitungen behandeln Cursor, Claude Desktop, VS Code, Windsurf, Cline, Zed und jeden MCP-kompatiblen Client.
</Info>

## Was Sie erhalten

Sobald das Plugin installiert ist, hat Ihr Agent Zugriff auf zwei MCP-Server und acht Skills.

### MCP-Server

| Server             | Zweck                                                                                            | Auth            |
| ------------------ | ------------------------------------------------------------------------------------------------ | --------------- |
| `dodopayments-api` | Live-API-Zugriff — Zahlungen, Abonnements, Kunden, Produkte, Rückerstattungen, Lizenzen, Nutzung | OAuth (Browser) |
| `dodo-knowledge`   | Semantische Suche in der gesamten Dodo Payments-Dokumentation                                    | Keine           |

Beide Server sind durch `mcp-remote` verbunden, sodass sie in jedem MCP-kompatiblen Client laufen.

### Agent-Skills

| Skill                      | Beschreibung                                                                |
| -------------------------- | --------------------------------------------------------------------------- |
| `best-practices`           | Umfassender Leitfaden zur Integration von Dodo Payments mit Best Practices  |
| `checkout-integration`     | Erstellen von Checkout-Sessions und Zahlungsabläufen                        |
| `subscription-integration` | Implementierung von Abrechnungsabläufen für Abonnements                     |
| `webhook-integration`      | Einrichten und Handhaben von Webhooks für Zahlungsevents                    |
| `usage-based-billing`      | Implementierung von Abrechnungen nach Verbrauch mit Ereignissen und Zählern |
| `credit-based-billing`     | Guthabenberechtigungen, Salden und verbrauchsabhängiger Kreditabzug         |
| `license-keys`             | Verwaltung von Lizenzschlüsseln für digitale Produkte                       |
| `billing-sdk`              | Verwendung von BillingSDK React-Komponenten                                 |

Skills werden automatisch geladen — Ihr Agent wählt den richtigen aus, wenn er eine relevante Aufgabe erkennt. Siehe die [Agent Skills Dokumentation](/developer-resources/agent-skills) für die vollständige Liste und individuelle Installation.

### Probieren Sie diesen Prompt zuerst aus

Sobald das Plugin aktiv ist, versuchen Sie:

```
Set up Dodo Payments webhook handlers in my Next.js app for payment.succeeded and subscription.active events.
```

Ihr Agent lädt den `webhook-integration` Skill, verwendet den `dodo-knowledge` MCP, um die neuesten Payload-Strukturen abzurufen, und schreibt einen Handler mit Signaturprüfung nach dem Standard Webhooks-Spezifikation.

## Andere unterstützte Agenten

Das Agent Plugin deckt Claude Code, Codex CLI, Cursor und OpenCode ab. Wenn Sie einen anderen Agenten verwenden, verbinden Sie sich über die MCP-Server und Skills CLI mit Dodo Payments:

| Agent                    | Schnellster Weg                                         | Unterstützt auch                                |
| ------------------------ | ------------------------------------------------------- | ----------------------------------------------- |
| **Claude Code**          | Agent Plugin (ein Befehl)                               | MCP-Server, individuelle Skills                 |
| **Codex CLI**            | Agent Plugin (ein Befehl)                               | MCP-Server                                      |
| **Cursor**               | Agent Plugin (git clone)                                | MCP-Server-Konfiguration, Skills-CLI            |
| **OpenCode**             | Agent Plugin (npm)                                      | MCP-Server-Konfiguration, Skills-CLI            |
| GitHub Copilot (VS Code) | [MCP Server Anleitung](/developer-resources/mcp-server) | [Skills CLI](/developer-resources/agent-skills) |
| Claude Desktop           | [MCP Server Anleitung](/developer-resources/mcp-server) | —                                               |
| Windsurf                 | [MCP Server Anleitung](/developer-resources/mcp-server) | [Skills CLI](/developer-resources/agent-skills) |
| Cline / Zed / andere     | [MCP Server Anleitung](/developer-resources/mcp-server) | [Skills CLI](/developer-resources/agent-skills) |

## Speziell für Agenten erstellte Dokumente

Jede Dodo Payments-Dokumentationsseite ist in einem für den KI-Verbrauch optimierten Format verfügbar:

* **Vollständiges Dokumentenindex**: [`docs.dodopayments.com/llms.txt`](https://docs.dodopayments.com/llms.txt) — dient als vollständiger Dokumentenindex für die Kontextaufnahme.
* **Reines Markdown**: Fügen Sie `.md` zu jeder Dokumentations-URL hinzu, um die rohe Markdown-Version zu erhalten (z. B. `/api-reference/introduction.md`).
* **Quellrepository**: [`github.com/dodopayments/dodo-docs`](https://github.com/dodopayments/dodo-docs) — klonen Sie für die Offline-Indexierung.

## Was Ihr Agent tun kann

Mit installiertem Plugin kann Ihr Coding-Agent:

* **Erstellen Sie Checkout-Sitzungen und Zahlungslinks** — [Einmalige Zahlungen](/features/one-time-payment-products) und [Abonnements](/features/subscription)
* **Komplette End-to-End-Abonnement- und nutzungsbasierte Abrechnung** — [Abonnements](/features/subscription), [Nutzungsbasierte Abrechnung](/features/usage-based-billing/introduction), [Kreditbasierte Abrechnung](/features/credit-based-billing)
* **Erstellen Sie Standard-Webhooks-konforme Handler** mit Signaturüberprüfung — [Webhooks](/developer-resources/webhooks)
* **Verkabeln Sie BillingSDK React-Komponenten** für Preistabellen und Abonnementverwaltung — [BillingSDK](/developer-resources/billingsdk)
* **Erstellen Sie Lizenzschlüssel-Flows** für digitale Produkte — [Lizenzschlüssel](/features/license-keys)
* **Implementieren Sie kreditbasierte Abrechnung** mit Berechtigungen, Guthaben, Übertrag und Übernutzung — [Kredite](/features/credit-based-billing)

## Sicherheit und Best Practices

<Warning>
  **Veröffentlichen Sie niemals Produktions-API-Schlüssel.** Verwenden Sie während der Entwicklung den [Testmodus](/miscellaneous/test-mode-vs-live-mode). Das Agent Plugin verwendet standardmäßig Browser-OAuth — wechseln Sie nur zu lokalen API-Schlüsseln, wenn Ihr Arbeitsablauf dies erfordert.
</Warning>

* **Verwenden Sie zuerst den Testmodus.** Testen Sie Ihre Integration mit `dodo_test_...` Schlüsseln, bevor Sie live gehen. Siehe [Testmodus vs Livemodus](/miscellaneous/test-mode-vs-live-mode).
* **OAuth ist der Standard.** Das Agent Plugin authentifiziert über Browser-OAuth (keine lokalen Geheimnisse). Verwenden Sie den API-Schlüsselmodus nur, wenn Sie ihn benötigen — siehe den Abschnitt Konfiguration unten.
* **Überprüfen Sie agentengenerierten Code.** Stellen Sie sicher, dass Webhook-Handler die Signaturverifizierung gemäß der [Standard Webhooks-Spezifikation](https://standardwebhooks.com/) enthalten.

## Mit einem API-Schlüssel konfigurieren

Standardmäßig verwendet das Agent Plugin den entfernten MCP-Server mit Browser-OAuth — keine lokalen Anmeldedaten erforderlich. Wenn Ihr Arbeitsablauf einen lokalen API-Schlüssel erfordert (z.B. CI-Umgebungen, headless Server), können Sie in den Stdio-Modus wechseln.

<AccordionGroup>
  <Accordion title="Local API key mode — Claude Code">
    Öffnen Sie `/plugins` in Claude Code, wählen Sie **Dodo Payments** und wählen Sie **Konfigurationsoptionen**. Füllen Sie ein:

    * `dodo_api_key` — Ihr `dodo_test_...` oder `dodo_live_...` Schlüssel
    * `dodo_webhook_key` — Ihr Webhook-Signatur-Geheimnis
    * `dodo_environment` — `test_mode` oder `live_mode`

    Bearbeiten Sie dann `.mcp.json`, um `dodopayments-api` auf den lokalen Stdio-Server zu verweisen:

    ```json theme={null}
    {
      "mcpServers": {
        "dodopayments-api": {
          "type": "stdio",
          "command": "npx",
          "args": ["-y", "dodopayments-mcp@latest"],
          "env": {
            "DODO_PAYMENTS_API_KEY": "${user_config.dodo_api_key}",
            "DODO_PAYMENTS_WEBHOOK_KEY": "${user_config.dodo_webhook_key}",
            "DODO_PAYMENTS_ENVIRONMENT": "${user_config.dodo_environment}"
          }
        }
      }
    }
    ```

    Führen Sie `/reload-plugins` aus, um Änderungen in Ihrer aktuellen Sitzung anzuwenden.
  </Accordion>

  <Accordion title="Local API key mode — OpenCode">
    Deklarieren Sie `dodopayments-api` selbst in `opencode.json` — Ihr Eintrag gewinnt über den Standard-Remote-Server des Plugins:

    ```json theme={null}
    {
      "$schema": "https://opencode.ai/config.json",
      "plugin": ["@dodopayments/opencode-plugin"],
      "mcp": {
        "dodopayments-api": {
          "type": "local",
          "command": ["npx", "-y", "dodopayments-mcp@latest"],
          "environment": {
            "DODO_PAYMENTS_API_KEY": "dodo_test_...",
            "DODO_PAYMENTS_WEBHOOK_KEY": "whsec_...",
            "DODO_PAYMENTS_ENVIRONMENT": "test_mode"
          },
          "enabled": true
        }
      }
    }
    ```

    Starten Sie OpenCode neu, um anzuwenden.
  </Accordion>
</AccordionGroup>

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="MCP Server" icon="terminal" href="/developer-resources/mcp-server">
    Vollständige Referenz für beide MCP-Server — alle unterstützten Clients, Konfiguration und verfügbare Tools
  </Card>

  <Card title="Agent Skills" icon="wand-magic-sparkles" href="/developer-resources/agent-skills">
    Individuelle Skill-Installation, Skill-Referenz und pro-Agent-Einrichtungsanleitungen
  </Card>

  <Card title="Sentra IDE Assistant" icon="bolt" href="/developer-resources/sentra">
    KI-gestützter Abrechnungsassistent für VS Code, Cursor und Windsurf — fragen, bauen und planen Sie in Ihrem Editor
  </Card>

  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    Vollständige OpenAPI-Referenz für alle Dodo Payments Endpunkte
  </Card>
</CardGroup>