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

# Servidor MCP

> Permite que los asistentes de IA interactúen con la API de Dodo Payments mediante Code Mode: una arquitectura de alto rendimiento para operaciones de pago y gestión de suscripciones sin inconvenientes.

## Descripción general

El Protocolo de Contexto del Modelo (MCP) es un estándar abierto que permite a las aplicaciones de IA conectarse de forma segura a fuentes de datos externas y APIs. El Servidor MCP de Dodo Payments proporciona a asistentes de IA como Claude, Cursor y otros clientes compatibles con MCP acceso estructurado a tu infraestructura de pagos.

El servidor MCP de Dodo Payments utiliza la arquitectura **Code Mode**. En lugar de exponer cientos de herramientas individuales para cada endpoint de la API, Code Mode permite que los agentes de IA escriban y ejecuten código TypeScript contra el SDK de Dodo Payments en un entorno aislado tipo sandbox.

### Capacidades clave

* **Operaciones de Pago**: Crear, recuperar y gestionar pagos y reembolsos
* **Gestión de Suscripciones**: Manejar facturación recurrente, actualizaciones y cancelaciones
* **Administración de Clientes**: Gestionar datos de clientes y acceso al portal
* **Catálogo de Productos**: Crear y actualizar productos, precios y descuentos
* **Gestión de Licencias**: Activar, validar y gestionar licencias de software
* **Facturación Basada en Uso**: Rastrear y facturar por uso medido

## Cómo Funciona el Modo de Código

El servidor MCP de Dodo Payments ofrece a tu agente de IA exactamente dos herramientas:

1. **Docs Search Tool**: Consulta la documentación sobre la API y el SDK de Dodo Payments para comprender las operaciones y parámetros disponibles.
2. **Code Execution Tool**: Escribe código TypeScript contra el SDK que se ejecuta en un entorno sandbox seguro.

Esta arquitectura permite a los agentes realizar operaciones complejas de múltiples pasos en una sola invocación. Por ejemplo, un agente puede listar todas las suscripciones activas, filtrarlas según criterios específicos y aplicar un descuento a cada una, todo dentro de un único script.

<Tip>
  Mediante Code Mode, los agentes pueden encadenar múltiples llamadas a la API, manejar lógica condicional y realizar cálculos sin requerir múltiples viajes de ida y vuelta al LLM.
</Tip>

### Configuración rápida

Conéctate al servidor MCP de Dodo Payments desde tu cliente de IA:

<Tabs>
  <Tab title="Agent Plugin (recommended)">
    El [Plugin Dodo Agent](/developer-resources/build-with-ai-coding-agents) instala tanto los servidores MCP como las ocho habilidades en un solo paso para Claude Code, Codex CLI, Cursor y OpenCode. Consulta la [guía de Agentes de Codificación AI](/developer-resources/build-with-ai-coding-agents) para comandos de instalación por agente.

    Si tu agente no está en esa lista, utiliza las pestañas a continuación para configurar el servidor MCP directamente.
  </Tab>

  <Tab title="Cursor">
    Añadir 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">
    Añadir a tu configuración de Claude Desktop:

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

    Ubicaciones de archivos de configuración:

    * **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">
    Añadir 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">
    Ejecutar en tu terminal:

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

<Note>
  Requiere Node.js 18 o superior. El servidor remoto utiliza OAuth para la autenticación: se te pedirá que ingreses tu clave API y selecciones tu entorno en la primera conexión.
</Note>

## Dodo Knowledge MCP

Además del Servidor MCP Dodo Payments (para ejecutar operaciones de API), proporcionamos **Dodo Knowledge MCP**—un servidor de búsqueda semántica que da a los asistentes de IA acceso instantáneo a la documentación base de conocimiento de Dodo Payments.

