# GPT Astra 6 API (https://wanapi.app/de/docs/gpt-6-astra)





Verwende **GPT Astra 6** im Format OpenAI Responses oder Chat Completions mit deinem Wan API-Schlüssel. [GPT-Modelle vergleichen](/de/docs/gpt-api).

## Modelleinstellungen [#modelleinstellungen]

| Einstellung              | GPT Astra 6                             |
| ------------------------ | --------------------------------------- |
| Modell-ID in der Anfrage | `gpt-6-astra`                           |
| Eingabe / Ausgabe        | Text und Bilder / Text                  |
| Kontextfenster           | 1.050.000 Tokens                        |
| Maximale Eingabe         | 922.000 Tokens                          |
| Maximale Ausgabe         | 128.000 Tokens einschließlich Reasoning |
| Reasoning-Aufwand        | `low`, `medium`, `high`, `xhigh`, `max` |
| Standardaufwand          | Explizit festlegen                      |

Dies sind die nativen Modellgrenzen. Für Anfragen gelten außerdem die Beschränkungen des verfügbaren Kanals und deines Kontos. Audio- und Videoeingaben werden nicht unterstützt.

## Verbindung herstellen und Anfrage senden [#verbindung-herstellen-und-anfrage-senden]

Erstelle einen Schlüssel in den [API-Schlüsseleinstellungen](/de/settings/apikeys). Speichere ihn auf deinem Server als `WAN_API_KEY`. Ein Schlüssel und dasselbe Prepaid-Guthaben gelten für alle Modelle und Gruppen. Verwende die genaue Modell-ID, einschließlich des Dezimalpunkts in den 6.1-IDs.

```bash
curl https://api.wanapi.app/v1/responses \
  -H "Authorization: Bearer $WAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "input": "Explain the purpose of a database index in three sentences.",
    "reasoning": {"effort": "low"},
    "max_output_tokens": 1024
  }'
```

```python
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["WAN_API_KEY"],
    base_url="https://api.wanapi.app/v1",
)
response = client.responses.create(
    model="gpt-6-astra",
    input="Explain the purpose of a database index in three sentences.",
    reasoning={"effort": "low"},
    max_output_tokens=1024,
)
print(response.output_text)
```

## Responses-Parameter [#responses-parameter]

| Feld                                                                 | Erforderlich | Spezifikation                                                                                                                               |
| -------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------- |
| `model`                                                              | Ja           | `gpt-6-astra`.                                                                                                                              |
| `input`                                                              | Ja           | Prompt als Zeichenfolge oder Array von Eingabeelementen.                                                                                    |
| `instructions`                                                       | Nein         | System- oder Entwickleranweisungen.                                                                                                         |
| `max_output_tokens`                                                  | Nein         | Ausgabebudget einschließlich Reasoning; bis zu 128.000 Tokens.                                                                              |
| `reasoning.effort`                                                   | Nein         | low, medium, high, xhigh, max.                                                                                                              |
| `reasoning.summary`                                                  | Nein         | `auto`, `concise` oder `detailed`.                                                                                                          |
| `text.verbosity`                                                     | Nein         | `low`, `medium` oder `high`.                                                                                                                |
| `text.format`                                                        | Nein         | Text oder strukturierte Ausgabe, etwa mit einem unterstützten JSON Schema.                                                                  |
| `stream`                                                             | Nein         | `true` für Server-Sent Events; andernfalls eine vollständige Antwort.                                                                       |
| `tools`, `tool_choice`                                               | Nein         | Tool-Deklarationen und Auswahl. Deine Anwendung führt die clientseitigen Funktionen aus.                                                    |
| `parallel_tool_calls`, `max_tool_calls`                              | Nein         | Parallelität und Aufrufgrenzen für Tools, sofern unterstützt.                                                                               |
| `include`                                                            | Nein         | Zusätzliche Antwortfelder, etwa `reasoning.encrypted_content`.                                                                              |
| `metadata`, `store`                                                  | Nein         | Metadaten und Einstellung zur Speicherung der Antwort.                                                                                      |
| `previous_response_id`                                               | Nein         | ID einer früheren Antwort, solange sie beim ausführenden Anbieter noch verfügbar ist.                                                       |
| `truncation`                                                         | Nein         | Regel zum Kürzen der Eingabe.                                                                                                               |
| `prompt_cache_key`, `prompt_cache_retention`, `prompt_cache_options` | Nein         | Cache-Routing und Aufbewahrung, sofern vom Kanal unterstützt.                                                                               |
| `reasoning.mode`, `reasoning.context`                                | Nein         | Werden an den Anbieter weitergeleitet; es gelten modellspezifische Einschränkungen. Lasse sie weg, sofern dein Workflow sie nicht benötigt. |
| `context_management`, `conversation`, `prompt`                       | Nein         | Native Einstellungen für den Kontext oder gespeicherte Prompts, sofern vom Anbieter unterstützt.                                            |

