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

> कोड मोड के माध्यम से Dodo Payments API के साथ इंटरैक्ट करने के लिए AI सहायक सक्षम करें—एक उच्च प्रदर्शन वास्तुकला जो सहज भुगतान संचालन और सब्सक्रिप्शन प्रबंधन प्रदान करती है।

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

Dodo Payments MCP सर्वर **कोड मोड** वास्तुकला का उपयोग करता है। प्रत्येक API एंडपॉइंट के लिए सैकड़ों व्यक्तिगत टूल्स को उजागर करने के बजाय, कोड मोड AI एजेंट्स को अलग संडबॉक्स वातावरण में Dodo Payments SDK के खिलाफ TypeScript कोड लिखने और निष्पादित करने में सक्षम बनाता है।

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

Dodo Payments MCP सर्वर आपके AI एजेंट को केवल दो टूल्स प्रदान करता है:

1. **डॉक्स सर्च टूल**: Dodo Payments API और SDK के बारे में डॉक्स को क्वेरी करता है ताकि उपलब्ध ऑपरेशंस और पैरामीटर समझे जा सकें।
2. **कोड निष्पादन टूल**: SDK के खिलाफ TypeScript कोड लिखता है जो सुरक्षित संडबॉक्स परिवेश में निष्पादित होता है।

यह वास्तुकला एजेंट्स को एकल इनवोकेशन में जटिल, बहु-चरण ऑपरेशंस करने की अनुमति देती है। उदाहरण के लिए, एक एजेंट सभी सक्रिय सब्सक्रिप्शन सूचीबद्ध कर सकता है, उन्हें विशिष्ट मानदंडों के आधार पर फ़िल्टर कर सकता है, और प्रत्येक पर छूट लागू कर सकता है—सब एक ही स्क्रिप्ट में।

<Tip>
  कोड मोड का उपयोग करके, एजेंट कई API कॉल्स को चेन कर सकते हैं, सशर्त तर्क संभाल सकते हैं, और गणनाएँ कर सकते हैं बिना LLM के साथ कई राउंड-ट्रिप्स की आवश्यकता के।
</Tip>

### त्वरित सेटअप

अपने AI क्लाइंट में Dodo Payments MCP सर्वर से कनेक्ट करें:

<Tabs>
  <Tab title="Agent Plugin (recommended)">
    [Dodo Agent Plugin](/developer-resources/build-with-ai-coding-agents) Claude Code, Codex CLI, Cursor, और OpenCode के लिए एक कदम में MCP सर्वर और सभी आठ स्किल्स इंस्टॉल करता है। [AI Coding Agents guide](/developer-resources/build-with-ai-coding-agents) में प्रति-एजेंट इंस्टॉल कमांड देखें।

    यदि आपका एजेंट उस सूची में नहीं है, तो नीचे दिए गए टैब का उपयोग करके MCP सर्वर को सीधे कॉन्फ़िगर करें।
  </Tab>

  <Tab title="Cursor">
    Add to `~/.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">
    अपने Claude Desktop कॉन्फ़िगरेशन में जोड़ें:

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

    कॉन्फ़िगरेशन फ़ाइल स्थान:

    * **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">
    Add to `~/.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">
    अपने टर्मिनल में चलाएं:

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

<Note>
  Node.js 18 या उच्चतर की आवश्यकता है। रिमोट सर्वर OAuth का उपयोग करके प्रमाणीकरण करता है — पहली बार कनेक्शन पर आपको अपनी API कुंजी दर्ज करने और अपने वातावरण का चयन करने के लिए कहा जाएगा।
</Note>

## Dodo Knowledge MCP

Dodo Payments MCP Server (API संचालन निष्पादित करने के लिए) के अतिरिक्त, हम **Dodo Knowledge MCP**—एक समानार्थी खोज सर्वर प्रदान करते हैं जो AI सहायकों को Dodo Payments प्रलेखन और ज्ञान आधार तक तत्काल पहुँच प्रदान करता है।

