# LLM API

> Ruf Modelle direkt aus deinem eigenen Code mit einem API-Schlüssel von endue auf, über das OpenAI- oder Anthropic-SDK, das du schon nutzt. Jeder Aufruf wird aus deinen Credits bezahlt.

Mit der **LLM API** ruft dein Code ein Modell direkt mit einem API-Schlüssel von endue auf, im selben Anfrageformat wie die APIs von OpenAI und Anthropic. Jeder Aufruf wird aus deinen Credits bezahlt.

## Wann du sie nutzt

Wenn du ein Modell brauchst und keinen Agenten: eine Completion in deiner eigenen App, Code, der bereits mit der API von OpenAI oder Anthropic spricht, oder Claude Code. Du änderst die Basis-URL und den Schlüssel, der Rest deines Codes bleibt, wie er ist.

Soll ein Agent die Arbeit erledigen, mit seinem Prompt, seinem Gedächtnis, seinen Tools und Connectors, ruf ihn stattdessen über die [Agent API](/de/docs/build/agent-api/) auf.

## Dein erster Aufruf

<Steps>

1. **Erstelle einen kontoweiten Schlüssel** unter **Einstellungen → Konto → API-Schlüssel**. Kopiere ihn, sobald er angezeigt wird, denn er erscheint nur einmal. Ein Schlüssel aus dem API-Bereich eines Agenten ist auf diesen Agenten beschränkt und kann Modelle nicht direkt aufrufen.

2. **Halte den Schlüssel aus deinem Code heraus.** Leg ihn in einer Umgebungsvariable ab, zum Beispiel `ENDUE_API_KEY`.