## Reasoning und Tools [#reasoning-und-tools]

Astra verwendet immer Reasoning: `none` und `minimal` werden nicht unterstützt. Tool-Aufrufe erfordern die Responses API. Lege den Aufwand explizit fest, statt dich auf einen nicht angegebenen Standardwert zu verlassen.

Lasse `temperature`, `top_p` und `top_logprobs` weg, wenn Reasoning aktiviert ist. Lasse bei Chat Completions auch `logprobs` weg; fordere bei Responses in `include` kein `message.output_text.logprobs` an.

Das Ausgabebudget umfasst sowohl Reasoning als auch sichtbaren Text. Die Ausgabegrenze kann erreicht werden, bevor eine vollständige Antwort vorliegt. Ein höherer Aufwand kann mehr Ausgabe-Tokens verbrauchen und länger dauern.

Verwende für strukturierte Ausgaben `text.format` mit `type: "json_schema"`, einem Namen und einem vom Modell unterstützten Schema. Ein Schema legt die Form fest, gewährleistet aber keine sachliche Richtigkeit. Sende bei der Fortsetzung einer Tool-Konversation die Ergebnisse clientseitiger Funktionen mit der ursprünglichen Aufruf-ID zurück.

## Aktueller API-Umfang [#aktueller-api-umfang]

Das Gateway akzeptiert `POST /v1/responses` und `POST /v1/chat/completions`. Die konfigurierten Kanäle bestimmen, welche Modelle verfügbar sind; prüfe vor der Integration das authentifizierte `GET /v1/models`. Fehlende Preise weiter unten belegen nicht, dass ein Modell für Aufrufe bereitsteht.

Die Kompatibilitätsschicht leitet erkannte Felder weiter, nicht beliebiges JSON. Das aktuelle Responses-DTO enthält die nativen Felder `access_programs`, `image` und `background` nicht. Gehe nicht davon aus, dass ein ignoriertes Feld wirksam wurde. Die Kanaleinstellungen können auch `service_tier` und `safety_identifier` herausfiltern.

Diese Integration bietet weder eine Files API noch eine Batch API oder einen Ablauf zum Abfragen von Hintergrundantworten. Verwende synchrone Antworten oder SSE. Integrierte Tools hängen von der Verfügbarkeit beim Anbieter ab und können gesonderte Kosten verursachen; eine Tool-Deklaration bestätigt nicht, dass die vollständige Tool-Sitzung hier verfügbar ist.

## Bildeingabe [#bildeingabe]

Verwende eine öffentlich erreichbare HTTP(S)-URL für ein Bild, das du selbst hostest. Füge das Bild und die Frage in ein Benutzereingabeelement ein:

```json
{"role":"user","content":[
  {"type":"input_image","image_url":"https://example.com/chart.png"},
  {"type":"input_text","text":"What does this chart show?"}
]}
```

Ersetze die Beispiel-URL durch dein eigenes Bild. Diese Integration bietet weder Uploads noch einen Mediendatenspeicher.

## Chat Completions [#chat-completions]

```bash
curl https://api.wanapi.app/v1/chat/completions \
  -H "Authorization: Bearer $WAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "messages": [{"role":"user","content":"Explain what a database index does."}],
    "reasoning_effort": "low",
    "max_completion_tokens": 1024
  }'
```

Lies `choices[0].message.content`. Chat Completions verwendet `messages`, `reasoning_effort` und `max_completion_tokens`; Responses verwendet `input`, `reasoning.effort` und `max_output_tokens`. Verwende für Bildnachrichten in Chat Completions `type: "image_url"` und `image_url: {"url":"https://..."}`.

## Preise [#preise]

USD pro 1 Million Tokens

Die aktuellen Tarife enthalten den Multiplikator der jeweiligen Gruppe. Preise werden bis zu 2 Minuten zwischengespeichert.

Ein API-Schlüssel funktioniert für alle Modelle und Gruppen. Standard kennzeichnet die erste geeignete Gruppe in der automatischen Routing-Reihenfolge. Es gelten die Tarife der tatsächlich gewählten Gruppe.

### GPT Astra 6

`gpt-6-astra`

