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

# MCP Server

> Consenti agli assistenti AI di interagire con l’API Dodo Payments tramite Code Mode: un’architettura ad alte prestazioni per operazioni di pagamento fluide e gestione delle sottoscrizioni.

## Overview

The Model Context Protocol (MCP) is an open standard that enables AI applications to securely connect to external data sources and APIs. The Dodo Payments MCP Server provides AI assistants like Claude, Cursor, and other MCP-compatible clients with structured access to your payment infrastructure.

Il server Dodo Payments MCP utilizza l’architettura **Code Mode**. Invece di esporre centinaia di strumenti individuali per ogni endpoint API, Code Mode consente agli agenti AI di scrivere ed eseguire codice TypeScript contro l’SDK Dodo Payments in un ambiente sandbox isolato.

### Key capabilities

* **Payment Operations**: Create, retrieve, and manage payments and refunds
* **Subscription Management**: Handle recurring billing, upgrades, and cancellations
* **Customer Administration**: Manage customer data and portal access
* **Product Catalog**: Create and update products, pricing, and discounts
* **License Management**: Activate, validate, and manage software licenses
* **Usage-Based Billing**: Track and bill for metered usage

## How Code Mode Works

Il server Dodo Payments MCP fornisce al tuo agente AI esattamente due strumenti:

1. **Docs Search Tool**: interroga la documentazione sull’API e sull’SDK di Dodo Payments per comprendere le operazioni e i parametri disponibili.
2. **Code Execution Tool**: scrive codice TypeScript contro l’SDK che viene eseguito in un ambiente sandbox sicuro.

Questa architettura consente agli agenti di eseguire operazioni complesse e multi-step in un’unica invocazione. Ad esempio, un agente può elencare tutte le sottoscrizioni attive, filtrarle in base a criteri specifici e applicare uno sconto a ciascuna, tutto all’interno di uno script.

<Tip>
  Usando Code Mode, gli agenti possono concatenare più chiamate API, gestire la logica condizionale ed eseguire calcoli senza richiedere molteplici round-trip al LLM.
</Tip>

### Configurazione rapida

Connettiti al server Dodo Payments MCP nel tuo client AI:

<Tabs>
  <Tab title="Agent Plugin (recommended)">
    Il [Dodo Agent Plugin](/developer-resources/build-with-ai-coding-agents) installa sia i server MCP che tutte le otto competenze in un solo passaggio per Claude Code, Codex CLI, Cursor e OpenCode. Vedi la [guida agli AI Coding Agents](/developer-resources/build-with-ai-coding-agents) per i comandi di installazione per agente.

    Se il tuo agente non è in questo elenco, usa le schede di seguito per configurare direttamente il server MCP.
  </Tab>

  <Tab title="Cursor">
    Aggiungi a `~/.cursor/mcp.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "dodopayments": {
          "command": "npx",
          "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
        }
      }
    }
    ```
  </Tab>

  <Tab title="Claude Desktop">
    Aggiungi alla configurazione di Claude Desktop:

    ```json theme={null}
    {
      "mcpServers": {
        "dodopayments": {
          "command": "npx",
          "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
        }
      }
    }
    ```

    Posizioni dei file di configurazione:

    * **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
    * **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
    * **Linux**: `~/.config/Claude/claude_desktop_config.json`
  </Tab>

  <Tab title="Windsurf">
    Aggiungi a `~/.codeium/windsurf/mcp_config.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "dodopayments": {
          "command": "npx",
          "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
        }
      }
    }
    ```
  </Tab>

  <Tab title="Claude Code">
    Esegui nel terminale:

    ```bash theme={null}
    claude mcp add dodopayments -- npx -y mcp-remote@latest https://mcp.dodopayments.com/sse
    ```
  </Tab>
</Tabs>

<Note>
  Richiede Node.js 18 o superiore. Il server remoto utilizza OAuth per l'autenticazione — ti verrà richiesto di inserire la tua chiave API e selezionare il tuo ambiente alla prima connessione.
</Note>

## Dodo Knowledge MCP

