SpaceXAI: Grok 4.6

Grok 4.6 direka untuk kerja berpanjangan pada kod, penyelidikan dan projek interaktif. Ia menerima teks dan imej, menyokong konteks 500 000 token dan empat tahap penaakulan.

Ailoot · Anthropic Messages POST /v1/messages grok-4.6
Ailoot · OpenAI Responses POST /v1/responses grok-4.6
Ailoot · OpenAI Chat POST /v1/chat/completions grok-4.6
Ailoot Ultra · OpenAI Chat POST /v1/chat/completions grok-4.6
Ailoot Ultra · Anthropic Messages POST /v1/messages grok-4.6
Ailoot · Anthropic Messages POST /v1/messages grok-4.6-latest
Ailoot · OpenAI Responses POST /v1/responses grok-4.6-latest
Ailoot · OpenAI Chat POST /v1/chat/completions grok-4.6-latest
Ailoot Ultra · OpenAI Chat POST /v1/chat/completions x-ai/grok-4.6
Ailoot Ultra · Anthropic Messages POST /v1/messages x-ai/grok-4.6

Tentang model

Huraian ini merangkumi keupayaan model. Input, output dan pilihan yang tersedia di Ailoot disenaraikan di bawah untuk kaedah yang dipilih.

Kerja berpanjangan pada projek

Grok 4.6 berfokus pada tugasan yang berterusan merentas banyak langkah: pengkajian topik, analisis bahan, kerja dengan pangkalan kod dan penciptaan aplikasi. Dalam contoh xAI, model menyelidik bidang yang tidak dikenali, menentukan struktur projek, melaksanakan interaksi utama dan memperhalus hasil selepas maklum balas.

Latihan menggunakan tugasan pengaturcaraan dan kerja berasaskan pengetahuan serta persekitaran khusus untuk pembangunan web, pengoptimuman kernel pengkomputeran dan reka bentuk berbantu komputer. Dalam proses berpanjangan, pengeluar menekankan semakan kendiri terhadap kerja yang telah dilakukan sebelum beralih ke langkah seterusnya.

Projek interaktif dan visual

Model boleh menukar idea produk umum menjadi versi awal yang berfungsi, menetapkan struktur serta bahasa visual aplikasi, kemudian menambah baik projek secara berulang. Ini melibatkan kod dan penerangan teks tentang hasil: aplikasi memerlukan alat yang sesuai untuk menjalankan, melihat dan mengubah fail.

Input menyokong teks dan imej, manakala output berupa teks. Satu konteks memuatkan sehingga 500 000 token. Bahan visual boleh digunakan bersama soalan; model teks ini tidak menghasilkan imej atau video berasingan.

Kedalaman pemikiran

Pilihan low, medium, high dan xhigh tersedia; nilai lalai ialah high. Kedalaman rendah sesuai untuk tindakan ejen mudah, sederhana untuk analisis data dan bahan panjang, tinggi untuk tugasan logik yang rumit. xhigh memperuntukkan lebih banyak usaha kepada tugasan paling sukar dan, menurut xAI, meningkatkan latensi.

Penaakulan tidak boleh dimatikan sepenuhnya. Parameter presencePenalty, frequencyPenalty dan stop tidak digunakan dengan model jenis ini. Saiz konteks dan kedalaman pemikiran yang dipilih menerangkan sifat berbeza: tetingkap besar itu sendiri tidak menentukan mod penaakulan.

Penyambungan ke aliran kerja

Grok 4.6 menyokong panggilan fungsi. Model boleh meminta beberapa tindakan dalam satu jawapan; kod anda melaksanakannya, mengembalikan hasil dan meneruskan dialog. Nama dan skema argumen ditetapkan untuk alat, manakala pemilihan panggilan boleh dibiarkan automatik atau dikawal secara jelas.

Jawapan berstruktur sesuai untuk mengekstrak data daripada dokumen dan menghantar hasil kepada program: JSON atau JSON mengikut skema anda sendiri boleh diminta. Jenis data, objek bersarang, tatasusunan dan enumerasi disokong. Bagi syarat skema yang rumit, satu penjanaan tidak mencukupi: kekangan yang tidak dijamin oleh struktur diperiksa dalam aplikasi.

Senario utama model ialah meneruskan kerja yang bermakna pada tugasan rumit dengan menggabungkan analisis, kod dan maklum balas. Proses penuh terdiri daripada jawapan model dan tindakan alat yang disambungkan.

Tugas praktikal

Contoh teknikal dalam bahasa Inggeris

Review a multi-step import design

Review this CSV-import plan: parse rows, insert records, then validate required email fields. Requirement: one invalid row must reject the entire import, with no new records left behind. Propose a corrected sequence, explain transaction boundaries, and list tests for a valid batch, one invalid row and a database failure. Use framework-neutral pseudocode.

Hasil yang dijangka

A corrected import sequence and three test specifications distinguishing validation failure from persistence failure.

Semak hasil

Neither an invalid row nor a failed database write leaves a partially imported batch.

Ailoot · Anthropic Messages POST /v1/messages grok-4.6

grok-4.6

SpaceXAI /grok-4.6

ID model

grok-4.6
grok-4.6-latest

Pengenalan

Grok 4.6 direka untuk kerja berpanjangan pada kod, penyelidikan dan projek interaktif. Ia menerima teks dan imej, menyokong konteks 500 000 token dan empat tahap penaakulan.

Input yang diterima: Teks · Imej
Hasil: Teks

Tersedia di Ailoot · input & kaedah

Ailoot · Anthropic Messages POST /v1/messages

Input: text, image
Output: text
Konteks: 500,000 tokens
Output maksimum: 500,000 tokens
Format output: json atau SSE

Medan	Jenis	Keperluan	Nilai & had	Lalai
Medan`model`	Jenis`string`	KeperluanDiperlukan	Nilai & had grok-4.6	Lalai—
Medan`messages`	Jenis`message[]`	KeperluanDiperlukan	Nilai & had Item minimum: 1	Lalai—
Medan`messages[].role`	Jenis`string`	KeperluanDiperlukan	Nilai & had user, assistant	Lalai—
Medan`messages[].content`	Jenis`string\|content_block[]`	KeperluanDiperlukan	Nilai & had	Lalai—
Medan`system`	Jenis`string\|content_block[]`	KeperluanPilihan	Nilai & had	Lalai—
Medan`max_tokens`	Jenis`integer`	KeperluanDiperlukan	Nilai & had Minimum: 1 Had terpakai pada: had maksimum tepat bagi model/kad yang dipilih	Lalai—
Medan`stream`	Jenis`boolean`	KeperluanPilihan	Nilai & had	Lalaifalse
Medan`temperature`	Jenis`number`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`top_p`	Jenis`number`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`stop_sequences`	Jenis`string[]`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`tools`	Jenis`tool[]`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`tools[].name`	Jenis`string`	KeperluanPilihan	Nilai & had Terpakai apabila: alat dibekalkan	Lalai—
Medan`tools[].description`	Jenis`string`	KeperluanPilihan	Nilai & had	Lalai—
Medan`tools[].input_schema`	Jenis`JSON_schema`	KeperluanPilihan	Nilai & had	Lalai—
Medan`tool_choice`	Jenis`object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`thinking.type`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`thinking.budget_tokens`	Jenis`integer`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`output_config.effort`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`metadata`	Jenis`object`	KeperluanPilihan	Nilai & had	Lalai—
Medan`cache_control`	Jenis`object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—

Gabungan bahan input

Teks · Teks UTF8

messages[].content atau blok type=text

Teks + imej

{type:image,source:{type:base64,media_type,data}} atau sumber dengan type=url

Parameter kaedah dan kitar hayat

Parameter	Kontrak
Parameter`material_types`	Kontraktext, image
Parameter`required`	Kontrakmodel, messages, max_tokens
Parameter`optional_controls`	Kontraknull
Parameter`content_type`	Kontrakapplication/json
Parameter`text_file_material`	Kontrakkandungan UTF-8 sebenar dimasukkan sebagai teks; ID fail atau alamat URL (URLs) memerlukan sokongan tepat yang berasingan

Kitar hayat: exact retained published method

Struktur kaedah dan ID adalah tepat; keupayaan pembekal berasingan daripada penerimaan permintaan.

Pelan harga

Kadar kaedah Ailoot

Ailoot Anthropic MessagesPOST /v1/messages

Input: USD 0.002 / 1K
Output: USD 0.006 / 1K
Bacaan cache: USD 0.0005 / 1K
Penulisan cache: USD 0.00 / 1K
Penulisan cache, 5 minit: USD 0.00 / 1K tokens
Penulisan cache, 1 jam: USD 0.00 / 1K tokens

Harga mengikut panjang permintaan · Anthropic Messages

Saiz permintaan, token	Input	Output	Bacaan cache	Penulisan cache	Cache 5 minit	Cache 1 jam
Saiz permintaan, token(0; 200,000]	InputUSD 0.002	OutputUSD 0.006	Bacaan cacheUSD 0.0005	Penulisan cacheUSD 0.00	Cache 5 minitUSD 0.00	Cache 1 jamUSD 0.00
Saiz permintaan, token(200,000; ∞)	InputUSD 0.004	OutputUSD 0.012	Bacaan cacheUSD 0.001	Penulisan cacheUSD 0.00	Cache 5 minitUSD 0.00	Cache 1 jamUSD 0.00

Kadar dalam USD setiap 1K token. Jika tiada kadar ditetapkan, kadar asas kaedah ini diwarisi; «—» bermaksud tiada kadar asas ditetapkan.

Ailoot merizabkan anggaran amaun sebelum permintaan. Selepas hasil diterima, caj akhir diselesaikan berdasarkan penggunaan terukur. Penyelesaian caj penstriman menggunakan rekod penggunaan akhir. Cara rizab dan penyelesaian caj berfungsi →

Butiran tarif rujukan

Jadual rujukan peringkat model tidak mengubah pemilihan kaedah, sebut harga atau caj. Caj aktif menggunakan kadar kaedah Ailoot yang dipilih.

Jadual rujukan model

Harga mengikut konfigurasi

Padankan setiap caj dengan syarat yang dipaparkan. Gunakan satu kadar bagi setiap set konfigurasi alternatif.

