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

# Costruisci con agenti di codifica AI

> Usa il Dodo Agent Plugin per creare integrazioni con Claude Code, Codex CLI, Cursor e OpenCode — server MCP e competenze in un'unica installazione.

Il plugin Dodo Agent connette due server MCP e otto competenze di integrazione nel tuo agente di codifica AI in un'unica installazione. Funziona con **Claude Code**, **Codex CLI**, **Cursor** e **OpenCode** — e i server MCP e la CLI delle competenze funzionano con qualsiasi client compatibile con MCP.

<Info>
  **Tre primitive, un plugin.** Il plugin Agent raccoglie tutto ciò di cui hai bisogno:

  * **Server API MCP** — accesso live a pagamenti, abbonamenti, clienti, prodotti, rimborsi, licenze e utilizzo. Autenticazione tramite OAuth del browser (non sono necessarie chiavi locali).
  * **Server di conoscenza MCP** — ricerca semantica in tutta la documentazione di Dodo Payments. Nessuna credenziale necessaria.
  * **Otto competenze degli agenti** — schede di riferimento rapido che il tuo agente carica su richiesta per checkout, abbonamenti, webhook, fatturazione basata sull'uso, fatturazione basata su crediti, chiavi di licenza, BillingSDK e best practices.
</Info>

## Installa il plugin

Scegli il tuo agente di codifica qui sotto. L'installazione aggiunge automaticamente entrambi i server MCP e tutte e otto le competenze.

<AccordionGroup>
  <Accordion title="Claude Code" defaultOpen>
    Installa dal marketplace:

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

    Il server API MCP utilizza di default OAuth del browser — non sono necessarie chiavi al momento dell'installazione. Alla prima chiamata di uno strumento Dodo da parte del tuo agente, ti verrà chiesto di accedere.

    <Card title="Dodo Agent Plugin on GitHub" icon="github" href="https://github.com/dodopayments/dodo-agent-plugin">
      Codice sorgente, opzioni di configurazione e istruzioni per lo sviluppo locale
    </Card>
  </Accordion>

  <Accordion title="Codex CLI">
    Codex installa i plugin in due passaggi: registra il marketplace dalla tua shell, poi installa il plugin dall'interno del TUI di Codex.

    <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">
        Apri Codex ed esegui il comando slash `/plugins`:

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

        Poi digita `/plugins`, passa al marketplace **Dodo Payments**, seleziona il plugin **dodopayments** e scegli **Installa plugin**.
      </Step>
    </Steps>

    Entrambi i server MCP e tutte le otto competenze vengono registrati automaticamente una volta installato il plugin.

    <Note>
      Codex CLI non dispone di un sottocomando `codex plugin install` — l'installazione del plugin avviene sempre tramite il flusso in-TUI `/plugins`. Vedi la [documentazione ufficiale dei plugin di Codex](https://developers.openai.com/codex/plugins).
    </Note>

    Se hai precedentemente aggiunto il marketplace e il plugin non appare sotto `/plugins`, aggiornalo:

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

  <Accordion title="Cursor">
    Installazione manuale — clona il repository nella directory dei plugin locali di Cursor:

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

    Riavvia Cursor. Il plugin carica le competenze da `.claude/skills/` (tramite il layer di compatibilità Claude Code di Cursor) e i server MCP da `.mcp.json`.

    <Info>
      Il supporto marketplace per Cursor è in arrivo. Per ora, usa l'installazione manuale sopra descritta.
    </Info>
  </Accordion>

  <Accordion title="OpenCode">
    OpenCode distribuisce tramite npm. Aggiungi il plugin al tuo `opencode.json`:

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

    Riavvia OpenCode. Entrambi i server MCP (`dodopayments-api`, `dodo-knowledge`) sono registrati automaticamente tramite il gancio di configurazione del plugin, e le otto competenze vengono scoperte automaticamente dal pacchetto installato. Non è necessario alcun blocco `mcp` manuale.
  </Accordion>
</AccordionGroup>

<Info>
  Usi un agente diverso? Le guide [MCP Server](/developer-resources/mcp-server) e [Agent Skills](/developer-resources/agent-skills) coprono Cursor, Claude Desktop, VS Code, Windsurf, Cline, Zed e qualsiasi client compatibile con MCP.
