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

# Développer avec des Agents de Codage IA

> Utilisez le Plugin Agent Dodo pour construire des intégrations avec Claude Code, Codex CLI, Cursor, et OpenCode — des serveurs et compétences MCP en une seule installation.

Le Plugin Agent Dodo connecte deux serveurs MCP et huit compétences d'intégration à votre agent de codage IA en une seule installation. Il fonctionne avec **Claude Code**, **Codex CLI**, **Cursor**, et **OpenCode** — et les serveurs et compétences MCP CLI fonctionnent avec tout client compatible MCP.

<Info>
  **Trois primitives, un plugin.** Le Plugin Agent regroupe tout ce dont vous avez besoin :

  * **Serveur API MCP** — accès en direct aux paiements, abonnements, clients, produits, remboursements, licences, et utilisation. Authentification via OAuth du navigateur (pas de clés locales requises).
  * **Serveur de Connaissances MCP** — recherche sémantique à travers toute la documentation Dodo Payments. Aucune référence requise.
  * **Huit compétences d'agent** — fiches pratiques que votre agent charge à la demande pour checkout, abonnements, webhooks, facturation basée sur l'utilisation, facturation basée sur le crédit, clés de licence, BillingSDK, et meilleures pratiques.
</Info>

## Installer le plugin

Choisissez votre agent de codage ci-dessous. L'installation ajoute automatiquement les deux serveurs MCP et toutes les huit compétences.