Konfigurasi	Jadual kadar	Token konteks, melebihi	Token konteks, sehingga dan termasuk	Caj
KonfigurasiOpenAI Chat · Kadar asas token	Jadual kadarKadar asas	Token konteks, melebihi—	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiOpenAI Chat · Tahap 1 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi0	Token konteks, sehingga dan termasuk200,000	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiOpenAI Chat · Tahap 2 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi200,000	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.008 / 1K token Output · Token output $0.024 / 1K token Input · Bacaan cache $0.002 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiAnthropic Messages · Kadar asas token	Jadual kadarKadar asas	Token konteks, melebihi—	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiAnthropic Messages · Tahap 1 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi0	Token konteks, sehingga dan termasuk200,000	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiAnthropic Messages · Tahap 2 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi200,000	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.008 / 1K token Output · Token output $0.024 / 1K token Input · Bacaan cache $0.002 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token

Contoh permintaan

Ailoot · Anthropic Messages

Contoh teksInput, imejPython SDKNode.js SDKPenstriman Python

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.6", "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

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.6", "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

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.6",
    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"))

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.6",
  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);

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.6',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")

Terima dan simpan hasil

Ailoot · Anthropic Messages

json atau SSE

Simpan semua hasil yang selesai

Simpan setiap respons lengkap, fail dan bahagian kandungan yang dikembalikan.

Kekalkan semua blok kandungan, tandatangan penaakulan dan ID penggunaan alat sebenar. Gabungkan semua delta blok SSE; blok teks pertama bukan keseluruhan output.

Jika respons asal perlu disemak

Kekalkan ID permintaan/respons dan pengepala. Tiada URL umum bagi pengambilan tugas teks dibekalkan.

Medan respons

Medan	Jenis
Medan`id`	Jenisstring
Medan`model`	Jenisstring
Medan`content[]`	Jenistext\|thinking\|tool_use\|other content block
Medan`stop_reason`	Jenisstring\|null
Medan`usage`	Jenisobject

Ralat dan langkah seterusnya

Respons	Syarat	Langkah seterusnya
Respons400 · `invalid_request_error`	SyaratMedan wajib, perwakilan bahan atau nilai parameter tidak sah	Langkah seterusnyaBetulkan medan yang ditunjukkan sebelum permintaan penciptaan baharu.

Alias

Alias model

Ailoot grok-4.6, grok-4.6-latest
Ailoot Ultra grok-4.6, x-ai/grok-4.6

Alias laluan kaedah

/chat/completions

ID pemanggil berkaitan

x-ai/grok-4.6, grok-4.6-latest, grok-4.6, grok-4.6

Ailoot · OpenAI Responses POST /v1/responses grok-4.6

grok-4.6

SpaceXAI /grok-4.6

ID model

grok-4.6
grok-4.6-latest

Pengenalan

Grok 4.6 direka untuk kerja berpanjangan pada kod, penyelidikan dan projek interaktif. Ia menerima teks dan imej, menyokong konteks 500 000 token dan empat tahap penaakulan.

Input yang diterima: Teks · Imej
Hasil: Teks

Tersedia di Ailoot · input & kaedah

Ailoot · OpenAI Responses POST /v1/responses

Input: text, image
Output: text
Konteks: 500,000 tokens
Output maksimum: 500,000 tokens
Format output: json atau SSE

Medan	Jenis	Keperluan	Nilai & had	Lalai
Medan`model`	Jenis`string`	KeperluanDiperlukan	Nilai & had grok-4.6	Lalai—
Medan`input`	Jenis`string\|input_item[]`	KeperluanDiperlukan	Nilai & had	Lalai—
Medan`instructions`	Jenis`string`	KeperluanPilihan	Nilai & had	Lalai—
Medan`input[].type`	Jenis`string`	KeperluanPilihan	Nilai & had message, reasoning, function_call, function_call_output	Lalai—
Medan`input[].content`	Jenis`string\|content_part[]`	KeperluanPilihan	Nilai & had	Lalai—
Medan`input[].call_id`	Jenis`string`	KeperluanPilihan	Nilai & had Terpakai apabila: function_call_output; kekalkan call_id sebenar yang dipulangkan	Lalai—
Medan`input[].output`	Jenis`string\|content_part[]`	KeperluanPilihan	Nilai & had Terpakai apabila: function_call_output	Lalai—
Medan`max_output_tokens`	Jenis`integer`	KeperluanPilihan	Nilai & had Minimum: 1 Bergantung pada model	Lalai—
Medan`stream`	Jenis`boolean`	KeperluanPilihan	Nilai & had	Lalaifalse
Medan`temperature`	Jenis`number`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`top_p`	Jenis`number`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`tools`	Jenis`tool[]`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`tool_choice`	Jenis`string\|object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`parallel_tool_calls`	Jenis`boolean`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`reasoning.effort`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`reasoning.summary`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`text.format`	Jenis`object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`text.verbosity`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`include`	Jenis`string[]`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`store`	Jenis`boolean`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`previous_response_id`	Jenis`string`	KeperluanPilihan	Nilai & had Keperluan ID: Hanya ID respons sebenar daripada penerusan yang disokong Bergantung pada model	Lalai—
Medan`service_tier`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`prompt_cache_key`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`prompt_cache_options`	Jenis`object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—

Gabungan bahan input

Teks · Teks UTF8

Teks input atau bahagian input_text

Teks + imej

{type:input_image,image_url}

Parameter kaedah dan kitar hayat

Parameter	Kontrak
Parameter`material_types`	Kontraktext, image
Parameter`required`	Kontrakmodel, input
Parameter`optional_controls`	Kontraknull
Parameter`content_type`	Kontrakapplication/json
Parameter`text_file_material`	Kontrakkandungan UTF-8 sebenar dimasukkan sebagai teks; ID fail atau alamat URL (URLs) memerlukan sokongan tepat yang berasingan

Kitar hayat: exact retained published method

Struktur kaedah dan ID adalah tepat; keupayaan pembekal berasingan daripada penerimaan permintaan.

Pelan harga

Kadar kaedah Ailoot

Ailoot OpenAI ResponsesPOST /v1/responses

Input: USD 0.002 / 1K
Output: USD 0.006 / 1K
Bacaan cache: USD 0.0005 / 1K
Penulisan cache: USD 0.00 / 1K
Penulisan cache, 5 minit: USD 0.00 / 1K tokens
Penulisan cache, 1 jam: USD 0.00 / 1K tokens

Harga mengikut panjang permintaan · OpenAI Responses

Saiz permintaan, token	Input	Output	Bacaan cache	Penulisan cache	Cache 5 minit	Cache 1 jam
Saiz permintaan, token(0; 200,000]	InputUSD 0.002	OutputUSD 0.006	Bacaan cacheUSD 0.0005	Penulisan cacheUSD 0.00	Cache 5 minitUSD 0.00	Cache 1 jamUSD 0.00
Saiz permintaan, token(200,000; ∞)	InputUSD 0.004	OutputUSD 0.012	Bacaan cacheUSD 0.001	Penulisan cacheUSD 0.00	Cache 5 minitUSD 0.00	Cache 1 jamUSD 0.00

Kadar dalam USD setiap 1K token. Jika tiada kadar ditetapkan, kadar asas kaedah ini diwarisi; «—» bermaksud tiada kadar asas ditetapkan.

Butiran tarif rujukan

Jadual rujukan peringkat model tidak mengubah pemilihan kaedah, sebut harga atau caj. Caj aktif menggunakan kadar kaedah Ailoot yang dipilih.

Jadual rujukan model

Harga mengikut konfigurasi

Padankan setiap caj dengan syarat yang dipaparkan. Gunakan satu kadar bagi setiap set konfigurasi alternatif.

Konfigurasi	Jadual kadar	Token konteks, melebihi	Token konteks, sehingga dan termasuk	Caj
KonfigurasiOpenAI Chat · Kadar asas token	Jadual kadarKadar asas	Token konteks, melebihi—	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiOpenAI Chat · Tahap 1 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi0	Token konteks, sehingga dan termasuk200,000	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiOpenAI Chat · Tahap 2 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi200,000	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.008 / 1K token Output · Token output $0.024 / 1K token Input · Bacaan cache $0.002 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiAnthropic Messages · Kadar asas token	Jadual kadarKadar asas	Token konteks, melebihi—	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiAnthropic Messages · Tahap 1 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi0	Token konteks, sehingga dan termasuk200,000	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiAnthropic Messages · Tahap 2 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi200,000	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.008 / 1K token Output · Token output $0.024 / 1K token Input · Bacaan cache $0.002 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token

Contoh permintaan

Ailoot · OpenAI Responses

Contoh teksInput, imejPython SDKNode.js SDKPenstriman Python

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.6", "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

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.6", "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

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.6", 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"))

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.6", 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);

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.6", 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")

Terima dan simpan hasil

Ailoot · OpenAI Responses

json atau SSE

Simpan semua hasil yang selesai

Simpan setiap respons lengkap, fail dan bahagian kandungan yang dikembalikan.

Kekalkan setiap item output dan bahagian kandungan, call_id fungsi sebenar, penaakulan disulitkan serta data penggunaan. Semasa penstriman, kekalkan identiti peristiwa/item yang lengkap.

Jika respons asal perlu disemak

Kekalkan ID permintaan/respons dan pengepala. Tiada URL umum bagi pengambilan tugas teks dibekalkan.

Medan respons

Medan	Jenis
Medan`id`	Jenisstring
Medan`status`	Jenisstring
Medan`output[]`	Jenismessage\|reasoning\|function_call\|other item
Medan`output[].content[]`	Jeniscontent part
Medan`usage`	Jenisobject

Ralat dan langkah seterusnya

Respons	Syarat	Langkah seterusnya
Respons400 · `invalid_request_error`	SyaratMedan wajib, perwakilan bahan atau nilai parameter tidak sah	Langkah seterusnyaBetulkan medan yang ditunjukkan sebelum permintaan penciptaan baharu.

Alias

Alias model

Ailoot grok-4.6, grok-4.6-latest
Ailoot Ultra grok-4.6, x-ai/grok-4.6

Alias laluan kaedah

/chat/completions

ID pemanggil berkaitan

x-ai/grok-4.6, grok-4.6-latest, grok-4.6, grok-4.6

Ailoot · OpenAI Chat POST /v1/chat/completions grok-4.6

grok-4.6

SpaceXAI /grok-4.6

ID model

grok-4.6
grok-4.6-latest

Pengenalan

Grok 4.6 direka untuk kerja berpanjangan pada kod, penyelidikan dan projek interaktif. Ia menerima teks dan imej, menyokong konteks 500 000 token dan empat tahap penaakulan.

Input yang diterima: Teks · Imej
Hasil: Teks

Tersedia di Ailoot · input & kaedah

Ailoot · OpenAI Chat POST /v1/chat/completions

Input: text, image
Output: text
Konteks: 500,000 tokens
Output maksimum: 500,000 tokens
Format output: json atau SSE

Medan	Jenis	Keperluan	Nilai & had	Lalai
Medan`model`	Jenis`string`	KeperluanDiperlukan	Nilai & had grok-4.6	Lalai—
Medan`messages`	Jenis`message[]`	KeperluanDiperlukan	Nilai & had Item minimum: 1	Lalai—
Medan`messages[].role`	Jenis`string`	KeperluanDiperlukan	Nilai & had Contoh: system, user, assistant, tool, function Syarat: Peranan ini diwakili secara eksplisit oleh jenis keserasian dalam kod sumber; set peranan model yang tepat kekal khusus untuk setiap model. Bergantung pada model	Lalai—
Medan`messages[].content`	Jenis`string\|content_part[]\|null`	KeperluanPilihan	Nilai & had	Lalai—
Medan`messages[].tool_calls`	Jenis`tool_call[]`	KeperluanPilihan	Nilai & had	Lalai—
Medan`messages[].tool_call_id`	Jenis`string`	KeperluanPilihan	Nilai & had Terpakai apabila: role=tool; gunakan ID sebenar yang dipulangkan	Lalai—
Medan`messages[].name`	Jenis`string`	KeperluanPilihan	Nilai & had	Lalai—
Medan`messages[].reasoning_content`	Jenis`string`	KeperluanPilihan	Nilai & had Terpakai apabila: Hantar semula penaakulan sebenar yang dipulangkan apabila model ini menggunakannya	Lalai—
Medan`messages[].reasoning_details`	Jenis`object\|array`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`max_tokens`	Jenis`integer`	KeperluanPilihan	Nilai & had Minimum: 1 Bergantung pada model	Lalai—
Medan`max_completion_tokens`	Jenis`integer`	KeperluanPilihan	Nilai & had Minimum: 1 Bergantung pada model	Lalai—
Medan`stream`	Jenis`boolean`	KeperluanPilihan	Nilai & had	Lalaifalse
Medan`stream_options.include_usage`	Jenis`boolean`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`temperature`	Jenis`number`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`top_p`	Jenis`number`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`stop`	Jenis`string\|string[]`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`tools`	Jenis`function_tool[]`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`tools[].type`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`tools[].function.name`	Jenis`string`	KeperluanDiperlukan	Nilai & had Terpakai apabila: alat fungsi dibekalkan	Lalai—
Medan`tools[].function.description`	Jenis`string`	KeperluanPilihan	Nilai & had	Lalai—
Medan`tools[].function.parameters`	Jenis`JSON_schema`	KeperluanPilihan	Nilai & had	Lalai—
Medan`tool_choice`	Jenis`string\|object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`parallel_tool_calls`	Jenis`boolean`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`response_format`	Jenis`object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`reasoning_effort`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`reasoning`	Jenis`object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`service_tier`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`instructions`	Jenis`string`	KeperluanPilihan	Nilai & had Medan keserasian	Lalai—
Medan`functions`	Jenis`function[]`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`function_call`	Jenis`string\|object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`prompt_cache_options`	Jenis`object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—