3. **Richte dein SDK mit dieser Basis-URL auf endue aus** und ruf ein Modell aus der [Modellliste](#modelle-und-preise) auf:

   ```
   https://platform.endue.ai/api/v1/llm
   ```

</Steps>

<Tabs syncKey="llm-api-lang">
  <TabItem label="Python">
    ```python
    import os
    from openai import OpenAI

    client = OpenAI(base_url="https://platform.endue.ai/api/v1/llm", api_key=os.environ["ENDUE_API_KEY"])
    res = client.chat.completions.create(
        model="openai/gpt-5.4",
        messages=[{"role": "user", "content": "Hello"}],
    )
    print(res.choices[0].message.content)
    ```
  </TabItem>
  <TabItem label="Node.js">
    ```js
    import OpenAI from 'openai';

    const client = new OpenAI({ baseURL: 'https://platform.endue.ai/api/v1/llm', apiKey: process.env.ENDUE_API_KEY });
    const res = await client.chat.completions.create({
      model: 'openai/gpt-5.4',
      messages: [{ role: 'user', content: 'Hello' }],
    });
    console.log(res.choices[0].message.content);
    ```
  </TabItem>
  <TabItem label="curl">
    ```bash
    curl https://platform.endue.ai/api/v1/llm/chat/completions \
      -H "Authorization: Bearer $ENDUE_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{"model":"openai/gpt-5.4","messages":[{"role":"user","content":"Hello"}]}'
    ```
  </TabItem>
  <TabItem label="Anthropic SDK">
    ```python
    import os
    import anthropic

    client = anthropic.Anthropic(base_url="https://platform.endue.ai/api/v1/llm", api_key=os.environ["ENDUE_API_KEY"])
    msg = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Hello"}],
    )
    print(msg.content[0].text)
    ```
  </TabItem>
  <TabItem label="Claude Code">
    ```bash
    export ANTHROPIC_BASE_URL=https://platform.endue.ai/api/v1/llm
    export ANTHROPIC_API_KEY=$ENDUE_API_KEY
    claude
    ```
  </TabItem>
</Tabs>

Unter **Einstellungen → Konto → LLM API** findest du dieselbe Basis-URL und dieselben Beispiele zum Kopieren.

## Modelle und Preise

`GET https://platform.endue.ai/api/v1/llm/models` listet jedes Modell, das du aufrufen kannst, mit Kontextlänge und Preis. Zum Abrufen der Liste brauchst du keinen Schlüssel.

- **Modell-IDs** sehen aus wie `openai/gpt-5.4` oder `x-ai/grok-4.6`: erst der Anbieter, dann das Modell.
- **Preise** sind in Credits pro Token angegeben, als Dezimalzahlen in Strings: `prompt` für die Eingabe, `completion` für die Ausgabe und `input_cache_read`, wenn das Modell gecachte Eingaben günstiger berechnet. Ein Credit entspricht einem US-Dollar.
- Manche Modelle berechnen für sehr lange Prompts mehr. Diese Preise stehen unter `overrides`, zusammen mit der Promptlänge, ab der sie gelten.

Dieselben Modelle kannst du auf der [Modellseite](/de/models) durchsehen.

## Streaming

Setz `"stream": true`. Du bekommst die Antwort als Server-Sent Events im Chunk-Format von OpenAI, abgeschlossen mit `data: [DONE]`. Der letzte Chunk vor `[DONE]` enthält `usage`, einschließlich der Kosten des Aufrufs.

## Wie ein Aufruf bezahlt wird

<Steps>

1. **Bevor das Modell läuft**, reserviert endue so viele deiner Credits, dass die höchstmöglichen Kosten des Aufrufs gedeckt sind: dein Prompt plus `max_tokens` Ausgabe. Ist dein Guthaben niedriger, wird das Modell nicht aufgerufen und du bekommst einen `402`.

2. **Wenn der Aufruf abgeschlossen ist**, wird dir berechnet, was er tatsächlich gekostet hat, und der Rest der Reservierung geht zurück auf dein Guthaben.

3. **Die Antwort nennt dir die Kosten.** `usage.cost` sind die für diesen Aufruf abgebuchten Credits, und der Header `X-Endue-Request-Id` identifiziert den Aufruf, falls du dazu eine Frage hast.

</Steps>

Lässt du `max_tokens` weg und reicht dein Guthaben nicht für die volle Ausgabelänge des Modells, läuft der Aufruf trotzdem, mit `max_tokens` gesenkt auf das, was dein Guthaben abdeckt, sofern das mindestens 1.024 Tokens sind. Darunter bekommst du einen `402`.

Aufrufe der LLM API werden nur aus **gekauften Credits und Aktions-Credits** bezahlt. Das Kontingent deines Tarifs ist für Agenten gedacht und wird hier nicht genutzt. Die Aufrufe erscheinen in der [Nutzungsübersicht](/de/docs/account/usage/#quellen) im Tab **Quellen** als **LLM API**.

## Anthropic-Format und Claude Code

Dieselbe Basis-URL akzeptiert auch das Format von Anthropic Messages. Das Anthropic SDK und Claude Code hängen `/v1/messages` selbst an die Basis-URL an, die Einrichtung besteht also aus den zwei Zeilen in den Tabs oben.

- Sende den Schlüssel als `x-api-key` oder als `Authorization: Bearer`.
- Claude-Modellnamen funktionieren so, wie du sie für Anthropic schreiben würdest, also `claude-sonnet-4-5` oder mit Datum wie `claude-sonnet-4-5-20250929`, sofern das Modell in der Modellliste steht. Jede ID aus der Modellliste funktioniert ebenfalls, auch für Modelle, die keine Claude-Modelle sind.
- Streaming nutzt das Event-Format von Anthropic, und Fehler haben die Fehlerstruktur von Anthropic.
- `/v1/messages/count_tokens` liefert eine Schätzung der Eingabe-Tokens. Das wird nicht berechnet und ist ein Näherungswert, keine exakte Zählung durch einen Tokenizer.

## Fehler

Fehler haben die Struktur des Formats, das du aufgerufen hast: `{"error": {…}}` bei OpenAI oder `{"type": "error", "error": {…}}` bei Anthropic.

| Status | Was passiert ist | Was du tun kannst |
| --- | --- | --- |
| `400` | Die Anfrage ist fehlerhaft, `n` ist größer als 1, oder das Modell hat die Eingabe abgelehnt | Korrigiere die Anfrage. Die Meldung sagt, was falsch ist |
| `401` | Der Schlüssel fehlt, wurde widerrufen oder ist falsch | Prüfe den Schlüssel und wie du ihn sendest |
| `402` | Dein Credit-Guthaben deckt den Aufruf nicht (`insufficient_credits`, im Anthropic-Format `billing_error`) | Kauf Credits oder senke `max_tokens` |
| `403` | Der Schlüssel ist auf einen Agenten beschränkt | Erstelle einen kontoweiten Schlüssel |
| `404` | Das Modell steht nicht in der Modellliste | Wähle eine ID aus `/models` |
| `429` | Zu viele Anfragen | Warte so viele Sekunden, wie `Retry-After` angibt |
| `502` | Beim Modellanbieter ist ein Fehler aufgetreten | Versuch es erneut |
| `503` | Abrechnung oder Modellliste sind kurzzeitig nicht erreichbar. Das Modell wurde nicht aufgerufen, und es wurde nichts berechnet | Versuch es kurz darauf erneut |

## Einschränkungen

- Nur Modelle aus der Modellliste können aufgerufen werden.
- Zwei Formate werden unterstützt: OpenAI Chat Completions und Anthropic Messages. Endpunkte für Embeddings, Bilder, Audio oder Responses gibt es nicht.
- `n` muss 1 sein.
- Felder außerhalb der Standardanfrage werden ignoriert, zum Beispiel eine Fallback-Liste anderer Modelle, Anbieter-Routing oder Plugins. Im Anthropic-Format werden Server-Tools wie die Websuche abgelehnt, und `top_k` wird ignoriert.
- Das Kontingent des Tarifs wird nicht genutzt. Aufrufe brauchen gekaufte Credits oder Aktions-Credits.
- Ein auf einen Agenten beschränkter Schlüssel kann keine Modelle aufrufen.
- Bis zu 100 Aufrufe pro Minute, gezählt pro Schlüssel und pro Konto. Der Body einer Anfrage darf bis zu 8 MB groß sein.
- `count_tokens` ist eine Schätzung.

## Siehe auch

<CardGrid>
  <LinkCard
    title="Agent API"
    href="/de/docs/build/agent-api/"
    description="Ruf statt eines reinen Modells einen Agenten mit Prompt, Gedächtnis und Tools auf."
  />
  <LinkCard
    title="Nutzungsübersicht"
    href="/de/docs/account/usage/"
    description="Sieh im Tab Quellen die Ausgaben für die LLM API neben denen deiner Agenten."
  />
  <LinkCard
    title="Modell wählen"
    href="/de/docs/build/models/"
    description="Wie sich die Modelle unterscheiden und was sie im Vergleich zueinander kosten."
  />
  <LinkCard
    title="Sicherheit und Berechtigungen"
    href="/de/docs/account/security/"
    description="Worauf ein Schlüssel zugreifen kann und wie du ihn widerrufst."
  />
</CardGrid>