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

> Suivez les appels API et l'utilisation au niveau de la passerelle pour la facturation. Parfait pour les plateformes API-as-a-service avec un suivi des demandes à fort volume.

## Cas d'utilisation

Explorez les scénarios courants pris en charge par le Blueprint API Gateway :

<CardGroup cols={2}>
  <Card title="API-as-a-Service" icon="server">
    Suivez l'utilisation par client pour les plates-formes API et facturez en fonction du nombre d'appels.
  </Card>

  <Card title="Rate Limiting" icon="gauge">
    Surveillez les modèles d'utilisation de l'API et mettez en œuvre des limitations de débit basées sur l'utilisation.
  </Card>

  <Card title="Performance Monitoring" icon="chart-line">
    Suivez les temps de réponse et les taux d'erreur parallèlement aux données de facturation.
  </Card>

  <Card title="Multi-Tenant SaaS" icon="users">
    Facturez les clients en fonction de leur consommation d'API sur différents points de terminaison.
  </Card>
</CardGroup>

<Info>
  Idéal pour suivre l'utilisation des points de terminaison API, la limitation de débit et la mise en œuvre de la facturation API basée sur l'utilisation.
</Info>

## Démarrage Rapide

Suivez les appels API au niveau de la passerelle avec un traitement par lots automatique pour des scénarios à fort volume :

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

  <Step title="Get Your API Keys">
    * **Clé API Dodo Payments** : obtenez-la depuis le [tableau de bord Dodo Payments](https://app.dodopayments.com/developer/api-keys)
  </Step>

  <Step title="Create a Meter">
    Créez un compteur dans votre [tableau de bord Dodo Payments](https://app.dodopayments.com/) :

    * **Nom de l'événement** : `api_call` (ou le nom de votre choix)
    * **Type d'agrégation** : `count` pour suivre le nombre d'appels
    * Configurez des propriétés supplémentaires si vous suivez des métadonnées comme les temps de réponse, les codes d'état, etc.
  </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>

## Configuration

### Configuration d'Ingestion

<ParamField path="apiKey" type="string" required>
  Votre clé API Dodo Payments depuis le tableau de bord.
</ParamField>

<ParamField path="environment" type="string" required>
  Mode d'environnement : `test_mode` ou `live_mode`.
</ParamField>

<ParamField path="eventName" type="string" required>
  Nom de l'événement correspondant à la configuration de votre compteur.
</ParamField>

### Options de Suivi des Appels API

<ParamField path="customerId" type="string" required>
  L'identifiant client pour l'attribution de facturation.
</ParamField>

<ParamField path="metadata" type="object">
  Métadonnées facultatives sur l'appel API, comme le point de terminaison, la méthode, le code d'état, le temps de réponse, etc.
</ParamField>

### Configuration par Lots

<ParamField path="maxSize" type="number">
  Nombre maximal d'événements avant vidage automatique. Par défaut : `100`.
</ParamField>

<ParamField path="flushInterval" type="number">
  Intervalle de vidage automatique en millisecondes. Par défaut : `5000` (5 secondes).
</ParamField>

## Meilleures Pratiques

<Tip>
  **Utilisez le traitement par lots pour les gros volumes** : pour les applications traitant plus de 10 requêtes par seconde, utilisez `createBatch()` pour réduire les frais généraux et améliorer les performances.
</Tip>

<Warning>
  **Nettoyez toujours les lots** : appelez `batch.cleanup()` lors de l'arrêt de l'application pour vider les événements en attente et éviter la perte de données.
</Warning>