Oltre al Dodo Payments MCP Server (per l'esecuzione delle operazioni API), forniamo **Dodo Knowledge MCP**—un server di ricerca semantica che offre agli assistenti AI accesso immediato alla documentazione e alla knowledge base di Dodo Payments.

<Info>
  **Costruito con [ContextMCP.ai](https://contextmcp.ai)**: Dodo Knowledge MCP è alimentato da ContextMCP, consentendo una rapida ricerca semantica nella nostra documentazione utilizzando incorporamenti vettoriali.
</Info>

### Cos'è Dodo Knowledge MCP?

Dodo Knowledge MCP è un server MCP remoto che fornisce:

* **Ricerca semantica nella documentazione**: Trova documentazione pertinente utilizzando query in linguaggio naturale.
* **Risposte contestuali**: Gli assistenti AI ottengono informazioni accurate e aggiornate su Dodo Payments.
* **Nessuna configurazione**: Nessuna chiave API o installazione locale richiesta—basta connettersi e iniziare a interrogare.

### Configurazione rapida

Collegati a Dodo Knowledge MCP nel tuo client AI:

<Tabs>
  <Tab title="Cursor">
    Aggiungi a `~/.cursor/mcp.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "dodo-knowledge": {
          "command": "npx",
          "args": ["-y", "mcp-remote@latest", "https://knowledge.dodopayments.com/mcp"]
        }
      }
    }
    ```
  </Tab>

  <Tab title="Claude Desktop">
    Aggiungi alla configurazione di Claude Desktop:

    ```json theme={null}
    {
      "mcpServers": {
        "dodo-knowledge": {
          "command": "npx",
          "args": ["-y", "mcp-remote@latest", "https://knowledge.dodopayments.com/mcp"]
        }
      }
    }
    ```

    Posizioni dei file di configurazione:

    * **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
    * **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
    * **Linux**: `~/.config/Claude/claude_desktop_config.json`
  </Tab>

  <Tab title="Windsurf">
    Aggiungi a `~/.codeium/windsurf/mcp_config.json`:

    ```json theme={null}
    {
      "mcpServers": {
        "dodo-knowledge": {
          "command": "npx",
          "args": ["-y", "mcp-remote@latest", "https://knowledge.dodopayments.com/mcp"]
        }
      }
    }
    ```
  </Tab>

  <Tab title="Claude Code">
    Esegui nel terminale:

    ```bash theme={null}
    claude mcp add dodo-knowledge -- npx -y mcp-remote@latest https://knowledge.dodopayments.com/mcp
    ```
  </Tab>
</Tabs>

<Note>
  Richiede Node.js 18 o superiore. Il pacchetto `mcp-remote` gestisce la connessione al server MCP remoto.
</Note>

### Utilizzo di entrambi i server MCP insieme

Per la migliore esperienza di sviluppo assistita da AI, si consiglia di utilizzare entrambi i server MCP:

| Server                 | Scopo                  | Caso d'uso                                                               |
| ---------------------- | ---------------------- | ------------------------------------------------------------------------ |
| **Dodo Knowledge MCP** | Ricerca documentazione | "Come gestisco i webhook?", "Quali metodi di pagamento sono supportati?" |
| **Dodo Payments MCP**  | Operazioni API         | Creare pagamenti, gestire abbonamenti, trattare rimborsi                 |

```json theme={null}
{
  "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"]
    }
  }
}
```

<Tip>
  Con entrambi i server configurati, il tuo assistente AI può prima cercare documentazione per capire come implementare una funzione, quindi eseguire le chiamate API effettive—tutto in una singola conversazione.
</Tip>

### Risoluzione dei problemi di Knowledge MCP

Se riscontri problemi di connessione:

1. **Cancella cache di autenticazione MCP**: `rm -rf ~/.mcp-auth`
2. **Riavvia la tua applicazione client**
3. **Controlla i log del client** per messaggi di errore
4. **Verifica la versione di Node.js**: Richiede Node.js 18+

<Card title="Knowledge MCP Server" icon="book-open" href="https://knowledge.dodopayments.com">
  Accedi alla pagina di configurazione di Dodo Knowledge MCP
</Card>

## Installazione

Scegli il metodo di installazione che meglio si adatta al tuo flusso di lavoro.

### Server MCP remoto (Consigliato)

Accedi al server MCP ospitato senza alcuna configurazione o installazione locale. Questo è il modo più veloce per iniziare.

<Frame>
  <iframe className="w-full aspect-video rounded-md" src="https://www.youtube.com/embed/TxGgYxNmkT4" title="Using Dodo Payment's Remote MCP Server" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen />
</Frame>

<Steps>
  <Step title="Access the remote server">
    Naviga a [https://mcp.dodopayments.com](https://mcp.dodopayments.com) nel tuo browser.
  </Step>

  <Step title="Configure your MCP client">
    Copia la configurazione JSON fornita per il tuo client specifico. Per Cursor o Claude Desktop, aggiungi questo alle tue impostazioni MCP:

    ```json theme={null}
    {
      "mcpServers": {
        "dodopayments_api": {
          "command": "npx",
          "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
        }
      }
    }
    ```
  </Step>

  <Step title="Authenticate and configure">
    Il flusso OAuth ti chiederà di:

    * Inserire la tua chiave API Dodo Payments
    * Selezionare il tuo ambiente (test o live)
    * Scegliere il tipo di client MCP

    <Warning>
      Mantieni la tua chiave API sicura. Usa le chiavi modalità test durante lo sviluppo.
    </Warning>
  </Step>

  <Step title="Complete setup">
    Clicca **Login e Approva** per autorizzare la connessione.

    <Check>
      Una volta connesso, il tuo assistente AI può interagire con l'API di Dodo Payments a tuo nome.
    </Check>
  </Step>
</Steps>

### Pacchetto NPM

Installa ed esegui il server MCP localmente usando NPM.

<Tabs>
  <Tab title="NPX (No Installation)">
    ```bash theme={null}
    # 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
    ```
  </Tab>

  <Tab title="MCP Client Configuration">
    ```json theme={null}
    {
      "mcpServers": {
        "dodopayments_api": {
          "command": "npx",
          "args": ["-y", "dodopayments-mcp@latest"],
          "env": {
            "DODO_PAYMENTS_API_KEY": "dodo_test_...",
            "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key",
            "DODO_PAYMENTS_ENVIRONMENT": "live_mode"
          }
        }
      }
    }
    ```
  </Tab>
</Tabs>

<Tip>
  Usa `@latest` per ottenere sempre l'ultima versione, oppure imposta una versione specifica come `@1.0.0` per stabilità.
</Tip>

### Docker

Esegui il server MCP in un ambiente containerizzato per un deployment coerente.

<CodeGroup>
  ```bash Docker theme={null}
  # 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
  ```

  ```yaml Docker Compose theme={null}
  services:
    dodopayments-mcp:
      image: ghcr.io/dodopayments/mcp:latest
      environment:
        - DODO_PAYMENTS_API_KEY=dodo_test_...
        - DODO_PAYMENTS_WEBHOOK_KEY=your_webhook_key
        - DODO_PAYMENTS_ENVIRONMENT=live_mode
      restart: unless-stopped
  ```
</CodeGroup>

<Note>
  Le immagini Docker sono disponibili su [GitHub Container Registry](https://github.com/orgs/dodopayments/packages/container/package/mcp).
</Note>

## Configurazione del client

Configura il server MCP di Dodo Payments nel tuo client AI preferito.

<Tabs>
  <Tab title="Cursor">
    Imposta il server MCP di Dodo Payments in Cursor per abilitare l'accesso conversazionale ai tuoi dati di pagamento.

    **Installazione con un clic**

    Usa il pulsante qui sotto per installare il server MCP direttamente in Cursor:

    \[

    ![Aggiungi a Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)

    ]\([https://cursor.com/en-US/install-mcp?name=dodopayments-mcp\&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsImRvZG9wYXltZW50cy1tY3AiXSwiZW52Ijp7IkRPRE9fUEFZTUVOVFNfQVBJX0tFWSI6IlNldCB5b3VyIERPRE9fUEFZTUVOVFNfQVBJX0tFWSBoZXJlLiIsIkRPRE9fUEFZTUVOVFNfV0VCSE9PS19LRVkiOiJTZXQgeW91ciBET0RPX1BBWU1FTlRTX1dFQkhPT0tfS0VZIGhlcmUuIn19](https://cursor.com/en-US/install-mcp?name=dodopayments-mcp\&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsImRvZG9wYXltZW50cy1tY3AiXSwiZW52Ijp7IkRPRE9fUEFZTUVOVFNfQVBJX0tFWSI6IlNldCB5b3VyIERPRE9fUEFZTUVOVFNfQVBJX0tFWSBoZXJlLiIsIkRPRE9fUEFZTUVOVFNfV0VCSE9PS19LRVkiOiJTZXQgeW91ciBET0RPX1BBWU1FTlRTX1dFQkhPT0tfS0VZIGhlcmUuIn19))

    Dopo aver cliccato, imposta le tue variabili d'ambiente in `mcp.json` di Cursor attraverso **Cursor Settings** > **Tools & MCP** > **New MCP Server**.

    **Configurazione manuale**

    <Steps>
      <Step title="Open Cursor settings">
        Naviga a **Cursor Settings** > **Features** > **Model Context Protocol** oppure premi `Cmd/Ctrl + Shift + P` e cerca "MCP Settings".
      </Step>

      <Step title="Edit configuration">
        Clicca **Edit Config** per aprire il file `mcp_config.json`.
      </Step>

      <Step title="Add Dodo Payments configuration">
        Scegli una delle seguenti configurazioni:

        **Server remoto (Consigliato)**

        ```json theme={null}
        {
          "mcpServers": {
            "dodopayments": {
              "command": "npx",
              "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
            }
          }
        }
        ```

        **NPX locale**

        ```json theme={null}
        {
          "mcpServers": {
            "dodopayments": {
              "command": "npx",
              "args": ["-y", "dodopayments-mcp@latest"],
              "env": {
                "DODO_PAYMENTS_API_KEY": "dodo_test_...",
                "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
              }
            }
          }
        }
        ```
      </Step>

      <Step title="Save and restart">
        Salva il file di configurazione e riavvia Cursor.

        <Check>
          Verifica la connessione chiedendo all'assistente AI informazioni sui tuoi dati di Dodo Payments.
        </Check>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Claude Desktop">
    Imposta il server MCP di Dodo Payments in Claude Desktop per abilitare l'accesso conversazionale ai tuoi dati di pagamento.

    <Steps>
      <Step title="Locate configuration file">
        Trova il file di configurazione di Claude Desktop:

        * **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
        * **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
        * **Linux**: `~/.config/Claude/claude_desktop_config.json`
      </Step>

      <Step title="Edit configuration">
        Apri il file in un editor di testo e aggiungi la configurazione di Dodo Payments:

        **Server remoto (Consigliato)**

        ```json theme={null}
        {
          "mcpServers": {
            "dodopayments": {
              "command": "npx",
              "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
            }
          }
        }
        ```

        **NPX locale**

        ```json theme={null}
        {
          "mcpServers": {
            "dodopayments": {
              "command": "npx",
              "args": ["-y", "dodopayments-mcp@latest"],
              "env": {
                "DODO_PAYMENTS_API_KEY": "dodo_test_...",
                "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
              }
            }
          }
        }
        ```
      </Step>

      <Step title="Restart Claude Desktop">
        Chiudi e riapri Claude Desktop affinché le modifiche abbiano effetto.

        <Tip>
          Cerca l'icona 🔌 in Claude Desktop per confermare che il server MCP è connesso.
        </Tip>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Claude Code">
    Imposta il server MCP di Dodo Payments in Claude Code CLI.

    Esegui il seguente comando nel terminale:

    ```bash theme={null}
    claude mcp add --transport stdio dodopayments_api \
      --env DODO_PAYMENTS_API_KEY="dodo_test_..." \
      DODO_PAYMENTS_WEBHOOK_KEY="your_webhook_key" \
      -- npx -y dodopayments-mcp
    ```

    La configurazione sarà memorizzata nel file `.claude.json` nella tua directory home.

    <Tip>
      Claude Code rileva automaticamente le variabili di ambiente dalla tua shell, quindi puoi anche esportarle prima di eseguire il comando.
    </Tip>
  </Tab>

  <Tab title="VS Code">
    Imposta il server MCP di Dodo Payments in VS Code.

    **Installazione con un clic**

    [Apri VS Code](https://vscode.stainless.com/mcp/%7B%22name%22%3A%22dodopayments-mcp%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22dodopayments-mcp%22%5D%2C%22env%22%3A%7B%22DODO_PAYMENTS_API_KEY%22%3A%22Set%20your%20DODO_PAYMENTS_API_KEY%20here.%22%2C%22DODO_PAYMENTS_WEBHOOK_KEY%22%3A%22Set%20your%20DODO_PAYMENTS_WEBHOOK_KEY%20here.%22%7D%7D)

    Dopo aver cliccato, imposta le tue variabili d'ambiente in `mcp.json` di VS Code tramite **Command Palette** > **MCP: Open User Configuration**.

    **Configurazione manuale**

    <Steps>
      <Step title="Open MCP configuration">
        Apri il Command Palette (`Cmd/Ctrl + Shift + P`) e cerca "MCP: Open User Configuration".
      </Step>

      <Step title="Add server configuration">
        Aggiungi il server MCP di Dodo Payments:

        ```json theme={null}
        {
          "mcpServers": {
            "dodopayments": {
              "command": "npx",
              "args": ["-y", "dodopayments-mcp@latest"],
              "env": {
                "DODO_PAYMENTS_API_KEY": "dodo_test_...",
                "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
              }
            }
          }
        }
        ```
      </Step>

      <Step title="Reload window">
        Ricarica VS Code (`Cmd/Ctrl + Shift + P` > "Reload Window") per attivare il server MCP.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Cline (VS Code)">
    Imposta il server MCP di Dodo Payments in Cline (VS Code) per abilitare l'accesso conversazionale ai tuoi dati di pagamento.

    <Steps>
      <Step title="Open Cline settings">
        Trova il file di configurazione di Cline:

        * **macOS**: `~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`
        * **Windows**: `%APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json`
        * **Linux**: `~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`
      </Step>

      <Step title="Configure MCP server">
        Aggiungi la configurazione del server MCP di Dodo Payments:

        ```json theme={null}
        {
          "mcpServers": {
            "dodopayments": {
              "command": "npx",
              "args": ["-y", "dodopayments-mcp@latest"],
              "env": {
                "DODO_PAYMENTS_API_KEY": "dodo_test_...",
                "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
              }
            }
          }
        }
        ```
      </Step>

      <Step title="Reload VS Code">
        Ricarica la finestra di VS Code (`Cmd/Ctrl + Shift + P` > "Reload Window") per attivare la connessione al server MCP.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Zed">
    Imposta il server MCP di Dodo Payments in Zed per abilitare l'accesso conversazionale ai tuoi dati di pagamento.

    <Steps>
      <Step title="Open Zed settings">
        Naviga a **Settings** > **Assistant** > **Model Context Protocol**.
      </Step>

      <Step title="Add server configuration">
        Aggiungi la seguente configurazione:

        ```json theme={null}
        {
          "mcpServers": {
            "dodopayments": {
              "command": "npx",
              "args": ["-y", "dodopayments-mcp@latest"],
              "env": {
                "DODO_PAYMENTS_API_KEY": "dodo_test_...",
                "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
              }
            }
          }
        }
        ```
      </Step>

      <Step title="Save and verify">
        Salva la configurazione. Il server MCP dovrebbe ora essere disponibile nell'assistente AI di Zed.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Other Clients">
    Imposta il server MCP di Dodo Payments in altri client compatibili con MCP.

    **Server remoto (Consigliato)**

    ```json theme={null}
    {
      "mcpServers": {
        "dodopayments": {
          "command": "npx",
          "args": ["-y", "mcp-remote@latest", "https://mcp.dodopayments.com/sse"]
        }
      }
    }
    ```

    **NPX locale**

    ```json theme={null}
    {
      "mcpServers": {
        "dodopayments": {
          "command": "npx",
          "args": ["-y", "dodopayments-mcp@latest"],
          "env": {
            "DODO_PAYMENTS_API_KEY": "dodo_test_...",
            "DODO_PAYMENTS_WEBHOOK_KEY": "your_webhook_key"
          }
        }
      }
    }
    ```

    <Info>
      Visita [modelcontextprotocol.io/clients](https://modelcontextprotocol.io/clients) per un elenco completo di client compatibili con MCP e i loro metodi di configurazione.
    </Info>
  </Tab>
</Tabs>

## Variabili d'ambiente

Configura il comportamento del server MCP utilizzando variabili d'ambiente.

| Variabile                   | Descrizione                              | Richiesto |
| --------------------------- | ---------------------------------------- | --------- |
| `DODO_PAYMENTS_API_KEY`     | La tua chiave API Dodo Payments          | Sì        |
| `DODO_PAYMENTS_WEBHOOK_KEY` | La tua chiave di firma webhook           | No        |
| `DODO_PAYMENTS_ENVIRONMENT` | Imposta su `live_mode` per la produzione | No        |

## Esecuzione Remota

Distribuisci il server MCP come server HTTP remoto per client basati sul web o flussi di lavoro agentici.

```bash theme={null}
# Start as remote server
npx -y dodopayments-mcp --transport=http

# Specify a custom port
npx -y dodopayments-mcp --transport=http --port=3000
```

### Configurazione del Server Remoto

Una volta distribuito, i client possono connettersi utilizzando l'URL del server:

```json theme={null}
{
  "mcpServers": {
    "dodopayments_api": {
      "url": "http://localhost:3000",
      "headers": {
        "Authorization": "Bearer your_api_key"
      }
    }
  }
}
```

### Headers di Autorizzazione

Il server remoto accetta l'autenticazione tramite i seguenti headers:

| Header                    | Descrizione                 |
| ------------------------- | --------------------------- |
| `Authorization`           | Autenticazione token Bearer |
| `x-dodo-payments-api-key` | Header diretto chiave API   |

## Migliori pratiche di Sicurezza

Code Mode fornisce sicurezza intrinseca eseguendo il codice in un ambiente isolato e iniettando le chiavi API lato server. Segui queste pratiche migliori per proteggere le tue credenziali.

<AccordionGroup>
  <Accordion title="API Key Management">
    **Non committare mai credenziali al controllo versione**

    Memorizza le chiavi API in variabili d'ambiente o sistemi di gestione segreti sicuri.

    ```bash theme={null}
    # 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
    ```

    **Rota le chiavi regolarmente**

    Genera periodicamente nuove chiavi API e revoca le vecchie tramite la tua dashboard di Dodo Payments.

    **Usa chiavi di test per lo sviluppo**

    Usa sempre chiavi API modalità test durante lo sviluppo per evitare di alterare i dati di produzione.
  </Accordion>

  <Accordion title="Access Control">
    **Implementa autenticazione per i server remoti**

    Durante la distribuzione remota, richiedi sempre l'autenticazione tramite l'header `Authorization` o `x-dodo-payments-api-key`.

    **Monitora l'uso dell'API**

    Traccia l'attività del server MCP attraverso la tua dashboard di Dodo Payments e configura avvisi per modelli insoliti.
  </Accordion>

  <Accordion title="Network Security">
    **Usa HTTPS per i server remoti**

    Distribuisci sempre i server MCP remoti dietro endpoint HTTPS.

    **Implementa limiti di frequenza**

    Proteggi contro gli abusi implementando limiti di frequenza sia a livello del server MCP che API.

    **Restringi l'accesso alla rete**

    Configura regole firewall per limitare quali client possono connettersi al tuo server MCP.
  </Accordion>
</AccordionGroup>

## Risoluzione dei Problemi

<AccordionGroup>
  <Accordion title="Connection issues">
    **Verifica la tua chiave API**

    Assicurati che la tua chiave API sia correttamente impostata e abbia le permessi necessari.

    ```bash theme={null}
    # Test your API key
    curl -H "Authorization: Bearer dodo_test_..." \
      https://test.dodopayments.com/payments
    ```

    **Controlla la tua connessione di rete**

    Verifica che puoi raggiungere gli endpoint API di Dodo Payments.

    **Rivedi i log del client**

    Abilita la registrazione dettagliata nel tuo client MCP per diagnosticare problemi di connessione.
  </Accordion>

  <Accordion title="Authentication errors">
    **Conferma l'ambiente della chiave API**

    Assicurati di usare chiavi di test con endpoint di test e chiavi live con endpoint di produzione.

    **Controlla la variabile d'ambiente**

    Verifica che `DODO_PAYMENTS_ENVIRONMENT` sia impostato correttamente (`live_mode` per la produzione).

    **Rigenera le credenziali**

    Se i problemi persistono, genera una nuova chiave API tramite la tua dashboard.
  </Accordion>

  <Accordion title="Tool execution failures">
    **Valida i parametri di input**

    Assicurati che l'assistente AI fornisca parametri correttamente formattati per ciascun strumento.

    **Rivedi i messaggi di errore**

    Controlla la risposta di errore dell'API per una guida specifica su cosa è andato storto.

    **Prova direttamente con l'API**

    Verifica che l'operazione funzioni chiamando direttamente l'API di Dodo Payments via curl o Postman.
  </Accordion>
</AccordionGroup>

## Perché Code Mode

Le implementazioni tradizionali di MCP soffrono spesso di "proliferazione degli strumenti," dove ogni endpoint API è esposto come uno strumento separato. Code Mode è un approccio superiore per diversi motivi:

### Gli LLM sono migliori a scrivere codice che a chiamare strumenti

Gli LLM sono stati addestrati su milioni di righe di codice del mondo reale, rendendoli naturalmente abili a scrivere script. Al contrario, la chiamata agli strumenti è spesso basata su esempi sintetici.

<Info>
  "Far eseguire compiti a un LLM con la chiamata agli strumenti è come sottoporre Shakespeare a un corso intensivo di un mese in mandarino e poi chiedergli di scrivere un'opera in quella lingua." — [Cloudflare](https://blog.cloudflare.com/code-mode/)
</Info>

### Elimina il gonfiore della finestra contestuale

In un approccio tradizionale, ogni definizione di strumento consuma token prima ancora che la conversazione inizi. Esporre 50+ strumenti può facilmente consumare 55K–100K+ token. Anthropic ha scoperto che le definizioni di strumento potevano consumare fino a 134K token prima dell'ottimizzazione.

Con Code Mode, solo 2 definizioni di strumento vengono caricate (\~1K token). L'agente ricerca la documentazione necessaria su richiesta. Il Tool Search Tool di Anthropic ha conservato il 95% della finestra contestuale, riducendo l'overhead da 77K a 8.7K token.

### Riduce la latenza attraverso l'orchestrazione programmatica

La chiamata agli strumenti tradizionale richiede un round-trip di inferenza completa del modello per ogni singola operazione. Se un compito richiede 20 chiamate API, sono 20 round-trip. In Code Mode, l'agente scrive uno script che esegue tutte le chiamate e restituisce solo il risultato finale.

Anthropic ha osservato una riduzione del 37% dei token e un miglioramento della precisione (il recupero delle conoscenze è migliorato dal 25,6% al 28,5%) utilizzando questo approccio programmatico.

### Più sicuro per design

Code Mode fornisce vantaggi di sicurezza intrinseci:

* **Nessuna chiave API nei parametri**: Le chiavi API vengono iniettate lato server e non vengono mai esposte nei parametri degli strumenti inviati agli LLM.
* **Sandbox isolato**: Il codice viene eseguito in un ambiente sicuro senza accesso alla rete o al file system host.
* **SDK controllato**: Solo i metodi SDK autorizzati sono disponibili per l'agente.

### Scala a qualsiasi dimensione API

Man mano che un'API cresce, le prestazioni tradizionali del MCP degradano perché più strumenti devono essere caricati nel contesto. Code Mode rimane costante con 2 strumenti indipendentemente dall'area dell'API. Cloudflare ha ridotto con successo oltre 2.500 endpoint API in soli 2 strumenti e circa 1.000 token di contesto.

<Info>
  Per i dettagli sui benefici di questa architettura, vedi i blog ingegneristici di [Anthropic](https://www.anthropic.com/engineering/advanced-tool-use) e [Cloudflare](https://blog.cloudflare.com/code-mode/), e la documentazione di [Programmatic Tool Calling](https://platform.claude.com/docs/en/agents-and-tools/tool-use/programmatic-tool-calling) di Claude.
</Info>

## Risorse

<CardGroup cols={2}>
  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    Esplora la documentazione completa dell'API di Dodo Payments
  </Card>

  <Card title="MCP Protocol" icon="link" href="https://modelcontextprotocol.io">
    Scopri di più sullo standard del Model Context Protocol
  </Card>

  <Card title="GitHub Repository" icon="github" href="https://github.com/dodopayments/dodopayments-typescript/tree/main/packages/mcp-server">
    Visualizza il codice sorgente del server MCP e contribuisci
  </Card>

  <Card title="NPM Package" icon="npm" href="https://www.npmjs.com/package/dodopayments-mcp">
    Installa il server MCP da NPM
  </Card>
</CardGroup>