</Info>

## Cosa ottieni

Una volta installato il plugin, il tuo agente ha accesso a due server MCP e otto competenze.

### Server MCP

| Server             | Scopo                                                                                     | Autenticazione  |
| ------------------ | ----------------------------------------------------------------------------------------- | --------------- |
| `dodopayments-api` | Accesso API live — pagamenti, abbonamenti, clienti, prodotti, rimborsi, licenze, utilizzo | OAuth (browser) |
| `dodo-knowledge`   | Ricerca semantica in tutta la documentazione di Dodo Payments                             | Nessuna         |

Entrambi i server sono connessi tramite `mcp-remote` in modo da funzionare con qualsiasi client compatibile con MCP.

### Competenze dell'agente

| Competenza                 | Descrizione                                                                |
| -------------------------- | -------------------------------------------------------------------------- |
| `best-practices`           | Guida completa all'integrazione dei Dodo Payments con le migliori pratiche |
| `checkout-integration`     | Creazione di sessioni di checkout e flussi di pagamento                    |
| `subscription-integration` | Implementazione di flussi di fatturazione per abbonamenti                  |
| `webhook-integration`      | Configurazione e gestione dei webhook per eventi di pagamento              |
| `usage-based-billing`      | Implementazione di fatturazione misurata con eventi e contatori            |
| `credit-based-billing`     | Diritto ai crediti, saldi e deduzione di crediti misurati                  |
| `license-keys`             | Gestione delle chiavi di licenza per prodotti digitali                     |
| `billing-sdk`              | Utilizzo dei componenti React di BillingSDK                                |

