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

# Estimer le coût d'une requête avant d'appeler un modèle

> Estimez le coût d'une requête CometAPI avant un appel de modèle en combinant la tarification du répertoire des modèles avec la taille des entrées, les limites de sortie ou le nombre de tâches.

Estimez le coût avant un appel de modèle en combinant le prix du répertoire des modèles avec les unités facturées par le point de terminaison : tokens, images, durée audio ou tâches vidéo. Considérez l'estimation comme une protection budgétaire, puis utilisez les données d'utilisation et de facturation réelles une fois la requête terminée.

## Estimer les appels basés sur les tokens

L'exemple Python suivant estime le coût d'une requête basée sur des tokens à partir des valeurs de tarification configurées :

```python theme={null}
import math
import os

prompt = "Write a short product description for CometAPI."
max_output_tokens = 200

input_price_per_1m = float(os.environ["MODEL_INPUT_PRICE_PER_1M"])
output_price_per_1m = float(os.environ["MODEL_OUTPUT_PRICE_PER_1M"])

estimated_input_tokens = math.ceil(len(prompt) / 4)

estimated_cost = (
    estimated_input_tokens * input_price_per_1m
    + max_output_tokens * output_price_per_1m
) / 1_000_000

print(f"Estimated maximum cost: ${estimated_cost:.6f}")
```

Le résultat est une estimation avant l'appel :

```text theme={null}
Estimated maximum cost: $0.000123
```

## Définir un budget de sortie maximal

La requête suivante plafonne la sortie générée afin que l'estimation ait une borne supérieure :

```bash theme={null}
curl https://api.cometapi.com/v1/chat/completions \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "your-model-id",
    "messages": [
      {
        "role": "user",
        "content": "Write a short product description for CometAPI."
      }
    ],
    "max_completion_tokens": 200
  }'
```

La réponse inclut l'utilisation réelle après l'appel du modèle :

```json theme={null}
{
  "usage": {
    "prompt_tokens": 10,
    "completion_tokens": 42,
    "total_tokens": 52
  }
}
```

## Estimer les appels basés sur des tâches

L'exemple JavaScript suivant estime un flux de travail basé sur des tâches, comme la génération d'images ou de vidéos :

```javascript theme={null}
const taskCount = 3;
const pricePerTask = Number(process.env.MODEL_PRICE_PER_TASK);

const estimatedCost = taskCount * pricePerTask;

console.log(`Estimated maximum cost: $${estimatedCost.toFixed(4)}`);
```

Le résultat correspond au budget de la tâche :

```text theme={null}
Estimated maximum cost: $0.4500
```

## Erreurs courantes

| Error                                             | Fix                                                                                                                       |
| ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| Utilisation d'un prix provenant du mauvais modèle | Copiez la tarification du même model ID dans le répertoire des modèles.                                                   |
| Ignorer les tokens de sortie                      | Définissez `max_completion_tokens` ou la limite de sortie propre au point de terminaison.                                 |
| Traiter les estimations comme des factures        | Comparez les estimations avec l'utilisation réelle après l'appel.                                                         |
| Oublier les multiplicateurs de tâche              | Pour les images, l'audio et la vidéo, vérifiez si la facturation se fait par tâche, par seconde ou par ressource générée. |

## Liens associés

* [Tarification](https://www.cometapi.com/pricing/)
* [Répertoire des modèles](https://www.cometapi.com/models/)
* [Page des modèles](/fr/overview/models)
* [À propos de la tarification](/fr/pricing/about-pricing)
* [Démarrage rapide CometAPI](/fr/overview/quick-start)

<script type="application/ld+json">
  {`
    {
    "@context": "https://schema.org",
    "@graph": [
      {
        "@type": "TechArticle",
        "@id": "https://apidoc.cometapi.com/guides/how-to-estimate-cost-before-calling-a-model",
        "headline": "Comment estimer le coût avant d’appeler un modèle ?",
        "description": "Estimez le coût d’une requête CometAPI avant l’appel d’un modèle en combinant la tarification du répertoire des modèles avec la taille d’entrée, les limites de sortie ou le nombre de tâches.",
        "url": "https://apidoc.cometapi.com/guides/how-to-estimate-cost-before-calling-a-model",
        "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 estimer le coût avant d’appeler un modèle ?",
            "item": "https://apidoc.cometapi.com/guides/how-to-estimate-cost-before-calling-a-model"
          }
        ]
      }
    ]
    }
    `}
</script>