<Info>
  **Construido con [ContextMCP.ai](https://contextmcp.ai)**: Dodo Knowledge MCP está impulsado por ContextMCP, lo que permite una búsqueda semántica rápida en nuestra documentación utilizando incrustaciones vectoriales.
</Info>

### ¿Qué es Dodo Knowledge MCP?

Dodo Knowledge MCP es un servidor MCP remoto que proporciona:

* **Búsqueda de Documentación Semántica**: Encuentra documentación relevante usando consultas en lenguaje natural.
* **Respuestas Contextuales**: Los asistentes de IA obtienen información precisa y actualizada sobre Dodo Payments.
* **Sin Configuración**: No se requieren claves de API o instalación local—simplemente conéctate y comienza a consultar.

### Configuración Rápida

Conecta con Dodo Knowledge MCP en tu cliente de IA:

<Tabs>
  <Tab title="Cursor">
    Añadir 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">
    Añadir a tu configuración de Claude Desktop:

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

    Ubicaciones de archivos de configuración:

    * **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">
    Añadir 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">
    Ejecutar en tu terminal:

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

<Note>
  Requiere Node.js 18 o superior. El paquete `mcp-remote` maneja la conexión con el servidor MCP remoto.
</Note>

### Usando Ambos Servidores MCP Juntos

Para la mejor experiencia de desarrollo asistido por IA, recomendamos usar ambos servidores MCP:

| Servidor               | Propósito                 | Caso de Uso                                                            |
| ---------------------- | ------------------------- | ---------------------------------------------------------------------- |
| **Dodo Knowledge MCP** | Búsqueda de documentación | "¿Cómo manejo los webhooks?", "¿Qué métodos de pago están soportados?" |
| **Dodo Payments MCP**  | Operaciones de API        | Crear pagos, gestionar suscripciones, manejar reembolsos               |

```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 ambos servidores configurados, tu asistente de IA puede primero buscar en la documentación para entender cómo implementar una función, luego ejecutar las llamadas API reales, todo en una sola conversación.
</Tip>

### Solución de Problemas de Knowledge MCP

Si encuentras problemas de conexión:

1. **Borrar caché de autenticación MCP**: `rm -rf ~/.mcp-auth`
2. **Reiniciar tu aplicación cliente**
3. **Verificar los registros del cliente** para mensajes de error
4. **Verificar la versión de Node.js**: Requiere Node.js 18+

<Card title="Knowledge MCP Server" icon="book-open" href="https://knowledge.dodopayments.com">
  Accede a la página de configuración de Dodo Knowledge MCP
</Card>

## Instalación

Elige el método de instalación que mejor se adapte a tu flujo de trabajo.

### Servidor MCP Remoto (Recomendado)

Accede al servidor MCP alojado sin ninguna configuración o instalación local. Esta es la forma más rápida de comenzar.

<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">
    Navega a [https://mcp.dodopayments.com](https://mcp.dodopayments.com) en tu navegador.
  </Step>

  <Step title="Configure your MCP client">
    Copia la configuración JSON proporcionada para tu cliente específico. Para Cursor o Claude Desktop, añade esto a tus ajustes 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">
    El flujo OAuth te pedirá:

    * Ingresar tu clave API de Dodo Payments
    * Seleccionar tu entorno (prueba o en vivo)
    * Elegir tu tipo de cliente MCP

    <Warning>
      Mantén tu clave API segura. Usa claves de modo de prueba durante el desarrollo.
    </Warning>
  </Step>

  <Step title="Complete setup">
    Haz clic en **Iniciar sesión y Aprobar** para autorizar la conexión.

    <Check>
      Una vez conectado, tu asistente de IA podrá interactuar con la API de Dodo Payments en tu nombre.
    </Check>
  </Step>
</Steps>

### Paquete NPM

Instala y ejecuta el servidor 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` para siempre obtener la versión más reciente, o fíjate en una versión específica como `@1.0.0` para estabilidad.
</Tip>

### Docker

Ejecuta el servidor MCP en un entorno containerizado para un despliegue consistente.

<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>
  Las imágenes de Docker están disponibles en [GitHub Container Registry](https://github.com/orgs/dodopayments/packages/container/package/mcp).
</Note>

## Configuración del Cliente

Configura el servidor MCP Dodo Payments en tu cliente de IA preferido.

<Tabs>
  <Tab title="Cursor">
    Configura el servidor MCP Dodo Payments en Cursor para habilitar el acceso conversacional a tus datos de pagos.

    **Instalación con Un Clic**

    Usa el botón a continuación para instalar el servidor MCP directamente en Cursor:

    \[

    ![Añadir 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))

    Después de hacer clic, establece tus variables de entorno en `mcp.json` de Cursor a través de **Configuración de Cursor** > **Tools & MCP** > **Nuevo Servidor MCP**.

    **Configuración Manual**

    <Steps>
      <Step title="Open Cursor settings">
        Navega a **Configuración de Cursor** > **Características** > **Protocolo de Modelo de Contexto** o presiona `Cmd/Ctrl + Shift + P` y busca "Configuración MCP".
      </Step>

      <Step title="Edit configuration">
        Haz clic en **Editar Configuración** para abrir el archivo `mcp_config.json`.
      </Step>

      <Step title="Add Dodo Payments configuration">
        Elige una de las siguientes configuraciones:

        **Servidor Remoto (Recomendado)**

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

        **Local NPX**

        ```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">
        Guarda el archivo de configuración y reinicia Cursor.

        <Check>
          Verifica la conexión preguntando al asistente de IA sobre tus datos de Dodo Payments.
        </Check>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Claude Desktop">
    Configura el servidor MCP de Dodo Payments en Claude Desktop para habilitar el acceso conversacional a tus datos de pagos.

    <Steps>
      <Step title="Locate configuration file">
        Encuentra el archivo de configuración de 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">
        Abre el archivo en un editor de texto y añade la configuración de Dodo Payments:

        **Servidor Remoto (Recomendado)**

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

        **Local NPX**

        ```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">
        Cierra y vuelve a abrir Claude Desktop para que los cambios surtan efecto.

        <Tip>
          Busca el ícono 🔌 en Claude Desktop para confirmar que el servidor MCP está conectado.
        </Tip>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Claude Code">
    Configura el servidor MCP Dodo Payments en Claude Code CLI.

    Ejecuta el siguiente comando en tu terminal:

    ```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 configuración se almacenará en el archivo `.claude.json` de tu directorio de inicio.

    <Tip>
      Claude Code automáticamente detecta variables de entorno desde tu shell, por lo que también puedes exportarlas antes de ejecutar el comando.
    </Tip>
  </Tab>

  <Tab title="VS Code">
    Configura el servidor MCP Dodo Payments en VS Code.

    **Instalación con Un Clic**

    [Abrir 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)

    Después de hacer clic, establece tus variables de entorno en `mcp.json` de VS Code a través de **Paleta de Comandos** > **MCP: Abrir Configuración de Usuario**.

    **Configuración Manual**

    <Steps>
      <Step title="Open MCP configuration">
        Abre la Paleta de Comandos (`Cmd/Ctrl + Shift + P`) y busca "MCP: Abrir Configuración de Usuario".
      </Step>

      <Step title="Add server configuration">
        Añadir el servidor MCP 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">
        Recarga VS Code (`Cmd/Ctrl + Shift + P` > "Recargar Ventana") para activar el servidor MCP.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Cline (VS Code)">
    Configura el servidor MCP Dodo Payments en Cline (VS Code) para habilitar el acceso conversacional a tus datos de pagos.

    <Steps>
      <Step title="Open Cline settings">
        Localiza el archivo de configuración de 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">
        Añadir la configuración del servidor MCP de 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">
        Recarga la ventana de VS Code (`Cmd/Ctrl + Shift + P` > "Recargar Ventana") para activar la conexión del servidor MCP.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Zed">
    Configura el servidor MCP Dodo Payments en Zed para habilitar el acceso conversacional a tus datos de pagos.

    <Steps>
      <Step title="Open Zed settings">
        Navega a **Ajustes** > **Asistente** > **Protocolo de Modelo de Contexto**.
      </Step>

      <Step title="Add server configuration">
        Añadir la siguiente configuración:

        ```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">
        Guarda la configuración. El servidor MCP ahora debería estar disponible en el asistente de IA de Zed.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Other Clients">
    Configura el servidor MCP Dodo Payments en otros clientes compatibles con MCP.

    **Servidor Remoto (Recomendado)**

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

    **Local NPX**

    ```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) para ver una lista completa de clientes compatibles con MCP y sus métodos de configuración.
    </Info>
  </Tab>
</Tabs>

## Variables de Entorno

Configura el comportamiento del servidor MCP utilizando variables de entorno.

| Variable                    | Descripción                               | Obligatoria |
| --------------------------- | ----------------------------------------- | ----------- |
| `DODO_PAYMENTS_API_KEY`     | Tu clave API de Dodo Payments             | Sí          |
| `DODO_PAYMENTS_WEBHOOK_KEY` | Tu clave de firma de webhook              | No          |
| `DODO_PAYMENTS_ENVIRONMENT` | Configurar en `live_mode` para producción | No          |

## Ejecución Remota

Despliega el servidor MCP como un servidor HTTP remoto para clientes basados en web o flujos de trabajo agente.

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

### Configuración del Servidor Remoto

Una vez desplegado, los clientes pueden conectarse usando la URL del servidor:

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

### Encabezados de Autorización

El servidor remoto acepta autenticación a través de los siguientes encabezados:

| Encabezado                | Descripción                     |
| ------------------------- | ------------------------------- |
| `Authorization`           | Autenticación de token Bearer   |
| `x-dodo-payments-api-key` | Encabezado de clave API directa |

## Mejores Prácticas de Seguridad

El Modo de Código proporciona seguridad inherente al ejecutar código en un entorno aislado e inyectar claves API del lado del servidor. Sigue estas mejores prácticas adicionales para proteger tus credenciales.

<AccordionGroup>
  <Accordion title="API Key Management">
    **Nunca comprometas credenciales en control de versiones**

    Almacena las claves API en variables de entorno o sistemas seguros de gestión de secretos.

    ```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 las claves regularmente**

    Genera nuevas claves API periódicamente y revoca las antiguas desde tu panel de Dodo Payments.

    **Usa claves de prueba para desarrollo**

    Siempre utiliza claves de modo de prueba durante el desarrollo para evitar afectar los datos de producción.
  </Accordion>

  <Accordion title="Access Control">
    **Implementa autenticación para servidores remotos**

    Cuando despliegues remotamente, siempre requiere autenticación a través del encabezado `Authorization` o `x-dodo-payments-api-key`.

    **Monitoriza el uso de la API**

    Rastrea la actividad del servidor MCP a través de tu panel de Dodo Payments y configura alertas para patrones inusuales.
  </Accordion>

  <Accordion title="Network Security">
    **Usa HTTPS para servidores remotos**

    Siempre despliega servidores MCP remotos detrás de puntos finales HTTPS.

    **Implementa limitación de tasa**

    Protege contra abusos implementando límites de tasa tanto a nivel del servidor MCP como de API.

    **Restringe el acceso a la red**

    Configura reglas de firewall para limitar qué clientes pueden conectarse a tu servidor MCP.
  </Accordion>
</AccordionGroup>

## Solución de Problemas

<AccordionGroup>
  <Accordion title="Connection issues">
    **Verifica tu clave API**

    Asegúrate de que tu clave API esté configurada correctamente y tenga los permisos necesarios.

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

    **Verifica tu conexión de red**

    Verifica que puedas alcanzar los puntos finales de la API de Dodo Payments.

    **Revisa los registros del cliente**

    Habilita el registro detallado en tu cliente MCP para diagnosticar problemas de conexión.
  </Accordion>

  <Accordion title="Authentication errors">
    **Confirma el entorno de tu clave API**

    Asegúrate de estar usando claves de prueba con puntos finales de prueba y claves en vivo con puntos finales de producción.

    **Verifica la variable de entorno**

    Verifica que `DODO_PAYMENTS_ENVIRONMENT` esté configurado correctamente (`live_mode` para producción).

    **Regenera credenciales**

    Si los problemas persisten, genera una nueva clave API desde tu panel.
  </Accordion>

  <Accordion title="Tool execution failures">
    **Valida los parámetros de entrada**

    Asegúrate de que el asistente de IA esté proporcionando parámetros correctamente formateados para cada herramienta.

    **Revisa los mensajes de error**

    Consulta la respuesta de error de la API para obtener orientación específica sobre qué salió mal.

    **Prueba directamente con la API**

    Verifica que la operación funcione al llamar directamente a la API de Dodo Payments mediante curl o Postman.
  </Accordion>
</AccordionGroup>

## Por Qué el Modo de Código

Las implementaciones tradicionales de MCP a menudo sufren de "proliferación de herramientas", donde cada punto final de API se expone como una herramienta separada. El Modo de Código es un enfoque superior por varias razones:

### Los LLMs son mejores escribiendo código que llamando herramientas

Los LLMs han sido entrenados con millones de líneas de código del mundo real, lo que los hace naturalmente competentes para escribir scripts. En contraste, la llamada a herramientas a menudo se basa en ejemplos sintéticos.

<Info>
  "Hacer que un LLM realice tareas con llamadas a herramientas es como poner a Shakespeare en un curso intensivo de mandarín y luego pedirle que escriba una obra en ese idioma." — [Cloudflare](https://blog.cloudflare.com/code-mode/)
</Info>

### Elimina la sobrecarga de la ventana de contexto

En un enfoque tradicional, cada definición de herramienta consume tokens antes de que la conversación siquiera comience. Exponer más de 50 herramientas puede fácilmente consumir de 55K a 100K+ tokens. Anthropic encontró que las definiciones de herramientas podrían consumir hasta 134K tokens antes de la optimización.

Con el Modo de Código, solo se cargan 2 definiciones de herramientas (\~1K tokens). El agente busca la documentación que necesita bajo demanda. La Herramienta de Búsqueda de Herramientas de Anthropic preservó el 95% de la ventana de contexto, reduciendo la sobrecarga de 77K a 8.7K tokens.

### Reduce la latencia mediante orquestación programática

La llamada a herramientas tradicional requiere un viaje completo de inferencia de modelo para cada operación. Si una tarea requiere 20 llamadas a API, son 20 viajes de ida y vuelta. En el Modo de Código, el agente escribe un solo script que ejecuta todas las llamadas y devuelve solo el resultado final.

Anthropic observó una reducción del 37% en tokens y una precisión mejorada (la recuperación de conocimientos mejoró de 25.6% a 28.5%) usando este enfoque programático.

### Más seguro por diseño

El Modo de Código proporciona beneficios de seguridad inherentes:

* **Sin claves API en los parámetros**: Las claves API se inyectan del lado del servidor y nunca se exponen en los parámetros de herramientas enviados al LLM.
* **Entorno aislado**: El código se ejecuta en un entorno seguro sin acceso a la red o al sistema de archivos del host.
* **SDK controlado**: Solo los métodos SDK autorizados están disponibles para el agente.

### Escalable a cualquier tamaño de API

A medida que una API crece, el rendimiento tradicional de MCP se degrada porque más herramientas deben cargarse en el contexto. El Modo de Código se mantiene constante con 2 herramientas independientemente del área de superficie de la API. Cloudflare colapsó con éxito más de 2,500 puntos finales de API en solo 2 herramientas y aproximadamente 1,000 tokens de contexto.

<Info>
  Para obtener más detalles sobre los beneficios de esta arquitectura, consulta los blogs de ingeniería de [Anthropic](https://www.anthropic.com/engineering/advanced-tool-use) y [Cloudflare](https://blog.cloudflare.com/code-mode/), y la documentación de [Llamada a Herramientas Programática](https://platform.claude.com/docs/en/agents-and-tools/tool-use/programmatic-tool-calling) de Claude.
</Info>

## Recursos

<CardGroup cols={2}>
  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    Explora la documentación completa de la API de Dodo Payments
  </Card>

  <Card title="MCP Protocol" icon="link" href="https://modelcontextprotocol.io">
    Aprende más sobre el estándar del Protocolo de Modelo de Contexto
  </Card>

  <Card title="GitHub Repository" icon="github" href="https://github.com/dodopayments/dodopayments-typescript/tree/main/packages/mcp-server">
    Mira el código fuente del servidor MCP y contribuye
  </Card>

  <Card title="NPM Package" icon="npm" href="https://www.npmjs.com/package/dodopayments-mcp">
    Instala el servidor MCP desde NPM
  </Card>
</CardGroup>