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

# Gérer les limites de débit et la concurrence

> Gérez les limites de débit de CometAPI en plafonnant la concurrence des requêtes, en réessayant les réponses `429` avec du jitter, et en surveillant l’utilisation par modèle et par route.

Gérez les limites de débit en contrôlant la concurrence avant que les requêtes ne quittent votre application. Lorsque CometAPI renvoie `429`, réessayez avec un backoff exponentiel et du jitter, puis réduisez le trafic en rafale si des réessais répétés se produisent.

## Limiter la concurrence

L’exemple Python suivant plafonne les requêtes de chat simultanées avec un sémaphore asynchrone :

```python theme={null}
import asyncio
import os
from openai import AsyncOpenAI

client = AsyncOpenAI(
    api_key=os.environ["COMETAPI_KEY"],
    base_url="https://api.cometapi.com/v1",
)

semaphore = asyncio.Semaphore(5)

async def ask(prompt):
    async with semaphore:
        completion = await client.chat.completions.create(
            model="your-model-id",
            messages=[{"role": "user", "content": prompt}],
        )
        return completion.choices[0].message.content

async def main():
    prompts = ["Say hello.", "Write a title.", "Return one JSON key."]
    results = await asyncio.gather(*(ask(prompt) for prompt in prompts))
    print(results)

asyncio.run(main())
```

Le résultat est un tableau de sorties du modèle :

```json theme={null}
[
  "Hello.",
  "A concise title",
  "{\"key\":\"value\"}"
]
```

## Réessayer en cas de limite de débit

L’exemple JavaScript suivant réessaie les réponses `429` avec du jitter :

```javascript theme={null}
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.COMETAPI_KEY,
  baseURL: "https://api.cometapi.com/v1",
});

async function sleep(milliseconds) {
  return new Promise((resolve) => setTimeout(resolve, milliseconds));
}

async function createCompletion() {
  for (let attempt = 0; attempt < 5; attempt += 1) {
    try {
      return await client.chat.completions.create({
        model: "your-model-id",
        messages: [{ role: "user", content: "Say hello." }],
      });
    } catch (error) {
      if (error.status !== 429 || attempt === 4) {
        throw error;
      }

      const delay = Math.min(30000, 1000 * 2 ** attempt);
      await sleep(delay + Math.random() * 1000);
    }
  }
}

const completion = await createCompletion();
console.log(completion.choices[0].message.content);
```

La réponse réussie contient une complétion de chat normale :

```json theme={null}
{
  "choices": [
    {
      "message": {
        "content": "Hello."
      }
    }
  ]
}
```

## Erreurs courantes

| Error                          | Correctif                                                                       |
| ------------------------------ | ------------------------------------------------------------------------------- |
| Requêtes parallèles illimitées | Ajoutez un sémaphore, une file d’attente ou un pool de workers.                 |
| Réessayer tous les échecs      | Réessayez uniquement `429` et les échecs temporaires du serveur.                |
| Aucune métrique par modèle     | Journalisez la route, le model ID, le statut et la latence pour chaque requête. |
| Tempête de réessais            | Ajoutez du jitter et plafonnez le délai maximal de réessai.                     |

## Liens associés

* [Codes d’erreur et stratégie de nouvelle tentative](/fr/guides/error-codes-and-retry-strategy)
* [Codes d’erreur et gestion](/fr/errors/error-codes-handling)
* [Page des modèles](/fr/overview/models)
* [Répertoire des modèles](https://www.cometapi.com/models/)
* [Tarification](https://www.cometapi.com/pricing/)
* [Démarrage rapide de CometAPI](/fr/overview/quick-start)

<script type="application/ld+json">
  {`
    {
    "@context": "https://schema.org",
    "@graph": [
      {
        "@type": "TechArticle",
        "@id": "https://apidoc.cometapi.com/guides/rate-limits-and-concurrency",
        "headline": "Comment gérer les limites de débit et la concurrence ?",
        "description": "Gérez les limites de débit de CometAPI en plafonnant la concurrence, en réessayant les réponses 429 avec jitter, et en surveillant l’utilisation par modèle et par route.",
        "url": "https://apidoc.cometapi.com/guides/rate-limits-and-concurrency",
        "author": {
          "@type": "Organization",
          "name": "CometAPI"
        },
        "publisher": {
          "@type": "Organization",
          "name": "CometAPI",
          "url": "https://www.cometapi.com"
        }
      },
      {
        "@type": "BreadcrumbList",
        "itemListElement": [
          {
            "@type": "ListItem",
            "position": 1,
            "name": "Documentation CometAPI",
            "item": "https://apidoc.cometapi.com/"
          },
          {
            "@type": "ListItem",
            "position": 2,
            "name": "Guides",
            "item": "https://apidoc.cometapi.com/guides/use-cometapi-with-openai-sdk"
          },
          {
            "@type": "ListItem",
            "position": 3,
            "name": "Comment gérer les limites de débit et la concurrence ?",
            "item": "https://apidoc.cometapi.com/guides/rate-limits-and-concurrency"
          }
        ]
      }
    ]
    }
    `}
</script>