Gabungan bahan input

Teks · Teks UTF8

messages[].content

Teks + imej

{type:image_url,image_url:{url,detail}}

Parameter kaedah dan kitar hayat

Parameter	Kontrak
Parameter`material_types`	Kontraktext, image
Parameter`required`	Kontrakmodel, messages
Parameter`optional_controls`	Kontraknull
Parameter`content_type`	Kontrakapplication/json
Parameter`text_file_material`	Kontrakkandungan UTF-8 sebenar dimasukkan sebagai teks; ID fail atau alamat URL (URLs) memerlukan sokongan tepat yang berasingan

Kitar hayat: exact retained published method

Struktur kaedah dan ID adalah tepat; keupayaan pembekal berasingan daripada penerimaan permintaan.

Pelan harga

Kadar kaedah Ailoot

Ailoot OpenAI ChatPOST /v1/chat/completions

Input: USD 0.002 / 1K
Output: USD 0.006 / 1K
Bacaan cache: USD 0.0005 / 1K
Penulisan cache: USD 0.00 / 1K
Penulisan cache, 5 minit: USD 0.00 / 1K tokens
Penulisan cache, 1 jam: USD 0.00 / 1K tokens

Harga mengikut panjang permintaan · OpenAI Chat

Saiz permintaan, token	Input	Output	Bacaan cache	Penulisan cache	Cache 5 minit	Cache 1 jam
Saiz permintaan, token(0; 200,000]	InputUSD 0.002	OutputUSD 0.006	Bacaan cacheUSD 0.0005	Penulisan cacheUSD 0.00	Cache 5 minitUSD 0.00	Cache 1 jamUSD 0.00
Saiz permintaan, token(200,000; ∞)	InputUSD 0.004	OutputUSD 0.012	Bacaan cacheUSD 0.001	Penulisan cacheUSD 0.00	Cache 5 minitUSD 0.00	Cache 1 jamUSD 0.00

Kadar dalam USD setiap 1K token. Jika tiada kadar ditetapkan, kadar asas kaedah ini diwarisi; «—» bermaksud tiada kadar asas ditetapkan.

Butiran tarif rujukan

Jadual rujukan peringkat model tidak mengubah pemilihan kaedah, sebut harga atau caj. Caj aktif menggunakan kadar kaedah Ailoot yang dipilih.

Jadual rujukan model

Harga mengikut konfigurasi

Padankan setiap caj dengan syarat yang dipaparkan. Gunakan satu kadar bagi setiap set konfigurasi alternatif.

Konfigurasi	Jadual kadar	Token konteks, melebihi	Token konteks, sehingga dan termasuk	Caj
KonfigurasiOpenAI Chat · Kadar asas token	Jadual kadarKadar asas	Token konteks, melebihi—	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiOpenAI Chat · Tahap 1 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi0	Token konteks, sehingga dan termasuk200,000	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiOpenAI Chat · Tahap 2 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi200,000	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.008 / 1K token Output · Token output $0.024 / 1K token Input · Bacaan cache $0.002 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiAnthropic Messages · Kadar asas token	Jadual kadarKadar asas	Token konteks, melebihi—	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiAnthropic Messages · Tahap 1 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi0	Token konteks, sehingga dan termasuk200,000	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiAnthropic Messages · Tahap 2 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi200,000	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.008 / 1K token Output · Token output $0.024 / 1K token Input · Bacaan cache $0.002 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token

Contoh permintaan

Ailoot · OpenAI Chat

Contoh teksInput, imejPython SDKNode.js SDKPenstriman Python

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.6", "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

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.6", "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

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.6",
    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"))

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.6",
  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);

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.6',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")

Terima dan simpan hasil

Ailoot · OpenAI Chat

json atau SSE

Simpan semua hasil yang selesai

Simpan setiap respons lengkap, fail dan bahagian kandungan yang dikembalikan.

Kekalkan setiap pilihan jawapan bersama kandungan, panggilan alat dan penaakulannya. Dalam SSE, gabungkan delta mengikut indeks pilihan jawapan/alat dan kekalkan sebab penamatan akhir serta data penggunaan.

Jika respons asal perlu disemak

Kekalkan ID permintaan/respons dan pengepala. Tiada URL umum bagi pengambilan tugas teks dibekalkan.

Medan respons

Medan	Jenis
Medan`choices[].index`	Jenisinteger
Medan`choices[].message.content`	Jenisstring\|null
Medan`choices[].message.tool_calls`	Jenistool_call[]
Medan`choices[].message.reasoning_content`	Jenisstring
Medan`choices[].message.reasoning_details`	Jenisobject\|array
Medan`choices[].finish_reason`	Jenisstring\|null
Medan`usage`	Jenisobject

Ralat dan langkah seterusnya

Respons	Syarat	Langkah seterusnya
Respons400 · `invalid_request_error`	SyaratMedan wajib, perwakilan bahan atau nilai parameter tidak sah	Langkah seterusnyaBetulkan medan yang ditunjukkan sebelum permintaan penciptaan baharu.

Alias

Alias model

Ailoot grok-4.6, grok-4.6-latest
Ailoot Ultra grok-4.6, x-ai/grok-4.6

Alias laluan kaedah

/chat/completions

ID pemanggil berkaitan

x-ai/grok-4.6, grok-4.6-latest, grok-4.6, grok-4.6

Ailoot Ultra · OpenAI Chat POST /v1/chat/completions grok-4.6

grok-4.6

SpaceXAI /grok-4.6

ID model

grok-4.6
x-ai/grok-4.6

Pengenalan

Grok 4.6 direka untuk kerja berpanjangan pada kod, penyelidikan dan projek interaktif. Ia menerima teks dan imej, menyokong konteks 500 000 token dan empat tahap penaakulan.

Input yang diterima: Teks
Hasil: Teks

Tersedia di Ailoot · input & kaedah

Ailoot Ultra · OpenAI Chat POST /v1/chat/completions

Input: text
Output: text
Format output: json atau SSE

Medan	Jenis	Keperluan	Nilai & had	Lalai
Medan`model`	Jenis`string`	KeperluanDiperlukan	Nilai & had grok-4.6	Lalai—
Medan`messages`	Jenis`message[]`	KeperluanDiperlukan	Nilai & had Item minimum: 1	Lalai—
Medan`messages[].role`	Jenis`string`	KeperluanDiperlukan	Nilai & had Bergantung pada model	Lalai—
Medan`messages[].content`	Jenis`string`	KeperluanPilihan	Nilai & had Terpakai apabila: Perbualan teks	Lalai—
Medan`stream`	Jenis`boolean`	KeperluanPilihan	Nilai & had	Lalaifalse