<AccordionGroup>
  <Accordion title="Claude Code" defaultOpen>
    Installez depuis le marché :

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

    Le serveur API MCP utilise OAuth du navigateur par défaut — pas de clés requises lors de l'installation. La première fois que votre agent appelle un outil Dodo, vous serez invité à vous connecter.

    <Card title="Dodo Agent Plugin on GitHub" icon="github" href="https://github.com/dodopayments/dodo-agent-plugin">
      Code source, options de configuration, et instructions de développement local
    </Card>
  </Accordion>

  <Accordion title="Codex CLI">
    Codex installe des plugins en deux étapes : enregistrez le marketplace depuis votre terminal, puis installez le plugin depuis l'intérieur de l'interface Codex TUI.

    <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">
        Ouvrez Codex et exécutez la commande slash `/plugins` :

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

        Ensuite, tapez `/plugins`, passez au marketplace **Dodo Payments**, sélectionnez le plugin **dodopayments** et choisissez **Installer le plugin**.
      </Step>
    </Steps>

    Les serveurs MCP et les huit compétences sont enregistrés automatiquement une fois le plugin installé.

    <Note>
      Codex CLI n'a pas de sous-commande `codex plugin install` — l'installation de plugins se fait toujours via le flux in-TUI `/plugins`. Voir la [documentation officielle des plugins Codex](https://developers.openai.com/codex/plugins).
    </Note>

    Si vous avez déjà ajouté le marketplace et que le plugin n'apparaît pas sous `/plugins`, actualisez-le :

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

  <Accordion title="Cursor">
    Installation manuelle — clonez le dépôt dans le répertoire local des plugins de Cursor :

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

    Redémarrez Cursor. Le plugin charge les compétences de `.claude/skills/` (via la couche de compatibilité Claude Code de Cursor) et les serveurs MCP de `.mcp.json`.

    <Info>
      Le support du marketplace Cursor arrive bientôt. Pour l'instant, utilisez l'installation manuelle ci-dessus.
    </Info>
  </Accordion>

  <Accordion title="OpenCode">
    OpenCode distribue via npm. Ajoutez le plugin à votre `opencode.json` :

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

    Redémarrez OpenCode. Les deux serveurs MCP (`dodopayments-api`, `dodo-knowledge`) sont enregistrés automatiquement via le hook de configuration du plugin, et les huit compétences sont découvertes automatiquement à partir du package installé. Aucun bloc `mcp` manuel requis.
  </Accordion>
</AccordionGroup>

<Info>
  Vous utilisez un autre agent ? Les guides [Serveur MCP](/developer-resources/mcp-server) et [Compétences d'agent](/developer-resources/agent-skills) couvrent Cursor, Claude Desktop, VS Code, Windsurf, Cline, Zed et tout client compatible MCP.
</Info>

## Ce que vous obtenez

Une fois le plugin installé, votre agent a accès à deux serveurs MCP et huit compétences.

### Serveurs MCP

| Serveur            | Objectif                                                                                               | Auth               |
| ------------------ | ------------------------------------------------------------------------------------------------------ | ------------------ |
| `dodopayments-api` | Accès API en direct — paiements, abonnements, clients, produits, remboursements, licences, utilisation | OAuth (navigateur) |
| `dodo-knowledge`   | Recherche sémantique dans toute la documentation Dodo Payments                                         | Aucun              |

Les deux serveurs sont connectés via `mcp-remote` afin qu'ils fonctionnent dans tout client compatible MCP.

### Compétences d'agent

| Compétence                 | Description                                                             |
| -------------------------- | ----------------------------------------------------------------------- |
| `best-practices`           | Guide complet pour intégrer Dodo Payments avec les meilleures pratiques |
| `checkout-integration`     | Création de sessions de paiement et flux de paiement                    |
| `subscription-integration` | Mise en œuvre de flux de facturation d'abonnement                       |
| `webhook-integration`      | Configuration et gestion des webhooks pour les événements de paiement   |
| `usage-based-billing`      | Mise en œuvre de la facturation mesurée avec événements et compteurs    |
| `credit-based-billing`     | Droits de crédit, soldes et déduction de crédit mesurée                 |
| `license-keys`             | Gestion des clés de licence pour produits numériques                    |
| `billing-sdk`              | Utilisation des composants React BillingSDK                             |

Les compétences se chargent automatiquement — votre agent choisit la bonne lorsqu'il détecte une tâche pertinente. Voir la [documentation des compétences d'agent](/developer-resources/agent-skills) pour la liste complète et l'installation individuelle.

### Essayez ce prompt en premier

Une fois le plugin actif, essayez :

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

Votre agent chargera la compétence `webhook-integration`, utilisera le MCP `dodo-knowledge` pour récupérer les dernières formes de charge utile, et écrira un gestionnaire avec vérification de signature suivant la spécification des Standard Webhooks.

## Autres agents pris en charge

Le plugin d'agent couvre Claude Code, Codex CLI, Cursor et OpenCode. Si vous utilisez un autre agent, connectez-vous à Dodo Payments via les serveurs MCP et le CLI des compétences :

| Agent                    | Chemin le plus rapide                                   | Prend également en charge                                |
| ------------------------ | ------------------------------------------------------- | -------------------------------------------------------- |
| **Claude Code**          | Plugin d'agent (une commande)                           | Serveur MCP, compétences individuelles                   |
| **Codex CLI**            | Plugin d'agent (une commande)                           | Serveur MCP                                              |
| **Cursor**               | Plugin d'agent (git clone)                              | Configuration du serveur MCP, CLI des compétences        |
| **OpenCode**             | Plugin d'agent (npm)                                    | Configuration du serveur MCP, CLI des compétences        |
| GitHub Copilot (VS Code) | [Guide du serveur MCP](/developer-resources/mcp-server) | [CLI des compétences](/developer-resources/agent-skills) |
| Claude Desktop           | [Guide du serveur MCP](/developer-resources/mcp-server) | —                                                        |
| Windsurf                 | [Guide du serveur MCP](/developer-resources/mcp-server) | [CLI des compétences](/developer-resources/agent-skills) |
| Cline / Zed / autres     | [Guide du serveur MCP](/developer-resources/mcp-server) | [CLI des compétences](/developer-resources/agent-skills) |

## Documentation conçue pour les agents

Chaque page de documentation Dodo Payments est disponible dans un format optimisé pour la consommation par IA :

* **Index complet des documents** : [`docs.dodopayments.com/llms.txt`](https://docs.dodopayments.com/llms.txt) — fournit l'index complet de la documentation pour l'ingestion contextuelle.
* **Markdown brut** : Ajoutez `.md` à n'importe quelle URL de documentation pour obtenir la version markdown brute (par exemple, `/api-reference/introduction.md`).
* **Dépôt source** : [`github.com/dodopayments/dodo-docs`](https://github.com/dodopayments/dodo-docs) — clonez pour indexation hors ligne.

## Ce que votre agent peut faire

Avec le plugin installé, votre agent de codage peut :

* **Créer des sessions de paiement et des liens de paiement** — [Paiements ponctuels](/features/one-time-payment-products) et [abonnements](/features/subscription)
* **Mettre en place un système de facturation par abonnement et basé sur l'utilisation de bout en bout** — [Abonnements](/features/subscription), [Facturation basée sur l'utilisation](/features/usage-based-billing/introduction), [Facturation à base de crédits](/features/credit-based-billing)
* **Générer des gestionnaires conformes aux webhooks standards** avec vérification de la signature — [Webhooks](/developer-resources/webhooks)
* **Utiliser les composants React de BillingSDK** pour les grilles tarifaires et la gestion des abonnements — [BillingSDK](/developer-resources/billingsdk)
* **Créer des flux de clés de licence** pour les produits numériques — [Clés de licence](/features/license-keys)
* **Implémenter la facturation à base de crédits** avec droits, soldes, report et dépassement — [Crédits](/features/credit-based-billing)

## Sécurité et meilleures pratiques

<Warning>
  **Ne vous engagez jamais avec des clés API de production.** Utilisez le [mode test](/miscellaneous/test-mode-vs-live-mode) pendant le développement. Le plugin d'agent utilise par défaut OAuth du navigateur — ne passez à des clés API locales que si votre flux de travail l'exige.
</Warning>

* **Utilisez d'abord le mode test.** Testez votre intégration avec les clés `dodo_test_...` avant de passer en production. Voir [Mode test vs Mode live](/miscellaneous/test-mode-vs-live-mode).
* **OAuth est par défaut.** Le plugin d'agent s'authentifie via OAuth du navigateur (aucun secret local). Utilisez le mode clé API uniquement si nécessaire — voir la section Configuration ci-dessous.
* **Relisez le code généré par l'agent.** Vérifiez toujours que les gestionnaires de webhooks incluent la vérification de signature suivant la [spécification des Standard Webhooks](https://standardwebhooks.com/).

## Configurer avec une clé API

Par défaut, le plugin d'agent utilise le serveur MCP distant avec OAuth du navigateur — pas besoin d'identifiants locaux. Si votre flux de travail nécessite une clé API locale (par exemple, environnements CI, serveurs sans interface), vous pouvez passer au mode stdio.

<AccordionGroup>
  <Accordion title="Local API key mode — Claude Code">
    Ouvrez `/plugins` dans Claude Code, sélectionnez **Dodo Payments** et choisissez **Configurer les options**. Remplissez :

    * `dodo_api_key` — votre clé `dodo_test_...` ou `dodo_live_...`
    * `dodo_webhook_key` — votre secret de signature de webhook
    * `dodo_environment` — `test_mode` ou `live_mode`

    Puis éditez `.mcp.json` pour pointer `dodopayments-api` vers le serveur stdio local :

    ```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}"
          }
        }
      }
    }
    ```

    Exécutez `/reload-plugins` pour appliquer les changements à votre session actuelle.
  </Accordion>

  <Accordion title="Local API key mode — OpenCode">
    Déclarez `dodopayments-api` vous-même dans `opencode.json` — votre entrée prévaut sur le serveur distant par défaut du plugin :

    ```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
        }
      }
    }
    ```

    Redémarrez OpenCode pour appliquer.
  </Accordion>
</AccordionGroup>

## Prochaines étapes

<CardGroup cols={2}>
  <Card title="MCP Server" icon="terminal" href="/developer-resources/mcp-server">
    Référence complète pour les serveurs MCP — tous les clients pris en charge, configuration et outils disponibles
  </Card>

  <Card title="Agent Skills" icon="wand-magic-sparkles" href="/developer-resources/agent-skills">
    Installation individuelle des compétences, référence des compétences et instructions de configuration par agent
  </Card>

  <Card title="Sentra IDE Assistant" icon="bolt" href="/developer-resources/sentra">
    Assistant de facturation alimenté par l'IA pour VS Code, Cursor, et Windsurf — demander, construire et planifier dans votre éditeur
  </Card>

  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    Référence OpenAPI complète pour tous les endpoints Dodo Payments
  </Card>
</CardGroup>