<Info>
  [ContextMCP.ai](https://contextmcp.ai) के साथ निर्मित\*\*: Dodo Knowledge MCP ContextMCP द्वारा संचालित है, जो हमारे दस्तावेज़ीकरण में तेज़ समानार्थी खोज को सक्षम करता है।
</Info>

### Dodo Knowledge MCP क्या है?

Dodo Knowledge MCP एक रिमोट MCP सर्वर है जो प्रदान करता है:

* **समानार्थी दस्तावेज़ खोज**: प्राकृतिक भाषा क्वेरी का उपयोग करके प्रासंगिक दस्तावेज़ीकरण खोजें।
* **प्रासंगिक उत्तर**: AI सहायकों को Dodo Payments के बारे में सटीक, अद्यतन जानकारी मिलती है।
* **शून्य सेटअप**: कोई API कुंजियाँ या स्थानीय स्थापना आवश्यक नहीं—बस कनेक्ट करें और पूछताछ शुरू करें।

### त्वरित सेटअप

अपने AI क्लाइंट में Dodo Knowledge MCP से कनेक्ट करें:

<Tabs>
  <Tab title="Cursor">
    Add to `~/.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">
    अपने Claude Desktop कॉन्फ़िगरेशन में जोड़ें:

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

    कॉन्फ़िगरेशन फ़ाइल स्थान:

    * **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">
    Add to `~/.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">
    अपने टर्मिनल में चलाएं:

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

<Note>
  Node.js 18 या उच्चतर की आवश्यकता है। `mcp-remote` पैकेज रिमोट MCP सर्वर से कनेक्शन को संभालता है।
</Note>

### दोनों MCP सर्वरों का एक साथ उपयोग करना

सर्वोत्तम AI-सहायता प्राप्त विकास अनुभव के लिए, हम दोनों MCP सर्वरों का उपयोग करने की अनुशंसा करते हैं:

| सर्वर                  | उद्देश्य      | उपयोग का मामला                                                      |
| ---------------------- | ------------- | ------------------------------------------------------------------- |
| **Dodo Knowledge MCP** | दस्तावेज़ खोज | "मैं वेबहुक्स को कैसे संभालूँ?", "कौन से भुगतान तरीके समर्थित हैं?" |
| **Dodo Payments MCP**  | API संचालन    | भुगतान बनाएं, सदस्यताओं का प्रबंधन करें, रिफंड को संभालें           |

```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>
  दोनों सर्वरों को कॉन्फ़िगर करने के बाद, आपका AI सहायक पहले फीचर को लागू करने की प्रक्रिया को समझने के लिए दस्तावेज़ खोज सकता है, फिर वास्तविक API कॉल्स को निष्पादित कर सकता है - यह सब एक ही वार्तालाप में।
</Tip>

### Knowledge MCP में समस्या निवारण

यदि आपको कनेक्शन समस्याएँ आती हैं:

1. **MCP प्रमाणिकरण कैश साफ करें**: `rm -rf ~/.mcp-auth`
2. **अपना क्लाइंट एप्लिकेशन पुनरारंभ करें**
3. **क्लाइंट लॉग्स की जाँच करें** त्रुटि संदेशों के लिए
4. **Node.js संस्करण सत्यापित करें**: Node.js 18+ की आवश्यकता है

<Card title="Knowledge MCP Server" icon="book-open" href="https://knowledge.dodopayments.com">
  Dodo Knowledge MCP कॉन्फ़िगरेशन पेज तक पहुँचें
</Card>

## इंस्टॉलेशन

उस स्थापना विधि का चयन करें जो आपकी कार्यप्रणाली के लिए सबसे उपयुक्त है।

### रिमोट MCP सर्वर (अनुशंसित)

बिना किसी स्थानीय सेटअप या स्थापना के होस्टेड MCP सर्वर तक पहुँचें। यह शुरू करने का सबसे तेज़ तरीका है।

<Frame>
  <iframe className="w-full aspect-video rounded-md" src="https://www.youtube.com/embed/TxGgYxNmkT4" title="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">
    अपने ब्राउज़र में [https://mcp.dodopayments.com](https://mcp.dodopayments.com) पर नेविगेट करें।
  </Step>

  <Step title="Configure your MCP client">
    अपने विशिष्ट क्लाइंट के लिए प्रदत्त JSON कॉन्फ़िगरेशन कॉपी करें। Cursor या Claude Desktop के लिए, इसे अपने 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">
    OAuth फ़्लो आपको प्रॉम्प्ट करेगा:

    * अपनी Dodo Payments API कुंजी दर्ज करें
    * अपना वातावरण चुनें (परीक्षण या लाइव)
    * अपना MCP क्लाइंट प्रकार चुनें

    <Warning>
      अपनी API कुंजी को सुरक्षित रखें। विकास के दौरान परीक्षण मोड कुंजियों का उपयोग करें।
    </Warning>
  </Step>

  <Step title="Complete setup">
    कनेक्शन को अधिकृत करने के लिए **लॉगिन और स्वीकृत करें** पर क्लिक करें।

    <Check>
      कनेक्ट होने के बाद, आपका AI सहायक आपके लिए Dodo Payments API के साथ इंटरैक्ट कर सकता है।
    </Check>
  </Step>
</Steps>

### NPM पैकेज

MCP सर्वर को स्थानीय रूप से 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>
  `@latest` का उपयोग करें ताकि हमेशा नवीनतम संस्करण प्राप्त कर सकें, या स्थिरता के लिए `@1.0.0` को किसी विशिष्ट संस्करण पर स्थिर करें।
</Tip>

### Docker

संगत तैनाती के लिए कंटेनरीकृत वातावरण में MCP सर्वर चलाएँ।

<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>
  Docker छवियाँ [GitHub Container Registry](https://github.com/orgs/dodopayments/packages/container/package/mcp) पर उपलब्ध हैं।
</Note>

## क्लाइंट कॉन्फ़िगरेशन

अपने पसंदीदा AI क्लाइंट में Dodo Payments MCP सर्वर को कॉन्फ़िगर करें।

<Tabs>
  <Tab title="Cursor">
    Dodo Payments MCP सर्वर को Cursor में सेट करें ताकि आपके भुगतानों के डेटा तक संवादात्मक पहुँच मिल सके।

    **एक-क्लिक इंस्टॉल**

    Cursor में सीधे MCP सर्वर को इंस्टॉल करने के लिए नीचे दिए गए बटन का उपयोग करें:

    \[

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

    क्लिक करने के बाद, Cursor के `mcp.json` में अपने पर्यावरण चर सेट करें **Cursor Settings** > **Tools & MCP** > **New MCP Server** के माध्यम से।

    **मैनुअल कॉन्फ़िगरेशन**

    <Steps>
      <Step title="Open Cursor settings">
        **Cursor Settings** > **Features** > **Model Context Protocol** पर नेविगेट करें या `Cmd/Ctrl + Shift + P` दबाएँ और "MCP Settings" खोजें।
      </Step>

      <Step title="Edit configuration">
        `mcp_config.json` फ़ाइल खोलने के लिए **Edit Config** पर क्लिक करें।
      </Step>

      <Step title="Add Dodo Payments configuration">
        निम्नलिखित कॉन्फ़िगरेशन में से एक चुनें:

        **रिमोट सर्वर (अनुशंसित)**

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

        **स्थानीय 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">
        कॉन्फ़िगरेशन फ़ाइल सहेजें और Cursor पुनरारंभ करें।

        <Check>
          अपने Dodo Payments डेटा के बारे में AI सहायक से पूछकर कनेक्शन सत्यापित करें।
        </Check>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Claude Desktop">
    Claude Desktop में Dodo Payments MCP सर्वर सेट करें ताकि आपके भुगतानों के डेटा तक संवादात्मक पहुँच मिल सके।

    <Steps>
      <Step title="Locate configuration file">
        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">
        टेक्स्ट एडिटर में फ़ाइल खोलें और Dodo Payments कॉन्फ़िगरेशन जोड़ें:

        **रिमोट सर्वर (अनुशंसित)**

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

        **स्थानीय 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">
        Claude Desktop को बंद करें और फिर से खोलें ताकि परिवर्तन प्रभावी हो सकें।

        <Tip>
          MCP सर्वर कनेक्ट है यह सुनिश्चित करने के लिए Claude Desktop में 🔌 आइकन की जाँच करें।
        </Tip>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Claude Code">
    Claude Code CLI में Dodo Payments MCP सर्वर सेट करें।

    अपने टर्मिनल में निम्नलिखित कमांड चलाएँ:

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

    कॉन्फ़िगरेशन आपके होम डायरेक्टरी के `.claude.json` फ़ाइल में संग्रहीत होगा।

    <Tip>
      Claude Code स्वचालित रूप से आपके शेल से पर्यावरण चर उठाता है, इसलिए आप कमांड चलाने से पहले उन्हें निर्यात भी कर सकते हैं।
    </Tip>
  </Tab>

  <Tab title="VS Code">
    VS Code में Dodo Payments MCP सर्वर सेट करें।

    **एक-क्लिक इंस्टॉल**

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

    क्लिक करने के बाद, VS Code के `mcp.json` में अपने पर्यावरण चर सेट करें **Command Palette** > **MCP: Open User Configuration** के माध्यम से।

    **मैनुअल कॉन्फ़िगरेशन**

    <Steps>
      <Step title="Open MCP configuration">
        Command Palette (`Cmd/Ctrl + Shift + P`) खोलें और "MCP: Open User Configuration" खोजें।
      </Step>

      <Step title="Add server configuration">
        Dodo Payments MCP सर्वर जोड़ें:

        ```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">
        MCP सर्वर को सक्रिय करने के लिए VS Code को पुनः लोड करें (`Cmd/Ctrl + Shift + P` > "Reload Window")।
      </Step>
    </Steps>
  </Tab>

  <Tab title="Cline (VS Code)">
    Cline (VS Code) में Dodo Payments MCP सर्वर सेट करें ताकि आपके भुगतानों के डेटा तक संवादात्मक पहुँच मिल सके।

    <Steps>
      <Step title="Open Cline settings">
        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">
        परिकल्पना जोड़ें:

        ```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">
        VS Code विंडो को पुनरारंभ करें (`Cmd/Ctrl + Shift + P` > "Reload Window") ताकि MCP सर्वर कनेक्शन सक्रिय हो सके।
      </Step>
    </Steps>
  </Tab>

  <Tab title="Zed">
    Zed में Dodo Payments MCP सर्वर सेट करें ताकि आपके भुगतानों के डेटा तक संवादात्मक पहुँच मिल सके।

    <Steps>
      <Step title="Open Zed settings">
        **Settings** > **Assistant** > **Model Context Protocol** पर नेविगेट करें।
      </Step>

      <Step title="Add server configuration">
        निम्नलिखित कॉन्फ़िगरेशन जोड़ें:

        ```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">
        कॉन्फ़िगरेशन सहेजें। MCP सर्वर अब Zed के AI सहायक में उपलब्ध होना चाहिए।
      </Step>
    </Steps>
  </Tab>

  <Tab title="Other Clients">
    अन्य MCP-संगत क्लाइंट्स में Dodo Payments MCP सर्वर सेट करें।

    **रिमोट सर्वर (अनुशंसित)**

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

    **स्थानीय 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>
      [modelcontextprotocol.io/clients](https://modelcontextprotocol.io/clients) पर MCP-संगत क्लाइंट्स और उनके कॉन्फ़िगरेशन विधियों की पूरी सूची के लिए विजिट करें।
    </Info>
  </Tab>
</Tabs>

## पर्यावरण वेरिएबल्स

पर्यावरण वेरिएबल्स का उपयोग करके MCP सर्वर व्यवहार को कॉन्फ़िगर करें।

| वेरिएबल                     | वर्णन                                  | आवश्यक |
| --------------------------- | -------------------------------------- | ------ |
| `DODO_PAYMENTS_API_KEY`     | आपकी Dodo Payments API कुंजी           | हाँ    |
| `DODO_PAYMENTS_WEBHOOK_KEY` | आपका वेबहुक साइनिंग कुंजी              | नहीं   |
| `DODO_PAYMENTS_ENVIRONMENT` | `live_mode` को उत्पादन के लिए सेट करें | नहीं   |

## रिमोटली चलाना

वेब-आधारित क्लाइंट्स या एजेंटिक वर्कफ़्लो के लिए MCP सर्वर को रिमोट HTTP सर्वर के रूप में तैनात करें।

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

### रिमोट सर्वर कॉन्फ़िगरेशन

एक बार तैनात होने के बाद, क्लाइंट्स सर्वर URL का उपयोग करके कनेक्ट कर सकते हैं:

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

### ऑथराइजेशन हैडर्स

रिमोट सर्वर निम्न हैडर्स के माध्यम से प्रमाणीकरण स्वीकार करता है:

| हैडर                      | वर्णन                   |
| ------------------------- | ----------------------- |
| `Authorization`           | बियरर टोकन प्रमाणीकरण   |
| `x-dodo-payments-api-key` | डायरेक्ट API कुंजी हैडर |

## सुरक्षा सर्वोत्तम प्रथाएँ

कोड मोड इनहेरेंट सुरक्षा प्रदान करता है जो एक सैंडबॉक्स वातावरण में कोड चलाकर और सर्वर-साइड API कुंजियों की इंजेक्शन प्रदान करता है। अपनी क्रेडेंशियल्स को सुरक्षित रखने के लिए इन अतिरिक्त सर्वोत्तम प्रथाओं का पालन करें।

<AccordionGroup>
  <Accordion title="API Key Management">
    **क्रेडेंशियल्स को कभी भी वर्शन कंट्रोल में न दें**

    API कुंजियों को पर्यावरण वेरिएबल्स या सुरक्षित सीक्रेट प्रबंधन प्रणालियों में स्टोर करें।

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

    **कुंजी नियमित रूप से घुमाएँ**

    नई API कुंजियाँ नियमित रूप से उत्पन्न करें और पुरानी कुंजियों को अपने Dodo Payments डैशबोर्ड के माध्यम से निष्क्रिय करें।

    **विकास के लिए परीक्षण कुंजियों का उपयोग करें**

    हमेशा परीक्षण मोड API कुंजियों का उपयोग विकास के दौरान करें ताकि उत्पादन डेटा को प्रभावित न करें।
  </Accordion>

  <Accordion title="Access Control">
    **रिमोट सर्वरों के लिए प्रमाणीकरण लागू करें**

    रिमोटली तैनात करते समय, हमेशा `Authorization` हैडर या `x-dodo-payments-api-key` हैडर के माध्यम से प्रमाणीकरण की आवश्यकता होती है।

    **API उपयोग की निगरानी करें**

    अपने Dodo Payments डैशबोर्ड के माध्यम से MCP सर्वर गतिविधि को ट्रैक करें और असामान्य पैटर्न के लिए अलर्ट सेट करें।
  </Accordion>

  <Accordion title="Network Security">
    **रिमोट सर्वरों के लिए HTTPS का उपयोग करें**

    हमेशा रिमोट MCP सर्वरों को HTTPS एंडपॉइंट्स के पीछे तैनात करें।

    **रेट लिमिटिंग लागू करें**

    दुरुपयोग से सुरक्षा के लिए MCP सर्वर और API स्तरों पर रेट लिमिट्स लागू करें।

    **नेटवर्क एक्सेस प्रतिबंधित करें**

    किस क्लाइंट्स आपके MCP सर्वर से कनेक्ट कर सकते हैं, इसे सीमित करने के लिए फ़ायरवॉल नियमों को कॉन्फ़िगर करें।
  </Accordion>
</AccordionGroup>

## समस्या निवारण

<AccordionGroup>
  <Accordion title="Connection issues">
    **अपनी API कुंजी सत्यापित करें**

    सुनिश्चित करें कि आपकी API कुंजी सही ढंग से सेट है और आवश्यक अनुमतियाँ हैं।

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

    **अपने नेटवर्क कनेक्शन की जाँच करें**

    सुनिश्चित करें कि आप Dodo Payments API एंडपॉइंट्स तक पहुँच सकते हैं।

    **क्लाइंट लॉग्स की समीक्षा करें**

    कनेक्शन समस्याओं का निदान करने के लिए अपने MCP क्लाइंट में विस्तृत लॉगिंग सक्षम करें।
  </Accordion>

  <Accordion title="Authentication errors">
    **API कुंजी पर्यावरण की पुष्टि करें**

    सुनिश्चित करें कि आप परीक्षण कुंजियों के साथ परीक्षण एंडपॉइंट्स और उत्पादन कुंजियों के साथ उत्पादन एंडपॉइंट्स का उपयोग कर रहे हैं।

    **पर्यावरण वेरिएबल की जाँच करें**

    सुनिश्चित करें `DODO_PAYMENTS_ENVIRONMENT` सही ढंग से सेट है (उत्पादन के लिए `live_mode` है)।

    **क्रेडेंशियल्स पुन: उत्पन्न करें**

    यदि समस्याएँ बनी रहती हैं, तो अपने डैशबोर्ड के माध्यम से एक नई API कुंजी उत्पन्न करें।
  </Accordion>

  <Accordion title="Tool execution failures">
    **इनपुट पैरामीटर्स सत्यापित करें**

    सुनिश्चित करें कि AI सहायक प्रत्येक उपकरण के लिए सही तरीके से स्वरूपित पैरामीटर प्रदान कर रहा है।

    **त्रुटि संदेशों की समीक्षा करें**

    गलती प्रतिक्रिया से विशिष्ट मार्गदर्शन के लिए API की त्रुटि प्रतिक्रिया की जाँच करें।

    **API के साथ सीधे परीक्षण करें**

    सुनिश्चित करें कि ऑपरेशन सीधे Dodo Payments API को curl या Postman के माध्यम से कॉल करते समय काम करता है।
  </Accordion>
</AccordionGroup>

## कोड मोड क्यों

पारंपरिक MCP कार्यान्वयन अक्सर "उपकरण प्रसार" से पीड़ित होते हैं, जहां प्रत्येक API समाप्ति बिंदु को एक अलग उपकरण के रूप में उजागर किया जाता है। कोड मोड कई कारणों से श्रेष्ठ दृष्टिकोण है:

### LLMs औजारों को बुलाने की तुलना में कोड लिखने में बेहतर हैं

LLMs को लाखों वास्तविक दुनिया के कोड लाइनों पर प्रशिक्षित किया गया है, जिससे वे स्वभाव से स्क्रिप्ट लिखने में निपुण हैं। इसके विपरीत, औजार बुलाने को अक्सर सिंथेटिक उदाहरणों के आधार पर किया जाता है।

<Info>
  "एक LLM को टूल कॉलिंग के साथ कार्य संरचना देने की कोशिश शेक्सपियर को एक महीने की मंडारिन क्लास में भेज कर उससे उसी भाषा में नाटक लिखवाना जैसा है।" — [Cloudflare](https://blog.cloudflare.com/code-mode/)
</Info>

### संदर्भ विंडो ब्लोट को समाप्त करता है

पारंपरिक दृष्टिकोण में, प्रत्येक औजार परिभाषा बातचीत शुरू होने से पहले टोकन का उपभोग करती है। 50+ उपकरणों को उजागर करने से आसानी से 55K–100K+ टोकन खा सकते हैं। Anthropic ने पाया कि औजार परिभाषाएँ अनुकूलन से पहले 134K तक टोकन का उपभोग कर सकती हैं।

कोड मोड के साथ, केवल 2 टूल परिभाषाएँ लोड की जाती हैं (\~1K टोकन्स)। एजेंट दस्तावेज़ीकरण को आवश्यकता होने पर मांग पर खोजता है। Anthropic के टूल सर्च टूल ने संदर्भ विंडो के 95% को संरक्षित किया, ओवरहेड को 77K से 8.7K टोकन्स तक घटाकर।

### प्रोग्रामेटिक ऑर्केस्ट्रेशन के माध्यम से विलंबता को कम करता है

पारंपरिक टूल-कॉलिंग के लिए हर एक ऑपरेशन के लिए एक पूर्ण मॉडल इंफेरेंस राउंड-ट्रिप की आवश्यकता होती है। यदि एक कार्य में 20 API कॉल की आवश्यकता होती है, तो यह 20 राउंड-ट्रिप्स हैं। कोड मोड में, एजेंट एक स्क्रिप्ट लिखता है जो सभी कॉल निष्पादित करता है और केवल अंतिम परिणाम लौटाता है।

अनथ्रोपिक ने इस प्रोग्रामेटिक दृष्टिकोण का उपयोग करके टोकनों में 37% की कमी देखी और सटीकता में सुधार (ज्ञान पुनः प्राप्ति 25.6% से 28.5% तक सुधरी)।

### डिज़ाइन द्वारा अधिक सुरक्षित

कोड मोड इनहेरेंट सुरक्षा लाभ प्रदान करता है:

* **पैरामीटर में कोई API कुंजी नहीं**: API कुंजियों को सर्वर-साइड इंजेक्ट किया जाता है और कभी भी LLM को भेजे गए टूल पैरामीटर में उजागर नहीं किया जाता है।
* **अलग सैंडबॉक्स**: कोड एक सुरक्षित पर्यावरण में चलता है जिसका नेटवर्क या होस्ट फ़ाइल सिस्टम तक कोई पहुँच नहीं है।
* **नियंत्रित SDK**: एजेंट को केवल अधिकृत SDK के तरीके उपलब्ध हैं।

### किसी भी API आकार तक स्केल करता है

जैसे-जैसे API बढ़ता है, पारंपरिक MCP प्रदर्शन में गिरावट आती है क्योंकि संदर्भ में अधिक उपकरणों को लोड करना पड़ता है। कोड मोड का स्तर 2 टूल्स के साथ लगातार बना रहता है जिससे कोई फर्क नहीं पड़ता API की सतह क्षेत्र कितना बड़ा है। Cloudflare ने सफलतापूर्वक 2,500 से अधिक API एंडपॉइंट्स को सिर्फ 2 टूल्स और लगभग 1,000 टोकन्स के संदर्भ में संकुचित किया।

<Info>
  इस आर्किटेक्चर के लाभों के बारे में अधिक विवरण के लिए, [Anthropic](https://www.anthropic.com/engineering/advanced-tool-use) और [Cloudflare](https://blog.cloudflare.com/code-mode/) के इंजीनियरिंग ब्लॉग्स और Claude के [Programmatic Tool Calling](https://platform.claude.com/docs/en/agents-and-tools/tool-use/programmatic-tool-calling) दस्तावेज़ देखें।
</Info>

## संसाधन

<CardGroup cols={2}>
  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    पूरी Dodo Payments API दस्तावेज़ीकरण का अन्वेषण करें
  </Card>

  <Card title="MCP Protocol" icon="link" href="https://modelcontextprotocol.io">
    मॉडल संदर्भ प्रोटोकॉल मानक के बारे में अधिक जानें
  </Card>

  <Card title="GitHub Repository" icon="github" href="https://github.com/dodopayments/dodopayments-typescript/tree/main/packages/mcp-server">
    MCP सर्वर स्रोत कोड देखें और योगदान करें
  </Card>

  <Card title="NPM Package" icon="npm" href="https://www.npmjs.com/package/dodopayments-mcp">
    NPM से MCP सर्वर इंस्टॉल करें
  </Card>
</CardGroup>