Gabungan bahan input

Teks · Teks UTF8

messages[].content

Parameter kaedah dan kitar hayat

Parameter	Kontrak
Parameter`content_type`	Kontrakapplication/json
Parameter`required`	Kontrakmodel, messages
Parameter`material_types`	Kontraktext
Parameter`messages`	Kontraktatasusunan mesej dengan struktur role/content
Parameter`file_material`	Kontrakdokumen UTF-8 sebenar dimasukkan sebagai teks literal; ID fail tidak diandaikan
Parameter`optional_controls`	Kontrakstream
Parameter`control_scope`	KontrakPerbualan teks; stream ialah nilai boolean dengan false sebagai lalai.
Parameter`output_modalities`	Kontraktext
Parameter`hosted_operations`	Kontrakfalse
Parameter`multimodal_input_binding`	Kontraknull

Alias kaedah: /chat/completions

Kitar hayat: synchronous_or_streamed

Hantar ID model yang tepat bersama messages.

Panjang konteks bukan had output.

Fail teks boleh membekalkan teks literal; input imej/audio/objek fail memerlukan pengikatan tepat.

Pelan harga

Rujukan tarif tidak menambah pilihan permintaan. Parameter yang disokong disenaraikan untuk kaedah yang dipilih.

Mod pantas: Kadar standard Apabila mod pantas dipilih
Mod flex: Kadar standard Apabila mod flex dipilih
Usaha penaakulan maksimum: Kadar standard Apabila usaha penaakulan maksimum menggunakan pelarasan default
Usaha penaakulan · high: Kadar standard Apabila usaha penaakulan ditetapkan kepada high
Usaha penaakulan · low: Kadar standard Apabila usaha penaakulan ditetapkan kepada low
Usaha penaakulan · medium: Kadar standard Apabila usaha penaakulan ditetapkan kepada medium
Usaha penaakulan · xhigh: Kadar standard Apabila usaha penaakulan ditetapkan kepada xhigh

Kadar Ailoot

Harga mengikut konfigurasi

Padankan setiap caj dengan syarat yang dipaparkan. Gunakan satu kadar bagi setiap set konfigurasi alternatif.

Konfigurasi	Jadual kadar	Token konteks, melebihi	Token konteks, sehingga dan termasuk	Caj
KonfigurasiKadar asas token	Jadual kadarKadar asas	Token konteks, melebihi—	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiTahap panjang permintaan 1	Jadual kadar—	Token konteks, melebihi0	Token konteks, sehingga dan termasuk200,000	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiTahap panjang permintaan 2	Jadual kadar—	Token konteks, melebihi200,000	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.008 / 1K token Output · Token output $0.024 / 1K token Input · Bacaan cache $0.002 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token

Contoh permintaan

Ailoot Ultra · OpenAI Chat

curlPython SDK

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.6","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

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.6", 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"))

Terima dan simpan hasil

Ailoot Ultra · OpenAI Chat

json atau SSE

Simpan semua hasil yang selesai

Simpan setiap respons lengkap, fail dan bahagian kandungan yang dikembalikan.

Jika respons asal perlu disemak

Kekalkan ID permintaan/respons dan pengepala. Tiada URL umum bagi pengambilan tugas teks dibekalkan.

Medan respons

Medan	Jenis
Medan`choices[].index`	Jenisinteger
Medan`choices[].message.content`	Jenisstring\|null
Medan`choices[].message.tool_calls`	Jenistool_call[]
Medan`choices[].message.reasoning_content`	Jenisstring
Medan`choices[].message.reasoning_details`	Jenisobject\|array
Medan`choices[].finish_reason`	Jenisstring\|null
Medan`usage`	Jenisobject

Ralat dan langkah seterusnya

Respons	Syarat	Langkah seterusnya
Respons400 · `invalid_request_error`	SyaratMedan wajib, perwakilan bahan atau nilai parameter tidak sah	Langkah seterusnyaBetulkan medan yang ditunjukkan sebelum permintaan penciptaan baharu.

Alias

Alias model

Ailoot grok-4.6, grok-4.6-latest
Ailoot Ultra grok-4.6, x-ai/grok-4.6

Alias laluan kaedah

/chat/completions

ID pemanggil berkaitan

x-ai/grok-4.6, grok-4.6-latest, grok-4.6, grok-4.6

Ailoot Ultra · Anthropic Messages POST /v1/messages grok-4.6

grok-4.6

SpaceXAI /grok-4.6

ID model

grok-4.6
x-ai/grok-4.6

Pengenalan

Grok 4.6 direka untuk kerja berpanjangan pada kod, penyelidikan dan projek interaktif. Ia menerima teks dan imej, menyokong konteks 500 000 token dan empat tahap penaakulan.

Input yang diterima: Teks
Hasil: json · sse

Tersedia di Ailoot · input & kaedah

Ailoot Ultra · Anthropic Messages POST /v1/messages

Input: text
Output: json, sse
Format output: JSON atau SSE

Medan	Jenis	Keperluan	Nilai & had	Lalai
Medan`model`	Jenis`string`	KeperluanDiperlukan	Nilai & had grok-4.6	Lalai—
Medan`messages`	Jenis`message[]`	KeperluanDiperlukan	Nilai & had	Lalai—
Medan`messages[].role`	Jenis`string`	KeperluanDiperlukan	Nilai & had user, assistant	Lalai—
Medan`messages[].content`	Jenis`string`	KeperluanDiperlukan	Nilai & had	Lalai—
Medan`max_tokens`	Jenis`integer`	KeperluanDiperlukan	Nilai & had	Lalai—
Medan`stream`	Jenis`boolean`	KeperluanPilihan	Nilai & had	Lalaifalse

Gabungan bahan input

Teks · Teks UTF-8

rentetan messages[].content

Parameter kaedah dan kitar hayat

Parameter	Kontrak
Parameter`content_type`	Kontrakapplication/json
Parameter`required`	Kontrakmodel, messages, max_tokens
Parameter`optional_controls`	Kontrakstream
Parameter`material_types`	Kontraktext
Parameter`text_file_material`	KontrakBaca dokumen UTF-8 sebenar dan letakkan teksnya dalam rentetan input atau kandungan mesej yang ditunjukkan.

Kitar hayat: synchronous_or_streamed

Pelan harga

Rujukan tarif tidak menambah pilihan permintaan. Parameter yang disokong disenaraikan untuk kaedah yang dipilih.

Mod pantas: Kadar standard Apabila mod pantas dipilih
Mod flex: Kadar standard Apabila mod flex dipilih
Usaha penaakulan maksimum: Kadar standard Apabila usaha penaakulan maksimum menggunakan pelarasan default
Usaha penaakulan · high: Kadar standard Apabila usaha penaakulan ditetapkan kepada high
Usaha penaakulan · low: Kadar standard Apabila usaha penaakulan ditetapkan kepada low
Usaha penaakulan · medium: Kadar standard Apabila usaha penaakulan ditetapkan kepada medium
Usaha penaakulan · xhigh: Kadar standard Apabila usaha penaakulan ditetapkan kepada xhigh

Kadar Ailoot

Harga mengikut konfigurasi

Padankan setiap caj dengan syarat yang dipaparkan. Gunakan satu kadar bagi setiap set konfigurasi alternatif.

Konfigurasi	Jadual kadar	Token konteks, melebihi	Token konteks, sehingga dan termasuk	Caj
KonfigurasiKadar asas token	Jadual kadarKadar asas	Token konteks, melebihi—	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiTahap panjang permintaan 1	Jadual kadar—	Token konteks, melebihi0	Token konteks, sehingga dan termasuk200,000	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiTahap panjang permintaan 2	Jadual kadar—	Token konteks, melebihi200,000	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.008 / 1K token Output · Token output $0.024 / 1K token Input · Bacaan cache $0.002 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token

Contoh permintaan

Ailoot Ultra · Anthropic Messages

Badan JSON minimum yang lengkapcurl · gunakan dokumen UTF-8 andaPython · simpan hasil lengkap

{
  "model": "grok-4.6",
  "max_tokens": 128,
  "messages": [
    {
      "role": "user",
      "content": "Summarize the incident report."
    }
  ],
  "stream": false
}

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.6', '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

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.6', '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))

Terima dan simpan hasil

Ailoot Ultra · Anthropic Messages

JSON atau SSE

Simpan semua hasil yang selesai

Simpan setiap respons lengkap, fail dan bahagian kandungan yang dikembalikan.

Kekalkan semua blok kandungan, tandatangan penaakulan dan ID penggunaan alat sebenar. Gabungkan semua delta blok SSE; blok teks pertama bukan keseluruhan output.

Jika respons asal perlu disemak

Kekalkan ID permintaan/respons dan pengepala. Tiada URL umum bagi pengambilan tugas teks dibekalkan.

Medan respons

Medan	Jenis
Medan`id`	Jenisstring
Medan`model`	Jenisstring
Medan`content[]`	Jenistext\|thinking\|tool_use\|other content block
Medan`stop_reason`	Jenisstring\|null
Medan`usage`	Jenisobject

Ralat dan langkah seterusnya

Respons	Syarat	Langkah seterusnya
Respons400 · `invalid_request_error`	SyaratMedan wajib, perwakilan bahan atau nilai parameter tidak sah	Langkah seterusnyaBetulkan medan yang ditunjukkan sebelum permintaan penciptaan baharu.

Alias

Alias model

Ailoot grok-4.6, grok-4.6-latest
Ailoot Ultra grok-4.6, x-ai/grok-4.6

Alias laluan kaedah

/chat/completions

ID pemanggil berkaitan

x-ai/grok-4.6, grok-4.6-latest, grok-4.6, grok-4.6

Ailoot · Anthropic Messages POST /v1/messages grok-4.6-latest

grok-4.6-latest

SpaceXAI /grok-4.6-latest

ID model

grok-4.6
grok-4.6-latest

Pengenalan