| Abrechenbare Tokens | gpt · Standard · ≤ 272.000 Eingabe-Tokens | gpt · Standard · > 272.000 Eingabe-Tokens | gpt-0.7 · ≤ 272.000 Eingabe-Tokens | gpt-0.7 · > 272.000 Eingabe-Tokens |
| --- | ---: | ---: | ---: | ---: |
| Eingabe (nicht gecacht) | 1 $ | 2 $ | 7 $ | 14 $ |
| Ausgabe | 5 $ | 7,5 $ | 35 $ | 52,5 $ |
| Cache-Lesezugriff | 0,1 $ | 0,2 $ | 0,7 $ | 1,4 $ |
| Cache-Schreibvorgang | 1,25 $ | 2,5 $ | 8,75 $ | 17,5 $ |

Die Schwelle zählt: Alle Eingabe-Tokens einschließlich gecachter Eingaben. Die gewählte Preisstufe gilt für die gesamte Anfrage, nicht nur für die Tokens oberhalb der Schwelle.

— bedeutet, dass kein verifizierter Preis vorliegt; es bedeutet nicht kostenlos.

Cache-Tarife gelten nur, wenn die Antwort den entsprechenden Cache-Verbrauch ausweist. Zähle gecachte Tokens nicht erneut als nicht gecachte Eingabe.

Multipliziere jede abrechenbare Token-Anzahl mit dem zugehörigen Tarif und teile durch 1.000.000. Reasoning ist in den Ausgabe-Tokens enthalten und wird nicht nochmals berechnet. Gecachte Eingaben dürfen nicht zusätzlich als nicht gecachte Eingaben gezählt werden. Verwende nur den in der Antwort ausgewiesenen Cache-Verbrauch; die Cache-Schreibeinheit in der Tabelle bedeutet nicht, dass jeder Aufbewahrungsmodus unterstützt wird.

Bei längenabhängigen Preisen gilt die zutreffende Preisstufe für die gesamte Anfrage. Beachte den Schwellenwert und die Eingabegrundlage in der Tabelle, statt von einem festen Tarif auszugehen. Anfragen ohne Gruppen-Header verwenden `gpt`. Für Responses oder Chat Completions kannst du die Gruppe mit `X-Model-Group: gpt` oder `X-Model-Group: gpt-0.7` wählen. `gpt-0.7` ist nur für Luna, Sol und Astra verfügbar; Terra unterstützt nur `gpt`. Eine explizite Auswahl wechselt bei Fehlern nicht in eine andere Gruppe. Die Modell-ID bleibt unverändert; Gruppensuffixe werden nicht unterstützt.

## Antworten und Streaming [#antworten-und-streaming]

Ein abgeschlossenes Responses-Ergebnis enthält `id`, `model`, `status`, `output` und `usage`. `output` kann Reasoning, Tool-Aufrufe und Nachrichten enthalten; das erste Element ist nicht zwangsläufig Text. Der Helfer `output_text` des OpenAI SDK sammelt die Textausgabe.

Setze `stream: true` und verwende `curl -N` für SSE. Verarbeite `response.created`, `response.output_text.delta`, `response.completed`, unvollständige Antworten und Fehler. Die abschließende Antwort enthält den Verbrauch. Chat Completions streamt `choices[].delta`; fordere mit `stream_options: {"include_usage":true}` den abschließenden Verbrauchs-Chunk an.

## Verbrauchsprotokolle und Fehler [#verbrauchsprotokolle-und-fehler]

Die [LLM-Protokolle](/de/usage) zeigen abgeschlossene Aufrufe der letzten 7 Tage mit Modell, Eingabe-Tokens, Ausgabe-Tokens und Kosten. Filtere nach `gpt-6-astra`. Für Bilder und Videos gibt es [Aufgabenprotokolle](/de/tasks).

Prüfe bei einem Fehler den HTTP-Status und das `error`-Objekt. Kontrolliere deinen Schlüssel, das [Guthaben](/de/docs/balance), die genaue Modell-ID und die Parameterkombination. Wird eine Anfrage oder ein Stream unterbrochen, prüfe vor einem erneuten Versuch die Protokolle: Eine weitere Anfrage kann weitere Kosten verursachen.

## Modellreferenzen [#modellreferenzen]

* [GPT Astra 6 – offizielle Spezifikation](https://developers.openai.com/api/docs/models/gpt-6-astra)
* [Responses-Referenz](https://developers.openai.com/api/reference/resources/responses/methods/create)
* [GPT-Modelle und Reasoning](https://developers.openai.com/api/docs/guides/latest-model)
