Source: https://ailoot.ai/models/de/grok-4-7/
Canonical: https://ailoot.ai/models/de/grok-4-7/
Language: de
# SpaceXAI: Grok 4.7
[Markdown](https://ailoot.ai/models/de/grok-4-7/index.md) · [JSON](https://ailoot.ai/models/de/grok-4-7/facts.json)
## [SpaceXAI: Grok 4.7](https://ailoot.ai/models/de/grok-4-7/)
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
- [**Ailoot · Anthropic Messages** `POST /v1/messages` `grok-4.7`](https://ailoot.ai/models/de/grok-4-7/#method-0)
- [**Ailoot · OpenAI Responses** `POST /v1/responses` `grok-4.7`](https://ailoot.ai/models/de/grok-4-7/#method-1)
- [**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `grok-4.7`](https://ailoot.ai/models/de/grok-4-7/#method-2)
- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `grok-4.7`](https://ailoot.ai/models/de/grok-4-7/#method-3)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `grok-4.7`](https://ailoot.ai/models/de/grok-4-7/#method-4)
- [**Ailoot · Anthropic Messages** `POST /v1/messages` `grok`](https://ailoot.ai/models/de/grok-4-7/#method-5)
- [**Ailoot · OpenAI Responses** `POST /v1/responses` `grok`](https://ailoot.ai/models/de/grok-4-7/#method-6)
- [**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `grok`](https://ailoot.ai/models/de/grok-4-7/#method-7)
- [**Ailoot · Anthropic Messages** `POST /v1/messages` `grok-4.7-latest`](https://ailoot.ai/models/de/grok-4-7/#method-8)
- [**Ailoot · OpenAI Responses** `POST /v1/responses` `grok-4.7-latest`](https://ailoot.ai/models/de/grok-4-7/#method-9)
- [**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `grok-4.7-latest`](https://ailoot.ai/models/de/grok-4-7/#method-10)
- [**Ailoot · Anthropic Messages** `POST /v1/messages` `grok-latest`](https://ailoot.ai/models/de/grok-4-7/#method-11)
- [**Ailoot · OpenAI Responses** `POST /v1/responses` `grok-latest`](https://ailoot.ai/models/de/grok-4-7/#method-12)
- [**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `grok-latest`](https://ailoot.ai/models/de/grok-4-7/#method-13)
- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `x-ai/grok-4.7`](https://ailoot.ai/models/de/grok-4-7/#method-14)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `x-ai/grok-4.7`](https://ailoot.ai/models/de/grok-4-7/#method-15)
- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `~x-ai/grok-latest`](https://ailoot.ai/models/de/grok-4-7/#method-16)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `~x-ai/grok-latest`](https://ailoot.ai/models/de/grok-4-7/#method-17)
Über das Modell
Diese Beschreibung erläutert die Fähigkeiten des Modells. Die über Ailoot verfügbaren Eingaben, Ausgaben und Optionen sind unten für die ausgewählte Methode aufgeführt.
#### Entwicklung und Wissensarbeit
Grok 4.7 dient Programmierung, Agentenaufgaben und fachlicher Informationsarbeit. xAI legt den Schwerpunkt auf komplexe Aufgaben mit längerer schrittweiser Ausführung, die Prüfung eigener Arbeit und die Verwaltung langen Kontexts.
Das Training verwendete ein größeres Basismodell und eine lange Reinforcement-Learning-Phase mit schwierigen Aufgaben. Praktische Einsatzbereiche umfassen Softwareentwicklung, Dokument- und Präsentationserstellung, Gespräche und Wissensarbeit. Befehlsausführung und Dateierstellung erfolgen über Werkzeuge der Umgebung; das Modell selbst gibt Text zurück.
#### Zentrale Merkmale
- **Eingabe:** Text und Bilder.
- **Ausgabe:** Text, einschließlich Programmcode und strukturierter Daten.
- **Kontext:** 500 000 Tokens.
- **Wissensgrenze:** Mai 2026.
- **Reasoning:** `low`, `medium`, `high` oder `xhigh`; standardmäßig `high`.
Diese Merkmale gelten für Grok 4.7. Zusätzliche Daten und Aktionsergebnisse erhält das Modell aus übermitteltem Kontext und angebundenen Funktionen.
Nach den xAI-Spezifikationen hat Grok 4.7 kein separates Textausgabelimit. Diese Modelleigenschaft verspricht keine unbegrenzte Antwort über die Ailoot API.
#### Reasoning in mehrstufiger Arbeit
`low` behält Überlegungen bei und eignet sich für einfache Aktionen; `medium` dient Datenanalyse und Arbeit mit langen Materialien. `high` weist komplexer Mathematik und Logik mehr Aufwand zu, `xhigh` den schwierigsten Aufgaben. Laut xAI geht eine höhere Tiefe mit höherer Latenz einher. Reasoning lässt sich nicht deaktivieren.
Im Responses-Format gibt Grok 4.7 **verschlüsselten Reasoning-Zustand** zurück. Diese Elemente können unverändert zusammen mit dem Verlauf an den nächsten Gesprächsschritt übermittelt werden, um den Zustand mehrstufiger Arbeit zu erhalten. Sie legen verstecktes Reasoning nicht in lesbarer Form offen. Chat Completions hat kein Feld mit solchen verschlüsselten Inhalten.
Das Modell unterstützt außerdem eine kurze Reasoning-Darstellung, die während der Antwort übermittelt werden kann. Sie unterscheidet sich von verschlüsselten Elementen: Die Zusammenfassung dient dem Lesen, der verschlüsselte Zustand der Prozessfortsetzung.
#### Werkzeuge und Ergebnisformat
Eigene Funktionen verbinden das Modell mit Anwendungsdaten und -aktionen. Das Modell formuliert einen Aufruf mit Argumenten; das Programm führt die Funktion aus und gibt das Ergebnis zurück. Unterstützt werden automatische Auswahl, verpflichtender Aufruf, Werkzeugverbot und die Wahl einer konkreten Funktion; mehrere Aufrufe können in einer Antwort erscheinen.
Für Ergebnisse, die von Code verarbeitet werden, sind JSON und JSON nach einem vorgegebenen Schema vorgesehen. Das Schema legt Feldtypen, verschachtelte Struktur und zulässige Varianten fest. Dieser Modus dient Datenextraktion, Dokumentanalyse und Berichtserstellung und lässt sich mit Aufrufen eigener Funktionen kombinieren.
Der von xAI beschriebene Modus sieht Websuche, Suche in X-Beiträgen und Codeausführung vor; sie lassen sich mit eigenen Funktionen verbinden. Die Verfügbarkeit integrierter Werkzeuge über die Ailoot API hängt von der Unterstützung durch die gewählte Methode ab.
#### Steuerungsgrenzen
`presencePenalty`, `frequencyPenalty` und `stop` werden mit diesem Modell nicht verwendet. JSON-Schema-Unterstützung hat Grenzen: Ein Teil bedingter Konstruktionen und komplexer Einschränkungen bleibt auf Ebene des Modellverhaltens und wird deshalb vom Programm geprüft. Großer Kontext hilft bei umfangreichen Materialien, ersetzt aber kein Werkzeug, das neue Fakten beschafft oder eine Aktion ausführt.
Praktische Aufgabe
### Praktische Aufgabe
Technisches Beispiel auf Englisch
```
Build a decision memo from supplied evidence
Prepare a procurement memo from these records: vendor A delivers in 5 days, costs 900 credits and offers a 12-month warranty; vendor B delivers in 9 days, costs 750 and offers 24 months. The team needs delivery within 7 days and budget below 1,000. Recommend an option, explain trade-offs and list missing evidence.
```
#### Erwartetes Ergebnis
```
A concise decision memo with requirements, recommendation, trade-offs and unanswered questions tied to the records.
```
#### Ergebnis prüfen
```
The recommendation applies both the delivery deadline and budget, while warranty length remains a separate trade-off.
```
**Ailoot · Anthropic Messages** `POST /v1/messages` `grok-4.7`
[`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=messages)
SpaceXAI /`grok-4.7`
Modell-ID
- `grok-4.7`
- `grok`
- `grok-4.7-latest`
- `grok-latest`
### Start
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
Zulässige Eingaben
Text · Bilder
Ergebnisse
Text
### In Ailoot verfügbar · Eingaben und Methoden
**Ailoot · Anthropic Messages** `POST /v1/messages`
Eingabetypen
`text`, `image`
Ausgabetypen
`text`
Kontext
500.000 tokens
Maximale Ausgabe
500.000 tokens
Ausgabeformat
json oder SSE
| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits grok-4.7 | Standard— |
| Feld`messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
| Feld`messages[].role` | Typ`string` | AnforderungErforderlich | Werte und Limits user, assistant | Standard— |
| Feld`messages[].content` | Typ`string\|content_block[]` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`system` | Typ`string\|content_block[]` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`max_tokens` | Typ`integer` | AnforderungErforderlich | Werte und Limits Minimum: 1 Limit gilt für: Genaue Obergrenze des ausgewählten Modells bzw. seiner Modellkarte | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
| Feld`temperature` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`top_p` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`stop_sequences` | Typ`string[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools` | Typ`tool[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools[].name` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: Werkzeug bereitgestellt | Standard— |
| Feld`tools[].description` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tools[].input_schema` | Typ`JSON_schema` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tool_choice` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`thinking.type` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`thinking.budget_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`output_config.effort` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`metadata` | Typ`object` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`cache_control` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Kombinationen von Eingabematerialien
**Text** · UTF8-Text
`messages[].content oder Block mit type=text`
**Text + Bild**
`{type:image,source:{type:base64,media_type,data}} oder Quelle mit type=url`
Methodenparameter und Lebenszyklus
| Parameter | Vertrag |
| --- | --- |
| Parameter`material_types` | Vertragtext, image |
| Parameter`required` | Vertragmodel, messages, max\_tokens |
| Parameter`optional_controls` | Vertragnull |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`text_file_material` | VertragTatsächlicher UTF-8-Inhalt wird als Text eingefügt; Datei-IDs/URLs müssen separat und exakt unterstützt werden |
Lebenszyklus: `exact retained published method`
Methodenstrukturen und IDs sind exakt; die Fähigkeiten des Anbieters sind von der Zulassung einer Anfrage zu unterscheiden.
### Tarife
#### Ailoot-Methodentarife
Eingabe
0,002 $ */ 1K*
Ausgabe
0,006 $ */ 1K*
Cache-Lesen
0,0005 $ */ 1K*
Cache-Schreiben
0,00 $ */ 1K*
Cache-Schreiben, 5 Min.
0,00 $ */ 1K tokens*
Cache-Schreiben, 1 Stunde
0,00 $ */ 1K tokens*
#### Preise nach Anfragelänge · Anthropic Messages
| Anfragegröße in Token | Eingabe | Ausgabe | Cache-Lesen | Cache-Schreiben | Cache 5 Min. | Cache 1 Stunde |
| --- | --- | --- | --- | --- | --- | --- |
| Anfragegröße in Token(0; 200.000\] | Eingabe0,002 $ | Ausgabe0,006 $ | Cache-Lesen0,0005 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
| Anfragegröße in Token(200.000; ∞) | Eingabe0,004 $ | Ausgabe0,012 $ | Cache-Lesen0,001 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
Tarife in USD pro 1K Token. Ist kein Tarif festgelegt, wird der Grundtarif dieser Methode übernommen; «—» bedeutet, dass kein Grundtarif festgelegt ist.
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)
#### Details zum Referenztarif
Referenztarifstaffeln auf Modellebene ändern weder Methodenauswahl noch Kostenvoranschläge oder Gebühren. Für die aktive Abrechnung gelten die Tarife der ausgewählten Ailoot-Methode.
Referenztarifstaffeln des Modells
#### Preise nach Konfiguration
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationOpenAI Chat · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
### Beispielanfragen
#### Ailoot · Anthropic Messages
TextbeispielEingabe, BildPython SDKNode.js SDKPython-Stream
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-4.7", "max_tokens": 1024, "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-4.7", "max_tokens": 1024, "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image","source":{"type":"base64","media_type":mime,"data":b64}})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```python
import anthropic
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
msg = client.messages.create(
model="grok-4.7",
max_tokens=1024,
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}],
)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(msg.to_dict(mode="json"))
```
```js
import Anthropic from "@anthropic-ai/sdk";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const msg = await client.messages.create({
model: "grok-4.7",
max_tokens: 1024,
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(msg);
```
```python
import anthropic,os
from pathlib import Path
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=anthropic.Anthropic(base_url="https://api.ailoot.ai",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
with client.messages.stream(model='grok-4.7',max_tokens=1024,messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
for event in stream:
payload=event.to_dict(mode="json")
log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
print(json.dumps(payload,ensure_ascii=False))
final=stream.get_final_message()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Ergebnisse abrufen und speichern
#### Ailoot · Anthropic Messages
json oder SSE
##### Alle fertiggestellten Ergebnisse aufbewahren
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Inhaltsblöcke, Thinking-Signaturen und tatsächlichen Werkzeugaufruf-IDs beibehalten. Alle SSE-Blockdeltas zusammensetzen; der erste Textblock ist nicht die vollständige Ausgabe.
##### Wenn die ursprüngliche Antwort geprüft werden muss
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
Antwortfelder
| Feld | Typ |
| --- | --- |
| Feld`id` | Typstring |
| Feld`model` | Typstring |
| Feld`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Feld`stop_reason` | Typstring\|null |
| Feld`usage` | Typobject |
Fehler und nächste Schritte
| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
### Aliasnamen
#### Modellaliasnamen
Ailoot [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=messages), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=messages), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=messages), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=messages)
**Ailoot Ultra** [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=messages), [`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=messages), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=messages)
#### Aliasnamen für Methodenpfade
`/chat/completions`
#### Zugehörige Aufrufer-IDs
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=messages), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=messages), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=messages), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=messages), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=messages), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=messages), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=messages)
**Ailoot · OpenAI Responses** `POST /v1/responses` `grok-4.7`
[`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=responses)
SpaceXAI /`grok-4.7`
Modell-ID
- `grok-4.7`
- `grok`
- `grok-4.7-latest`
- `grok-latest`
### Start
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
Zulässige Eingaben
Text · Bilder
Ergebnisse
Text
### In Ailoot verfügbar · Eingaben und Methoden
**Ailoot · OpenAI Responses** `POST /v1/responses`
Eingabetypen
`text`, `image`
Ausgabetypen
`text`
Kontext
500.000 tokens
Maximale Ausgabe
500.000 tokens
Ausgabeformat
json oder SSE
| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits grok-4.7 | Standard— |
| Feld`input` | Typ`string\|input_item[]` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`instructions` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`input[].type` | Typ`string` | AnforderungOptional | Werte und Limits message, reasoning, function\_call, function\_call\_output | Standard— |
| Feld`input[].content` | Typ`string\|content_part[]` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`input[].call_id` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: function\_call\_output; den tatsächlich zurückgegebenen Wert von call\_id beibehalten | Standard— |
| Feld`input[].output` | Typ`string\|content_part[]` | AnforderungOptional | Werte und Limits Gilt, wenn: function\_call\_output | Standard— |
| Feld`max_output_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
| Feld`temperature` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`top_p` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools` | Typ`tool[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tool_choice` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`parallel_tool_calls` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning.effort` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning.summary` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`text.format` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`text.verbosity` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`include` | Typ`string[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`store` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`previous_response_id` | Typ`string` | AnforderungOptional | Werte und Limits ID-Anforderung: Nur eine tatsächliche Antwort-ID aus einer unterstützten Fortsetzung Modellabhängig | Standard— |
| Feld`service_tier` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`prompt_cache_key` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`prompt_cache_options` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Kombinationen von Eingabematerialien
**Text** · UTF8-Text
`Eingabetext oder input_text-Teil`
**Text + Bild**
`{type:input_image,image_url}`
Methodenparameter und Lebenszyklus
| Parameter | Vertrag |
| --- | --- |
| Parameter`material_types` | Vertragtext, image |
| Parameter`required` | Vertragmodel, input |
| Parameter`optional_controls` | Vertragnull |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`text_file_material` | VertragTatsächlicher UTF-8-Inhalt wird als Text eingefügt; Datei-IDs/URLs müssen separat und exakt unterstützt werden |
Lebenszyklus: `exact retained published method`
Methodenstrukturen und IDs sind exakt; die Fähigkeiten des Anbieters sind von der Zulassung einer Anfrage zu unterscheiden.
### Tarife
#### Ailoot-Methodentarife
Eingabe
0,002 $ */ 1K*
Ausgabe
0,006 $ */ 1K*
Cache-Lesen
0,0005 $ */ 1K*
Cache-Schreiben
0,00 $ */ 1K*
Cache-Schreiben, 5 Min.
0,00 $ */ 1K tokens*
Cache-Schreiben, 1 Stunde
0,00 $ */ 1K tokens*
#### Preise nach Anfragelänge · OpenAI Responses
| Anfragegröße in Token | Eingabe | Ausgabe | Cache-Lesen | Cache-Schreiben | Cache 5 Min. | Cache 1 Stunde |
| --- | --- | --- | --- | --- | --- | --- |
| Anfragegröße in Token(0; 200.000\] | Eingabe0,002 $ | Ausgabe0,006 $ | Cache-Lesen0,0005 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
| Anfragegröße in Token(200.000; ∞) | Eingabe0,004 $ | Ausgabe0,012 $ | Cache-Lesen0,001 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
Tarife in USD pro 1K Token. Ist kein Tarif festgelegt, wird der Grundtarif dieser Methode übernommen; «—» bedeutet, dass kein Grundtarif festgelegt ist.
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)
#### Details zum Referenztarif
Referenztarifstaffeln auf Modellebene ändern weder Methodenauswahl noch Kostenvoranschläge oder Gebühren. Für die aktive Abrechnung gelten die Tarife der ausgewählten Ailoot-Methode.
Referenztarifstaffeln des Modells
#### Preise nach Konfiguration
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationOpenAI Chat · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
### Beispielanfragen
#### Ailoot · OpenAI Responses
TextbeispielEingabe, BildPython SDKNode.js SDKPython-Stream
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-4.7", "input": ""}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["input"]="Summarize this material and quote supporting source passages.\n\n"+text
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/responses \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-4.7", "input": [{"role": "user", "content": [{"type": "input_text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["input"][0]["content"].append({"type":"input_image","image_url":"data:"+mime+";base64,"+b64})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/responses \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```
```python
from openai import OpenAI
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = OpenAI(base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
resp = client.responses.create(model="grok-4.7", input="Explain the difference between an observation and a hypothesis in three sentences.")
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.responses.create({ model: "grok-4.7", input: "Explain the difference between an observation and a hypothesis in three sentences." });
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```python
from openai import OpenAI
import os
from pathlib import Path
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
with client.responses.stream(model="grok-4.7", input="Explain the difference between an observation and a hypothesis in three sentences.") as stream:
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
for event in stream:
payload=event.to_dict(mode="json")
log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
print(json.dumps(payload,ensure_ascii=False))
final=stream.get_final_response()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Ergebnisse abrufen und speichern
#### Ailoot · OpenAI Responses
json oder SSE
##### Alle fertiggestellten Ergebnisse aufbewahren
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Ausgabeelemente und Inhaltsteile, die tatsächliche call\_id der Funktion, verschlüsselte Reasoning-Daten und Verbrauchsdaten beibehalten. Beim Streaming die vollständige Identität von Ereignis und Element bewahren.
##### Wenn die ursprüngliche Antwort geprüft werden muss
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
Antwortfelder
| Feld | Typ |
| --- | --- |
| Feld`id` | Typstring |
| Feld`status` | Typstring |
| Feld`output[]` | Typmessage\|reasoning\|function\_call\|other item |
| Feld`output[].content[]` | Typcontent part |
| Feld`usage` | Typobject |
Fehler und nächste Schritte
| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
### Aliasnamen
#### Modellaliasnamen
Ailoot [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=responses), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=responses), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=responses), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=responses)
**Ailoot Ultra** [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7), [`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest)
#### Aliasnamen für Methodenpfade
`/chat/completions`
#### Zugehörige Aufrufer-IDs
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=responses), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=responses), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=responses), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=responses), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7)
**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `grok-4.7`
[`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=chat)
SpaceXAI /`grok-4.7`
Modell-ID
- `grok-4.7`
- `grok`
- `grok-4.7-latest`
- `grok-latest`
### Start
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
Zulässige Eingaben
Text · Bilder
Ergebnisse
Text
### In Ailoot verfügbar · Eingaben und Methoden
**Ailoot · OpenAI Chat** `POST /v1/chat/completions`
Eingabetypen
`text`, `image`
Ausgabetypen
`text`
Kontext
500.000 tokens
Maximale Ausgabe
500.000 tokens
Ausgabeformat
json oder SSE
| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits grok-4.7 | Standard— |
| Feld`messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
| Feld`messages[].role` | Typ`string` | AnforderungErforderlich | Werte und Limits Beispiele: system, user, assistant, tool, function Bedingungen: Diese Rollen sind in den Kompatibilitätstypen des Quellcodes ausdrücklich dargestellt; der genaue Rollenumfang bleibt modellspezifisch. Modellabhängig | Standard— |
| Feld`messages[].content` | Typ`string\|content_part[]\|null` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].tool_calls` | Typ`tool_call[]` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].tool_call_id` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: role=tool; die tatsächlich zurückgegebene ID verwenden | Standard— |
| Feld`messages[].name` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].reasoning_content` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: Tatsächlich zurückgegebene Reasoning-Daten erneut übermitteln, sofern dieses Modell sie verwendet | Standard— |
| Feld`messages[].reasoning_details` | Typ`object\|array` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`max_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`max_completion_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
| Feld`stream_options.include_usage` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`temperature` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`top_p` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`stop` | Typ`string\|string[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools` | Typ`function_tool[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools[].type` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools[].function.name` | Typ`string` | AnforderungErforderlich | Werte und Limits Gilt, wenn: Funktionswerkzeug bereitgestellt | Standard— |
| Feld`tools[].function.description` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tools[].function.parameters` | Typ`JSON_schema` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tool_choice` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`parallel_tool_calls` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`response_format` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning_effort` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`service_tier` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`instructions` | Typ`string` | AnforderungOptional | Werte und Limits Kompatibilitätsfeld | Standard— |
| Feld`functions` | Typ`function[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`function_call` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`prompt_cache_options` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Kombinationen von Eingabematerialien
**Text** · UTF8-Text
`messages[].content`
**Text + Bild**
`{type:image_url,image_url:{url,detail}}`
Methodenparameter und Lebenszyklus
| Parameter | Vertrag |
| --- | --- |
| Parameter`material_types` | Vertragtext, image |
| Parameter`required` | Vertragmodel, messages |
| Parameter`optional_controls` | Vertragnull |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`text_file_material` | VertragTatsächlicher UTF-8-Inhalt wird als Text eingefügt; Datei-IDs/URLs müssen separat und exakt unterstützt werden |
Lebenszyklus: `exact retained published method`
Methodenstrukturen und IDs sind exakt; die Fähigkeiten des Anbieters sind von der Zulassung einer Anfrage zu unterscheiden.
### Tarife
#### Ailoot-Methodentarife
Eingabe
0,002 $ */ 1K*
Ausgabe
0,006 $ */ 1K*
Cache-Lesen
0,0005 $ */ 1K*
Cache-Schreiben
0,00 $ */ 1K*
Cache-Schreiben, 5 Min.
0,00 $ */ 1K tokens*
Cache-Schreiben, 1 Stunde
0,00 $ */ 1K tokens*
#### Preise nach Anfragelänge · OpenAI Chat
| Anfragegröße in Token | Eingabe | Ausgabe | Cache-Lesen | Cache-Schreiben | Cache 5 Min. | Cache 1 Stunde |
| --- | --- | --- | --- | --- | --- | --- |
| Anfragegröße in Token(0; 200.000\] | Eingabe0,002 $ | Ausgabe0,006 $ | Cache-Lesen0,0005 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
| Anfragegröße in Token(200.000; ∞) | Eingabe0,004 $ | Ausgabe0,012 $ | Cache-Lesen0,001 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
Tarife in USD pro 1K Token. Ist kein Tarif festgelegt, wird der Grundtarif dieser Methode übernommen; «—» bedeutet, dass kein Grundtarif festgelegt ist.
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)
#### Details zum Referenztarif
Referenztarifstaffeln auf Modellebene ändern weder Methodenauswahl noch Kostenvoranschläge oder Gebühren. Für die aktive Abrechnung gelten die Tarife der ausgewählten Ailoot-Methode.
Referenztarifstaffeln des Modells
#### Preise nach Konfiguration
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationOpenAI Chat · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
### Beispielanfragen
#### Ailoot · OpenAI Chat
TextbeispielEingabe, BildPython SDKNode.js SDKPython-Stream
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-4.7", "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-4.7", "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image_url","image_url":{"url":"data:"+mime+";base64,"+b64}})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```python
from openai import OpenAI
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = OpenAI(base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
resp = client.chat.completions.create(
model="grok-4.7",
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}],
)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.chat.completions.create({
model: "grok-4.7",
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```python
from openai import OpenAI
import os
from pathlib import Path
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
with client.chat.completions.stream(model='grok-4.7',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
for event in stream:
payload=event.to_dict(mode="json")
log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
print(json.dumps(payload,ensure_ascii=False))
final=stream.get_final_completion()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Ergebnisse abrufen und speichern
#### Ailoot · OpenAI Chat
json oder SSE
##### Alle fertiggestellten Ergebnisse aufbewahren
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Antwortvarianten mit ihren Inhalten, Werkzeugaufrufen und Reasoning-Daten beibehalten. In SSE die Deltas nach Varianten- und Werkzeugindex zusammensetzen; endgültigen Beendigungsgrund und Verbrauchsdaten beibehalten.
##### Wenn die ursprüngliche Antwort geprüft werden muss
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
Antwortfelder
| Feld | Typ |
| --- | --- |
| Feld`choices[].index` | Typinteger |
| Feld`choices[].message.content` | Typstring\|null |
| Feld`choices[].message.tool_calls` | Typtool\_call\[\] |
| Feld`choices[].message.reasoning_content` | Typstring |
| Feld`choices[].message.reasoning_details` | Typobject\|array |
| Feld`choices[].finish_reason` | Typstring\|null |
| Feld`usage` | Typobject |
Fehler und nächste Schritte
| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
### Aliasnamen
#### Modellaliasnamen
Ailoot [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=chat), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=chat), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=chat), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=chat)
**Ailoot Ultra** [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=chat), [`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=chat), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=chat)
#### Aliasnamen für Methodenpfade
`/chat/completions`
#### Zugehörige Aufrufer-IDs
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=chat), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=chat), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=chat), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=chat), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=chat), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=chat), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=chat)
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `grok-4.7`
[`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=chat)
SpaceXAI /`grok-4.7`
Modell-ID
- `grok-4.7`
- `x-ai/grok-4.7`
- `~x-ai/grok-latest`
### Start
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
Zulässige Eingaben
Text
Ergebnisse
Text
### In Ailoot verfügbar · Eingaben und Methoden
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions`
Eingabetypen
`text`
Ausgabetypen
`text`
Ausgabeformat
json oder SSE
| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits grok-4.7 | Standard— |
| Feld`messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
| Feld`messages[].role` | Typ`string` | AnforderungErforderlich | Werte und Limits Modellabhängig | Standard— |
| Feld`messages[].content` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: Textgespräch | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
Kombinationen von Eingabematerialien
**Text** · UTF8-Text
`messages[].content`
Methodenparameter und Lebenszyklus
| Parameter | Vertrag |
| --- | --- |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`required` | Vertragmodel, messages |
| Parameter`material_types` | Vertragtext |
| Parameter`messages` | VertragNachrichtenarray mit role/content-Struktur |
| Parameter`file_material` | VertragTatsächliches UTF-8-Dokument als wörtlicher Text eingefügt; keine Datei-ID abgeleitet |
| Parameter`optional_controls` | Vertragstream |
| Parameter`control_scope` | VertragTextgespräch; stream ist ein boolescher Wert und standardmäßig false. |
| Parameter`output_modalities` | Vertragtext |
| Parameter`hosted_operations` | Vertragfalse |
| Parameter`multimodal_input_binding` | Vertragnull |
Methodenaliasnamen: `/chat/completions`
Lebenszyklus: `synchronous_or_streamed`
Die genaue Modell-ID zusammen mit messages senden.
Die Kontextlänge ist keine Ausgabeobergrenze.
Eine Textdatei kann wörtlichen Text liefern; Bild-, Audio- und Dateiobjekteingaben benötigen eine exakte Zuordnung.
### Tarife
Tarifangaben erweitern die Anfrageoptionen nicht. Unterstützte Parameter stehen bei der ausgewählten Methode.
Schnellmodus
Standardtarif Wenn der Schnellmodus ausgewählt ist
Flex-Modus
Standardtarif Wenn der Modus flex ausgewählt ist
Maximaler Denkaufwand
Standardtarif Wenn beim maximalen Denkaufwand die Standardanpassung (default) verwendet wird
Denkaufwand · hoch
Standardtarif Wenn der Denkaufwand hoch ist
Denkaufwand · niedrig
Standardtarif Wenn der Denkaufwand niedrig ist
Denkaufwand · mittel
Standardtarif Wenn der Denkaufwand mittel ist
Denkaufwand · xhigh
Standardtarif Wenn der Denkaufwand xhigh ist
#### Ailoot-Tarife
#### Preise nach Konfiguration
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationBasistarife für Token | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnfragelängenstufe 1 | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnfragelängenstufe 2 | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)
### Beispielanfragen
#### Ailoot Ultra · OpenAI Chat
curlPython SDK
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model":"grok-4.7","messages":[{"role":"user","content":"hello"}],"stream":false}')
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
r=json.loads(Path("result.json").read_text())
for x in r.get("choices",[]):
if x.get("message",{}).get("content"): print(x["message"]["content"])
PY_RESULT
```
```python
from openai import OpenAI
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.chat.completions.create(model="grok-4.7", messages=[{"role":"user","content":"hello"}], stream=False)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(result.to_dict(mode="json"))
```
### Ergebnisse abrufen und speichern
#### Ailoot Ultra · OpenAI Chat
json oder SSE
##### Alle fertiggestellten Ergebnisse aufbewahren
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Antwortvarianten mit ihren Inhalten, Werkzeugaufrufen und Reasoning-Daten beibehalten. In SSE die Deltas nach Varianten- und Werkzeugindex zusammensetzen; endgültigen Beendigungsgrund und Verbrauchsdaten beibehalten.
##### Wenn die ursprüngliche Antwort geprüft werden muss
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
Antwortfelder
| Feld | Typ |
| --- | --- |
| Feld`choices[].index` | Typinteger |
| Feld`choices[].message.content` | Typstring\|null |
| Feld`choices[].message.tool_calls` | Typtool\_call\[\] |
| Feld`choices[].message.reasoning_content` | Typstring |
| Feld`choices[].message.reasoning_details` | Typobject\|array |
| Feld`choices[].finish_reason` | Typstring\|null |
| Feld`usage` | Typobject |
Fehler und nächste Schritte
| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
### Aliasnamen
#### Modellaliasnamen
Ailoot [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=chat), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=chat), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=chat), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=chat)
**Ailoot Ultra** [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=chat), [`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=chat), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=chat)
#### Aliasnamen für Methodenpfade
`/chat/completions`
#### Zugehörige Aufrufer-IDs
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=chat), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=chat), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=chat), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=chat), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=chat), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=chat), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=chat)
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `grok-4.7`
[`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=messages)
SpaceXAI /`grok-4.7`
Modell-ID
- `grok-4.7`
- `x-ai/grok-4.7`
- `~x-ai/grok-latest`
### Start
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
Zulässige Eingaben
Text
Ergebnisse
json · sse
### In Ailoot verfügbar · Eingaben und Methoden
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages`
Eingabetypen
`text`
Ausgabetypen
`json`, `sse`
Ausgabeformat
JSON oder SSE
| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits grok-4.7 | Standard— |
| Feld`messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`messages[].role` | Typ`string` | AnforderungErforderlich | Werte und Limits user, assistant | Standard— |
| Feld`messages[].content` | Typ`string` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`max_tokens` | Typ`integer` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
Kombinationen von Eingabematerialien
**Text** · UTF-8-Text
`Zeichenfolge messages[].content`
Methodenparameter und Lebenszyklus
| Parameter | Vertrag |
| --- | --- |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`required` | Vertragmodel, messages, max\_tokens |
| Parameter`optional_controls` | Vertragstream |
| Parameter`material_types` | Vertragtext |
| Parameter`text_file_material` | VertragDas tatsächliche UTF-8-Dokument lesen und seinen Text in die angegebene Zeichenfolge für Eingabe oder Nachrichteninhalt einfügen. |
Lebenszyklus: `synchronous_or_streamed`
### Tarife
Tarifangaben erweitern die Anfrageoptionen nicht. Unterstützte Parameter stehen bei der ausgewählten Methode.
Schnellmodus
Standardtarif Wenn der Schnellmodus ausgewählt ist
Flex-Modus
Standardtarif Wenn der Modus flex ausgewählt ist
Maximaler Denkaufwand
Standardtarif Wenn beim maximalen Denkaufwand die Standardanpassung (default) verwendet wird
Denkaufwand · hoch
Standardtarif Wenn der Denkaufwand hoch ist
Denkaufwand · niedrig
Standardtarif Wenn der Denkaufwand niedrig ist
Denkaufwand · mittel
Standardtarif Wenn der Denkaufwand mittel ist
Denkaufwand · xhigh
Standardtarif Wenn der Denkaufwand xhigh ist
#### Ailoot-Tarife
#### Preise nach Konfiguration
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationBasistarife für Token | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnfragelängenstufe 1 | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnfragelängenstufe 2 | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)
### Beispielanfragen
#### Ailoot Ultra · Anthropic Messages
Vollständiger minimaler JSON-Bodycurl · eigenes UTF-8-Dokument verwendenPython · das vollständige Ergebnis speichern
```json
{
"model": "grok-4.7",
"max_tokens": 128,
"messages": [
{
"role": "user",
"content": "Summarize the incident report."
}
],
"stream": false
}
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json, os
from pathlib import Path
source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
raise SystemExit('Choose a document containing text')
payload = {'model': 'grok-4.7', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
Path('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
PY_RESULT
```
```python
import json, os
from pathlib import Path
source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
raise SystemExit('Choose a document containing text')
payload = {'model': 'grok-4.7', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
from urllib.request import Request, urlopen
from urllib.error import HTTPError
api_key = os.environ['AILOOT_API_KEY']
if not api_key.strip():
raise SystemExit('Set AILOOT_API_KEY before making a request')
headers = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}
headers['x-api-key'] = api_key
request = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')
try:
with urlopen(request, timeout=120) as response:
raw = response.read()
Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')
except HTTPError as error:
Path('result.json').write_bytes(error.read())
Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')
raise
Path('result.json').write_bytes(raw)
import json
from pathlib import Path
result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
```
### Ergebnisse abrufen und speichern
#### Ailoot Ultra · Anthropic Messages
JSON oder SSE
##### Alle fertiggestellten Ergebnisse aufbewahren
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Inhaltsblöcke, Thinking-Signaturen und tatsächlichen Werkzeugaufruf-IDs beibehalten. Alle SSE-Blockdeltas zusammensetzen; der erste Textblock ist nicht die vollständige Ausgabe.
##### Wenn die ursprüngliche Antwort geprüft werden muss
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
Antwortfelder
| Feld | Typ |
| --- | --- |
| Feld`id` | Typstring |
| Feld`model` | Typstring |
| Feld`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Feld`stop_reason` | Typstring\|null |
| Feld`usage` | Typobject |
Fehler und nächste Schritte
| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
### Aliasnamen
#### Modellaliasnamen
Ailoot [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=messages), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=messages), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=messages), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=messages)
**Ailoot Ultra** [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=messages), [`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=messages), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=messages)
#### Aliasnamen für Methodenpfade
`/chat/completions`
#### Zugehörige Aufrufer-IDs
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=messages), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=messages), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=messages), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=messages), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=messages), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=messages), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=messages)
**Ailoot · Anthropic Messages** `POST /v1/messages` `grok`
[`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=messages)
SpaceXAI /`grok`
Modell-ID
- `grok-4.7`
- `grok`
- `grok-4.7-latest`
- `grok-latest`
### Start
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
Zulässige Eingaben
Text · Bilder
Ergebnisse
Text
### In Ailoot verfügbar · Eingaben und Methoden
**Ailoot · Anthropic Messages** `POST /v1/messages`
Eingabetypen
`text`, `image`
Ausgabetypen
`text`
Kontext
500.000 tokens
Maximale Ausgabe
500.000 tokens
Ausgabeformat
json oder SSE
| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits grok | Standard— |
| Feld`messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
| Feld`messages[].role` | Typ`string` | AnforderungErforderlich | Werte und Limits user, assistant | Standard— |
| Feld`messages[].content` | Typ`string\|content_block[]` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`system` | Typ`string\|content_block[]` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`max_tokens` | Typ`integer` | AnforderungErforderlich | Werte und Limits Minimum: 1 Limit gilt für: Genaue Obergrenze des ausgewählten Modells bzw. seiner Modellkarte | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
| Feld`temperature` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`top_p` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`stop_sequences` | Typ`string[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools` | Typ`tool[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools[].name` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: Werkzeug bereitgestellt | Standard— |
| Feld`tools[].description` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tools[].input_schema` | Typ`JSON_schema` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tool_choice` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`thinking.type` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`thinking.budget_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`output_config.effort` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`metadata` | Typ`object` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`cache_control` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Kombinationen von Eingabematerialien
**Text** · UTF8-Text
`messages[].content oder Block mit type=text`
**Text + Bild**
`{type:image,source:{type:base64,media_type,data}} oder Quelle mit type=url`
Methodenparameter und Lebenszyklus
| Parameter | Vertrag |
| --- | --- |
| Parameter`material_types` | Vertragtext, image |
| Parameter`required` | Vertragmodel, messages, max\_tokens |
| Parameter`optional_controls` | Vertragnull |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`text_file_material` | VertragTatsächlicher UTF-8-Inhalt wird als Text eingefügt; Datei-IDs/URLs müssen separat und exakt unterstützt werden |
Lebenszyklus: `exact retained published method`
Methodenstrukturen und IDs sind exakt; die Fähigkeiten des Anbieters sind von der Zulassung einer Anfrage zu unterscheiden.
### Tarife
#### Ailoot-Methodentarife
Eingabe
0,002 $ */ 1K*
Ausgabe
0,006 $ */ 1K*
Cache-Lesen
0,0005 $ */ 1K*
Cache-Schreiben
0,00 $ */ 1K*
Cache-Schreiben, 5 Min.
0,00 $ */ 1K tokens*
Cache-Schreiben, 1 Stunde
0,00 $ */ 1K tokens*
#### Preise nach Anfragelänge · Anthropic Messages
| Anfragegröße in Token | Eingabe | Ausgabe | Cache-Lesen | Cache-Schreiben | Cache 5 Min. | Cache 1 Stunde |
| --- | --- | --- | --- | --- | --- | --- |
| Anfragegröße in Token(0; 200.000\] | Eingabe0,002 $ | Ausgabe0,006 $ | Cache-Lesen0,0005 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
| Anfragegröße in Token(200.000; ∞) | Eingabe0,004 $ | Ausgabe0,012 $ | Cache-Lesen0,001 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
Tarife in USD pro 1K Token. Ist kein Tarif festgelegt, wird der Grundtarif dieser Methode übernommen; «—» bedeutet, dass kein Grundtarif festgelegt ist.
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)
#### Details zum Referenztarif
Referenztarifstaffeln auf Modellebene ändern weder Methodenauswahl noch Kostenvoranschläge oder Gebühren. Für die aktive Abrechnung gelten die Tarife der ausgewählten Ailoot-Methode.
Referenztarifstaffeln des Modells
#### Preise nach Konfiguration
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationOpenAI Chat · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
### Beispielanfragen
#### Ailoot · Anthropic Messages
TextbeispielEingabe, BildPython SDKNode.js SDKPython-Stream
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok", "max_tokens": 1024, "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok", "max_tokens": 1024, "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image","source":{"type":"base64","media_type":mime,"data":b64}})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```python
import anthropic
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
msg = client.messages.create(
model="grok",
max_tokens=1024,
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}],
)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(msg.to_dict(mode="json"))
```
```js
import Anthropic from "@anthropic-ai/sdk";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const msg = await client.messages.create({
model: "grok",
max_tokens: 1024,
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(msg);
```
```python
import anthropic,os
from pathlib import Path
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=anthropic.Anthropic(base_url="https://api.ailoot.ai",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
with client.messages.stream(model='grok',max_tokens=1024,messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
for event in stream:
payload=event.to_dict(mode="json")
log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
print(json.dumps(payload,ensure_ascii=False))
final=stream.get_final_message()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Ergebnisse abrufen und speichern
#### Ailoot · Anthropic Messages
json oder SSE
##### Alle fertiggestellten Ergebnisse aufbewahren
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Inhaltsblöcke, Thinking-Signaturen und tatsächlichen Werkzeugaufruf-IDs beibehalten. Alle SSE-Blockdeltas zusammensetzen; der erste Textblock ist nicht die vollständige Ausgabe.
##### Wenn die ursprüngliche Antwort geprüft werden muss
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
Antwortfelder
| Feld | Typ |
| --- | --- |
| Feld`id` | Typstring |
| Feld`model` | Typstring |
| Feld`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Feld`stop_reason` | Typstring\|null |
| Feld`usage` | Typobject |
Fehler und nächste Schritte
| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
### Aliasnamen
#### Modellaliasnamen
Ailoot [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=messages), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=messages), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=messages), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=messages)
**Ailoot Ultra** [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=messages), [`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=messages), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=messages)
#### Aliasnamen für Methodenpfade
`/chat/completions`
#### Zugehörige Aufrufer-IDs
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=messages), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=messages), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=messages), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=messages), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=messages), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=messages), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=messages)
**Ailoot · OpenAI Responses** `POST /v1/responses` `grok`
[`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=responses)
SpaceXAI /`grok`
Modell-ID
- `grok-4.7`
- `grok`
- `grok-4.7-latest`
- `grok-latest`
### Start
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
Zulässige Eingaben
Text · Bilder
Ergebnisse
Text
### In Ailoot verfügbar · Eingaben und Methoden
**Ailoot · OpenAI Responses** `POST /v1/responses`
Eingabetypen
`text`, `image`
Ausgabetypen
`text`
Kontext
500.000 tokens
Maximale Ausgabe
500.000 tokens
Ausgabeformat
json oder SSE
| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits grok | Standard— |
| Feld`input` | Typ`string\|input_item[]` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`instructions` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`input[].type` | Typ`string` | AnforderungOptional | Werte und Limits message, reasoning, function\_call, function\_call\_output | Standard— |
| Feld`input[].content` | Typ`string\|content_part[]` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`input[].call_id` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: function\_call\_output; den tatsächlich zurückgegebenen Wert von call\_id beibehalten | Standard— |
| Feld`input[].output` | Typ`string\|content_part[]` | AnforderungOptional | Werte und Limits Gilt, wenn: function\_call\_output | Standard— |
| Feld`max_output_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
| Feld`temperature` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`top_p` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools` | Typ`tool[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tool_choice` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`parallel_tool_calls` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning.effort` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning.summary` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`text.format` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`text.verbosity` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`include` | Typ`string[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`store` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`previous_response_id` | Typ`string` | AnforderungOptional | Werte und Limits ID-Anforderung: Nur eine tatsächliche Antwort-ID aus einer unterstützten Fortsetzung Modellabhängig | Standard— |
| Feld`service_tier` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`prompt_cache_key` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`prompt_cache_options` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Kombinationen von Eingabematerialien
**Text** · UTF8-Text
`Eingabetext oder input_text-Teil`
**Text + Bild**
`{type:input_image,image_url}`
Methodenparameter und Lebenszyklus
| Parameter | Vertrag |
| --- | --- |
| Parameter`material_types` | Vertragtext, image |
| Parameter`required` | Vertragmodel, input |
| Parameter`optional_controls` | Vertragnull |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`text_file_material` | VertragTatsächlicher UTF-8-Inhalt wird als Text eingefügt; Datei-IDs/URLs müssen separat und exakt unterstützt werden |
Lebenszyklus: `exact retained published method`
Methodenstrukturen und IDs sind exakt; die Fähigkeiten des Anbieters sind von der Zulassung einer Anfrage zu unterscheiden.
### Tarife
#### Ailoot-Methodentarife
Eingabe
0,002 $ */ 1K*
Ausgabe
0,006 $ */ 1K*
Cache-Lesen
0,0005 $ */ 1K*
Cache-Schreiben
0,00 $ */ 1K*
Cache-Schreiben, 5 Min.
0,00 $ */ 1K tokens*
Cache-Schreiben, 1 Stunde
0,00 $ */ 1K tokens*
#### Preise nach Anfragelänge · OpenAI Responses
| Anfragegröße in Token | Eingabe | Ausgabe | Cache-Lesen | Cache-Schreiben | Cache 5 Min. | Cache 1 Stunde |
| --- | --- | --- | --- | --- | --- | --- |
| Anfragegröße in Token(0; 200.000\] | Eingabe0,002 $ | Ausgabe0,006 $ | Cache-Lesen0,0005 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
| Anfragegröße in Token(200.000; ∞) | Eingabe0,004 $ | Ausgabe0,012 $ | Cache-Lesen0,001 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
Tarife in USD pro 1K Token. Ist kein Tarif festgelegt, wird der Grundtarif dieser Methode übernommen; «—» bedeutet, dass kein Grundtarif festgelegt ist.
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)
#### Details zum Referenztarif
Referenztarifstaffeln auf Modellebene ändern weder Methodenauswahl noch Kostenvoranschläge oder Gebühren. Für die aktive Abrechnung gelten die Tarife der ausgewählten Ailoot-Methode.
Referenztarifstaffeln des Modells
#### Preise nach Konfiguration
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationOpenAI Chat · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
### Beispielanfragen
#### Ailoot · OpenAI Responses
TextbeispielEingabe, BildPython SDKNode.js SDKPython-Stream
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok", "input": ""}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["input"]="Summarize this material and quote supporting source passages.\n\n"+text
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/responses \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok", "input": [{"role": "user", "content": [{"type": "input_text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["input"][0]["content"].append({"type":"input_image","image_url":"data:"+mime+";base64,"+b64})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/responses \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```
```python
from openai import OpenAI
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = OpenAI(base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
resp = client.responses.create(model="grok", input="Explain the difference between an observation and a hypothesis in three sentences.")
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.responses.create({ model: "grok", input: "Explain the difference between an observation and a hypothesis in three sentences." });
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```python
from openai import OpenAI
import os
from pathlib import Path
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
with client.responses.stream(model="grok", input="Explain the difference between an observation and a hypothesis in three sentences.") as stream:
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
for event in stream:
payload=event.to_dict(mode="json")
log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
print(json.dumps(payload,ensure_ascii=False))
final=stream.get_final_response()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Ergebnisse abrufen und speichern
#### Ailoot · OpenAI Responses
json oder SSE
##### Alle fertiggestellten Ergebnisse aufbewahren
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Ausgabeelemente und Inhaltsteile, die tatsächliche call\_id der Funktion, verschlüsselte Reasoning-Daten und Verbrauchsdaten beibehalten. Beim Streaming die vollständige Identität von Ereignis und Element bewahren.
##### Wenn die ursprüngliche Antwort geprüft werden muss
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
Antwortfelder
| Feld | Typ |
| --- | --- |
| Feld`id` | Typstring |
| Feld`status` | Typstring |
| Feld`output[]` | Typmessage\|reasoning\|function\_call\|other item |
| Feld`output[].content[]` | Typcontent part |
| Feld`usage` | Typobject |
Fehler und nächste Schritte
| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
### Aliasnamen
#### Modellaliasnamen
Ailoot [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=responses), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=responses), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=responses), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=responses)
**Ailoot Ultra** [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7), [`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest)
#### Aliasnamen für Methodenpfade
`/chat/completions`
#### Zugehörige Aufrufer-IDs
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=responses), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=responses), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=responses), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=responses), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7)
**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `grok`
[`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=chat)
SpaceXAI /`grok`
Modell-ID
- `grok-4.7`
- `grok`
- `grok-4.7-latest`
- `grok-latest`
### Start
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
Zulässige Eingaben
Text · Bilder
Ergebnisse
Text
### In Ailoot verfügbar · Eingaben und Methoden
**Ailoot · OpenAI Chat** `POST /v1/chat/completions`
Eingabetypen
`text`, `image`
Ausgabetypen
`text`
Kontext
500.000 tokens
Maximale Ausgabe
500.000 tokens
Ausgabeformat
json oder SSE
| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits grok | Standard— |
| Feld`messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
| Feld`messages[].role` | Typ`string` | AnforderungErforderlich | Werte und Limits Beispiele: system, user, assistant, tool, function Bedingungen: Diese Rollen sind in den Kompatibilitätstypen des Quellcodes ausdrücklich dargestellt; der genaue Rollenumfang bleibt modellspezifisch. Modellabhängig | Standard— |
| Feld`messages[].content` | Typ`string\|content_part[]\|null` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].tool_calls` | Typ`tool_call[]` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].tool_call_id` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: role=tool; die tatsächlich zurückgegebene ID verwenden | Standard— |
| Feld`messages[].name` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].reasoning_content` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: Tatsächlich zurückgegebene Reasoning-Daten erneut übermitteln, sofern dieses Modell sie verwendet | Standard— |
| Feld`messages[].reasoning_details` | Typ`object\|array` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`max_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`max_completion_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
| Feld`stream_options.include_usage` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`temperature` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`top_p` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`stop` | Typ`string\|string[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools` | Typ`function_tool[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools[].type` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools[].function.name` | Typ`string` | AnforderungErforderlich | Werte und Limits Gilt, wenn: Funktionswerkzeug bereitgestellt | Standard— |
| Feld`tools[].function.description` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tools[].function.parameters` | Typ`JSON_schema` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tool_choice` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`parallel_tool_calls` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`response_format` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning_effort` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`service_tier` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`instructions` | Typ`string` | AnforderungOptional | Werte und Limits Kompatibilitätsfeld | Standard— |
| Feld`functions` | Typ`function[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`function_call` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`prompt_cache_options` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Kombinationen von Eingabematerialien
**Text** · UTF8-Text
`messages[].content`
**Text + Bild**
`{type:image_url,image_url:{url,detail}}`
Methodenparameter und Lebenszyklus
| Parameter | Vertrag |
| --- | --- |
| Parameter`material_types` | Vertragtext, image |
| Parameter`required` | Vertragmodel, messages |
| Parameter`optional_controls` | Vertragnull |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`text_file_material` | VertragTatsächlicher UTF-8-Inhalt wird als Text eingefügt; Datei-IDs/URLs müssen separat und exakt unterstützt werden |
Lebenszyklus: `exact retained published method`
Methodenstrukturen und IDs sind exakt; die Fähigkeiten des Anbieters sind von der Zulassung einer Anfrage zu unterscheiden.
### Tarife
#### Ailoot-Methodentarife
Eingabe
0,002 $ */ 1K*
Ausgabe
0,006 $ */ 1K*
Cache-Lesen
0,0005 $ */ 1K*
Cache-Schreiben
0,00 $ */ 1K*
Cache-Schreiben, 5 Min.
0,00 $ */ 1K tokens*
Cache-Schreiben, 1 Stunde
0,00 $ */ 1K tokens*
#### Preise nach Anfragelänge · OpenAI Chat
| Anfragegröße in Token | Eingabe | Ausgabe | Cache-Lesen | Cache-Schreiben | Cache 5 Min. | Cache 1 Stunde |
| --- | --- | --- | --- | --- | --- | --- |
| Anfragegröße in Token(0; 200.000\] | Eingabe0,002 $ | Ausgabe0,006 $ | Cache-Lesen0,0005 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
| Anfragegröße in Token(200.000; ∞) | Eingabe0,004 $ | Ausgabe0,012 $ | Cache-Lesen0,001 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
Tarife in USD pro 1K Token. Ist kein Tarif festgelegt, wird der Grundtarif dieser Methode übernommen; «—» bedeutet, dass kein Grundtarif festgelegt ist.
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)
#### Details zum Referenztarif
Referenztarifstaffeln auf Modellebene ändern weder Methodenauswahl noch Kostenvoranschläge oder Gebühren. Für die aktive Abrechnung gelten die Tarife der ausgewählten Ailoot-Methode.
Referenztarifstaffeln des Modells
#### Preise nach Konfiguration
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationOpenAI Chat · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
### Beispielanfragen
#### Ailoot · OpenAI Chat
TextbeispielEingabe, BildPython SDKNode.js SDKPython-Stream
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok", "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok", "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image_url","image_url":{"url":"data:"+mime+";base64,"+b64}})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```python
from openai import OpenAI
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = OpenAI(base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
resp = client.chat.completions.create(
model="grok",
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}],
)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.chat.completions.create({
model: "grok",
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```python
from openai import OpenAI
import os
from pathlib import Path
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
with client.chat.completions.stream(model='grok',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
for event in stream:
payload=event.to_dict(mode="json")
log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
print(json.dumps(payload,ensure_ascii=False))
final=stream.get_final_completion()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Ergebnisse abrufen und speichern
#### Ailoot · OpenAI Chat
json oder SSE
##### Alle fertiggestellten Ergebnisse aufbewahren
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Antwortvarianten mit ihren Inhalten, Werkzeugaufrufen und Reasoning-Daten beibehalten. In SSE die Deltas nach Varianten- und Werkzeugindex zusammensetzen; endgültigen Beendigungsgrund und Verbrauchsdaten beibehalten.
##### Wenn die ursprüngliche Antwort geprüft werden muss
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
Antwortfelder
| Feld | Typ |
| --- | --- |
| Feld`choices[].index` | Typinteger |
| Feld`choices[].message.content` | Typstring\|null |
| Feld`choices[].message.tool_calls` | Typtool\_call\[\] |
| Feld`choices[].message.reasoning_content` | Typstring |
| Feld`choices[].message.reasoning_details` | Typobject\|array |
| Feld`choices[].finish_reason` | Typstring\|null |
| Feld`usage` | Typobject |
Fehler und nächste Schritte
| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
### Aliasnamen
#### Modellaliasnamen
Ailoot [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=chat), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=chat), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=chat), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=chat)
**Ailoot Ultra** [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=chat), [`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=chat), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=chat)
#### Aliasnamen für Methodenpfade
`/chat/completions`
#### Zugehörige Aufrufer-IDs
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=chat), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=chat), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=chat), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=chat), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=chat), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=chat), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=chat)
**Ailoot · Anthropic Messages** `POST /v1/messages` `grok-4.7-latest`
[`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=messages)
SpaceXAI /`grok-4.7-latest`
Modell-ID
- `grok-4.7`
- `grok`
- `grok-4.7-latest`
- `grok-latest`
### Start
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
Zulässige Eingaben
Text · Bilder
Ergebnisse
Text
### In Ailoot verfügbar · Eingaben und Methoden
**Ailoot · Anthropic Messages** `POST /v1/messages`
Eingabetypen
`text`, `image`
Ausgabetypen
`text`
Kontext
500.000 tokens
Maximale Ausgabe
500.000 tokens
Ausgabeformat
json oder SSE
| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits grok-4.7-latest | Standard— |
| Feld`messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
| Feld`messages[].role` | Typ`string` | AnforderungErforderlich | Werte und Limits user, assistant | Standard— |
| Feld`messages[].content` | Typ`string\|content_block[]` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`system` | Typ`string\|content_block[]` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`max_tokens` | Typ`integer` | AnforderungErforderlich | Werte und Limits Minimum: 1 Limit gilt für: Genaue Obergrenze des ausgewählten Modells bzw. seiner Modellkarte | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
| Feld`temperature` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`top_p` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`stop_sequences` | Typ`string[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools` | Typ`tool[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools[].name` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: Werkzeug bereitgestellt | Standard— |
| Feld`tools[].description` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tools[].input_schema` | Typ`JSON_schema` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tool_choice` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`thinking.type` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`thinking.budget_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`output_config.effort` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`metadata` | Typ`object` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`cache_control` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Kombinationen von Eingabematerialien
**Text** · UTF8-Text
`messages[].content oder Block mit type=text`
**Text + Bild**
`{type:image,source:{type:base64,media_type,data}} oder Quelle mit type=url`
Methodenparameter und Lebenszyklus
| Parameter | Vertrag |
| --- | --- |
| Parameter`material_types` | Vertragtext, image |
| Parameter`required` | Vertragmodel, messages, max\_tokens |
| Parameter`optional_controls` | Vertragnull |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`text_file_material` | VertragTatsächlicher UTF-8-Inhalt wird als Text eingefügt; Datei-IDs/URLs müssen separat und exakt unterstützt werden |
Lebenszyklus: `exact retained published method`
Methodenstrukturen und IDs sind exakt; die Fähigkeiten des Anbieters sind von der Zulassung einer Anfrage zu unterscheiden.
### Tarife
#### Ailoot-Methodentarife
Eingabe
0,002 $ */ 1K*
Ausgabe
0,006 $ */ 1K*
Cache-Lesen
0,0005 $ */ 1K*
Cache-Schreiben
0,00 $ */ 1K*
Cache-Schreiben, 5 Min.
0,00 $ */ 1K tokens*
Cache-Schreiben, 1 Stunde
0,00 $ */ 1K tokens*
#### Preise nach Anfragelänge · Anthropic Messages
| Anfragegröße in Token | Eingabe | Ausgabe | Cache-Lesen | Cache-Schreiben | Cache 5 Min. | Cache 1 Stunde |
| --- | --- | --- | --- | --- | --- | --- |
| Anfragegröße in Token(0; 200.000\] | Eingabe0,002 $ | Ausgabe0,006 $ | Cache-Lesen0,0005 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
| Anfragegröße in Token(200.000; ∞) | Eingabe0,004 $ | Ausgabe0,012 $ | Cache-Lesen0,001 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
Tarife in USD pro 1K Token. Ist kein Tarif festgelegt, wird der Grundtarif dieser Methode übernommen; «—» bedeutet, dass kein Grundtarif festgelegt ist.
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)
#### Details zum Referenztarif
Referenztarifstaffeln auf Modellebene ändern weder Methodenauswahl noch Kostenvoranschläge oder Gebühren. Für die aktive Abrechnung gelten die Tarife der ausgewählten Ailoot-Methode.
Referenztarifstaffeln des Modells
#### Preise nach Konfiguration
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationOpenAI Chat · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
### Beispielanfragen
#### Ailoot · Anthropic Messages
TextbeispielEingabe, BildPython SDKNode.js SDKPython-Stream
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-4.7-latest", "max_tokens": 1024, "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-4.7-latest", "max_tokens": 1024, "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image","source":{"type":"base64","media_type":mime,"data":b64}})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```python
import anthropic
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
msg = client.messages.create(
model="grok-4.7-latest",
max_tokens=1024,
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}],
)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(msg.to_dict(mode="json"))
```
```js
import Anthropic from "@anthropic-ai/sdk";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const msg = await client.messages.create({
model: "grok-4.7-latest",
max_tokens: 1024,
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(msg);
```
```python
import anthropic,os
from pathlib import Path
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=anthropic.Anthropic(base_url="https://api.ailoot.ai",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
with client.messages.stream(model='grok-4.7-latest',max_tokens=1024,messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
for event in stream:
payload=event.to_dict(mode="json")
log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
print(json.dumps(payload,ensure_ascii=False))
final=stream.get_final_message()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Ergebnisse abrufen und speichern
#### Ailoot · Anthropic Messages
json oder SSE
##### Alle fertiggestellten Ergebnisse aufbewahren
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Inhaltsblöcke, Thinking-Signaturen und tatsächlichen Werkzeugaufruf-IDs beibehalten. Alle SSE-Blockdeltas zusammensetzen; der erste Textblock ist nicht die vollständige Ausgabe.
##### Wenn die ursprüngliche Antwort geprüft werden muss
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
Antwortfelder
| Feld | Typ |
| --- | --- |
| Feld`id` | Typstring |
| Feld`model` | Typstring |
| Feld`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Feld`stop_reason` | Typstring\|null |
| Feld`usage` | Typobject |
Fehler und nächste Schritte
| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
### Aliasnamen
#### Modellaliasnamen
Ailoot [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=messages), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=messages), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=messages), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=messages)
**Ailoot Ultra** [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=messages), [`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=messages), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=messages)
#### Aliasnamen für Methodenpfade
`/chat/completions`
#### Zugehörige Aufrufer-IDs
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=messages), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=messages), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=messages), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=messages), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=messages), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=messages), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=messages)
**Ailoot · OpenAI Responses** `POST /v1/responses` `grok-4.7-latest`
[`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=responses)
SpaceXAI /`grok-4.7-latest`
Modell-ID
- `grok-4.7`
- `grok`
- `grok-4.7-latest`
- `grok-latest`
### Start
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
Zulässige Eingaben
Text · Bilder
Ergebnisse
Text
### In Ailoot verfügbar · Eingaben und Methoden
**Ailoot · OpenAI Responses** `POST /v1/responses`
Eingabetypen
`text`, `image`
Ausgabetypen
`text`
Kontext
500.000 tokens
Maximale Ausgabe
500.000 tokens
Ausgabeformat
json oder SSE
| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits grok-4.7-latest | Standard— |
| Feld`input` | Typ`string\|input_item[]` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`instructions` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`input[].type` | Typ`string` | AnforderungOptional | Werte und Limits message, reasoning, function\_call, function\_call\_output | Standard— |
| Feld`input[].content` | Typ`string\|content_part[]` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`input[].call_id` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: function\_call\_output; den tatsächlich zurückgegebenen Wert von call\_id beibehalten | Standard— |
| Feld`input[].output` | Typ`string\|content_part[]` | AnforderungOptional | Werte und Limits Gilt, wenn: function\_call\_output | Standard— |
| Feld`max_output_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
| Feld`temperature` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`top_p` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools` | Typ`tool[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tool_choice` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`parallel_tool_calls` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning.effort` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning.summary` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`text.format` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`text.verbosity` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`include` | Typ`string[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`store` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`previous_response_id` | Typ`string` | AnforderungOptional | Werte und Limits ID-Anforderung: Nur eine tatsächliche Antwort-ID aus einer unterstützten Fortsetzung Modellabhängig | Standard— |
| Feld`service_tier` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`prompt_cache_key` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`prompt_cache_options` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Kombinationen von Eingabematerialien
**Text** · UTF8-Text
`Eingabetext oder input_text-Teil`
**Text + Bild**
`{type:input_image,image_url}`
Methodenparameter und Lebenszyklus
| Parameter | Vertrag |
| --- | --- |
| Parameter`material_types` | Vertragtext, image |
| Parameter`required` | Vertragmodel, input |
| Parameter`optional_controls` | Vertragnull |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`text_file_material` | VertragTatsächlicher UTF-8-Inhalt wird als Text eingefügt; Datei-IDs/URLs müssen separat und exakt unterstützt werden |
Lebenszyklus: `exact retained published method`
Methodenstrukturen und IDs sind exakt; die Fähigkeiten des Anbieters sind von der Zulassung einer Anfrage zu unterscheiden.
### Tarife
#### Ailoot-Methodentarife
Eingabe
0,002 $ */ 1K*
Ausgabe
0,006 $ */ 1K*
Cache-Lesen
0,0005 $ */ 1K*
Cache-Schreiben
0,00 $ */ 1K*
Cache-Schreiben, 5 Min.
0,00 $ */ 1K tokens*
Cache-Schreiben, 1 Stunde
0,00 $ */ 1K tokens*
#### Preise nach Anfragelänge · OpenAI Responses
| Anfragegröße in Token | Eingabe | Ausgabe | Cache-Lesen | Cache-Schreiben | Cache 5 Min. | Cache 1 Stunde |
| --- | --- | --- | --- | --- | --- | --- |
| Anfragegröße in Token(0; 200.000\] | Eingabe0,002 $ | Ausgabe0,006 $ | Cache-Lesen0,0005 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
| Anfragegröße in Token(200.000; ∞) | Eingabe0,004 $ | Ausgabe0,012 $ | Cache-Lesen0,001 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
Tarife in USD pro 1K Token. Ist kein Tarif festgelegt, wird der Grundtarif dieser Methode übernommen; «—» bedeutet, dass kein Grundtarif festgelegt ist.
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)
#### Details zum Referenztarif
Referenztarifstaffeln auf Modellebene ändern weder Methodenauswahl noch Kostenvoranschläge oder Gebühren. Für die aktive Abrechnung gelten die Tarife der ausgewählten Ailoot-Methode.
Referenztarifstaffeln des Modells
#### Preise nach Konfiguration
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationOpenAI Chat · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
### Beispielanfragen
#### Ailoot · OpenAI Responses
TextbeispielEingabe, BildPython SDKNode.js SDKPython-Stream
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-4.7-latest", "input": ""}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["input"]="Summarize this material and quote supporting source passages.\n\n"+text
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/responses \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-4.7-latest", "input": [{"role": "user", "content": [{"type": "input_text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["input"][0]["content"].append({"type":"input_image","image_url":"data:"+mime+";base64,"+b64})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/responses \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```
```python
from openai import OpenAI
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = OpenAI(base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
resp = client.responses.create(model="grok-4.7-latest", input="Explain the difference between an observation and a hypothesis in three sentences.")
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.responses.create({ model: "grok-4.7-latest", input: "Explain the difference between an observation and a hypothesis in three sentences." });
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```python
from openai import OpenAI
import os
from pathlib import Path
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
with client.responses.stream(model="grok-4.7-latest", input="Explain the difference between an observation and a hypothesis in three sentences.") as stream:
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
for event in stream:
payload=event.to_dict(mode="json")
log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
print(json.dumps(payload,ensure_ascii=False))
final=stream.get_final_response()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Ergebnisse abrufen und speichern
#### Ailoot · OpenAI Responses
json oder SSE
##### Alle fertiggestellten Ergebnisse aufbewahren
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Ausgabeelemente und Inhaltsteile, die tatsächliche call\_id der Funktion, verschlüsselte Reasoning-Daten und Verbrauchsdaten beibehalten. Beim Streaming die vollständige Identität von Ereignis und Element bewahren.
##### Wenn die ursprüngliche Antwort geprüft werden muss
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
Antwortfelder
| Feld | Typ |
| --- | --- |
| Feld`id` | Typstring |
| Feld`status` | Typstring |
| Feld`output[]` | Typmessage\|reasoning\|function\_call\|other item |
| Feld`output[].content[]` | Typcontent part |
| Feld`usage` | Typobject |
Fehler und nächste Schritte
| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
### Aliasnamen
#### Modellaliasnamen
Ailoot [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=responses), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=responses), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=responses), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=responses)
**Ailoot Ultra** [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7), [`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest)
#### Aliasnamen für Methodenpfade
`/chat/completions`
#### Zugehörige Aufrufer-IDs
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=responses), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=responses), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=responses), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=responses), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7)
**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `grok-4.7-latest`
[`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=chat)
SpaceXAI /`grok-4.7-latest`
Modell-ID
- `grok-4.7`
- `grok`
- `grok-4.7-latest`
- `grok-latest`
### Start
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
Zulässige Eingaben
Text · Bilder
Ergebnisse
Text
### In Ailoot verfügbar · Eingaben und Methoden
**Ailoot · OpenAI Chat** `POST /v1/chat/completions`
Eingabetypen
`text`, `image`
Ausgabetypen
`text`
Kontext
500.000 tokens
Maximale Ausgabe
500.000 tokens
Ausgabeformat
json oder SSE
| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits grok-4.7-latest | Standard— |
| Feld`messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
| Feld`messages[].role` | Typ`string` | AnforderungErforderlich | Werte und Limits Beispiele: system, user, assistant, tool, function Bedingungen: Diese Rollen sind in den Kompatibilitätstypen des Quellcodes ausdrücklich dargestellt; der genaue Rollenumfang bleibt modellspezifisch. Modellabhängig | Standard— |
| Feld`messages[].content` | Typ`string\|content_part[]\|null` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].tool_calls` | Typ`tool_call[]` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].tool_call_id` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: role=tool; die tatsächlich zurückgegebene ID verwenden | Standard— |
| Feld`messages[].name` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].reasoning_content` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: Tatsächlich zurückgegebene Reasoning-Daten erneut übermitteln, sofern dieses Modell sie verwendet | Standard— |
| Feld`messages[].reasoning_details` | Typ`object\|array` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`max_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`max_completion_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
| Feld`stream_options.include_usage` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`temperature` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`top_p` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`stop` | Typ`string\|string[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools` | Typ`function_tool[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools[].type` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools[].function.name` | Typ`string` | AnforderungErforderlich | Werte und Limits Gilt, wenn: Funktionswerkzeug bereitgestellt | Standard— |
| Feld`tools[].function.description` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tools[].function.parameters` | Typ`JSON_schema` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tool_choice` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`parallel_tool_calls` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`response_format` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning_effort` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`service_tier` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`instructions` | Typ`string` | AnforderungOptional | Werte und Limits Kompatibilitätsfeld | Standard— |
| Feld`functions` | Typ`function[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`function_call` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`prompt_cache_options` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Kombinationen von Eingabematerialien
**Text** · UTF8-Text
`messages[].content`
**Text + Bild**
`{type:image_url,image_url:{url,detail}}`
Methodenparameter und Lebenszyklus
| Parameter | Vertrag |
| --- | --- |
| Parameter`material_types` | Vertragtext, image |
| Parameter`required` | Vertragmodel, messages |
| Parameter`optional_controls` | Vertragnull |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`text_file_material` | VertragTatsächlicher UTF-8-Inhalt wird als Text eingefügt; Datei-IDs/URLs müssen separat und exakt unterstützt werden |
Lebenszyklus: `exact retained published method`
Methodenstrukturen und IDs sind exakt; die Fähigkeiten des Anbieters sind von der Zulassung einer Anfrage zu unterscheiden.
### Tarife
#### Ailoot-Methodentarife
Eingabe
0,002 $ */ 1K*
Ausgabe
0,006 $ */ 1K*
Cache-Lesen
0,0005 $ */ 1K*
Cache-Schreiben
0,00 $ */ 1K*
Cache-Schreiben, 5 Min.
0,00 $ */ 1K tokens*
Cache-Schreiben, 1 Stunde
0,00 $ */ 1K tokens*
#### Preise nach Anfragelänge · OpenAI Chat
| Anfragegröße in Token | Eingabe | Ausgabe | Cache-Lesen | Cache-Schreiben | Cache 5 Min. | Cache 1 Stunde |
| --- | --- | --- | --- | --- | --- | --- |
| Anfragegröße in Token(0; 200.000\] | Eingabe0,002 $ | Ausgabe0,006 $ | Cache-Lesen0,0005 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
| Anfragegröße in Token(200.000; ∞) | Eingabe0,004 $ | Ausgabe0,012 $ | Cache-Lesen0,001 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
Tarife in USD pro 1K Token. Ist kein Tarif festgelegt, wird der Grundtarif dieser Methode übernommen; «—» bedeutet, dass kein Grundtarif festgelegt ist.
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)
#### Details zum Referenztarif
Referenztarifstaffeln auf Modellebene ändern weder Methodenauswahl noch Kostenvoranschläge oder Gebühren. Für die aktive Abrechnung gelten die Tarife der ausgewählten Ailoot-Methode.
Referenztarifstaffeln des Modells
#### Preise nach Konfiguration
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationOpenAI Chat · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
### Beispielanfragen
#### Ailoot · OpenAI Chat
TextbeispielEingabe, BildPython SDKNode.js SDKPython-Stream
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-4.7-latest", "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-4.7-latest", "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image_url","image_url":{"url":"data:"+mime+";base64,"+b64}})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```python
from openai import OpenAI
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = OpenAI(base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
resp = client.chat.completions.create(
model="grok-4.7-latest",
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}],
)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.chat.completions.create({
model: "grok-4.7-latest",
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```python
from openai import OpenAI
import os
from pathlib import Path
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
with client.chat.completions.stream(model='grok-4.7-latest',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
for event in stream:
payload=event.to_dict(mode="json")
log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
print(json.dumps(payload,ensure_ascii=False))
final=stream.get_final_completion()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Ergebnisse abrufen und speichern
#### Ailoot · OpenAI Chat
json oder SSE
##### Alle fertiggestellten Ergebnisse aufbewahren
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Antwortvarianten mit ihren Inhalten, Werkzeugaufrufen und Reasoning-Daten beibehalten. In SSE die Deltas nach Varianten- und Werkzeugindex zusammensetzen; endgültigen Beendigungsgrund und Verbrauchsdaten beibehalten.
##### Wenn die ursprüngliche Antwort geprüft werden muss
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
Antwortfelder
| Feld | Typ |
| --- | --- |
| Feld`choices[].index` | Typinteger |
| Feld`choices[].message.content` | Typstring\|null |
| Feld`choices[].message.tool_calls` | Typtool\_call\[\] |
| Feld`choices[].message.reasoning_content` | Typstring |
| Feld`choices[].message.reasoning_details` | Typobject\|array |
| Feld`choices[].finish_reason` | Typstring\|null |
| Feld`usage` | Typobject |
Fehler und nächste Schritte
| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
### Aliasnamen
#### Modellaliasnamen
Ailoot [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=chat), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=chat), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=chat), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=chat)
**Ailoot Ultra** [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=chat), [`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=chat), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=chat)
#### Aliasnamen für Methodenpfade
`/chat/completions`
#### Zugehörige Aufrufer-IDs
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=chat), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=chat), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=chat), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=chat), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=chat), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=chat), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=chat)
**Ailoot · Anthropic Messages** `POST /v1/messages` `grok-latest`
[`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=messages)
SpaceXAI /`grok-latest`
Modell-ID
- `grok-4.7`
- `grok`
- `grok-4.7-latest`
- `grok-latest`
### Start
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
Zulässige Eingaben
Text · Bilder
Ergebnisse
Text
### In Ailoot verfügbar · Eingaben und Methoden
**Ailoot · Anthropic Messages** `POST /v1/messages`
Eingabetypen
`text`, `image`
Ausgabetypen
`text`
Kontext
500.000 tokens
Maximale Ausgabe
500.000 tokens
Ausgabeformat
json oder SSE
| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits grok-latest | Standard— |
| Feld`messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
| Feld`messages[].role` | Typ`string` | AnforderungErforderlich | Werte und Limits user, assistant | Standard— |
| Feld`messages[].content` | Typ`string\|content_block[]` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`system` | Typ`string\|content_block[]` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`max_tokens` | Typ`integer` | AnforderungErforderlich | Werte und Limits Minimum: 1 Limit gilt für: Genaue Obergrenze des ausgewählten Modells bzw. seiner Modellkarte | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
| Feld`temperature` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`top_p` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`stop_sequences` | Typ`string[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools` | Typ`tool[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools[].name` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: Werkzeug bereitgestellt | Standard— |
| Feld`tools[].description` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tools[].input_schema` | Typ`JSON_schema` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tool_choice` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`thinking.type` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`thinking.budget_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`output_config.effort` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`metadata` | Typ`object` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`cache_control` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Kombinationen von Eingabematerialien
**Text** · UTF8-Text
`messages[].content oder Block mit type=text`
**Text + Bild**
`{type:image,source:{type:base64,media_type,data}} oder Quelle mit type=url`
Methodenparameter und Lebenszyklus
| Parameter | Vertrag |
| --- | --- |
| Parameter`material_types` | Vertragtext, image |
| Parameter`required` | Vertragmodel, messages, max\_tokens |
| Parameter`optional_controls` | Vertragnull |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`text_file_material` | VertragTatsächlicher UTF-8-Inhalt wird als Text eingefügt; Datei-IDs/URLs müssen separat und exakt unterstützt werden |
Lebenszyklus: `exact retained published method`
Methodenstrukturen und IDs sind exakt; die Fähigkeiten des Anbieters sind von der Zulassung einer Anfrage zu unterscheiden.
### Tarife
#### Ailoot-Methodentarife
Eingabe
0,002 $ */ 1K*
Ausgabe
0,006 $ */ 1K*
Cache-Lesen
0,0005 $ */ 1K*
Cache-Schreiben
0,00 $ */ 1K*
Cache-Schreiben, 5 Min.
0,00 $ */ 1K tokens*
Cache-Schreiben, 1 Stunde
0,00 $ */ 1K tokens*
#### Preise nach Anfragelänge · Anthropic Messages
| Anfragegröße in Token | Eingabe | Ausgabe | Cache-Lesen | Cache-Schreiben | Cache 5 Min. | Cache 1 Stunde |
| --- | --- | --- | --- | --- | --- | --- |
| Anfragegröße in Token(0; 200.000\] | Eingabe0,002 $ | Ausgabe0,006 $ | Cache-Lesen0,0005 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
| Anfragegröße in Token(200.000; ∞) | Eingabe0,004 $ | Ausgabe0,012 $ | Cache-Lesen0,001 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
Tarife in USD pro 1K Token. Ist kein Tarif festgelegt, wird der Grundtarif dieser Methode übernommen; «—» bedeutet, dass kein Grundtarif festgelegt ist.
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)
#### Details zum Referenztarif
Referenztarifstaffeln auf Modellebene ändern weder Methodenauswahl noch Kostenvoranschläge oder Gebühren. Für die aktive Abrechnung gelten die Tarife der ausgewählten Ailoot-Methode.
Referenztarifstaffeln des Modells
#### Preise nach Konfiguration
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationOpenAI Chat · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
### Beispielanfragen
#### Ailoot · Anthropic Messages
TextbeispielEingabe, BildPython SDKNode.js SDKPython-Stream
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-latest", "max_tokens": 1024, "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-latest", "max_tokens": 1024, "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image","source":{"type":"base64","media_type":mime,"data":b64}})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```python
import anthropic
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
msg = client.messages.create(
model="grok-latest",
max_tokens=1024,
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}],
)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(msg.to_dict(mode="json"))
```
```js
import Anthropic from "@anthropic-ai/sdk";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const msg = await client.messages.create({
model: "grok-latest",
max_tokens: 1024,
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(msg);
```
```python
import anthropic,os
from pathlib import Path
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=anthropic.Anthropic(base_url="https://api.ailoot.ai",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
with client.messages.stream(model='grok-latest',max_tokens=1024,messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
for event in stream:
payload=event.to_dict(mode="json")
log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
print(json.dumps(payload,ensure_ascii=False))
final=stream.get_final_message()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Ergebnisse abrufen und speichern
#### Ailoot · Anthropic Messages
json oder SSE
##### Alle fertiggestellten Ergebnisse aufbewahren
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Inhaltsblöcke, Thinking-Signaturen und tatsächlichen Werkzeugaufruf-IDs beibehalten. Alle SSE-Blockdeltas zusammensetzen; der erste Textblock ist nicht die vollständige Ausgabe.
##### Wenn die ursprüngliche Antwort geprüft werden muss
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
Antwortfelder
| Feld | Typ |
| --- | --- |
| Feld`id` | Typstring |
| Feld`model` | Typstring |
| Feld`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Feld`stop_reason` | Typstring\|null |
| Feld`usage` | Typobject |
Fehler und nächste Schritte
| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
### Aliasnamen
#### Modellaliasnamen
Ailoot [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=messages), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=messages), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=messages), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=messages)
**Ailoot Ultra** [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=messages), [`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=messages), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=messages)
#### Aliasnamen für Methodenpfade
`/chat/completions`
#### Zugehörige Aufrufer-IDs
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=messages), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=messages), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=messages), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=messages), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=messages), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=messages), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=messages)
**Ailoot · OpenAI Responses** `POST /v1/responses` `grok-latest`
[`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=responses)
SpaceXAI /`grok-latest`
Modell-ID
- `grok-4.7`
- `grok`
- `grok-4.7-latest`
- `grok-latest`
### Start
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
Zulässige Eingaben
Text · Bilder
Ergebnisse
Text
### In Ailoot verfügbar · Eingaben und Methoden
**Ailoot · OpenAI Responses** `POST /v1/responses`
Eingabetypen
`text`, `image`
Ausgabetypen
`text`
Kontext
500.000 tokens
Maximale Ausgabe
500.000 tokens
Ausgabeformat
json oder SSE
| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits grok-latest | Standard— |
| Feld`input` | Typ`string\|input_item[]` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`instructions` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`input[].type` | Typ`string` | AnforderungOptional | Werte und Limits message, reasoning, function\_call, function\_call\_output | Standard— |
| Feld`input[].content` | Typ`string\|content_part[]` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`input[].call_id` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: function\_call\_output; den tatsächlich zurückgegebenen Wert von call\_id beibehalten | Standard— |
| Feld`input[].output` | Typ`string\|content_part[]` | AnforderungOptional | Werte und Limits Gilt, wenn: function\_call\_output | Standard— |
| Feld`max_output_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
| Feld`temperature` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`top_p` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools` | Typ`tool[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tool_choice` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`parallel_tool_calls` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning.effort` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning.summary` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`text.format` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`text.verbosity` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`include` | Typ`string[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`store` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`previous_response_id` | Typ`string` | AnforderungOptional | Werte und Limits ID-Anforderung: Nur eine tatsächliche Antwort-ID aus einer unterstützten Fortsetzung Modellabhängig | Standard— |
| Feld`service_tier` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`prompt_cache_key` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`prompt_cache_options` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Kombinationen von Eingabematerialien
**Text** · UTF8-Text
`Eingabetext oder input_text-Teil`
**Text + Bild**
`{type:input_image,image_url}`
Methodenparameter und Lebenszyklus
| Parameter | Vertrag |
| --- | --- |
| Parameter`material_types` | Vertragtext, image |
| Parameter`required` | Vertragmodel, input |
| Parameter`optional_controls` | Vertragnull |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`text_file_material` | VertragTatsächlicher UTF-8-Inhalt wird als Text eingefügt; Datei-IDs/URLs müssen separat und exakt unterstützt werden |
Lebenszyklus: `exact retained published method`
Methodenstrukturen und IDs sind exakt; die Fähigkeiten des Anbieters sind von der Zulassung einer Anfrage zu unterscheiden.
### Tarife
#### Ailoot-Methodentarife
Eingabe
0,002 $ */ 1K*
Ausgabe
0,006 $ */ 1K*
Cache-Lesen
0,0005 $ */ 1K*
Cache-Schreiben
0,00 $ */ 1K*
Cache-Schreiben, 5 Min.
0,00 $ */ 1K tokens*
Cache-Schreiben, 1 Stunde
0,00 $ */ 1K tokens*
#### Preise nach Anfragelänge · OpenAI Responses
| Anfragegröße in Token | Eingabe | Ausgabe | Cache-Lesen | Cache-Schreiben | Cache 5 Min. | Cache 1 Stunde |
| --- | --- | --- | --- | --- | --- | --- |
| Anfragegröße in Token(0; 200.000\] | Eingabe0,002 $ | Ausgabe0,006 $ | Cache-Lesen0,0005 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
| Anfragegröße in Token(200.000; ∞) | Eingabe0,004 $ | Ausgabe0,012 $ | Cache-Lesen0,001 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
Tarife in USD pro 1K Token. Ist kein Tarif festgelegt, wird der Grundtarif dieser Methode übernommen; «—» bedeutet, dass kein Grundtarif festgelegt ist.
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)
#### Details zum Referenztarif
Referenztarifstaffeln auf Modellebene ändern weder Methodenauswahl noch Kostenvoranschläge oder Gebühren. Für die aktive Abrechnung gelten die Tarife der ausgewählten Ailoot-Methode.
Referenztarifstaffeln des Modells
#### Preise nach Konfiguration
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationOpenAI Chat · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
### Beispielanfragen
#### Ailoot · OpenAI Responses
TextbeispielEingabe, BildPython SDKNode.js SDKPython-Stream
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-latest", "input": ""}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["input"]="Summarize this material and quote supporting source passages.\n\n"+text
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/responses \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-latest", "input": [{"role": "user", "content": [{"type": "input_text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["input"][0]["content"].append({"type":"input_image","image_url":"data:"+mime+";base64,"+b64})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/responses \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```
```python
from openai import OpenAI
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = OpenAI(base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
resp = client.responses.create(model="grok-latest", input="Explain the difference between an observation and a hypothesis in three sentences.")
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.responses.create({ model: "grok-latest", input: "Explain the difference between an observation and a hypothesis in three sentences." });
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```python
from openai import OpenAI
import os
from pathlib import Path
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
with client.responses.stream(model="grok-latest", input="Explain the difference between an observation and a hypothesis in three sentences.") as stream:
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
for event in stream:
payload=event.to_dict(mode="json")
log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
print(json.dumps(payload,ensure_ascii=False))
final=stream.get_final_response()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Ergebnisse abrufen und speichern
#### Ailoot · OpenAI Responses
json oder SSE
##### Alle fertiggestellten Ergebnisse aufbewahren
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Ausgabeelemente und Inhaltsteile, die tatsächliche call\_id der Funktion, verschlüsselte Reasoning-Daten und Verbrauchsdaten beibehalten. Beim Streaming die vollständige Identität von Ereignis und Element bewahren.
##### Wenn die ursprüngliche Antwort geprüft werden muss
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
Antwortfelder
| Feld | Typ |
| --- | --- |
| Feld`id` | Typstring |
| Feld`status` | Typstring |
| Feld`output[]` | Typmessage\|reasoning\|function\_call\|other item |
| Feld`output[].content[]` | Typcontent part |
| Feld`usage` | Typobject |
Fehler und nächste Schritte
| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
### Aliasnamen
#### Modellaliasnamen
Ailoot [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=responses), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=responses), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=responses), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=responses)
**Ailoot Ultra** [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7), [`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest)
#### Aliasnamen für Methodenpfade
`/chat/completions`
#### Zugehörige Aufrufer-IDs
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=responses), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=responses), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=responses), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=responses), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7)
**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `grok-latest`
[`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=chat)
SpaceXAI /`grok-latest`
Modell-ID
- `grok-4.7`
- `grok`
- `grok-4.7-latest`
- `grok-latest`
### Start
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
Zulässige Eingaben
Text · Bilder
Ergebnisse
Text
### In Ailoot verfügbar · Eingaben und Methoden
**Ailoot · OpenAI Chat** `POST /v1/chat/completions`
Eingabetypen
`text`, `image`
Ausgabetypen
`text`
Kontext
500.000 tokens
Maximale Ausgabe
500.000 tokens
Ausgabeformat
json oder SSE
| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits grok-latest | Standard— |
| Feld`messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
| Feld`messages[].role` | Typ`string` | AnforderungErforderlich | Werte und Limits Beispiele: system, user, assistant, tool, function Bedingungen: Diese Rollen sind in den Kompatibilitätstypen des Quellcodes ausdrücklich dargestellt; der genaue Rollenumfang bleibt modellspezifisch. Modellabhängig | Standard— |
| Feld`messages[].content` | Typ`string\|content_part[]\|null` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].tool_calls` | Typ`tool_call[]` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].tool_call_id` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: role=tool; die tatsächlich zurückgegebene ID verwenden | Standard— |
| Feld`messages[].name` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].reasoning_content` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: Tatsächlich zurückgegebene Reasoning-Daten erneut übermitteln, sofern dieses Modell sie verwendet | Standard— |
| Feld`messages[].reasoning_details` | Typ`object\|array` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`max_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`max_completion_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
| Feld`stream_options.include_usage` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`temperature` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`top_p` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`stop` | Typ`string\|string[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools` | Typ`function_tool[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools[].type` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools[].function.name` | Typ`string` | AnforderungErforderlich | Werte und Limits Gilt, wenn: Funktionswerkzeug bereitgestellt | Standard— |
| Feld`tools[].function.description` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tools[].function.parameters` | Typ`JSON_schema` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tool_choice` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`parallel_tool_calls` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`response_format` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning_effort` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`service_tier` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`instructions` | Typ`string` | AnforderungOptional | Werte und Limits Kompatibilitätsfeld | Standard— |
| Feld`functions` | Typ`function[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`function_call` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`prompt_cache_options` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Kombinationen von Eingabematerialien
**Text** · UTF8-Text
`messages[].content`
**Text + Bild**
`{type:image_url,image_url:{url,detail}}`
Methodenparameter und Lebenszyklus
| Parameter | Vertrag |
| --- | --- |
| Parameter`material_types` | Vertragtext, image |
| Parameter`required` | Vertragmodel, messages |
| Parameter`optional_controls` | Vertragnull |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`text_file_material` | VertragTatsächlicher UTF-8-Inhalt wird als Text eingefügt; Datei-IDs/URLs müssen separat und exakt unterstützt werden |
Lebenszyklus: `exact retained published method`
Methodenstrukturen und IDs sind exakt; die Fähigkeiten des Anbieters sind von der Zulassung einer Anfrage zu unterscheiden.
### Tarife
#### Ailoot-Methodentarife
Eingabe
0,002 $ */ 1K*
Ausgabe
0,006 $ */ 1K*
Cache-Lesen
0,0005 $ */ 1K*
Cache-Schreiben
0,00 $ */ 1K*
Cache-Schreiben, 5 Min.
0,00 $ */ 1K tokens*
Cache-Schreiben, 1 Stunde
0,00 $ */ 1K tokens*
#### Preise nach Anfragelänge · OpenAI Chat
| Anfragegröße in Token | Eingabe | Ausgabe | Cache-Lesen | Cache-Schreiben | Cache 5 Min. | Cache 1 Stunde |
| --- | --- | --- | --- | --- | --- | --- |
| Anfragegröße in Token(0; 200.000\] | Eingabe0,002 $ | Ausgabe0,006 $ | Cache-Lesen0,0005 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
| Anfragegröße in Token(200.000; ∞) | Eingabe0,004 $ | Ausgabe0,012 $ | Cache-Lesen0,001 $ | Cache-Schreiben0,00 $ | Cache 5 Min.0,00 $ | Cache 1 Stunde0,00 $ |
Tarife in USD pro 1K Token. Ist kein Tarif festgelegt, wird der Grundtarif dieser Methode übernommen; «—» bedeutet, dass kein Grundtarif festgelegt ist.
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)
#### Details zum Referenztarif
Referenztarifstaffeln auf Modellebene ändern weder Methodenauswahl noch Kostenvoranschläge oder Gebühren. Für die aktive Abrechnung gelten die Tarife der ausgewählten Ailoot-Methode.
Referenztarifstaffeln des Modells
#### Preise nach Konfiguration
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationOpenAI Chat · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationOpenAI Chat · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnthropic Messages · Stufe 2 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
### Beispielanfragen
#### Ailoot · OpenAI Chat
TextbeispielEingabe, BildPython SDKNode.js SDKPython-Stream
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-latest", "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-latest", "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image_url","image_url":{"url":"data:"+mime+";base64,"+b64}})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```python
from openai import OpenAI
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = OpenAI(base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
resp = client.chat.completions.create(
model="grok-latest",
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}],
)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.chat.completions.create({
model: "grok-latest",
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```python
from openai import OpenAI
import os
from pathlib import Path
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
with client.chat.completions.stream(model='grok-latest',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
for event in stream:
payload=event.to_dict(mode="json")
log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
print(json.dumps(payload,ensure_ascii=False))
final=stream.get_final_completion()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Ergebnisse abrufen und speichern
#### Ailoot · OpenAI Chat
json oder SSE
##### Alle fertiggestellten Ergebnisse aufbewahren
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Antwortvarianten mit ihren Inhalten, Werkzeugaufrufen und Reasoning-Daten beibehalten. In SSE die Deltas nach Varianten- und Werkzeugindex zusammensetzen; endgültigen Beendigungsgrund und Verbrauchsdaten beibehalten.
##### Wenn die ursprüngliche Antwort geprüft werden muss
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
Antwortfelder
| Feld | Typ |
| --- | --- |
| Feld`choices[].index` | Typinteger |
| Feld`choices[].message.content` | Typstring\|null |
| Feld`choices[].message.tool_calls` | Typtool\_call\[\] |
| Feld`choices[].message.reasoning_content` | Typstring |
| Feld`choices[].message.reasoning_details` | Typobject\|array |
| Feld`choices[].finish_reason` | Typstring\|null |
| Feld`usage` | Typobject |
Fehler und nächste Schritte
| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
### Aliasnamen
#### Modellaliasnamen
Ailoot [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=chat), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=chat), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=chat), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=chat)
**Ailoot Ultra** [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=chat), [`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=chat), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=chat)
#### Aliasnamen für Methodenpfade
`/chat/completions`
#### Zugehörige Aufrufer-IDs
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=chat), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=chat), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=chat), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=chat), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=chat), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=chat), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=chat)
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `x-ai/grok-4.7`
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=chat)
SpaceXAI /`x-ai/grok-4.7`
Modell-ID
- `grok-4.7`
- `x-ai/grok-4.7`
- `~x-ai/grok-latest`
### Start
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
Zulässige Eingaben
Text
Ergebnisse
Text
### In Ailoot verfügbar · Eingaben und Methoden
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions`
Eingabetypen
`text`
Ausgabetypen
`text`
Ausgabeformat
json oder SSE
| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits x-ai/grok-4.7 | Standard— |
| Feld`messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
| Feld`messages[].role` | Typ`string` | AnforderungErforderlich | Werte und Limits Beispiele: system, user, assistant, tool, function Bedingungen: Diese Rollen sind in den Kompatibilitätstypen des Quellcodes ausdrücklich dargestellt; der genaue Rollenumfang bleibt modellspezifisch. Modellabhängig | Standard— |
| Feld`messages[].content` | Typ`string\|content_part[]\|null` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].tool_calls` | Typ`tool_call[]` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].tool_call_id` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: role=tool; die tatsächlich zurückgegebene ID verwenden | Standard— |
| Feld`messages[].name` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].reasoning_content` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: Tatsächlich zurückgegebene Reasoning-Daten erneut übermitteln, sofern dieses Modell sie verwendet | Standard— |
| Feld`messages[].reasoning_details` | Typ`object\|array` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`max_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`max_completion_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
| Feld`stream_options.include_usage` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`temperature` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`top_p` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`stop` | Typ`string\|string[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools` | Typ`function_tool[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools[].type` | Typ`string` | AnforderungOptional | Werte und Limits function Modellabhängig | Standard— |
| Feld`tools[].function.name` | Typ`string` | AnforderungErforderlich | Werte und Limits Gilt, wenn: Funktionswerkzeug bereitgestellt | Standard— |
| Feld`tools[].function.description` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tools[].function.parameters` | Typ`JSON_schema` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tool_choice` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`parallel_tool_calls` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`response_format` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning_effort` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`service_tier` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`instructions` | Typ`string` | AnforderungOptional | Werte und Limits Kompatibilitätsfeld | Standard— |
| Feld`functions` | Typ`function[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`function_call` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`prompt_cache_options` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`modalities` | Typ`string[]` | AnforderungOptional | Werte und Limits text | Standard— |
| Feld`provider` | Typ`object` | AnforderungOptional | Werte und Limits Bedingungen: provider.options wird auf dieser Ultra-Textroute abgelehnt | Standard— |
| Feld`cache_control.ttl` | Typ`string` | AnforderungOptional | Werte und Limits Bedingungen: 1h wird in den tatsächlichen Prompt-Cache-Feldern abgelehnt | Standard— |
Kombinationen von Eingabematerialien
**Text** · UTF8-Text
`messages[].content`
Methodenparameter und Lebenszyklus
| Parameter | Vertrag |
| --- | --- |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`required` | Vertragmodel, messages |
| Parameter`material_types` | Vertragtext |
| Parameter`messages` | VertragNachrichtenarray mit role/content-Struktur |
| Parameter`file_material` | VertragTatsächliches UTF-8-Dokument als wörtlicher Text eingefügt; keine Datei-ID abgeleitet |
| Parameter`optional_controls` | Vertragstream, temperature, top\_p, stop, max\_tokens, max\_completion\_tokens, reasoning, response\_format, tools, tool\_choice |
| Parameter`control_scope` | VertragModellspezifisch; benutzerseitige Funktionswerkzeuge unterscheiden sich von gehosteten Werkzeugen |
| Parameter`output_modalities` | Vertragtext |
| Parameter`hosted_operations` | Vertragfalse |
| Parameter`multimodal_input_binding` | Vertragnull |
Lebenszyklus: `synchronous_or_streamed`
Die genaue Modell-ID zusammen mit messages senden.
Die Kontextlänge ist keine Ausgabeobergrenze.
Eine Textdatei kann wörtlichen Text liefern; Bild-, Audio- und Dateiobjekteingaben benötigen eine exakte Zuordnung.
### Tarife
Tarifangaben erweitern die Anfrageoptionen nicht. Unterstützte Parameter stehen bei der ausgewählten Methode.
Schnellmodus
Standardtarif Wenn der Schnellmodus ausgewählt ist
Flex-Modus
Standardtarif Wenn der Modus flex ausgewählt ist
Maximaler Denkaufwand
Standardtarif Wenn beim maximalen Denkaufwand die Standardanpassung (default) verwendet wird
Denkaufwand · hoch
Standardtarif Wenn der Denkaufwand hoch ist
Denkaufwand · niedrig
Standardtarif Wenn der Denkaufwand niedrig ist
Denkaufwand · mittel
Standardtarif Wenn der Denkaufwand mittel ist
Denkaufwand · xhigh
Standardtarif Wenn der Denkaufwand xhigh ist
#### Ailoot-Tarife
#### Preise nach Konfiguration
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationBasistarife für Token | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnfragelängenstufe 1 | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnfragelängenstufe 2 | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)
### Beispielanfragen
#### Ailoot Ultra · OpenAI Chat
curlPython SDKPython-Stream
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "x-ai/grok-4.7", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
r=json.loads(Path("result.json").read_text())
for x in r.get("choices",[]):
if x.get("message",{}).get("content"): print(x["message"]["content"])
PY_RESULT
```
```python
from openai import OpenAI
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.chat.completions.create(model='x-ai/grok-4.7',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}])
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(result.to_dict(mode="json"))
```
```python
from openai import OpenAI
import os
from pathlib import Path
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
with client.chat.completions.stream(model='x-ai/grok-4.7',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
for event in stream:
payload=event.to_dict(mode="json")
log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
print(json.dumps(payload,ensure_ascii=False))
final=stream.get_final_completion()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Ergebnisse abrufen und speichern
#### Ailoot Ultra · OpenAI Chat
json oder SSE
##### Alle fertiggestellten Ergebnisse aufbewahren
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Antwortvarianten mit ihren Inhalten, Werkzeugaufrufen und Reasoning-Daten beibehalten. In SSE die Deltas nach Varianten- und Werkzeugindex zusammensetzen; endgültigen Beendigungsgrund und Verbrauchsdaten beibehalten.
##### Wenn die ursprüngliche Antwort geprüft werden muss
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
Antwortfelder
| Feld | Typ |
| --- | --- |
| Feld`choices[].index` | Typinteger |
| Feld`choices[].message.content` | Typstring\|null |
| Feld`choices[].message.tool_calls` | Typtool\_call\[\] |
| Feld`choices[].message.reasoning_content` | Typstring |
| Feld`choices[].message.reasoning_details` | Typobject\|array |
| Feld`choices[].finish_reason` | Typstring\|null |
| Feld`usage` | Typobject |
Fehler und nächste Schritte
| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
### Aliasnamen
#### Modellaliasnamen
Ailoot [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=chat), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=chat), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=chat), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=chat)
**Ailoot Ultra** [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=chat), [`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=chat), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=chat)
#### Aliasnamen für Methodenpfade
`/chat/completions`
#### Zugehörige Aufrufer-IDs
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=chat), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=chat), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=chat), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=chat), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=chat), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=chat), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=chat)
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `x-ai/grok-4.7`
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=messages)
SpaceXAI /`x-ai/grok-4.7`
Modell-ID
- `grok-4.7`
- `x-ai/grok-4.7`
- `~x-ai/grok-latest`
### Start
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
Zulässige Eingaben
Text
Ergebnisse
json · sse
### In Ailoot verfügbar · Eingaben und Methoden
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages`
Eingabetypen
`text`
Ausgabetypen
`json`, `sse`
Ausgabeformat
JSON oder SSE
| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits x-ai/grok-4.7 | Standard— |
| Feld`messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`messages[].role` | Typ`string` | AnforderungErforderlich | Werte und Limits user, assistant | Standard— |
| Feld`messages[].content` | Typ`string` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`max_tokens` | Typ`integer` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
Kombinationen von Eingabematerialien
**Text** · UTF-8-Text
`Zeichenfolge messages[].content`
Methodenparameter und Lebenszyklus
| Parameter | Vertrag |
| --- | --- |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`required` | Vertragmodel, messages, max\_tokens |
| Parameter`optional_controls` | Vertragstream |
| Parameter`material_types` | Vertragtext |
| Parameter`text_file_material` | VertragDas tatsächliche UTF-8-Dokument lesen und seinen Text in die angegebene Zeichenfolge für Eingabe oder Nachrichteninhalt einfügen. |
Lebenszyklus: `synchronous_or_streamed`
### Tarife
Tarifangaben erweitern die Anfrageoptionen nicht. Unterstützte Parameter stehen bei der ausgewählten Methode.
Schnellmodus
Standardtarif Wenn der Schnellmodus ausgewählt ist
Flex-Modus
Standardtarif Wenn der Modus flex ausgewählt ist
Maximaler Denkaufwand
Standardtarif Wenn beim maximalen Denkaufwand die Standardanpassung (default) verwendet wird
Denkaufwand · hoch
Standardtarif Wenn der Denkaufwand hoch ist
Denkaufwand · niedrig
Standardtarif Wenn der Denkaufwand niedrig ist
Denkaufwand · mittel
Standardtarif Wenn der Denkaufwand mittel ist
Denkaufwand · xhigh
Standardtarif Wenn der Denkaufwand xhigh ist
#### Ailoot-Tarife
#### Preise nach Konfiguration
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationBasistarife für Token | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnfragelängenstufe 1 | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnfragelängenstufe 2 | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)
### Beispielanfragen
#### Ailoot Ultra · Anthropic Messages
Vollständiger minimaler JSON-Bodycurl · eigenes UTF-8-Dokument verwendenPython · das vollständige Ergebnis speichern
```json
{
"model": "x-ai/grok-4.7",
"max_tokens": 128,
"messages": [
{
"role": "user",
"content": "Summarize the incident report."
}
],
"stream": false
}
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json, os
from pathlib import Path
source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
raise SystemExit('Choose a document containing text')
payload = {'model': 'x-ai/grok-4.7', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
Path('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
PY_RESULT
```
```python
import json, os
from pathlib import Path
source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
raise SystemExit('Choose a document containing text')
payload = {'model': 'x-ai/grok-4.7', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
from urllib.request import Request, urlopen
from urllib.error import HTTPError
api_key = os.environ['AILOOT_API_KEY']
if not api_key.strip():
raise SystemExit('Set AILOOT_API_KEY before making a request')
headers = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}
headers['x-api-key'] = api_key
request = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')
try:
with urlopen(request, timeout=120) as response:
raw = response.read()
Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')
except HTTPError as error:
Path('result.json').write_bytes(error.read())
Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')
raise
Path('result.json').write_bytes(raw)
import json
from pathlib import Path
result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
```
### Ergebnisse abrufen und speichern
#### Ailoot Ultra · Anthropic Messages
JSON oder SSE
##### Alle fertiggestellten Ergebnisse aufbewahren
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Inhaltsblöcke, Thinking-Signaturen und tatsächlichen Werkzeugaufruf-IDs beibehalten. Alle SSE-Blockdeltas zusammensetzen; der erste Textblock ist nicht die vollständige Ausgabe.
##### Wenn die ursprüngliche Antwort geprüft werden muss
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
Antwortfelder
| Feld | Typ |
| --- | --- |
| Feld`id` | Typstring |
| Feld`model` | Typstring |
| Feld`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Feld`stop_reason` | Typstring\|null |
| Feld`usage` | Typobject |
Fehler und nächste Schritte
| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
### Aliasnamen
#### Modellaliasnamen
Ailoot [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=messages), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=messages), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=messages), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=messages)
**Ailoot Ultra** [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=messages), [`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=messages), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=messages)
#### Aliasnamen für Methodenpfade
`/chat/completions`
#### Zugehörige Aufrufer-IDs
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=messages), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=messages), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=messages), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=messages), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=messages), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=messages), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=messages)
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `~x-ai/grok-latest`
[`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=chat)
SpaceXAI /`~x-ai/grok-latest`
Modell-ID
- `grok-4.7`
- `x-ai/grok-4.7`
- `~x-ai/grok-latest`
### Start
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
Zulässige Eingaben
Text
Ergebnisse
Text
### In Ailoot verfügbar · Eingaben und Methoden
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions`
Eingabetypen
`text`
Ausgabetypen
`text`
Ausgabeformat
json oder SSE
| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits ~x-ai/grok-latest | Standard— |
| Feld`messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
| Feld`messages[].role` | Typ`string` | AnforderungErforderlich | Werte und Limits Beispiele: system, user, assistant, tool, function Bedingungen: Diese Rollen sind in den Kompatibilitätstypen des Quellcodes ausdrücklich dargestellt; der genaue Rollenumfang bleibt modellspezifisch. Modellabhängig | Standard— |
| Feld`messages[].content` | Typ`string\|content_part[]\|null` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].tool_calls` | Typ`tool_call[]` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].tool_call_id` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: role=tool; die tatsächlich zurückgegebene ID verwenden | Standard— |
| Feld`messages[].name` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].reasoning_content` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: Tatsächlich zurückgegebene Reasoning-Daten erneut übermitteln, sofern dieses Modell sie verwendet | Standard— |
| Feld`messages[].reasoning_details` | Typ`object\|array` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`max_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`max_completion_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
| Feld`stream_options.include_usage` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`temperature` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`top_p` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`stop` | Typ`string\|string[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools` | Typ`function_tool[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools[].type` | Typ`string` | AnforderungOptional | Werte und Limits function Modellabhängig | Standard— |
| Feld`tools[].function.name` | Typ`string` | AnforderungErforderlich | Werte und Limits Gilt, wenn: Funktionswerkzeug bereitgestellt | Standard— |
| Feld`tools[].function.description` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tools[].function.parameters` | Typ`JSON_schema` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tool_choice` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`parallel_tool_calls` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`response_format` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning_effort` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`service_tier` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`instructions` | Typ`string` | AnforderungOptional | Werte und Limits Kompatibilitätsfeld | Standard— |
| Feld`functions` | Typ`function[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`function_call` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`prompt_cache_options` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`modalities` | Typ`string[]` | AnforderungOptional | Werte und Limits text | Standard— |
| Feld`provider` | Typ`object` | AnforderungOptional | Werte und Limits Bedingungen: provider.options wird auf dieser Ultra-Textroute abgelehnt | Standard— |
| Feld`cache_control.ttl` | Typ`string` | AnforderungOptional | Werte und Limits Bedingungen: 1h wird in den tatsächlichen Prompt-Cache-Feldern abgelehnt | Standard— |
Kombinationen von Eingabematerialien
**Text** · UTF8-Text
`messages[].content`
Methodenparameter und Lebenszyklus
| Parameter | Vertrag |
| --- | --- |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`required` | Vertragmodel, messages |
| Parameter`material_types` | Vertragtext |
| Parameter`messages` | VertragNachrichtenarray mit role/content-Struktur |
| Parameter`file_material` | VertragTatsächliches UTF-8-Dokument als wörtlicher Text eingefügt; keine Datei-ID abgeleitet |
| Parameter`optional_controls` | Vertragstream, temperature, top\_p, stop, max\_tokens, max\_completion\_tokens, reasoning, response\_format, tools, tool\_choice |
| Parameter`control_scope` | VertragModellspezifisch; benutzerseitige Funktionswerkzeuge unterscheiden sich von gehosteten Werkzeugen |
| Parameter`output_modalities` | Vertragtext |
| Parameter`hosted_operations` | Vertragfalse |
| Parameter`multimodal_input_binding` | Vertragnull |
Lebenszyklus: `synchronous_or_streamed`
Die genaue Modell-ID zusammen mit messages senden.
Die Kontextlänge ist keine Ausgabeobergrenze.
Eine Textdatei kann wörtlichen Text liefern; Bild-, Audio- und Dateiobjekteingaben benötigen eine exakte Zuordnung.
### Tarife
Tarifangaben erweitern die Anfrageoptionen nicht. Unterstützte Parameter stehen bei der ausgewählten Methode.
Schnellmodus
Standardtarif Wenn der Schnellmodus ausgewählt ist
Flex-Modus
Standardtarif Wenn der Modus flex ausgewählt ist
Maximaler Denkaufwand
Standardtarif Wenn beim maximalen Denkaufwand die Standardanpassung (default) verwendet wird
Denkaufwand · hoch
Standardtarif Wenn der Denkaufwand hoch ist
Denkaufwand · niedrig
Standardtarif Wenn der Denkaufwand niedrig ist
Denkaufwand · mittel
Standardtarif Wenn der Denkaufwand mittel ist
Denkaufwand · xhigh
Standardtarif Wenn der Denkaufwand xhigh ist
#### Ailoot-Tarife
#### Preise nach Konfiguration
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationBasistarife für Token | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnfragelängenstufe 1 | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnfragelängenstufe 2 | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)
### Beispielanfragen
#### Ailoot Ultra · OpenAI Chat
curlPython SDKPython-Stream
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "~x-ai/grok-latest", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
r=json.loads(Path("result.json").read_text())
for x in r.get("choices",[]):
if x.get("message",{}).get("content"): print(x["message"]["content"])
PY_RESULT
```
```python
from openai import OpenAI
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.chat.completions.create(model='~x-ai/grok-latest',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}])
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(result.to_dict(mode="json"))
```
```python
from openai import OpenAI
import os
from pathlib import Path
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
with client.chat.completions.stream(model='~x-ai/grok-latest',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
for event in stream:
payload=event.to_dict(mode="json")
log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
print(json.dumps(payload,ensure_ascii=False))
final=stream.get_final_completion()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Ergebnisse abrufen und speichern
#### Ailoot Ultra · OpenAI Chat
json oder SSE
##### Alle fertiggestellten Ergebnisse aufbewahren
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Antwortvarianten mit ihren Inhalten, Werkzeugaufrufen und Reasoning-Daten beibehalten. In SSE die Deltas nach Varianten- und Werkzeugindex zusammensetzen; endgültigen Beendigungsgrund und Verbrauchsdaten beibehalten.
##### Wenn die ursprüngliche Antwort geprüft werden muss
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
Antwortfelder
| Feld | Typ |
| --- | --- |
| Feld`choices[].index` | Typinteger |
| Feld`choices[].message.content` | Typstring\|null |
| Feld`choices[].message.tool_calls` | Typtool\_call\[\] |
| Feld`choices[].message.reasoning_content` | Typstring |
| Feld`choices[].message.reasoning_details` | Typobject\|array |
| Feld`choices[].finish_reason` | Typstring\|null |
| Feld`usage` | Typobject |
Fehler und nächste Schritte
| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
### Aliasnamen
#### Modellaliasnamen
Ailoot [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=chat), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=chat), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=chat), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=chat)
**Ailoot Ultra** [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=chat), [`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=chat), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=chat)
#### Aliasnamen für Methodenpfade
`/chat/completions`
#### Zugehörige Aufrufer-IDs
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=chat), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=chat), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=chat), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=chat), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=chat), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=chat), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=chat)
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `~x-ai/grok-latest`
[`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=messages)
SpaceXAI /`~x-ai/grok-latest`
Modell-ID
- `grok-4.7`
- `x-ai/grok-4.7`
- `~x-ai/grok-latest`
### Start
Grok 4.7 ist ein xAI-Modell für Softwareentwicklung und professionelle Wissensarbeit. Unterstützt Text, Bilder, 500 000 Tokens Kontext, Funktionsaufrufe und strukturierte Antworten.
Zulässige Eingaben
Text
Ergebnisse
json · sse
### In Ailoot verfügbar · Eingaben und Methoden
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages`
Eingabetypen
`text`
Ausgabetypen
`json`, `sse`
Ausgabeformat
JSON oder SSE
| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits ~x-ai/grok-latest | Standard— |
| Feld`messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`messages[].role` | Typ`string` | AnforderungErforderlich | Werte und Limits user, assistant | Standard— |
| Feld`messages[].content` | Typ`string` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`max_tokens` | Typ`integer` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
Kombinationen von Eingabematerialien
**Text** · UTF-8-Text
`Zeichenfolge messages[].content`
Methodenparameter und Lebenszyklus
| Parameter | Vertrag |
| --- | --- |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`required` | Vertragmodel, messages, max\_tokens |
| Parameter`optional_controls` | Vertragstream |
| Parameter`material_types` | Vertragtext |
| Parameter`text_file_material` | VertragDas tatsächliche UTF-8-Dokument lesen und seinen Text in die angegebene Zeichenfolge für Eingabe oder Nachrichteninhalt einfügen. |
Lebenszyklus: `synchronous_or_streamed`
### Tarife
Tarifangaben erweitern die Anfrageoptionen nicht. Unterstützte Parameter stehen bei der ausgewählten Methode.
Schnellmodus
Standardtarif Wenn der Schnellmodus ausgewählt ist
Flex-Modus
Standardtarif Wenn der Modus flex ausgewählt ist
Maximaler Denkaufwand
Standardtarif Wenn beim maximalen Denkaufwand die Standardanpassung (default) verwendet wird
Denkaufwand · hoch
Standardtarif Wenn der Denkaufwand hoch ist
Denkaufwand · niedrig
Standardtarif Wenn der Denkaufwand niedrig ist
Denkaufwand · mittel
Standardtarif Wenn der Denkaufwand mittel ist
Denkaufwand · xhigh
Standardtarif Wenn der Denkaufwand xhigh ist
#### Ailoot-Tarife
#### Preise nach Konfiguration
Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.
| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationBasistarife für Token | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnfragelängenstufe 1 | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlich200.000 | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.012** / 1K Token Eingabe · Cache-Lesen **$0.001** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnfragelängenstufe 2 | Tarifstaffel— | Kontexttoken, mehr als200.000 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.008** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.002** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)
### Beispielanfragen
#### Ailoot Ultra · Anthropic Messages
Vollständiger minimaler JSON-Bodycurl · eigenes UTF-8-Dokument verwendenPython · das vollständige Ergebnis speichern
```json
{
"model": "~x-ai/grok-latest",
"max_tokens": 128,
"messages": [
{
"role": "user",
"content": "Summarize the incident report."
}
],
"stream": false
}
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json, os
from pathlib import Path
source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
raise SystemExit('Choose a document containing text')
payload = {'model': '~x-ai/grok-latest', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
Path('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
PY_RESULT
```
```python
import json, os
from pathlib import Path
source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
raise SystemExit('Choose a document containing text')
payload = {'model': '~x-ai/grok-latest', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
from urllib.request import Request, urlopen
from urllib.error import HTTPError
api_key = os.environ['AILOOT_API_KEY']
if not api_key.strip():
raise SystemExit('Set AILOOT_API_KEY before making a request')
headers = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}
headers['x-api-key'] = api_key
request = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')
try:
with urlopen(request, timeout=120) as response:
raw = response.read()
Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')
except HTTPError as error:
Path('result.json').write_bytes(error.read())
Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')
raise
Path('result.json').write_bytes(raw)
import json
from pathlib import Path
result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
```
### Ergebnisse abrufen und speichern
#### Ailoot Ultra · Anthropic Messages
JSON oder SSE
##### Alle fertiggestellten Ergebnisse aufbewahren
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Inhaltsblöcke, Thinking-Signaturen und tatsächlichen Werkzeugaufruf-IDs beibehalten. Alle SSE-Blockdeltas zusammensetzen; der erste Textblock ist nicht die vollständige Ausgabe.
##### Wenn die ursprüngliche Antwort geprüft werden muss
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
Antwortfelder
| Feld | Typ |
| --- | --- |
| Feld`id` | Typstring |
| Feld`model` | Typstring |
| Feld`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Feld`stop_reason` | Typstring\|null |
| Feld`usage` | Typobject |
Fehler und nächste Schritte
| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
### Aliasnamen
#### Modellaliasnamen
Ailoot [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=messages), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=messages), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=messages), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=messages)
**Ailoot Ultra** [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=messages), [`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=messages), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=messages)
#### Aliasnamen für Methodenpfade
`/chat/completions`
#### Zugehörige Aufrufer-IDs
[`x-ai/grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=x-ai%2Fgrok-4.7&fmt=messages), [`grok`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok&fmt=messages), [`grok-4.7-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7-latest&fmt=messages), [`grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-latest&fmt=messages), [`~x-ai/grok-latest`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=~x-ai%2Fgrok-latest&fmt=messages), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Core&caller=grok-4.7&fmt=messages), [`grok-4.7`](https://ailoot.ai/models/de/#m=x-ai%2Fgrok-4.7&route=Ultra&caller=grok-4.7&fmt=messages)
FAQ · SpaceXAI: Grok 4.7
Welche Eingaben und Ergebnisse sind verfügbar?
`POST /v1/messages` · `grok-4.7`: `text`, `image` → `text` `POST /v1/responses` · `grok-4.7`: `text`, `image` → `text` `POST /v1/chat/completions` · `grok-4.7`: `text`, `image` → `text` `POST /v1/chat/completions` · `grok-4.7`: `text` → `text` `POST /v1/messages` · `grok-4.7`: `text` → `json`, `sse` `POST /v1/messages` · `grok`: `text`, `image` → `text` `POST /v1/responses` · `grok`: `text`, `image` → `text` `POST /v1/chat/completions` · `grok`: `text`, `image` → `text` `POST /v1/messages` · `grok-4.7-latest`: `text`, `image` → `text` `POST /v1/responses` · `grok-4.7-latest`: `text`, `image` → `text` `POST /v1/chat/completions` · `grok-4.7-latest`: `text`, `image` → `text` `POST /v1/messages` · `grok-latest`: `text`, `image` → `text` `POST /v1/responses` · `grok-latest`: `text`, `image` → `text` `POST /v1/chat/completions` · `grok-latest`: `text`, `image` → `text` `POST /v1/chat/completions` · `x-ai/grok-4.7`: `text` → `text` `POST /v1/messages` · `x-ai/grok-4.7`: `text` → `json`, `sse` `POST /v1/chat/completions` · `~x-ai/grok-latest`: `text` → `text` `POST /v1/messages` · `~x-ai/grok-latest`: `text` → `json`, `sse`
Welche Felder verwendet die Anfrage?
`POST /v1/messages` · `grok-4.7`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1/responses` · `grok-4.7`: `model`, `input`, `instructions`, `stream` `POST /v1/chat/completions` · `grok-4.7`: `model`, `messages`, `stream` `POST /v1/chat/completions` · `grok-4.7`: `model`, `messages`, `stream` `POST /v1/messages` · `grok-4.7`: `model`, `messages`, `max_tokens`, `stream` `POST /v1/messages` · `grok`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1/responses` · `grok`: `model`, `input`, `instructions`, `stream` `POST /v1/chat/completions` · `grok`: `model`, `messages`, `stream` `POST /v1/messages` · `grok-4.7-latest`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1/responses` · `grok-4.7-latest`: `model`, `input`, `instructions`, `stream` `POST /v1/chat/completions` · `grok-4.7-latest`: `model`, `messages`, `stream` `POST /v1/messages` · `grok-latest`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1/responses` · `grok-latest`: `model`, `input`, `instructions`, `stream` `POST /v1/chat/completions` · `grok-latest`: `model`, `messages`, `stream` `POST /v1/chat/completions` · `x-ai/grok-4.7`: `model`, `messages`, `stream`, `modalities`, `provider` `POST /v1/messages` · `x-ai/grok-4.7`: `model`, `messages`, `max_tokens`, `stream` `POST /v1/chat/completions` · `~x-ai/grok-latest`: `model`, `messages`, `stream`, `modalities`, `provider` `POST /v1/messages` · `~x-ai/grok-latest`: `model`, `messages`, `max_tokens`, `stream`
Welche Grenzen gelten?
`POST /v1/messages` · `grok-4.7`: `ctx`: `500000`; `max_out`: `500000`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1/responses` · `grok-4.7`: `ctx`: `500000`; `max_out`: `500000` `POST /v1/chat/completions` · `grok-4.7`: `ctx`: `500000`; `max_out`: `500000`; `messages.min_items`: `1` `POST /v1/chat/completions` · `grok-4.7`: `messages.min_items`: `1` `POST /v1/messages` · `grok`: `ctx`: `500000`; `max_out`: `500000`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1/responses` · `grok`: `ctx`: `500000`; `max_out`: `500000` `POST /v1/chat/completions` · `grok`: `ctx`: `500000`; `max_out`: `500000`; `messages.min_items`: `1` `POST /v1/messages` · `grok-4.7-latest`: `ctx`: `500000`; `max_out`: `500000`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1/responses` · `grok-4.7-latest`: `ctx`: `500000`; `max_out`: `500000` `POST /v1/chat/completions` · `grok-4.7-latest`: `ctx`: `500000`; `max_out`: `500000`; `messages.min_items`: `1` `POST /v1/messages` · `grok-latest`: `ctx`: `500000`; `max_out`: `500000`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1/responses` · `grok-latest`: `ctx`: `500000`; `max_out`: `500000` `POST /v1/chat/completions` · `grok-latest`: `ctx`: `500000`; `max_out`: `500000`; `messages.min_items`: `1` `POST /v1/chat/completions` · `x-ai/grok-4.7`: `messages.min_items`: `1` `POST /v1/chat/completions` · `~x-ai/grok-latest`: `messages.min_items`: `1`
Verbinden Sie Ailoot mit Claude Code, OpenCode, Hermes oder Ihrer eigenen Anwendung.
## Das Unternehmen und sein Projektportfolio
Das Unternehmen und sein Projektportfolio: Millionen von Kunden; monatliche Umsätze in Milliardenhöhe.
## Tokens mit Rabatt kaufen.
Aborabatt für regelmäßige Arbeit. Aktionscodes bieten bis 50% beim Tokenkauf.
Abo
Wählen Sie einen Tarif mit Rabatt für Ihre regelmäßigen Anfragen.
Aktionscode bis 50%
Geben Sie den Code beim Kauf ein. Der Preis wird nach den gültigen Aktionsbedingungen berechnet.
Ausgaben in der Historie
Modell, Tokens und Betrag werden für jede Anfrage gespeichert.
[Abo wählen](https://ailoot.ai/docs/de/billing/subscriptions/) · [Modellpreise ansehen](https://ailoot.ai/models/de/)
## Verbinden Sie die API mit dem Produkt, das Sie verkaufen.
SaaS, Anwendungen und Bots nach dem offiziellen Angebot und Lizenzvertrag von Ailoot. Fordern Sie für den Weiterverkauf eine Reseller-Lizenz an.
Kommerzielle Anwendung
Integrieren Sie Text-, Bild-, Video- und Audioerzeugung in kostenpflichtige Funktionen Ihres Dienstes.
Reseller-Lizenz
Senden Sie Projektbeschreibung und Zugangsmodell. Fordern Sie schriftliche Nutzungs- und Weiterverkaufsbedingungen an.
Dokumente auf der Website
Offizielles Angebot, Lizenzvertrag und Datenschutzerklärung sind vor der Verbindung zugänglich.
[Reseller-Lizenz anfordern](mailto:support@ailoot.ai) · [Offizielles Angebot und Lizenzvertrag](https://ailoot.ai/legal/offer?lang=de)
## Ailoot · Das Unternehmen und sein Projektportfolio
Ailoot baut auf bewährte Betriebserfahrung, einen großen Kundenstamm, stabilen Service und kontinuierliche KPI-Kontrolle.
Das Unternehmen und sein Projektportfolio: Millionen von Kunden; monatliche Umsätze in Milliardenhöhe.
Ailoot nutzt diese Betriebserfahrung für den API-Zugang zu KI-Funktionen in Kundenprodukten, Agenten, Anwendungen und Automatisierungen.