Grok 4.6 direka untuk kerja berpanjangan pada kod, penyelidikan dan projek interaktif. Ia menerima teks dan imej, menyokong konteks 500 000 token dan empat tahap penaakulan.

Input yang diterima: Teks · Imej
Hasil: Teks

Tersedia di Ailoot · input & kaedah

Ailoot · Anthropic Messages POST /v1/messages

Input: text, image
Output: text
Konteks: 500,000 tokens
Output maksimum: 500,000 tokens
Format output: json atau SSE

Medan	Jenis	Keperluan	Nilai & had	Lalai
Medan`model`	Jenis`string`	KeperluanDiperlukan	Nilai & had grok-4.6-latest	Lalai—
Medan`messages`	Jenis`message[]`	KeperluanDiperlukan	Nilai & had Item minimum: 1	Lalai—
Medan`messages[].role`	Jenis`string`	KeperluanDiperlukan	Nilai & had user, assistant	Lalai—
Medan`messages[].content`	Jenis`string\|content_block[]`	KeperluanDiperlukan	Nilai & had	Lalai—
Medan`system`	Jenis`string\|content_block[]`	KeperluanPilihan	Nilai & had	Lalai—
Medan`max_tokens`	Jenis`integer`	KeperluanDiperlukan	Nilai & had Minimum: 1 Had terpakai pada: had maksimum tepat bagi model/kad yang dipilih	Lalai—
Medan`stream`	Jenis`boolean`	KeperluanPilihan	Nilai & had	Lalaifalse
Medan`temperature`	Jenis`number`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`top_p`	Jenis`number`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`stop_sequences`	Jenis`string[]`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`tools`	Jenis`tool[]`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`tools[].name`	Jenis`string`	KeperluanPilihan	Nilai & had Terpakai apabila: alat dibekalkan	Lalai—
Medan`tools[].description`	Jenis`string`	KeperluanPilihan	Nilai & had	Lalai—
Medan`tools[].input_schema`	Jenis`JSON_schema`	KeperluanPilihan	Nilai & had	Lalai—
Medan`tool_choice`	Jenis`object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`thinking.type`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`thinking.budget_tokens`	Jenis`integer`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`output_config.effort`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`metadata`	Jenis`object`	KeperluanPilihan	Nilai & had	Lalai—
Medan`cache_control`	Jenis`object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—

Gabungan bahan input

Teks · Teks UTF8

messages[].content atau blok type=text

Teks + imej

{type:image,source:{type:base64,media_type,data}} atau sumber dengan type=url

Parameter kaedah dan kitar hayat

Parameter	Kontrak
Parameter`material_types`	Kontraktext, image
Parameter`required`	Kontrakmodel, messages, max_tokens
Parameter`optional_controls`	Kontraknull
Parameter`content_type`	Kontrakapplication/json
Parameter`text_file_material`	Kontrakkandungan UTF-8 sebenar dimasukkan sebagai teks; ID fail atau alamat URL (URLs) memerlukan sokongan tepat yang berasingan

Kitar hayat: exact retained published method

Struktur kaedah dan ID adalah tepat; keupayaan pembekal berasingan daripada penerimaan permintaan.

Pelan harga

Kadar kaedah Ailoot

Ailoot Anthropic MessagesPOST /v1/messages

Input: USD 0.002 / 1K
Output: USD 0.006 / 1K
Bacaan cache: USD 0.0005 / 1K
Penulisan cache: USD 0.00 / 1K
Penulisan cache, 5 minit: USD 0.00 / 1K tokens
Penulisan cache, 1 jam: USD 0.00 / 1K tokens

Harga mengikut panjang permintaan · Anthropic Messages

Saiz permintaan, token	Input	Output	Bacaan cache	Penulisan cache	Cache 5 minit	Cache 1 jam
Saiz permintaan, token(0; 200,000]	InputUSD 0.002	OutputUSD 0.006	Bacaan cacheUSD 0.0005	Penulisan cacheUSD 0.00	Cache 5 minitUSD 0.00	Cache 1 jamUSD 0.00
Saiz permintaan, token(200,000; ∞)	InputUSD 0.004	OutputUSD 0.012	Bacaan cacheUSD 0.001	Penulisan cacheUSD 0.00	Cache 5 minitUSD 0.00	Cache 1 jamUSD 0.00

Kadar dalam USD setiap 1K token. Jika tiada kadar ditetapkan, kadar asas kaedah ini diwarisi; «—» bermaksud tiada kadar asas ditetapkan.

Butiran tarif rujukan

Jadual rujukan peringkat model tidak mengubah pemilihan kaedah, sebut harga atau caj. Caj aktif menggunakan kadar kaedah Ailoot yang dipilih.

Jadual rujukan model

Harga mengikut konfigurasi

Padankan setiap caj dengan syarat yang dipaparkan. Gunakan satu kadar bagi setiap set konfigurasi alternatif.

Konfigurasi	Jadual kadar	Token konteks, melebihi	Token konteks, sehingga dan termasuk	Caj
KonfigurasiOpenAI Chat · Kadar asas token	Jadual kadarKadar asas	Token konteks, melebihi—	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiOpenAI Chat · Tahap 1 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi0	Token konteks, sehingga dan termasuk200,000	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiOpenAI Chat · Tahap 2 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi200,000	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.008 / 1K token Output · Token output $0.024 / 1K token Input · Bacaan cache $0.002 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiAnthropic Messages · Kadar asas token	Jadual kadarKadar asas	Token konteks, melebihi—	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiAnthropic Messages · Tahap 1 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi0	Token konteks, sehingga dan termasuk200,000	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiAnthropic Messages · Tahap 2 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi200,000	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.008 / 1K token Output · Token output $0.024 / 1K token Input · Bacaan cache $0.002 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token

Contoh permintaan

Ailoot · Anthropic Messages

Contoh teksInput, imejPython SDKNode.js SDKPenstriman Python

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

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

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.6-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"))

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.6-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);

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.6-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")

Terima dan simpan hasil

Ailoot · Anthropic Messages

json atau SSE

Simpan semua hasil yang selesai

Simpan setiap respons lengkap, fail dan bahagian kandungan yang dikembalikan.

Kekalkan semua blok kandungan, tandatangan penaakulan dan ID penggunaan alat sebenar. Gabungkan semua delta blok SSE; blok teks pertama bukan keseluruhan output.

Jika respons asal perlu disemak

Kekalkan ID permintaan/respons dan pengepala. Tiada URL umum bagi pengambilan tugas teks dibekalkan.

Medan respons

Medan	Jenis
Medan`id`	Jenisstring
Medan`model`	Jenisstring
Medan`content[]`	Jenistext\|thinking\|tool_use\|other content block
Medan`stop_reason`	Jenisstring\|null
Medan`usage`	Jenisobject

Ralat dan langkah seterusnya

Respons	Syarat	Langkah seterusnya
Respons400 · `invalid_request_error`	SyaratMedan wajib, perwakilan bahan atau nilai parameter tidak sah	Langkah seterusnyaBetulkan medan yang ditunjukkan sebelum permintaan penciptaan baharu.

Alias

Alias model

Ailoot grok-4.6, grok-4.6-latest
Ailoot Ultra grok-4.6, x-ai/grok-4.6

Alias laluan kaedah

/chat/completions

ID pemanggil berkaitan

x-ai/grok-4.6, grok-4.6-latest, grok-4.6, grok-4.6

Ailoot · OpenAI Responses POST /v1/responses grok-4.6-latest

grok-4.6-latest

SpaceXAI /grok-4.6-latest

ID model

grok-4.6
grok-4.6-latest

Pengenalan

Grok 4.6 direka untuk kerja berpanjangan pada kod, penyelidikan dan projek interaktif. Ia menerima teks dan imej, menyokong konteks 500 000 token dan empat tahap penaakulan.

Input yang diterima: Teks · Imej
Hasil: Teks

Tersedia di Ailoot · input & kaedah

Ailoot · OpenAI Responses POST /v1/responses

Input: text, image
Output: text
Konteks: 500,000 tokens
Output maksimum: 500,000 tokens
Format output: json atau SSE

