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

# API गेटवे ब्लूप्रिंट

> API कॉल और गेटवे-स्तरीय उपयोग को ट्रैक करें। उच्च मात्रा में अनुरोध ट्रैकिंग के साथ API-as-a-service प्लेटफार्मों के लिए आदर्श।

## उपयोग के मामले

API गेटवे ब्लूप्रिंट द्वारा समर्थित सामान्य परिदृश्यों का अन्वेषण करें:

<CardGroup cols={2}>
  <Card title="API-as-a-Service" icon="server">
    एपीआई प्लेटफ़ॉर्म के लिए ग्राहक के अनुसार उपयोग ट्रैक करें और कॉल की संख्या के आधार पर शुल्क लें।
  </Card>

  <Card title="Rate Limiting" icon="gauge">
    एपीआई उपयोग पैटर्न की निगरानी करें और उपयोग-आधारित दर-सीमा लागू करें।
  </Card>

  <Card title="Performance Monitoring" icon="chart-line">
    बिलिंग डेटा के साथ प्रतिक्रिया समय और त्रुटि दर को ट्रैक करें।
  </Card>

  <Card title="Multi-Tenant SaaS" icon="users">
    विभिन्न एंडपॉइंट्स पर उनके एपीआई उपयोग के आधार पर ग्राहकों को बिल करें।
  </Card>
</CardGroup>

<Info>
  एपीआई एंडपॉइंट उपयोग, दर-सीमा, और उपयोग-आधारित एपीआई बिलिंग लागू करने के लिए आदर्श।
</Info>

## त्वरित प्रारंभ

उच्च मात्रा के परिदृश्यों के लिए स्वचालित बैचिंग के साथ गेटवे स्तर पर API कॉल को ट्रैक करें:

<Steps>
  <Step title="Install the SDK">
    ```bash theme={null}
    npm install @dodopayments/ingestion-blueprints
    ```
  </Step>

  <Step title="Get Your API Keys">
    * **Dodo Payments API Key**: इसे [Dodo Payments Dashboard](https://app.dodopayments.com/developer/api-keys) से प्राप्त करें
  </Step>

  <Step title="Create a Meter">
    अपने [Dodo Payments Dashboard](https://app.dodopayments.com/) में एक मीटर बनाएं:

    * **Event Name**: `api_call` (या अपनी पसंद का नाम)
    * **Aggregation Type**: `count` कॉल्स की संख्या ट्रैक करने के लिए
    * प्रतिक्रिया समय, स्थिति कोड आदि जैसे मेटाडेटा को ट्रैक करने पर अतिरिक्त गुण कॉन्फ़िगर करें।
  </Step>

  <Step title="Track API Calls">
    <CodeGroup>
      ```javascript Single API Call theme={null}
      import { Ingestion, trackAPICall } from '@dodopayments/ingestion-blueprints';

      const ingestion = new Ingestion({
        apiKey: process.env.DODO_PAYMENTS_API_KEY,
        environment: 'test_mode',
        eventName: 'api_call'
      });

      // Track a single API call
      await trackAPICall(ingestion, {
        customerId: 'customer_123',
        metadata: {
          endpoint: '/api/v1/users',
          method: 'GET',
          status_code: 200,
          response_time_ms: 45
        }
      });
      ```

      ```javascript High-Volume with Batching theme={null}
      import { Ingestion, createBatch } from '@dodopayments/ingestion-blueprints';

      const ingestion = new Ingestion({
        apiKey: process.env.DODO_PAYMENTS_API_KEY,
        environment: 'live_mode',
        eventName: 'api_call'
      });

      // Create batch for high-volume tracking
      const batch = createBatch(ingestion, {
        maxSize: 100,      // Flush after 100 events
        flushInterval: 5000 // Or flush every 5 seconds
      });

      // Add API calls to batch
      batch.add({
        customerId: 'customer_123',
        metadata: {
          endpoint: '/api/v1/products',
          method: 'GET',
          status_code: 200
        }
      });

      // Clean up when done
      await batch.cleanup();
      ```

      ```javascript Express.js Middleware theme={null}
      import express from 'express';
      import { Ingestion, createBatch } from '@dodopayments/ingestion-blueprints';

      const app = express();

      const ingestion = new Ingestion({
        apiKey: process.env.DODO_PAYMENTS_API_KEY,
        environment: 'live_mode',
        eventName: 'api_call'
      });

      const batch = createBatch(ingestion, {
        maxSize: 50,
        flushInterval: 10000
      });

      // Middleware to track all API calls
      app.use((req, res, next) => {
        const startTime = Date.now();
        
        res.on('finish', () => {
          const responseTime = Date.now() - startTime;
          
          batch.add({
            customerId: req.user?.id || 'anonymous',
            metadata: {
              endpoint: req.path,
              method: req.method,
              status_code: res.statusCode,
              response_time_ms: responseTime
            }
          });
        });
        
        next();
      });

      // Cleanup on shutdown
      process.on('SIGTERM', async () => {
        await batch.cleanup();
        process.exit(0);
      });
      ```
    </CodeGroup>
  </Step>
</Steps>

## कॉन्फ़िगरेशन

### इनजेशन कॉन्फ़िगरेशन

<ParamField path="apiKey" type="string" required>
  डैशबोर्ड से आपका Dodo Payments API कुंजी।
</ParamField>

<ParamField path="environment" type="string" required>
  पर्यावरण मोड: `test_mode` या `live_mode`।
</ParamField>

<ParamField path="eventName" type="string" required>
  इवेंट नाम जो आपके मीटर कॉन्फ़िगरेशन से मेल खाता है।
</ParamField>

### API कॉल विकल्प ट्रैक करें

<ParamField path="customerId" type="string" required>
  बिलिंग अट्रिब्यूशन के लिए ग्राहक आईडी।
</ParamField>

<ParamField path="metadata" type="object">
  एपीआई कॉल के बारे में वैकल्पिक मेटाडेटा जैसे एंडपॉइंट, मेथड, स्थिति कोड, प्रतिक्रिया समय, आदि।
</ParamField>

### बैच कॉन्फ़िगरेशन

<ParamField path="maxSize" type="number">
  ऑटो-फ़्लश से पहले अधिकतम ईवेंट की संख्या। डिफ़ॉल्ट: `100`।
</ParamField>

<ParamField path="flushInterval" type="number">
  मिलीसेकंड में ऑटो-फ़्लश अंतराल। डिफ़ॉल्ट: `5000` (5 सेकंड)।
</ParamField>

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

<Tip>
  **उच्च मात्रा के लिए बैचिंग का उपयोग करें**: जो एप्लिकेशन प्रति सेकंड 10 से अधिक अनुरोधों को संभालते हैं, वे ओवरहेड कम करने और प्रदर्शन में सुधार के लिए `createBatch()` का उपयोग करें।
</Tip>

<Warning>
  **हमेशा बैच साफ़ करें**: लंबित ईवेंट्स को फ्लश करने और डेटा हानि से बचने के लिए एप्लिकेशन शटडाउन पर `batch.cleanup()` को कॉल करें।
</Warning>