> ## Documentation Index
> Fetch the complete documentation index at: https://chariow.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Limites de débit

> Comprendre la limitation de débit de l'API et comment la gérer

L'API Chariow implémente une limitation de débit pour garantir une utilisation équitable et maintenir la qualité du service pour tous les utilisateurs.

## Limites par défaut

| Type d'endpoint         | Limite       | Fenêtre    |
| ----------------------- | ------------ | ---------- |
| Toutes les requêtes API | 100 requêtes | par minute |

Les limites de débit sont appliquées par clé API. Chaque clé API a son propre compteur de limite séparé.

## En-têtes de limite de débit

Chaque réponse API inclut des en-têtes indiquant votre statut actuel de limite de débit :

```http theme={null}
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 98
X-RateLimit-Reset: 1642089600
```

| En-tête                 | Description                                           |
| ----------------------- | ----------------------------------------------------- |
| `X-RateLimit-Limit`     | Nombre maximum de requêtes autorisées dans la fenêtre |
| `X-RateLimit-Remaining` | Requêtes restantes dans la fenêtre actuelle           |
| `X-RateLimit-Reset`     | Timestamp Unix de réinitialisation de la limite       |

## Limite de débit dépassée

Lorsque vous dépassez la limite de débit, vous recevrez une réponse `429 Too Many Requests` :

```json theme={null}
{
  "message": "Trop de requêtes. Veuillez réessayer plus tard.",
  "data": [],
  "errors": []
}
```

La réponse inclut un en-tête `Retry-After` indiquant combien de temps attendre :

```http theme={null}
HTTP/1.1 429 Too Many Requests
Retry-After: 60
```

## Gérer les limites de débit

### Backoff exponentiel

Implémentez un backoff exponentiel pour gérer gracieusement les limites de débit :

```javascript theme={null}
async function fetchWithRetry(url, options, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const response = await fetch(url, options);

    if (response.status === 429) {
      const retryAfter = response.headers.get('Retry-After') || 60;
      const delay = Math.min(retryAfter * 1000, Math.pow(2, attempt) * 1000);

      console.log(`Limite atteinte. Nouvel essai dans ${delay}ms...`);
      await new Promise(resolve => setTimeout(resolve, delay));
      continue;
    }

    return response;
  }

  throw new Error('Nombre maximum de tentatives dépassé');
}
```

### Regroupement des requêtes

Regroupez plusieurs opérations pour réduire le nombre de requêtes :

```javascript theme={null}
// Au lieu de faire 100 requêtes individuelles
for (const customerId of customerIds) {
  await getCustomer(customerId); // 100 requêtes
}

// Utilisez la pagination pour en récupérer plusieurs à la fois
const customers = await listCustomers({ per_page: 100 }); // 1 requête
```

### Mise en cache

Mettez en cache les réponses pour éviter les requêtes inutiles :

```javascript theme={null}
const cache = new Map();
const CACHE_TTL = 60000; // 1 minute

async function getCachedCustomer(customerId) {
  const cached = cache.get(customerId);

  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
    return cached.data;
  }

  const response = await fetch(`/v1/customers/${customerId}`, {
    headers: { 'Authorization': `Bearer ${apiKey}` }
  });

  const data = await response.json();
  cache.set(customerId, { data, timestamp: Date.now() });

  return data;
}
```

## Augmenter les limites

Si vous avez besoin de limites de débit plus élevées :

1. **Plans Entreprise** - Des limites plus élevées sont disponibles sur les plans entreprise
2. **Contacter le support** - Demandez une augmentation temporaire pour des cas d'utilisation spécifiques
3. **Optimiser l'utilisation** - Examinez votre implémentation pour des opportunités d'optimisation

<Info>
  Contactez [support@chariow.com](mailto:support@chariow.com) pour discuter de limites de débit plus élevées pour votre cas d'utilisation.
</Info>

## Bonnes pratiques

<AccordionGroup>
  <Accordion title="Surveiller votre utilisation" icon="chart-line">
    Suivez les en-têtes de limite de débit pour comprendre vos schémas d'utilisation et ajustez en conséquence.
  </Accordion>

  <Accordion title="Utiliser les webhooks" icon="webhook">
    Au lieu de faire du polling pour les changements, utilisez les webhooks pour recevoir des notifications en temps réel.
  </Accordion>

  <Accordion title="Implémenter une file d'attente" icon="list-ol">
    Mettez les requêtes en file d'attente et traitez-les à un rythme contrôlé pour éviter les pics.
  </Accordion>

  <Accordion title="Mettre en cache agressivement" icon="database">
    Mettez en cache les données qui ne changent pas fréquemment pour réduire les appels API.
  </Accordion>
</AccordionGroup>