Medan	Jenis	Keperluan	Nilai & had	Lalai
Medan`model`	Jenis`string`	KeperluanDiperlukan	Nilai & had grok-4.6-latest	Lalai—
Medan`input`	Jenis`string\|input_item[]`	KeperluanDiperlukan	Nilai & had	Lalai—
Medan`instructions`	Jenis`string`	KeperluanPilihan	Nilai & had	Lalai—
Medan`input[].type`	Jenis`string`	KeperluanPilihan	Nilai & had message, reasoning, function_call, function_call_output	Lalai—
Medan`input[].content`	Jenis`string\|content_part[]`	KeperluanPilihan	Nilai & had	Lalai—
Medan`input[].call_id`	Jenis`string`	KeperluanPilihan	Nilai & had Terpakai apabila: function_call_output; kekalkan call_id sebenar yang dipulangkan	Lalai—
Medan`input[].output`	Jenis`string\|content_part[]`	KeperluanPilihan	Nilai & had Terpakai apabila: function_call_output	Lalai—
Medan`max_output_tokens`	Jenis`integer`	KeperluanPilihan	Nilai & had Minimum: 1 Bergantung pada model	Lalai—
Medan`stream`	Jenis`boolean`	KeperluanPilihan	Nilai & had	Lalaifalse
Medan`temperature`	Jenis`number`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`top_p`	Jenis`number`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`tools`	Jenis`tool[]`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`tool_choice`	Jenis`string\|object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`parallel_tool_calls`	Jenis`boolean`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`reasoning.effort`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`reasoning.summary`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`text.format`	Jenis`object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`text.verbosity`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`include`	Jenis`string[]`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`store`	Jenis`boolean`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`previous_response_id`	Jenis`string`	KeperluanPilihan	Nilai & had Keperluan ID: Hanya ID respons sebenar daripada penerusan yang disokong Bergantung pada model	Lalai—
Medan`service_tier`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`prompt_cache_key`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`prompt_cache_options`	Jenis`object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—

Gabungan bahan input

Teks · Teks UTF8

Teks input atau bahagian input_text

Teks + imej

{type:input_image,image_url}

Parameter kaedah dan kitar hayat

Parameter	Kontrak
Parameter`material_types`	Kontraktext, image
Parameter`required`	Kontrakmodel, input
Parameter`optional_controls`	Kontraknull
Parameter`content_type`	Kontrakapplication/json
Parameter`text_file_material`	Kontrakkandungan UTF-8 sebenar dimasukkan sebagai teks; ID fail atau alamat URL (URLs) memerlukan sokongan tepat yang berasingan

Kitar hayat: exact retained published method

Struktur kaedah dan ID adalah tepat; keupayaan pembekal berasingan daripada penerimaan permintaan.

Pelan harga

Kadar kaedah Ailoot

Ailoot OpenAI ResponsesPOST /v1/responses

Input: USD 0.002 / 1K
Output: USD 0.006 / 1K
Bacaan cache: USD 0.0005 / 1K
Penulisan cache: USD 0.00 / 1K
Penulisan cache, 5 minit: USD 0.00 / 1K tokens
Penulisan cache, 1 jam: USD 0.00 / 1K tokens

Harga mengikut panjang permintaan · OpenAI Responses

Saiz permintaan, token	Input	Output	Bacaan cache	Penulisan cache	Cache 5 minit	Cache 1 jam
Saiz permintaan, token(0; 200,000]	InputUSD 0.002	OutputUSD 0.006	Bacaan cacheUSD 0.0005	Penulisan cacheUSD 0.00	Cache 5 minitUSD 0.00	Cache 1 jamUSD 0.00
Saiz permintaan, token(200,000; ∞)	InputUSD 0.004	OutputUSD 0.012	Bacaan cacheUSD 0.001	Penulisan cacheUSD 0.00	Cache 5 minitUSD 0.00	Cache 1 jamUSD 0.00

Kadar dalam USD setiap 1K token. Jika tiada kadar ditetapkan, kadar asas kaedah ini diwarisi; «—» bermaksud tiada kadar asas ditetapkan.

Butiran tarif rujukan

Jadual rujukan peringkat model tidak mengubah pemilihan kaedah, sebut harga atau caj. Caj aktif menggunakan kadar kaedah Ailoot yang dipilih.

Jadual rujukan model

Harga mengikut konfigurasi

Padankan setiap caj dengan syarat yang dipaparkan. Gunakan satu kadar bagi setiap set konfigurasi alternatif.

Konfigurasi	Jadual kadar	Token konteks, melebihi	Token konteks, sehingga dan termasuk	Caj
KonfigurasiOpenAI Chat · Kadar asas token	Jadual kadarKadar asas	Token konteks, melebihi—	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiOpenAI Chat · Tahap 1 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi0	Token konteks, sehingga dan termasuk200,000	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiOpenAI Chat · Tahap 2 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi200,000	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.008 / 1K token Output · Token output $0.024 / 1K token Input · Bacaan cache $0.002 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiAnthropic Messages · Kadar asas token	Jadual kadarKadar asas	Token konteks, melebihi—	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiAnthropic Messages · Tahap 1 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi0	Token konteks, sehingga dan termasuk200,000	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiAnthropic Messages · Tahap 2 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi200,000	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.008 / 1K token Output · Token output $0.024 / 1K token Input · Bacaan cache $0.002 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token

Contoh permintaan

Ailoot · OpenAI Responses

Contoh teksInput, imejPython SDKNode.js SDKPenstriman Python

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

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

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.6-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"))

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.6-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);

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.6-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")

Terima dan simpan hasil

Ailoot · OpenAI Responses

json atau SSE

Simpan semua hasil yang selesai

Simpan setiap respons lengkap, fail dan bahagian kandungan yang dikembalikan.

Kekalkan setiap item output dan bahagian kandungan, call_id fungsi sebenar, penaakulan disulitkan serta data penggunaan. Semasa penstriman, kekalkan identiti peristiwa/item yang lengkap.

Jika respons asal perlu disemak

Kekalkan ID permintaan/respons dan pengepala. Tiada URL umum bagi pengambilan tugas teks dibekalkan.

Medan respons

Medan	Jenis
Medan`id`	Jenisstring
Medan`status`	Jenisstring
Medan`output[]`	Jenismessage\|reasoning\|function_call\|other item
Medan`output[].content[]`	Jeniscontent part
Medan`usage`	Jenisobject

Ralat dan langkah seterusnya

Respons	Syarat	Langkah seterusnya
Respons400 · `invalid_request_error`	SyaratMedan wajib, perwakilan bahan atau nilai parameter tidak sah	Langkah seterusnyaBetulkan medan yang ditunjukkan sebelum permintaan penciptaan baharu.

Alias

Alias model

Ailoot grok-4.6, grok-4.6-latest
Ailoot Ultra grok-4.6, x-ai/grok-4.6

Alias laluan kaedah

/chat/completions

ID pemanggil berkaitan

x-ai/grok-4.6, grok-4.6-latest, grok-4.6, grok-4.6

Ailoot · OpenAI Chat POST /v1/chat/completions grok-4.6-latest

grok-4.6-latest

SpaceXAI /grok-4.6-latest

ID model

grok-4.6
grok-4.6-latest

Pengenalan

Grok 4.6 direka untuk kerja berpanjangan pada kod, penyelidikan dan projek interaktif. Ia menerima teks dan imej, menyokong konteks 500 000 token dan empat tahap penaakulan.

Input yang diterima: Teks · Imej
Hasil: Teks

Tersedia di Ailoot · input & kaedah

Ailoot · OpenAI Chat POST /v1/chat/completions

Input: text, image
Output: text
Konteks: 500,000 tokens
Output maksimum: 500,000 tokens
Format output: json atau SSE

Medan	Jenis	Keperluan	Nilai & had	Lalai
Medan`model`	Jenis`string`	KeperluanDiperlukan	Nilai & had grok-4.6-latest	Lalai—
Medan`messages`	Jenis`message[]`	KeperluanDiperlukan	Nilai & had Item minimum: 1	Lalai—
Medan`messages[].role`	Jenis`string`	KeperluanDiperlukan	Nilai & had Contoh: system, user, assistant, tool, function Syarat: Peranan ini diwakili secara eksplisit oleh jenis keserasian dalam kod sumber; set peranan model yang tepat kekal khusus untuk setiap model. Bergantung pada model	Lalai—
Medan`messages[].content`	Jenis`string\|content_part[]\|null`	KeperluanPilihan	Nilai & had	Lalai—
Medan`messages[].tool_calls`	Jenis`tool_call[]`	KeperluanPilihan	Nilai & had	Lalai—
Medan`messages[].tool_call_id`	Jenis`string`	KeperluanPilihan	Nilai & had Terpakai apabila: role=tool; gunakan ID sebenar yang dipulangkan	Lalai—
Medan`messages[].name`	Jenis`string`	KeperluanPilihan	Nilai & had	Lalai—
Medan`messages[].reasoning_content`	Jenis`string`	KeperluanPilihan	Nilai & had Terpakai apabila: Hantar semula penaakulan sebenar yang dipulangkan apabila model ini menggunakannya	Lalai—
Medan`messages[].reasoning_details`	Jenis`object\|array`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`max_tokens`	Jenis`integer`	KeperluanPilihan	Nilai & had Minimum: 1 Bergantung pada model	Lalai—
Medan`max_completion_tokens`	Jenis`integer`	KeperluanPilihan	Nilai & had Minimum: 1 Bergantung pada model	Lalai—
Medan`stream`	Jenis`boolean`	KeperluanPilihan	Nilai & had	Lalaifalse
Medan`stream_options.include_usage`	Jenis`boolean`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`temperature`	Jenis`number`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`top_p`	Jenis`number`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`stop`	Jenis`string\|string[]`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`tools`	Jenis`function_tool[]`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`tools[].type`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`tools[].function.name`	Jenis`string`	KeperluanDiperlukan	Nilai & had Terpakai apabila: alat fungsi dibekalkan	Lalai—
Medan`tools[].function.description`	Jenis`string`	KeperluanPilihan	Nilai & had	Lalai—
Medan`tools[].function.parameters`	Jenis`JSON_schema`	KeperluanPilihan	Nilai & had	Lalai—
Medan`tool_choice`	Jenis`string\|object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`parallel_tool_calls`	Jenis`boolean`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`response_format`	Jenis`object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`reasoning_effort`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`reasoning`	Jenis`object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`service_tier`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`instructions`	Jenis`string`	KeperluanPilihan	Nilai & had Medan keserasian	Lalai—
Medan`functions`	Jenis`function[]`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`function_call`	Jenis`string\|object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`prompt_cache_options`	Jenis`object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—

Gabungan bahan input

Teks · Teks UTF8

messages[].content

Teks + imej

{type:image_url,image_url:{url,detail}}

Parameter kaedah dan kitar hayat

Parameter	Kontrak
Parameter`material_types`	Kontraktext, image
Parameter`required`	Kontrakmodel, messages
Parameter`optional_controls`	Kontraknull
Parameter`content_type`	Kontrakapplication/json
Parameter`text_file_material`	Kontrakkandungan UTF-8 sebenar dimasukkan sebagai teks; ID fail atau alamat URL (URLs) memerlukan sokongan tepat yang berasingan

Kitar hayat: exact retained published method

Struktur kaedah dan ID adalah tepat; keupayaan pembekal berasingan daripada penerimaan permintaan.

Pelan harga

Kadar kaedah Ailoot

Ailoot OpenAI ChatPOST /v1/chat/completions

Input: USD 0.002 / 1K
Output: USD 0.006 / 1K
Bacaan cache: USD 0.0005 / 1K
Penulisan cache: USD 0.00 / 1K
Penulisan cache, 5 minit: USD 0.00 / 1K tokens
Penulisan cache, 1 jam: USD 0.00 / 1K tokens

Harga mengikut panjang permintaan · OpenAI Chat