Le competenze si caricano automaticamente — il tuo agente sceglie quella giusta quando rileva un compito pertinente. Vedi la [documentazione delle competenze dell'agente](/developer-resources/agent-skills) per l'elenco completo e l'installazione individuale.

### Prova questo prompt prima

Una volta che il plugin è attivo, prova:

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

Il tuo agente caricherà la competenza `webhook-integration`, userà il server MCP `dodo-knowledge` per ottenere le forme di payload più recenti e scriverà un gestore con verifica della firma seguendo la specifica Standard Webhooks.

## Altri agenti supportati

Il plugin Agent copre Claude Code, Codex CLI, Cursor e OpenCode. Se utilizzi un altro agente, connettiti a Dodo Payments tramite i server MCP e la CLI delle competenze:

| Agente                   | Percorso più veloce                                 | Supporta anche                                            |
| ------------------------ | --------------------------------------------------- | --------------------------------------------------------- |
| **Claude Code**          | Plugin Agent (un comando)                           | Server MCP, competenze individuali                        |
| **Codex CLI**            | Plugin Agent (un comando)                           | Server MCP                                                |
| **Cursor**               | Plugin Agent (git clone)                            | Configurazione del server MCP, CLI delle competenze       |
| **OpenCode**             | Plugin Agent (npm)                                  | Configurazione del server MCP, CLI delle competenze       |
| GitHub Copilot (VS Code) | [Guida MCP Server](/developer-resources/mcp-server) | [CLI delle competenze](/developer-resources/agent-skills) |
| Claude Desktop           | [Guida MCP Server](/developer-resources/mcp-server) | —                                                         |
| Windsurf                 | [Guida MCP Server](/developer-resources/mcp-server) | [CLI delle competenze](/developer-resources/agent-skills) |
| Cline / Zed / altri      | [Guida MCP Server](/developer-resources/mcp-server) | [CLI delle competenze](/developer-resources/agent-skills) |

## Documenti costruiti per agenti

Ogni pagina della documentazione di Dodo Payments è disponibile in un formato ottimizzato per il consumo AI:

* **Indice completo dei documenti**: [`docs.dodopayments.com/llms.txt`](https://docs.dodopayments.com/llms.txt) — fornisce l'indice completo della documentazione per l'ingestione contestuale.
* **Markdown semplice**: Aggiungi `.md` a qualsiasi URL della documentazione per ottenere la versione raw markdown (ad es., `/api-reference/introduction.md`).
* **Repository di origine**: [`github.com/dodopayments/dodo-docs`](https://github.com/dodopayments/dodo-docs) — clona per l'indicizzazione offline.

## Cosa può fare il tuo agente

Con il plugin installato, il tuo agente di codifica può:

* **Creare sessioni di checkout e link di pagamento** — [Pagamenti una tantum](/features/one-time-payment-products) e [abbonamenti](/features/subscription)
* **Stabilire la fatturazione basata su abbonamento e uso end-to-end** — [Abbonamenti](/features/subscription), [Fatturazione basata sull'uso](/features/usage-based-billing), [Fatturazione basata sui crediti](/features/credit-based-billing)
* **Generare gestori conformi a Standard Webhooks** con verifica della firma — [Webhooks](/developer-resources/webhooks)
* **Integrare i componenti React di BillingSDK** per tabelle di prezzi e gestione degli abbonamenti — [BillingSDK](/developer-resources/billingsdk)
* **Progettare flussi di chiavi di licenza** per prodotti digitali — [Chiavi di licenza](/features/license-keys)
* **Implementare la fatturazione basata sui crediti** con diritti, saldi, rollover e superamenti — [Crediti](/features/credit-based-billing)

## Sicurezza e migliori pratiche

<Warning>
  **Non commettere mai chiavi API di produzione.** Usa [modalità test](/miscellaneous/test-mode-vs-live-mode) durante lo sviluppo. Il plugin Agent utilizza di default OAuth del browser — passa alle chiavi API locali solo se il tuo flusso di lavoro lo richiede.
</Warning>

* **Usa prima la modalità test.** Sandbox la tua integrazione con chiavi `dodo_test_...` prima di andare live. Vedi [Modalità test vs Modalità live](/miscellaneous/test-mode-vs-live-mode).
* **OAuth è il default.** Il plugin Agent si autentica tramite OAuth del browser (nessun segreto locale). Usa la modalità chiave API solo se necessario — vedi la sezione Configura sotto.
* **Rivedi il codice generato dall'agente.** Verifica sempre che i gestori dei webhook includano la verifica della firma secondo la [standard Webhooks spec](https://standardwebhooks.com/).

## Configurare con una chiave API

Di default, il plugin Agent utilizza il server remoto MCP con OAuth del browser — nessuna credenziale locale necessaria. Se il tuo flusso di lavoro richiede una chiave API locale (es., ambienti CI, server senza testa), puoi passare alla modalità stdio.

<AccordionGroup>
  <Accordion title="Local API key mode — Claude Code">
    Apri `/plugins` in Claude Code, seleziona **Dodo Payments** e scegli **Configura opzioni**. Compila:

    * `dodo_api_key` — la tua chiave `dodo_test_...` o `dodo_live_...`
    * `dodo_webhook_key` — il tuo segreto di firma del webhook
    * `dodo_environment` — `test_mode` o `live_mode`

    Poi modifica `.mcp.json` per puntare `dodopayments-api` al server stdio locale:

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

    Esegui `/reload-plugins` per applicare le modifiche alla tua sessione corrente.
  </Accordion>

  <Accordion title="Local API key mode — OpenCode">
    Dichiara `dodopayments-api` da solo in `opencode.json` — la tua voce prevarrà sul server remoto predefinito del 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
        }
      }
    }
    ```

    Riavvia OpenCode per applicare.
  </Accordion>
</AccordionGroup>

## Passi successivi

<CardGroup cols={2}>
  <Card title="MCP Server" icon="terminal" href="/developer-resources/mcp-server">
    Riferimento completo per entrambi i server MCP — tutti i client supportati, configurazione e strumenti disponibili
  </Card>

  <Card title="Agent Skills" icon="wand-magic-sparkles" href="/developer-resources/agent-skills">
    Installazione individuale delle competenze, riferimento delle competenze e istruzioni per la configurazione per agente
  </Card>

  <Card title="Sentra IDE Assistant" icon="bolt" href="/developer-resources/sentra">
    Assistente di fatturazione AI-powered per VS Code, Cursor e Windsurf — chiedi, costruisci e pianifica nel tuo editor
  </Card>

  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    Riferimento completo OpenAPI per tutti gli endpoint di Dodo Payments
  </Card>
</CardGroup>