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

# Anfragekosten vor dem Aufruf eines Modells schätzen

> Schätzen Sie die Kosten einer CometAPI-Anfrage vor einem Modellaufruf, indem Sie die Preise aus dem Modellverzeichnis mit der Eingabegröße, Ausgabelimits oder der Anzahl der Tasks kombinieren.

Schätzen Sie die Kosten vor einem Modellaufruf, indem Sie den Preis aus dem Modellverzeichnis mit den Einheiten kombinieren, die der Endpoint abrechnet: Tokens, Bilder, Audiolänge oder Video-Tasks. Betrachten Sie die Schätzung als Budgetschutz und verwenden Sie nach Abschluss der Anfrage die tatsächlichen Nutzungs- und Abrechnungsdaten.

## Token-basierte Aufrufe schätzen

Das folgende Python-Beispiel schätzt die Kosten einer token-basierten Anfrage anhand konfigurierter Preiswerte:

```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}")
```

Das Ergebnis ist eine Schätzung vor dem Aufruf:

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

## Ein maximales Ausgabebudget festlegen

Die folgende Anfrage begrenzt die generierte Ausgabe, sodass die Schätzung eine Obergrenze hat:

```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
  }'
```

Die Antwort enthält die tatsächliche Nutzung nach dem Modellaufruf:

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

## Task-basierte Aufrufe schätzen

Das folgende JavaScript-Beispiel schätzt einen Task-basierten Workflow wie Bild- oder Videogenerierung:

```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)}`);
```

Das Ergebnis ist das Task-Budget:

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

## Häufige Fehler

| Error                                            | Fix                                                                                                         |
| ------------------------------------------------ | ----------------------------------------------------------------------------------------------------------- |
| Verwendung eines Preises aus dem falschen Modell | Übernehmen Sie die Preisangaben aus demselben model ID im Modellverzeichnis.                                |
| Ausgabetokens ignorieren                         | Legen Sie `max_completion_tokens` oder das endpoint-spezifische Ausgabelimit fest.                          |
| Schätzungen als Rechnungen behandeln             | Vergleichen Sie Schätzungen nach dem Aufruf mit der tatsächlichen Nutzung.                                  |
| Fehlende Task-Multiplikatoren                    | Prüfen Sie bei Bild, Audio und Video, ob pro Task, pro Sekunde oder pro generiertem Asset abgerechnet wird. |

## Verwandte Links

* [Preise](https://www.cometapi.com/pricing/)
* [Modellverzeichnis](https://www.cometapi.com/models/)
* [Modellseite](/de/overview/models)
* [Über Preise](/de/pricing/about-pricing)
* [CometAPI-Schnellstart](/de/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": "Wie schätze ich die Kosten vor dem Aufruf eines Modells?",
        "description": "Schätzen Sie die Kosten einer CometAPI-Anfrage vor einem Modellaufruf, indem Sie die Preise aus dem Modellverzeichnis mit der Eingabegröße, Ausgabelimits oder der Anzahl der Aufgaben kombinieren.",
        "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": "CometAPI-Dokumentation",
            "item": "https://apidoc.cometapi.com/"
          },
          {
            "@type": "ListItem",
            "position": 2,
            "name": "Anleitungen",
            "item": "https://apidoc.cometapi.com/guides/use-cometapi-with-openai-sdk"
          },
          {
            "@type": "ListItem",
            "position": 3,
            "name": "Wie schätze ich die Kosten vor dem Aufruf eines Modells?",
            "item": "https://apidoc.cometapi.com/guides/how-to-estimate-cost-before-calling-a-model"
          }
        ]
      }
    ]
    }
    `}
</script>