Saiz permintaan, token	Input	Output	Bacaan cache	Penulisan cache	Cache 5 minit	Cache 1 jam
Saiz permintaan, token(0; 200,000]	InputUSD 0.002	OutputUSD 0.006	Bacaan cacheUSD 0.0005	Penulisan cacheUSD 0.00	Cache 5 minitUSD 0.00	Cache 1 jamUSD 0.00
Saiz permintaan, token(200,000; ∞)	InputUSD 0.004	OutputUSD 0.012	Bacaan cacheUSD 0.001	Penulisan cacheUSD 0.00	Cache 5 minitUSD 0.00	Cache 1 jamUSD 0.00

Kadar dalam USD setiap 1K token. Jika tiada kadar ditetapkan, kadar asas kaedah ini diwarisi; «—» bermaksud tiada kadar asas ditetapkan.

Butiran tarif rujukan

Jadual rujukan peringkat model tidak mengubah pemilihan kaedah, sebut harga atau caj. Caj aktif menggunakan kadar kaedah Ailoot yang dipilih.

Jadual rujukan model

Harga mengikut konfigurasi

Padankan setiap caj dengan syarat yang dipaparkan. Gunakan satu kadar bagi setiap set konfigurasi alternatif.

Konfigurasi	Jadual kadar	Token konteks, melebihi	Token konteks, sehingga dan termasuk	Caj
KonfigurasiOpenAI Chat · Kadar asas token	Jadual kadarKadar asas	Token konteks, melebihi—	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiOpenAI Chat · Tahap 1 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi0	Token konteks, sehingga dan termasuk200,000	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiOpenAI Chat · Tahap 2 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi200,000	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.008 / 1K token Output · Token output $0.024 / 1K token Input · Bacaan cache $0.002 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiAnthropic Messages · Kadar asas token	Jadual kadarKadar asas	Token konteks, melebihi—	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiAnthropic Messages · Tahap 1 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi0	Token konteks, sehingga dan termasuk200,000	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiAnthropic Messages · Tahap 2 berdasarkan panjang permintaan	Jadual kadar—	Token konteks, melebihi200,000	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.008 / 1K token Output · Token output $0.024 / 1K token Input · Bacaan cache $0.002 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token

Contoh permintaan

Ailoot · OpenAI Chat

Contoh teksInput, imejPython SDKNode.js SDKPenstriman Python

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

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

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.6-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"))

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.6-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);

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.6-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")

Terima dan simpan hasil

Ailoot · OpenAI Chat

json atau SSE

Simpan semua hasil yang selesai

Simpan setiap respons lengkap, fail dan bahagian kandungan yang dikembalikan.

Jika respons asal perlu disemak

Kekalkan ID permintaan/respons dan pengepala. Tiada URL umum bagi pengambilan tugas teks dibekalkan.

Medan respons

Medan	Jenis
Medan`choices[].index`	Jenisinteger
Medan`choices[].message.content`	Jenisstring\|null
Medan`choices[].message.tool_calls`	Jenistool_call[]
Medan`choices[].message.reasoning_content`	Jenisstring
Medan`choices[].message.reasoning_details`	Jenisobject\|array
Medan`choices[].finish_reason`	Jenisstring\|null
Medan`usage`	Jenisobject

Ralat dan langkah seterusnya

Respons	Syarat	Langkah seterusnya
Respons400 · `invalid_request_error`	SyaratMedan wajib, perwakilan bahan atau nilai parameter tidak sah	Langkah seterusnyaBetulkan medan yang ditunjukkan sebelum permintaan penciptaan baharu.

Alias

Alias model

Ailoot grok-4.6, grok-4.6-latest
Ailoot Ultra grok-4.6, x-ai/grok-4.6

Alias laluan kaedah

/chat/completions

ID pemanggil berkaitan

x-ai/grok-4.6, grok-4.6-latest, grok-4.6, grok-4.6

Ailoot Ultra · OpenAI Chat POST /v1/chat/completions x-ai/grok-4.6

x-ai/grok-4.6

SpaceXAI /x-ai/grok-4.6

ID model

grok-4.6
x-ai/grok-4.6

Pengenalan

Grok 4.6 direka untuk kerja berpanjangan pada kod, penyelidikan dan projek interaktif. Ia menerima teks dan imej, menyokong konteks 500 000 token dan empat tahap penaakulan.

Input yang diterima: Teks
Hasil: Teks

Tersedia di Ailoot · input & kaedah

Ailoot Ultra · OpenAI Chat POST /v1/chat/completions

Input: text
Output: text
Format output: json atau SSE

Medan	Jenis	Keperluan	Nilai & had	Lalai
Medan`model`	Jenis`string`	KeperluanDiperlukan	Nilai & had x-ai/grok-4.6	Lalai—
Medan`messages`	Jenis`message[]`	KeperluanDiperlukan	Nilai & had Item minimum: 1	Lalai—
Medan`messages[].role`	Jenis`string`	KeperluanDiperlukan	Nilai & had Contoh: system, user, assistant, tool, function Syarat: Peranan ini diwakili secara eksplisit oleh jenis keserasian dalam kod sumber; set peranan model yang tepat kekal khusus untuk setiap model. Bergantung pada model	Lalai—
Medan`messages[].content`	Jenis`string\|content_part[]\|null`	KeperluanPilihan	Nilai & had	Lalai—
Medan`messages[].tool_calls`	Jenis`tool_call[]`	KeperluanPilihan	Nilai & had	Lalai—
Medan`messages[].tool_call_id`	Jenis`string`	KeperluanPilihan	Nilai & had Terpakai apabila: role=tool; gunakan ID sebenar yang dipulangkan	Lalai—
Medan`messages[].name`	Jenis`string`	KeperluanPilihan	Nilai & had	Lalai—
Medan`messages[].reasoning_content`	Jenis`string`	KeperluanPilihan	Nilai & had Terpakai apabila: Hantar semula penaakulan sebenar yang dipulangkan apabila model ini menggunakannya	Lalai—
Medan`messages[].reasoning_details`	Jenis`object\|array`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`max_tokens`	Jenis`integer`	KeperluanPilihan	Nilai & had Minimum: 1 Bergantung pada model	Lalai—
Medan`max_completion_tokens`	Jenis`integer`	KeperluanPilihan	Nilai & had Minimum: 1 Bergantung pada model	Lalai—
Medan`stream`	Jenis`boolean`	KeperluanPilihan	Nilai & had	Lalaifalse
Medan`stream_options.include_usage`	Jenis`boolean`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`temperature`	Jenis`number`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`top_p`	Jenis`number`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`stop`	Jenis`string\|string[]`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`tools`	Jenis`function_tool[]`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`tools[].type`	Jenis`string`	KeperluanPilihan	Nilai & had function Bergantung pada model	Lalai—
Medan`tools[].function.name`	Jenis`string`	KeperluanDiperlukan	Nilai & had Terpakai apabila: alat fungsi dibekalkan	Lalai—
Medan`tools[].function.description`	Jenis`string`	KeperluanPilihan	Nilai & had	Lalai—
Medan`tools[].function.parameters`	Jenis`JSON_schema`	KeperluanPilihan	Nilai & had	Lalai—
Medan`tool_choice`	Jenis`string\|object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`parallel_tool_calls`	Jenis`boolean`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`response_format`	Jenis`object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`reasoning_effort`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`reasoning`	Jenis`object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`service_tier`	Jenis`string`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`instructions`	Jenis`string`	KeperluanPilihan	Nilai & had Medan keserasian	Lalai—
Medan`functions`	Jenis`function[]`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`function_call`	Jenis`string\|object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`prompt_cache_options`	Jenis`object`	KeperluanPilihan	Nilai & had Bergantung pada model	Lalai—
Medan`modalities`	Jenis`string[]`	KeperluanPilihan	Nilai & had text	Lalai—
Medan`provider`	Jenis`object`	KeperluanPilihan	Nilai & had Syarat: provider.options ditolak pada laluan teks Ultra ini	Lalai—
Medan`cache_control.ttl`	Jenis`string`	KeperluanPilihan	Nilai & had Syarat: 1h ditolak pada lokasi cache prompt yang digunakan	Lalai—

Gabungan bahan input

Teks · Teks UTF8

messages[].content

Parameter kaedah dan kitar hayat

Parameter	Kontrak
Parameter`content_type`	Kontrakapplication/json
Parameter`required`	Kontrakmodel, messages
Parameter`material_types`	Kontraktext
Parameter`messages`	Kontraktatasusunan mesej dengan struktur role/content
Parameter`file_material`	Kontrakdokumen UTF-8 sebenar dimasukkan sebagai teks literal; ID fail tidak diandaikan
Parameter`optional_controls`	Kontrakstream, temperature, top_p, stop, max_tokens, max_completion_tokens, reasoning, response_format, tools, tool_choice
Parameter`control_scope`	Kontrakkhusus model; alat fungsi pengguna berbeza daripada alat yang dihoskan
Parameter`output_modalities`	Kontraktext
Parameter`hosted_operations`	Kontrakfalse
Parameter`multimodal_input_binding`	Kontraknull

Kitar hayat: synchronous_or_streamed

Hantar ID model yang tepat bersama messages.

Panjang konteks bukan had output.

Fail teks boleh membekalkan teks literal; input imej/audio/objek fail memerlukan pengikatan tepat.

Pelan harga

Rujukan tarif tidak menambah pilihan permintaan. Parameter yang disokong disenaraikan untuk kaedah yang dipilih.

Mod pantas: Kadar standard Apabila mod pantas dipilih
Mod flex: Kadar standard Apabila mod flex dipilih
Usaha penaakulan maksimum: Kadar standard Apabila usaha penaakulan maksimum menggunakan pelarasan default
Usaha penaakulan · high: Kadar standard Apabila usaha penaakulan ditetapkan kepada high
Usaha penaakulan · low: Kadar standard Apabila usaha penaakulan ditetapkan kepada low
Usaha penaakulan · medium: Kadar standard Apabila usaha penaakulan ditetapkan kepada medium
Usaha penaakulan · xhigh: Kadar standard Apabila usaha penaakulan ditetapkan kepada xhigh

Kadar Ailoot

Harga mengikut konfigurasi

Padankan setiap caj dengan syarat yang dipaparkan. Gunakan satu kadar bagi setiap set konfigurasi alternatif.

Konfigurasi	Jadual kadar	Token konteks, melebihi	Token konteks, sehingga dan termasuk	Caj
KonfigurasiKadar asas token	Jadual kadarKadar asas	Token konteks, melebihi—	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiTahap panjang permintaan 1	Jadual kadar—	Token konteks, melebihi0	Token konteks, sehingga dan termasuk200,000	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiTahap panjang permintaan 2	Jadual kadar—	Token konteks, melebihi200,000	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.008 / 1K token Output · Token output $0.024 / 1K token Input · Bacaan cache $0.002 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token

Contoh permintaan

Ailoot Ultra · OpenAI Chat

curlPython SDKPenstriman Python

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.6", "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

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.6',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"))

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.6',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")

Terima dan simpan hasil

Ailoot Ultra · OpenAI Chat

json atau SSE

Simpan semua hasil yang selesai

Simpan setiap respons lengkap, fail dan bahagian kandungan yang dikembalikan.

Jika respons asal perlu disemak

Kekalkan ID permintaan/respons dan pengepala. Tiada URL umum bagi pengambilan tugas teks dibekalkan.

Medan respons

Medan	Jenis
Medan`choices[].index`	Jenisinteger
Medan`choices[].message.content`	Jenisstring\|null
Medan`choices[].message.tool_calls`	Jenistool_call[]
Medan`choices[].message.reasoning_content`	Jenisstring
Medan`choices[].message.reasoning_details`	Jenisobject\|array
Medan`choices[].finish_reason`	Jenisstring\|null
Medan`usage`	Jenisobject

Ralat dan langkah seterusnya

Respons	Syarat	Langkah seterusnya
Respons400 · `invalid_request_error`	SyaratMedan wajib, perwakilan bahan atau nilai parameter tidak sah	Langkah seterusnyaBetulkan medan yang ditunjukkan sebelum permintaan penciptaan baharu.

Alias

Alias model

Ailoot grok-4.6, grok-4.6-latest
Ailoot Ultra grok-4.6, x-ai/grok-4.6

Alias laluan kaedah

/chat/completions

ID pemanggil berkaitan

x-ai/grok-4.6, grok-4.6-latest, grok-4.6, grok-4.6

Ailoot Ultra · Anthropic Messages POST /v1/messages x-ai/grok-4.6

x-ai/grok-4.6

SpaceXAI /x-ai/grok-4.6

ID model

grok-4.6
x-ai/grok-4.6

Pengenalan

Grok 4.6 direka untuk kerja berpanjangan pada kod, penyelidikan dan projek interaktif. Ia menerima teks dan imej, menyokong konteks 500 000 token dan empat tahap penaakulan.

Input yang diterima: Teks
Hasil: json · sse

Tersedia di Ailoot · input & kaedah

Ailoot Ultra · Anthropic Messages POST /v1/messages

Input: text
Output: json, sse
Format output: JSON atau SSE

Medan	Jenis	Keperluan	Nilai & had	Lalai
Medan`model`	Jenis`string`	KeperluanDiperlukan	Nilai & had x-ai/grok-4.6	Lalai—
Medan`messages`	Jenis`message[]`	KeperluanDiperlukan	Nilai & had	Lalai—
Medan`messages[].role`	Jenis`string`	KeperluanDiperlukan	Nilai & had user, assistant	Lalai—
Medan`messages[].content`	Jenis`string`	KeperluanDiperlukan	Nilai & had	Lalai—
Medan`max_tokens`	Jenis`integer`	KeperluanDiperlukan	Nilai & had	Lalai—
Medan`stream`	Jenis`boolean`	KeperluanPilihan	Nilai & had	Lalaifalse

Gabungan bahan input

Teks · Teks UTF-8

rentetan messages[].content

Parameter kaedah dan kitar hayat

Parameter	Kontrak
Parameter`content_type`	Kontrakapplication/json
Parameter`required`	Kontrakmodel, messages, max_tokens
Parameter`optional_controls`	Kontrakstream
Parameter`material_types`	Kontraktext
Parameter`text_file_material`	KontrakBaca dokumen UTF-8 sebenar dan letakkan teksnya dalam rentetan input atau kandungan mesej yang ditunjukkan.

Kitar hayat: synchronous_or_streamed

Pelan harga

Rujukan tarif tidak menambah pilihan permintaan. Parameter yang disokong disenaraikan untuk kaedah yang dipilih.

Mod pantas: Kadar standard Apabila mod pantas dipilih
Mod flex: Kadar standard Apabila mod flex dipilih
Usaha penaakulan maksimum: Kadar standard Apabila usaha penaakulan maksimum menggunakan pelarasan default
Usaha penaakulan · high: Kadar standard Apabila usaha penaakulan ditetapkan kepada high
Usaha penaakulan · low: Kadar standard Apabila usaha penaakulan ditetapkan kepada low
Usaha penaakulan · medium: Kadar standard Apabila usaha penaakulan ditetapkan kepada medium
Usaha penaakulan · xhigh: Kadar standard Apabila usaha penaakulan ditetapkan kepada xhigh

Kadar Ailoot

Harga mengikut konfigurasi

Padankan setiap caj dengan syarat yang dipaparkan. Gunakan satu kadar bagi setiap set konfigurasi alternatif.

Konfigurasi	Jadual kadar	Token konteks, melebihi	Token konteks, sehingga dan termasuk	Caj
KonfigurasiKadar asas token	Jadual kadarKadar asas	Token konteks, melebihi—	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiTahap panjang permintaan 1	Jadual kadar—	Token konteks, melebihi0	Token konteks, sehingga dan termasuk200,000	Caj Input · Token input $0.004 / 1K token Output · Token output $0.012 / 1K token Input · Bacaan cache $0.001 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token
KonfigurasiTahap panjang permintaan 2	Jadual kadar—	Token konteks, melebihi200,000	Token konteks, sehingga dan termasukTiada had atas	Caj Input · Token input $0.008 / 1K token Output · Token output $0.024 / 1K token Input · Bacaan cache $0.002 / 1K token Input · Penulisan cache — / 1K token Input · Penulisan cache, 1 jam — / 1K token

Contoh permintaan

Ailoot Ultra · Anthropic Messages

Badan JSON minimum yang lengkapcurl · gunakan dokumen UTF-8 andaPython · simpan hasil lengkap

{
  "model": "x-ai/grok-4.6",
  "max_tokens": 128,
  "messages": [
    {
      "role": "user",
      "content": "Summarize the incident report."
    }
  ],
  "stream": false
}

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.6', '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

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.6', '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))

Terima dan simpan hasil

Ailoot Ultra · Anthropic Messages

JSON atau SSE

Simpan semua hasil yang selesai

Simpan setiap respons lengkap, fail dan bahagian kandungan yang dikembalikan.

Kekalkan semua blok kandungan, tandatangan penaakulan dan ID penggunaan alat sebenar. Gabungkan semua delta blok SSE; blok teks pertama bukan keseluruhan output.

Jika respons asal perlu disemak

Kekalkan ID permintaan/respons dan pengepala. Tiada URL umum bagi pengambilan tugas teks dibekalkan.

Medan respons

Medan	Jenis
Medan`id`	Jenisstring
Medan`model`	Jenisstring
Medan`content[]`	Jenistext\|thinking\|tool_use\|other content block
Medan`stop_reason`	Jenisstring\|null
Medan`usage`	Jenisobject

Ralat dan langkah seterusnya

Respons	Syarat	Langkah seterusnya
Respons400 · `invalid_request_error`	SyaratMedan wajib, perwakilan bahan atau nilai parameter tidak sah	Langkah seterusnyaBetulkan medan yang ditunjukkan sebelum permintaan penciptaan baharu.

Alias

Alias model

Ailoot grok-4.6, grok-4.6-latest
Ailoot Ultra grok-4.6, x-ai/grok-4.6

Alias laluan kaedah

/chat/completions

ID pemanggil berkaitan

x-ai/grok-4.6, grok-4.6-latest, grok-4.6, grok-4.6

FAQ · SpaceXAI: Grok 4.6

Apakah input dan hasil yang tersedia?

POST /v1/messages · grok-4.6: text, image → text

POST /v1/responses · grok-4.6: text, image → text

POST /v1/chat/completions · grok-4.6: text, image → text

POST /v1/chat/completions · grok-4.6: text → text

POST /v1/messages · grok-4.6: text → json, sse

POST /v1/messages · grok-4.6-latest: text, image → text

POST /v1/responses · grok-4.6-latest: text, image → text

POST /v1/chat/completions · grok-4.6-latest: text, image → text

POST /v1/chat/completions · x-ai/grok-4.6: text → text

POST /v1/messages · x-ai/grok-4.6: text → json, sse

Apakah medan yang digunakan oleh permintaan?

POST /v1/messages · grok-4.6: model, messages, system, max_tokens, stream, metadata

POST /v1/responses · grok-4.6: model, input, instructions, stream

POST /v1/chat/completions · grok-4.6: model, messages, stream

POST /v1/messages · grok-4.6: model, messages, max_tokens, stream

POST /v1/messages · grok-4.6-latest: model, messages, system, max_tokens, stream, metadata

POST /v1/responses · grok-4.6-latest: model, input, instructions, stream

POST /v1/chat/completions · grok-4.6-latest: model, messages, stream

POST /v1/chat/completions · x-ai/grok-4.6: model, messages, stream, modalities, provider

POST /v1/messages · x-ai/grok-4.6: model, messages, max_tokens, stream

Apakah had yang terpakai?

POST /v1/messages · grok-4.6: ctx: 500000; max_out: 500000; messages.min_items: 1; max_tokens.minimum: 1

POST /v1/responses · grok-4.6: ctx: 500000; max_out: 500000

POST /v1/chat/completions · grok-4.6: ctx: 500000; max_out: 500000; messages.min_items: 1

POST /v1/chat/completions · grok-4.6: messages.min_items: 1

POST /v1/messages · grok-4.6-latest: ctx: 500000; max_out: 500000; messages.min_items: 1; max_tokens.minimum: 1

POST /v1/responses · grok-4.6-latest: ctx: 500000; max_out: 500000

POST /v1/chat/completions · grok-4.6-latest: ctx: 500000; max_out: 500000; messages.min_items: 1

POST /v1/chat/completions · x-ai/grok-4.6: messages.min_items: 1