SpaceXAI: Grok 4.6

Grok 4.6 is designed for sustained work on code, research and interactive projects. Accepts text and images and supports 500,000 tokens of context and four reasoning levels.

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

About the model

This description covers the model’s capabilities. Available in Ailoot inputs, outputs and options are listed for the selected method below.

Sustained project work

Grok 4.6 is intended for tasks that continue across many steps: studying a topic, analyzing material, working with a codebase and creating an application. In xAI's examples, the model researches an unfamiliar subject area, determines project structure, implements core interactions and refines the result after feedback.

Training used coding and knowledge-work tasks, as well as specialized environments for web development, computational-kernel optimization and computer-aided design. In sustained workflows, the manufacturer notes independent checking of completed work before moving to the next step.

Interactive and visual projects

The model can turn a general product idea into an initial working version, define application structure and visual language, then improve the project through iterations. This is work with code and textual descriptions of the result: running, viewing and modifying files requires appropriate application tools.

Input supports text and images, and output is text. Up to 500,000 tokens fit in one context. Visual material can be used alongside a question; this text model does not create a separate image or video.

Depth of thinking

low, medium, high and xhigh are available, with high as the default. Low depth is suited to simple agentic actions, medium to data analysis and long material, and high to complex logical tasks. xhigh allocates more effort to the hardest tasks and, according to xAI, increases latency.

Reasoning cannot be fully disabled. presencePenalty, frequencyPenalty and stop are not used with models of this type. Context capacity and selected thinking depth describe different properties: a large window does not by itself set the reasoning mode.

Connecting to a workflow

Grok 4.6 supports function calling. The model can request several actions in one response; your code executes them, returns results and continues the dialogue. Names and argument schemas are specified for tools, while call selection can be left automatic or explicitly controlled.

Structured responses are suited to extracting document data and passing results to a program: JSON or JSON under a custom schema can be requested. Data types, nested objects, arrays and enumerations are supported. For complex schema conditions, generation alone is insufficient: constraints not structurally enforced are checked in the application.

The model's main use is continuing meaningful work on a complex task by combining analysis, code and feedback. The complete workflow consists of model responses and actions performed by connected tools.

Practical task

Review a multi-step import design

Technical example in English

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.

Expected result

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

Check the result

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

Model ID

grok-4.6
grok-4.6-latest

Overview

Grok 4.6 is designed for sustained work on code, research and interactive projects. Accepts text and images and supports 500,000 tokens of context and four reasoning levels.

Accepted inputs: Text · Images
Results: Text

Available in Ailoot · inputs & methods

Ailoot · Anthropic Messages POST /v1/messages

Input types: text, image
Output types: text
Context: 500,000 tokens
Maximum output: 500,000 tokens
Output format: json or SSE

Field	Type	Requirement	Values & limits	Default
Field`model`	Type`string`	RequirementRequired	Values & limits grok-4.6	Default—
Field`messages`	Type`message[]`	RequirementRequired	Values & limits Minimum items: 1	Default—
Field`messages[].role`	Type`string`	RequirementRequired	Values & limits user, assistant	Default—
Field`messages[].content`	Type`string\|content_block[]`	RequirementRequired	Values & limits	Default—
Field`system`	Type`string\|content_block[]`	RequirementOptional	Values & limits	Default—
Field`max_tokens`	Type`integer`	RequirementRequired	Values & limits Minimum: 1 Limit applies to: exact selected model/card ceiling	Default—
Field`stream`	Type`boolean`	RequirementOptional	Values & limits	Defaultfalse
Field`temperature`	Type`number`	RequirementOptional	Values & limits Model-specific	Default—
Field`top_p`	Type`number`	RequirementOptional	Values & limits Model-specific	Default—
Field`stop_sequences`	Type`string[]`	RequirementOptional	Values & limits Model-specific	Default—
Field`tools`	Type`tool[]`	RequirementOptional	Values & limits Model-specific	Default—
Field`tools[].name`	Type`string`	RequirementOptional	Values & limits Applies when: tool supplied	Default—
Field`tools[].description`	Type`string`	RequirementOptional	Values & limits	Default—
Field`tools[].input_schema`	Type`JSON_schema`	RequirementOptional	Values & limits	Default—
Field`tool_choice`	Type`object`	RequirementOptional	Values & limits Model-specific	Default—
Field`thinking.type`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`thinking.budget_tokens`	Type`integer`	RequirementOptional	Values & limits Model-specific	Default—
Field`output_config.effort`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`metadata`	Type`object`	RequirementOptional	Values & limits	Default—
Field`cache_control`	Type`object`	RequirementOptional	Values & limits Model-specific	Default—

Input material combinations

Text · UTF8 text

messages[].content or type=text block

Text + image

{type:image,source:{type:base64,media_type,data}} or source type=url

Method parameters and lifecycle

Parameter	Contract
Parameter`material_types`	Contracttext, image
Parameter`required`	Contractmodel, messages, max_tokens
Parameter`optional_controls`	Contractnull
Parameter`content_type`	Contractapplication/json
Parameter`text_file_material`	Contractactual UTF-8 content inserted as text; file IDs/URLs need separate exact support

Lifecycle: exact retained published method

Method shapes and IDs are exact; supplier capability is separate from admission.

Pricing

Ailoot method rates

Ailoot Anthropic MessagesPOST /v1/messages

Input: $0.002 / 1K
Output: $0.006 / 1K
Cache read: $0.0005 / 1K
Cache write: $0.00 / 1K
Cache write, 5 min: $0.00 / 1K tokens
Cache write, 1 hour: $0.00 / 1K tokens

Prices by request length · Anthropic Messages

Request size, tokens	Input	Output	Cache read	Cache write	5 min cache	1 hour cache
Request size, tokens(0; 200,000]	Input$0.002	Output$0.006	Cache read$0.0005	Cache write$0.00	5 min cache$0.00	1 hour cache$0.00
Request size, tokens(200,000; ∞)	Input$0.004	Output$0.012	Cache read$0.001	Cache write$0.00	5 min cache$0.00	1 hour cache$0.00

Rates in USD per 1K tokens. If no rate is set, the base rate for this method is inherited; «—» means no base rate is set.

Ailoot reserves an estimated amount before a request. After the result, it settles the final charge from measured usage. Streaming settlement uses the final usage record. How reservation and settlement work →

Reference tariff details

Model-level reference schedules do not change method selection, quotes or charges. Active charges use the selected Ailoot method rates.

Model reference schedules

Prices by configuration

Match each charge to the conditions shown. Use one rate for each set of alternative configurations.

Configuration	Rate schedule	Context tokens, more than	Context tokens, up to and including	Charge
ConfigurationOpenAI Chat · Base token rates	Rate scheduleBase rate	Context tokens, more than—	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationOpenAI Chat · Request-length tier 1	Rate schedule—	Context tokens, more than0	Context tokens, up to and including200,000	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationOpenAI Chat · Request-length tier 2	Rate schedule—	Context tokens, more than200,000	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.008 / 1K tokens Output · Output tokens $0.024 / 1K tokens Input · Cache read $0.002 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationAnthropic Messages · Base token rates	Rate scheduleBase rate	Context tokens, more than—	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationAnthropic Messages · Request-length tier 1	Rate schedule—	Context tokens, more than0	Context tokens, up to and including200,000	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationAnthropic Messages · Request-length tier 2	Rate schedule—	Context tokens, more than200,000	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.008 / 1K tokens Output · Output tokens $0.024 / 1K tokens Input · Cache read $0.002 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens

Example requests

Ailoot · Anthropic Messages

Text exampleImage inputPython SDKNode.js SDKPython stream

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

Receive and save results

Ailoot · Anthropic Messages

json or SSE

Keep all completed results

Keep every complete returned response, file and content part.

Keep all content blocks, thinking signatures and actual tool-use IDs. Assemble all SSE block deltas; a first text block is not the complete output.

If the original response needs checking

Keep request/response IDs and headers. No generic text job retrieval URL is supplied.

Response fields

Field	Type
Field`id`	Typestring
Field`model`	Typestring
Field`content[]`	Typetext\|thinking\|tool_use\|other content block
Field`stop_reason`	Typestring\|null
Field`usage`	Typeobject

Errors and next steps

Response	Condition	Next step
Response400 · `invalid_request_error`	ConditionInvalid required fields, material representation or parameter value	Next stepCorrect the indicated fields before a new creation request.

Aliases

Model aliases

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

Method path aliases

/chat/completions

Related caller IDs

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

Model ID

grok-4.6
grok-4.6-latest

Overview

Grok 4.6 is designed for sustained work on code, research and interactive projects. Accepts text and images and supports 500,000 tokens of context and four reasoning levels.

Accepted inputs: Text · Images
Results: Text

Available in Ailoot · inputs & methods

Ailoot · OpenAI Responses POST /v1/responses

Input types: text, image
Output types: text
Context: 500,000 tokens
Maximum output: 500,000 tokens
Output format: json or SSE

Field	Type	Requirement	Values & limits	Default
Field`model`	Type`string`	RequirementRequired	Values & limits grok-4.6	Default—
Field`input`	Type`string\|input_item[]`	RequirementRequired	Values & limits	Default—
Field`instructions`	Type`string`	RequirementOptional	Values & limits	Default—
Field`input[].type`	Type`string`	RequirementOptional	Values & limits message, reasoning, function_call, function_call_output	Default—
Field`input[].content`	Type`string\|content_part[]`	RequirementOptional	Values & limits	Default—
Field`input[].call_id`	Type`string`	RequirementOptional	Values & limits Applies when: function_call_output; retain actual returned call_id	Default—
Field`input[].output`	Type`string\|content_part[]`	RequirementOptional	Values & limits Applies when: function_call_output	Default—
Field`max_output_tokens`	Type`integer`	RequirementOptional	Values & limits Minimum: 1 Model-specific	Default—
Field`stream`	Type`boolean`	RequirementOptional	Values & limits	Defaultfalse
Field`temperature`	Type`number`	RequirementOptional	Values & limits Model-specific	Default—
Field`top_p`	Type`number`	RequirementOptional	Values & limits Model-specific	Default—
Field`tools`	Type`tool[]`	RequirementOptional	Values & limits Model-specific	Default—
Field`tool_choice`	Type`string\|object`	RequirementOptional	Values & limits Model-specific	Default—
Field`parallel_tool_calls`	Type`boolean`	RequirementOptional	Values & limits Model-specific	Default—
Field`reasoning.effort`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`reasoning.summary`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`text.format`	Type`object`	RequirementOptional	Values & limits Model-specific	Default—
Field`text.verbosity`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`include`	Type`string[]`	RequirementOptional	Values & limits Model-specific	Default—
Field`store`	Type`boolean`	RequirementOptional	Values & limits Model-specific	Default—
Field`previous_response_id`	Type`string`	RequirementOptional	Values & limits ID requirement: Only an actual response ID from a supported continuation Model-specific	Default—
Field`service_tier`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`prompt_cache_key`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`prompt_cache_options`	Type`object`	RequirementOptional	Values & limits Model-specific	Default—

Input material combinations

Text · UTF8 text

input text or input_text part

Text + image

{type:input_image,image_url}

Method parameters and lifecycle

Parameter	Contract
Parameter`material_types`	Contracttext, image
Parameter`required`	Contractmodel, input
Parameter`optional_controls`	Contractnull
Parameter`content_type`	Contractapplication/json
Parameter`text_file_material`	Contractactual UTF-8 content inserted as text; file IDs/URLs need separate exact support

Lifecycle: exact retained published method

Method shapes and IDs are exact; supplier capability is separate from admission.

Pricing

Ailoot method rates

Ailoot OpenAI ResponsesPOST /v1/responses

Input: $0.002 / 1K
Output: $0.006 / 1K
Cache read: $0.0005 / 1K
Cache write: $0.00 / 1K
Cache write, 5 min: $0.00 / 1K tokens
Cache write, 1 hour: $0.00 / 1K tokens

Prices by request length · OpenAI Responses

Request size, tokens	Input	Output	Cache read	Cache write	5 min cache	1 hour cache
Request size, tokens(0; 200,000]	Input$0.002	Output$0.006	Cache read$0.0005	Cache write$0.00	5 min cache$0.00	1 hour cache$0.00
Request size, tokens(200,000; ∞)	Input$0.004	Output$0.012	Cache read$0.001	Cache write$0.00	5 min cache$0.00	1 hour cache$0.00

Rates in USD per 1K tokens. If no rate is set, the base rate for this method is inherited; «—» means no base rate is set.

Reference tariff details

Model-level reference schedules do not change method selection, quotes or charges. Active charges use the selected Ailoot method rates.

Model reference schedules

Prices by configuration

Match each charge to the conditions shown. Use one rate for each set of alternative configurations.

Configuration	Rate schedule	Context tokens, more than	Context tokens, up to and including	Charge
ConfigurationOpenAI Chat · Base token rates	Rate scheduleBase rate	Context tokens, more than—	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationOpenAI Chat · Request-length tier 1	Rate schedule—	Context tokens, more than0	Context tokens, up to and including200,000	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationOpenAI Chat · Request-length tier 2	Rate schedule—	Context tokens, more than200,000	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.008 / 1K tokens Output · Output tokens $0.024 / 1K tokens Input · Cache read $0.002 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationAnthropic Messages · Base token rates	Rate scheduleBase rate	Context tokens, more than—	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationAnthropic Messages · Request-length tier 1	Rate schedule—	Context tokens, more than0	Context tokens, up to and including200,000	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationAnthropic Messages · Request-length tier 2	Rate schedule—	Context tokens, more than200,000	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.008 / 1K tokens Output · Output tokens $0.024 / 1K tokens Input · Cache read $0.002 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens

Example requests

Ailoot · OpenAI Responses

Text exampleImage inputPython SDKNode.js SDKPython stream

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

Receive and save results

Ailoot · OpenAI Responses

json or SSE

Keep all completed results

Keep every complete returned response, file and content part.

Keep every output item and content part, actual function call_id, encrypted reasoning and usage. In streaming retain complete event/item identity.

If the original response needs checking

Keep request/response IDs and headers. No generic text job retrieval URL is supplied.

Response fields

Field	Type
Field`id`	Typestring
Field`status`	Typestring
Field`output[]`	Typemessage\|reasoning\|function_call\|other item
Field`output[].content[]`	Typecontent part
Field`usage`	Typeobject

Errors and next steps

Response	Condition	Next step
Response400 · `invalid_request_error`	ConditionInvalid required fields, material representation or parameter value	Next stepCorrect the indicated fields before a new creation request.

Aliases

Model aliases

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

Method path aliases

/chat/completions

Related caller IDs

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

Model ID

grok-4.6
grok-4.6-latest

Overview

Grok 4.6 is designed for sustained work on code, research and interactive projects. Accepts text and images and supports 500,000 tokens of context and four reasoning levels.

Accepted inputs: Text · Images
Results: Text

Available in Ailoot · inputs & methods

Ailoot · OpenAI Chat POST /v1/chat/completions

Input types: text, image
Output types: text
Context: 500,000 tokens
Maximum output: 500,000 tokens
Output format: json or SSE

Field	Type	Requirement	Values & limits	Default
Field`model`	Type`string`	RequirementRequired	Values & limits grok-4.6	Default—
Field`messages`	Type`message[]`	RequirementRequired	Values & limits Minimum items: 1	Default—
Field`messages[].role`	Type`string`	RequirementRequired	Values & limits Examples: system, user, assistant, tool, function Conditions: These roles are explicitly represented by Source compatibility types; the exact model role set remains model-specific. Model-specific	Default—
Field`messages[].content`	Type`string\|content_part[]\|null`	RequirementOptional	Values & limits	Default—
Field`messages[].tool_calls`	Type`tool_call[]`	RequirementOptional	Values & limits	Default—
Field`messages[].tool_call_id`	Type`string`	RequirementOptional	Values & limits Applies when: role=tool; use actual returned ID	Default—
Field`messages[].name`	Type`string`	RequirementOptional	Values & limits	Default—
Field`messages[].reasoning_content`	Type`string`	RequirementOptional	Values & limits Applies when: Round-trip actual returned reasoning where this model uses it	Default—
Field`messages[].reasoning_details`	Type`object\|array`	RequirementOptional	Values & limits Model-specific	Default—
Field`max_tokens`	Type`integer`	RequirementOptional	Values & limits Minimum: 1 Model-specific	Default—
Field`max_completion_tokens`	Type`integer`	RequirementOptional	Values & limits Minimum: 1 Model-specific	Default—
Field`stream`	Type`boolean`	RequirementOptional	Values & limits	Defaultfalse
Field`stream_options.include_usage`	Type`boolean`	RequirementOptional	Values & limits Model-specific	Default—
Field`temperature`	Type`number`	RequirementOptional	Values & limits Model-specific	Default—
Field`top_p`	Type`number`	RequirementOptional	Values & limits Model-specific	Default—
Field`stop`	Type`string\|string[]`	RequirementOptional	Values & limits Model-specific	Default—
Field`tools`	Type`function_tool[]`	RequirementOptional	Values & limits Model-specific	Default—
Field`tools[].type`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`tools[].function.name`	Type`string`	RequirementRequired	Values & limits Applies when: function tool supplied	Default—
Field`tools[].function.description`	Type`string`	RequirementOptional	Values & limits	Default—
Field`tools[].function.parameters`	Type`JSON_schema`	RequirementOptional	Values & limits	Default—
Field`tool_choice`	Type`string\|object`	RequirementOptional	Values & limits Model-specific	Default—
Field`parallel_tool_calls`	Type`boolean`	RequirementOptional	Values & limits Model-specific	Default—
Field`response_format`	Type`object`	RequirementOptional	Values & limits Model-specific	Default—
Field`reasoning_effort`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`reasoning`	Type`object`	RequirementOptional	Values & limits Model-specific	Default—
Field`service_tier`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`instructions`	Type`string`	RequirementOptional	Values & limits Compatibility field	Default—
Field`functions`	Type`function[]`	RequirementOptional	Values & limits Model-specific	Default—
Field`function_call`	Type`string\|object`	RequirementOptional	Values & limits Model-specific	Default—
Field`prompt_cache_options`	Type`object`	RequirementOptional	Values & limits Model-specific	Default—

Input material combinations

Text · UTF8 text

messages[].content

Text + image

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

Method parameters and lifecycle

Parameter	Contract
Parameter`material_types`	Contracttext, image
Parameter`required`	Contractmodel, messages
Parameter`optional_controls`	Contractnull
Parameter`content_type`	Contractapplication/json
Parameter`text_file_material`	Contractactual UTF-8 content inserted as text; file IDs/URLs need separate exact support

Lifecycle: exact retained published method

Method shapes and IDs are exact; supplier capability is separate from admission.

Pricing

Ailoot method rates

Ailoot OpenAI ChatPOST /v1/chat/completions

Input: $0.002 / 1K
Output: $0.006 / 1K
Cache read: $0.0005 / 1K
Cache write: $0.00 / 1K
Cache write, 5 min: $0.00 / 1K tokens
Cache write, 1 hour: $0.00 / 1K tokens

Prices by request length · OpenAI Chat

Request size, tokens	Input	Output	Cache read	Cache write	5 min cache	1 hour cache
Request size, tokens(0; 200,000]	Input$0.002	Output$0.006	Cache read$0.0005	Cache write$0.00	5 min cache$0.00	1 hour cache$0.00
Request size, tokens(200,000; ∞)	Input$0.004	Output$0.012	Cache read$0.001	Cache write$0.00	5 min cache$0.00	1 hour cache$0.00

Rates in USD per 1K tokens. If no rate is set, the base rate for this method is inherited; «—» means no base rate is set.

Reference tariff details

Model-level reference schedules do not change method selection, quotes or charges. Active charges use the selected Ailoot method rates.

Model reference schedules

Prices by configuration

Match each charge to the conditions shown. Use one rate for each set of alternative configurations.

Configuration	Rate schedule	Context tokens, more than	Context tokens, up to and including	Charge
ConfigurationOpenAI Chat · Base token rates	Rate scheduleBase rate	Context tokens, more than—	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationOpenAI Chat · Request-length tier 1	Rate schedule—	Context tokens, more than0	Context tokens, up to and including200,000	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationOpenAI Chat · Request-length tier 2	Rate schedule—	Context tokens, more than200,000	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.008 / 1K tokens Output · Output tokens $0.024 / 1K tokens Input · Cache read $0.002 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationAnthropic Messages · Base token rates	Rate scheduleBase rate	Context tokens, more than—	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationAnthropic Messages · Request-length tier 1	Rate schedule—	Context tokens, more than0	Context tokens, up to and including200,000	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationAnthropic Messages · Request-length tier 2	Rate schedule—	Context tokens, more than200,000	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.008 / 1K tokens Output · Output tokens $0.024 / 1K tokens Input · Cache read $0.002 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens

Example requests

Ailoot · OpenAI Chat

Text exampleImage inputPython SDKNode.js SDKPython stream

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

Receive and save results

Ailoot · OpenAI Chat

json or SSE

Keep all completed results

Keep every complete returned response, file and content part.

Keep every choice and its content/tool calls/reasoning. In SSE assemble deltas by choice/tool index, retain the final finish reason and usage.

If the original response needs checking

Keep request/response IDs and headers. No generic text job retrieval URL is supplied.

Response fields

Field	Type
Field`choices[].index`	Typeinteger
Field`choices[].message.content`	Typestring\|null
Field`choices[].message.tool_calls`	Typetool_call[]
Field`choices[].message.reasoning_content`	Typestring
Field`choices[].message.reasoning_details`	Typeobject\|array
Field`choices[].finish_reason`	Typestring\|null
Field`usage`	Typeobject

Errors and next steps

Response	Condition	Next step
Response400 · `invalid_request_error`	ConditionInvalid required fields, material representation or parameter value	Next stepCorrect the indicated fields before a new creation request.

Aliases

Model aliases

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

Method path aliases

/chat/completions

Related caller IDs

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

Model ID

grok-4.6
x-ai/grok-4.6

Overview

Grok 4.6 is designed for sustained work on code, research and interactive projects. Accepts text and images and supports 500,000 tokens of context and four reasoning levels.

Accepted inputs: Text
Results: Text

Available in Ailoot · inputs & methods

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

Input types: text
Output types: text
Output format: json or SSE

Field	Type	Requirement	Values & limits	Default
Field`model`	Type`string`	RequirementRequired	Values & limits grok-4.6	Default—
Field`messages`	Type`message[]`	RequirementRequired	Values & limits Minimum items: 1	Default—
Field`messages[].role`	Type`string`	RequirementRequired	Values & limits Model-specific	Default—
Field`messages[].content`	Type`string`	RequirementOptional	Values & limits Applies when: Text conversation	Default—
Field`stream`	Type`boolean`	RequirementOptional	Values & limits	Defaultfalse

Input material combinations

Text · UTF8 text

messages[].content

Method parameters and lifecycle

Parameter	Contract
Parameter`content_type`	Contractapplication/json
Parameter`required`	Contractmodel, messages
Parameter`material_types`	Contracttext
Parameter`messages`	Contractmessage array with role/content shape
Parameter`file_material`	Contractactual UTF-8 document inserted as literal text; no file ID inferred
Parameter`optional_controls`	Contractstream
Parameter`control_scope`	ContractText conversation; stream is a boolean and defaults to false.
Parameter`output_modalities`	Contracttext
Parameter`hosted_operations`	Contractfalse
Parameter`multimodal_input_binding`	Contractnull

Method aliases: /chat/completions

Lifecycle: synchronous_or_streamed

Send exact model ID with messages.

Context length is not an output cap.

A text file may supply literal text; image/audio/file-object inputs need exact binding.

Pricing

Tariff references do not add request options. Supported parameters are listed for the selected method.

Fast mode: Standard rate When fast mode is selected
Flex mode: Standard rate When flex mode is selected
Maximum reasoning effort: Standard rate When maximum reasoning effort uses the default adjustment
Reasoning effort · high: Standard rate When reasoning effort is high
Reasoning effort · low: Standard rate When reasoning effort is low
Reasoning effort · medium: Standard rate When reasoning effort is medium
Reasoning effort · xhigh: Standard rate When reasoning effort is xhigh

Ailoot rates

Prices by configuration

Match each charge to the conditions shown. Use one rate for each set of alternative configurations.

Configuration	Rate schedule	Context tokens, more than	Context tokens, up to and including	Charge
ConfigurationBase token rates	Rate scheduleBase rate	Context tokens, more than—	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationRequest-length tier 1	Rate schedule—	Context tokens, more than0	Context tokens, up to and including200,000	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationRequest-length tier 2	Rate schedule—	Context tokens, more than200,000	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.008 / 1K tokens Output · Output tokens $0.024 / 1K tokens Input · Cache read $0.002 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens

Example requests

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

Receive and save results

Ailoot Ultra · OpenAI Chat

json or SSE

Keep all completed results

Keep every complete returned response, file and content part.

Keep every choice and its content/tool calls/reasoning. In SSE assemble deltas by choice/tool index, retain the final finish reason and usage.

If the original response needs checking

Keep request/response IDs and headers. No generic text job retrieval URL is supplied.

Response fields

Field	Type
Field`choices[].index`	Typeinteger
Field`choices[].message.content`	Typestring\|null
Field`choices[].message.tool_calls`	Typetool_call[]
Field`choices[].message.reasoning_content`	Typestring
Field`choices[].message.reasoning_details`	Typeobject\|array
Field`choices[].finish_reason`	Typestring\|null
Field`usage`	Typeobject

Errors and next steps

Response	Condition	Next step
Response400 · `invalid_request_error`	ConditionInvalid required fields, material representation or parameter value	Next stepCorrect the indicated fields before a new creation request.

Aliases

Model aliases

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

Method path aliases

/chat/completions

Related caller IDs

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

Model ID

grok-4.6
x-ai/grok-4.6

Overview

Grok 4.6 is designed for sustained work on code, research and interactive projects. Accepts text and images and supports 500,000 tokens of context and four reasoning levels.

Accepted inputs: Text
Results: json · sse

Available in Ailoot · inputs & methods

Ailoot Ultra · Anthropic Messages POST /v1/messages

Input types: text
Output types: json, sse
Output format: JSON or SSE

Field	Type	Requirement	Values & limits	Default
Field`model`	Type`string`	RequirementRequired	Values & limits grok-4.6	Default—
Field`messages`	Type`message[]`	RequirementRequired	Values & limits	Default—
Field`messages[].role`	Type`string`	RequirementRequired	Values & limits user, assistant	Default—
Field`messages[].content`	Type`string`	RequirementRequired	Values & limits	Default—
Field`max_tokens`	Type`integer`	RequirementRequired	Values & limits	Default—
Field`stream`	Type`boolean`	RequirementOptional	Values & limits	Defaultfalse

Input material combinations

Text · UTF-8 text

messages[].content string

Method parameters and lifecycle

Parameter	Contract
Parameter`content_type`	Contractapplication/json
Parameter`required`	Contractmodel, messages, max_tokens
Parameter`optional_controls`	Contractstream
Parameter`material_types`	Contracttext
Parameter`text_file_material`	ContractRead the actual UTF-8 document and put its text in the indicated input or message content string.

Lifecycle: synchronous_or_streamed

Pricing

Tariff references do not add request options. Supported parameters are listed for the selected method.

Fast mode: Standard rate When fast mode is selected
Flex mode: Standard rate When flex mode is selected
Maximum reasoning effort: Standard rate When maximum reasoning effort uses the default adjustment
Reasoning effort · high: Standard rate When reasoning effort is high
Reasoning effort · low: Standard rate When reasoning effort is low
Reasoning effort · medium: Standard rate When reasoning effort is medium
Reasoning effort · xhigh: Standard rate When reasoning effort is xhigh

Ailoot rates

Prices by configuration

Match each charge to the conditions shown. Use one rate for each set of alternative configurations.

Configuration	Rate schedule	Context tokens, more than	Context tokens, up to and including	Charge
ConfigurationBase token rates	Rate scheduleBase rate	Context tokens, more than—	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationRequest-length tier 1	Rate schedule—	Context tokens, more than0	Context tokens, up to and including200,000	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationRequest-length tier 2	Rate schedule—	Context tokens, more than200,000	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.008 / 1K tokens Output · Output tokens $0.024 / 1K tokens Input · Cache read $0.002 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens

Example requests

Ailoot Ultra · Anthropic Messages

Complete minimal JSON bodycurl · use your UTF-8 documentPython · save the complete result

{
  "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))

Receive and save results

Ailoot Ultra · Anthropic Messages

JSON or SSE

Keep all completed results

Keep every complete returned response, file and content part.

Keep all content blocks, thinking signatures and actual tool-use IDs. Assemble all SSE block deltas; a first text block is not the complete output.

If the original response needs checking

Keep request/response IDs and headers. No generic text job retrieval URL is supplied.

Response fields

Field	Type
Field`id`	Typestring
Field`model`	Typestring
Field`content[]`	Typetext\|thinking\|tool_use\|other content block
Field`stop_reason`	Typestring\|null
Field`usage`	Typeobject

Errors and next steps

Response	Condition	Next step
Response400 · `invalid_request_error`	ConditionInvalid required fields, material representation or parameter value	Next stepCorrect the indicated fields before a new creation request.

Aliases

Model aliases

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

Method path aliases

/chat/completions

Related caller IDs

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

Model ID

grok-4.6
grok-4.6-latest

Overview

Grok 4.6 is designed for sustained work on code, research and interactive projects. Accepts text and images and supports 500,000 tokens of context and four reasoning levels.

Accepted inputs: Text · Images
Results: Text

Available in Ailoot · inputs & methods

Ailoot · Anthropic Messages POST /v1/messages

Input types: text, image
Output types: text
Context: 500,000 tokens
Maximum output: 500,000 tokens
Output format: json or SSE

Field	Type	Requirement	Values & limits	Default
Field`model`	Type`string`	RequirementRequired	Values & limits grok-4.6-latest	Default—
Field`messages`	Type`message[]`	RequirementRequired	Values & limits Minimum items: 1	Default—
Field`messages[].role`	Type`string`	RequirementRequired	Values & limits user, assistant	Default—
Field`messages[].content`	Type`string\|content_block[]`	RequirementRequired	Values & limits	Default—
Field`system`	Type`string\|content_block[]`	RequirementOptional	Values & limits	Default—
Field`max_tokens`	Type`integer`	RequirementRequired	Values & limits Minimum: 1 Limit applies to: exact selected model/card ceiling	Default—
Field`stream`	Type`boolean`	RequirementOptional	Values & limits	Defaultfalse
Field`temperature`	Type`number`	RequirementOptional	Values & limits Model-specific	Default—
Field`top_p`	Type`number`	RequirementOptional	Values & limits Model-specific	Default—
Field`stop_sequences`	Type`string[]`	RequirementOptional	Values & limits Model-specific	Default—
Field`tools`	Type`tool[]`	RequirementOptional	Values & limits Model-specific	Default—
Field`tools[].name`	Type`string`	RequirementOptional	Values & limits Applies when: tool supplied	Default—
Field`tools[].description`	Type`string`	RequirementOptional	Values & limits	Default—
Field`tools[].input_schema`	Type`JSON_schema`	RequirementOptional	Values & limits	Default—
Field`tool_choice`	Type`object`	RequirementOptional	Values & limits Model-specific	Default—
Field`thinking.type`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`thinking.budget_tokens`	Type`integer`	RequirementOptional	Values & limits Model-specific	Default—
Field`output_config.effort`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`metadata`	Type`object`	RequirementOptional	Values & limits	Default—
Field`cache_control`	Type`object`	RequirementOptional	Values & limits Model-specific	Default—

Input material combinations

Text · UTF8 text

messages[].content or type=text block

Text + image

{type:image,source:{type:base64,media_type,data}} or source type=url

Method parameters and lifecycle

Parameter	Contract
Parameter`material_types`	Contracttext, image
Parameter`required`	Contractmodel, messages, max_tokens
Parameter`optional_controls`	Contractnull
Parameter`content_type`	Contractapplication/json
Parameter`text_file_material`	Contractactual UTF-8 content inserted as text; file IDs/URLs need separate exact support

Lifecycle: exact retained published method

Method shapes and IDs are exact; supplier capability is separate from admission.

Pricing

Ailoot method rates

Ailoot Anthropic MessagesPOST /v1/messages

Input: $0.002 / 1K
Output: $0.006 / 1K
Cache read: $0.0005 / 1K
Cache write: $0.00 / 1K
Cache write, 5 min: $0.00 / 1K tokens
Cache write, 1 hour: $0.00 / 1K tokens

Prices by request length · Anthropic Messages

Request size, tokens	Input	Output	Cache read	Cache write	5 min cache	1 hour cache
Request size, tokens(0; 200,000]	Input$0.002	Output$0.006	Cache read$0.0005	Cache write$0.00	5 min cache$0.00	1 hour cache$0.00
Request size, tokens(200,000; ∞)	Input$0.004	Output$0.012	Cache read$0.001	Cache write$0.00	5 min cache$0.00	1 hour cache$0.00

Rates in USD per 1K tokens. If no rate is set, the base rate for this method is inherited; «—» means no base rate is set.

Reference tariff details

Model-level reference schedules do not change method selection, quotes or charges. Active charges use the selected Ailoot method rates.

Model reference schedules

Prices by configuration

Match each charge to the conditions shown. Use one rate for each set of alternative configurations.

Configuration	Rate schedule	Context tokens, more than	Context tokens, up to and including	Charge
ConfigurationOpenAI Chat · Base token rates	Rate scheduleBase rate	Context tokens, more than—	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationOpenAI Chat · Request-length tier 1	Rate schedule—	Context tokens, more than0	Context tokens, up to and including200,000	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationOpenAI Chat · Request-length tier 2	Rate schedule—	Context tokens, more than200,000	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.008 / 1K tokens Output · Output tokens $0.024 / 1K tokens Input · Cache read $0.002 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationAnthropic Messages · Base token rates	Rate scheduleBase rate	Context tokens, more than—	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationAnthropic Messages · Request-length tier 1	Rate schedule—	Context tokens, more than0	Context tokens, up to and including200,000	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationAnthropic Messages · Request-length tier 2	Rate schedule—	Context tokens, more than200,000	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.008 / 1K tokens Output · Output tokens $0.024 / 1K tokens Input · Cache read $0.002 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens

Example requests

Ailoot · Anthropic Messages

Text exampleImage inputPython SDKNode.js SDKPython stream

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

Receive and save results

Ailoot · Anthropic Messages

json or SSE

Keep all completed results

Keep every complete returned response, file and content part.

Keep all content blocks, thinking signatures and actual tool-use IDs. Assemble all SSE block deltas; a first text block is not the complete output.

If the original response needs checking

Keep request/response IDs and headers. No generic text job retrieval URL is supplied.

Response fields

Field	Type
Field`id`	Typestring
Field`model`	Typestring
Field`content[]`	Typetext\|thinking\|tool_use\|other content block
Field`stop_reason`	Typestring\|null
Field`usage`	Typeobject

Errors and next steps

Response	Condition	Next step
Response400 · `invalid_request_error`	ConditionInvalid required fields, material representation or parameter value	Next stepCorrect the indicated fields before a new creation request.

Aliases

Model aliases

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

Method path aliases

/chat/completions

Related caller IDs

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

Model ID

grok-4.6
grok-4.6-latest

Overview

Grok 4.6 is designed for sustained work on code, research and interactive projects. Accepts text and images and supports 500,000 tokens of context and four reasoning levels.

Accepted inputs: Text · Images
Results: Text

Available in Ailoot · inputs & methods

Ailoot · OpenAI Responses POST /v1/responses

Input types: text, image
Output types: text
Context: 500,000 tokens
Maximum output: 500,000 tokens
Output format: json or SSE

Field	Type	Requirement	Values & limits	Default
Field`model`	Type`string`	RequirementRequired	Values & limits grok-4.6-latest	Default—
Field`input`	Type`string\|input_item[]`	RequirementRequired	Values & limits	Default—
Field`instructions`	Type`string`	RequirementOptional	Values & limits	Default—
Field`input[].type`	Type`string`	RequirementOptional	Values & limits message, reasoning, function_call, function_call_output	Default—
Field`input[].content`	Type`string\|content_part[]`	RequirementOptional	Values & limits	Default—
Field`input[].call_id`	Type`string`	RequirementOptional	Values & limits Applies when: function_call_output; retain actual returned call_id	Default—
Field`input[].output`	Type`string\|content_part[]`	RequirementOptional	Values & limits Applies when: function_call_output	Default—
Field`max_output_tokens`	Type`integer`	RequirementOptional	Values & limits Minimum: 1 Model-specific	Default—
Field`stream`	Type`boolean`	RequirementOptional	Values & limits	Defaultfalse
Field`temperature`	Type`number`	RequirementOptional	Values & limits Model-specific	Default—
Field`top_p`	Type`number`	RequirementOptional	Values & limits Model-specific	Default—
Field`tools`	Type`tool[]`	RequirementOptional	Values & limits Model-specific	Default—
Field`tool_choice`	Type`string\|object`	RequirementOptional	Values & limits Model-specific	Default—
Field`parallel_tool_calls`	Type`boolean`	RequirementOptional	Values & limits Model-specific	Default—
Field`reasoning.effort`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`reasoning.summary`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`text.format`	Type`object`	RequirementOptional	Values & limits Model-specific	Default—
Field`text.verbosity`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`include`	Type`string[]`	RequirementOptional	Values & limits Model-specific	Default—
Field`store`	Type`boolean`	RequirementOptional	Values & limits Model-specific	Default—
Field`previous_response_id`	Type`string`	RequirementOptional	Values & limits ID requirement: Only an actual response ID from a supported continuation Model-specific	Default—
Field`service_tier`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`prompt_cache_key`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`prompt_cache_options`	Type`object`	RequirementOptional	Values & limits Model-specific	Default—

Input material combinations

Text · UTF8 text

input text or input_text part

Text + image

{type:input_image,image_url}

Method parameters and lifecycle

Parameter	Contract
Parameter`material_types`	Contracttext, image
Parameter`required`	Contractmodel, input
Parameter`optional_controls`	Contractnull
Parameter`content_type`	Contractapplication/json
Parameter`text_file_material`	Contractactual UTF-8 content inserted as text; file IDs/URLs need separate exact support

Lifecycle: exact retained published method

Method shapes and IDs are exact; supplier capability is separate from admission.

Pricing

Ailoot method rates

Ailoot OpenAI ResponsesPOST /v1/responses

Input: $0.002 / 1K
Output: $0.006 / 1K
Cache read: $0.0005 / 1K
Cache write: $0.00 / 1K
Cache write, 5 min: $0.00 / 1K tokens
Cache write, 1 hour: $0.00 / 1K tokens

Prices by request length · OpenAI Responses

Request size, tokens	Input	Output	Cache read	Cache write	5 min cache	1 hour cache
Request size, tokens(0; 200,000]	Input$0.002	Output$0.006	Cache read$0.0005	Cache write$0.00	5 min cache$0.00	1 hour cache$0.00
Request size, tokens(200,000; ∞)	Input$0.004	Output$0.012	Cache read$0.001	Cache write$0.00	5 min cache$0.00	1 hour cache$0.00

Rates in USD per 1K tokens. If no rate is set, the base rate for this method is inherited; «—» means no base rate is set.

Reference tariff details

Model-level reference schedules do not change method selection, quotes or charges. Active charges use the selected Ailoot method rates.

Model reference schedules

Prices by configuration

Match each charge to the conditions shown. Use one rate for each set of alternative configurations.

Configuration	Rate schedule	Context tokens, more than	Context tokens, up to and including	Charge
ConfigurationOpenAI Chat · Base token rates	Rate scheduleBase rate	Context tokens, more than—	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationOpenAI Chat · Request-length tier 1	Rate schedule—	Context tokens, more than0	Context tokens, up to and including200,000	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationOpenAI Chat · Request-length tier 2	Rate schedule—	Context tokens, more than200,000	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.008 / 1K tokens Output · Output tokens $0.024 / 1K tokens Input · Cache read $0.002 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationAnthropic Messages · Base token rates	Rate scheduleBase rate	Context tokens, more than—	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationAnthropic Messages · Request-length tier 1	Rate schedule—	Context tokens, more than0	Context tokens, up to and including200,000	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationAnthropic Messages · Request-length tier 2	Rate schedule—	Context tokens, more than200,000	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.008 / 1K tokens Output · Output tokens $0.024 / 1K tokens Input · Cache read $0.002 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens

Example requests

Ailoot · OpenAI Responses

Text exampleImage inputPython SDKNode.js SDKPython stream

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

Receive and save results

Ailoot · OpenAI Responses

json or SSE

Keep all completed results

Keep every complete returned response, file and content part.

Keep every output item and content part, actual function call_id, encrypted reasoning and usage. In streaming retain complete event/item identity.

If the original response needs checking

Keep request/response IDs and headers. No generic text job retrieval URL is supplied.

Response fields

Field	Type
Field`id`	Typestring
Field`status`	Typestring
Field`output[]`	Typemessage\|reasoning\|function_call\|other item
Field`output[].content[]`	Typecontent part
Field`usage`	Typeobject

Errors and next steps

Response	Condition	Next step
Response400 · `invalid_request_error`	ConditionInvalid required fields, material representation or parameter value	Next stepCorrect the indicated fields before a new creation request.

Aliases

Model aliases

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

Method path aliases

/chat/completions

Related caller IDs

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

Model ID

grok-4.6
grok-4.6-latest

Overview

Grok 4.6 is designed for sustained work on code, research and interactive projects. Accepts text and images and supports 500,000 tokens of context and four reasoning levels.

Accepted inputs: Text · Images
Results: Text

Available in Ailoot · inputs & methods

Ailoot · OpenAI Chat POST /v1/chat/completions

Input types: text, image
Output types: text
Context: 500,000 tokens
Maximum output: 500,000 tokens
Output format: json or SSE

Field	Type	Requirement	Values & limits	Default
Field`model`	Type`string`	RequirementRequired	Values & limits grok-4.6-latest	Default—
Field`messages`	Type`message[]`	RequirementRequired	Values & limits Minimum items: 1	Default—
Field`messages[].role`	Type`string`	RequirementRequired	Values & limits Examples: system, user, assistant, tool, function Conditions: These roles are explicitly represented by Source compatibility types; the exact model role set remains model-specific. Model-specific	Default—
Field`messages[].content`	Type`string\|content_part[]\|null`	RequirementOptional	Values & limits	Default—
Field`messages[].tool_calls`	Type`tool_call[]`	RequirementOptional	Values & limits	Default—
Field`messages[].tool_call_id`	Type`string`	RequirementOptional	Values & limits Applies when: role=tool; use actual returned ID	Default—
Field`messages[].name`	Type`string`	RequirementOptional	Values & limits	Default—
Field`messages[].reasoning_content`	Type`string`	RequirementOptional	Values & limits Applies when: Round-trip actual returned reasoning where this model uses it	Default—
Field`messages[].reasoning_details`	Type`object\|array`	RequirementOptional	Values & limits Model-specific	Default—
Field`max_tokens`	Type`integer`	RequirementOptional	Values & limits Minimum: 1 Model-specific	Default—
Field`max_completion_tokens`	Type`integer`	RequirementOptional	Values & limits Minimum: 1 Model-specific	Default—
Field`stream`	Type`boolean`	RequirementOptional	Values & limits	Defaultfalse
Field`stream_options.include_usage`	Type`boolean`	RequirementOptional	Values & limits Model-specific	Default—
Field`temperature`	Type`number`	RequirementOptional	Values & limits Model-specific	Default—
Field`top_p`	Type`number`	RequirementOptional	Values & limits Model-specific	Default—
Field`stop`	Type`string\|string[]`	RequirementOptional	Values & limits Model-specific	Default—
Field`tools`	Type`function_tool[]`	RequirementOptional	Values & limits Model-specific	Default—
Field`tools[].type`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`tools[].function.name`	Type`string`	RequirementRequired	Values & limits Applies when: function tool supplied	Default—
Field`tools[].function.description`	Type`string`	RequirementOptional	Values & limits	Default—
Field`tools[].function.parameters`	Type`JSON_schema`	RequirementOptional	Values & limits	Default—
Field`tool_choice`	Type`string\|object`	RequirementOptional	Values & limits Model-specific	Default—
Field`parallel_tool_calls`	Type`boolean`	RequirementOptional	Values & limits Model-specific	Default—
Field`response_format`	Type`object`	RequirementOptional	Values & limits Model-specific	Default—
Field`reasoning_effort`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`reasoning`	Type`object`	RequirementOptional	Values & limits Model-specific	Default—
Field`service_tier`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`instructions`	Type`string`	RequirementOptional	Values & limits Compatibility field	Default—
Field`functions`	Type`function[]`	RequirementOptional	Values & limits Model-specific	Default—
Field`function_call`	Type`string\|object`	RequirementOptional	Values & limits Model-specific	Default—
Field`prompt_cache_options`	Type`object`	RequirementOptional	Values & limits Model-specific	Default—

Input material combinations

Text · UTF8 text

messages[].content

Text + image

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

Method parameters and lifecycle

Parameter	Contract
Parameter`material_types`	Contracttext, image
Parameter`required`	Contractmodel, messages
Parameter`optional_controls`	Contractnull
Parameter`content_type`	Contractapplication/json
Parameter`text_file_material`	Contractactual UTF-8 content inserted as text; file IDs/URLs need separate exact support

Lifecycle: exact retained published method

Method shapes and IDs are exact; supplier capability is separate from admission.

Pricing

Ailoot method rates

Ailoot OpenAI ChatPOST /v1/chat/completions

Input: $0.002 / 1K
Output: $0.006 / 1K
Cache read: $0.0005 / 1K
Cache write: $0.00 / 1K
Cache write, 5 min: $0.00 / 1K tokens
Cache write, 1 hour: $0.00 / 1K tokens

Prices by request length · OpenAI Chat

Request size, tokens	Input	Output	Cache read	Cache write	5 min cache	1 hour cache
Request size, tokens(0; 200,000]	Input$0.002	Output$0.006	Cache read$0.0005	Cache write$0.00	5 min cache$0.00	1 hour cache$0.00
Request size, tokens(200,000; ∞)	Input$0.004	Output$0.012	Cache read$0.001	Cache write$0.00	5 min cache$0.00	1 hour cache$0.00

Rates in USD per 1K tokens. If no rate is set, the base rate for this method is inherited; «—» means no base rate is set.

Reference tariff details

Model-level reference schedules do not change method selection, quotes or charges. Active charges use the selected Ailoot method rates.

Model reference schedules

Prices by configuration

Match each charge to the conditions shown. Use one rate for each set of alternative configurations.

Configuration	Rate schedule	Context tokens, more than	Context tokens, up to and including	Charge
ConfigurationOpenAI Chat · Base token rates	Rate scheduleBase rate	Context tokens, more than—	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationOpenAI Chat · Request-length tier 1	Rate schedule—	Context tokens, more than0	Context tokens, up to and including200,000	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationOpenAI Chat · Request-length tier 2	Rate schedule—	Context tokens, more than200,000	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.008 / 1K tokens Output · Output tokens $0.024 / 1K tokens Input · Cache read $0.002 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationAnthropic Messages · Base token rates	Rate scheduleBase rate	Context tokens, more than—	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationAnthropic Messages · Request-length tier 1	Rate schedule—	Context tokens, more than0	Context tokens, up to and including200,000	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationAnthropic Messages · Request-length tier 2	Rate schedule—	Context tokens, more than200,000	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.008 / 1K tokens Output · Output tokens $0.024 / 1K tokens Input · Cache read $0.002 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens

Example requests

Ailoot · OpenAI Chat

Text exampleImage inputPython SDKNode.js SDKPython stream

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

Receive and save results

Ailoot · OpenAI Chat

json or SSE

Keep all completed results

Keep every complete returned response, file and content part.

Keep every choice and its content/tool calls/reasoning. In SSE assemble deltas by choice/tool index, retain the final finish reason and usage.

If the original response needs checking

Keep request/response IDs and headers. No generic text job retrieval URL is supplied.

Response fields

Field	Type
Field`choices[].index`	Typeinteger
Field`choices[].message.content`	Typestring\|null
Field`choices[].message.tool_calls`	Typetool_call[]
Field`choices[].message.reasoning_content`	Typestring
Field`choices[].message.reasoning_details`	Typeobject\|array
Field`choices[].finish_reason`	Typestring\|null
Field`usage`	Typeobject

Errors and next steps

Response	Condition	Next step
Response400 · `invalid_request_error`	ConditionInvalid required fields, material representation or parameter value	Next stepCorrect the indicated fields before a new creation request.

Aliases

Model aliases

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

Method path aliases

/chat/completions

Related caller IDs

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

Model ID

grok-4.6
x-ai/grok-4.6

Overview

Grok 4.6 is designed for sustained work on code, research and interactive projects. Accepts text and images and supports 500,000 tokens of context and four reasoning levels.

Accepted inputs: Text
Results: Text

Available in Ailoot · inputs & methods

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

Input types: text
Output types: text
Output format: json or SSE

Field	Type	Requirement	Values & limits	Default
Field`model`	Type`string`	RequirementRequired	Values & limits x-ai/grok-4.6	Default—
Field`messages`	Type`message[]`	RequirementRequired	Values & limits Minimum items: 1	Default—
Field`messages[].role`	Type`string`	RequirementRequired	Values & limits Examples: system, user, assistant, tool, function Conditions: These roles are explicitly represented by Source compatibility types; the exact model role set remains model-specific. Model-specific	Default—
Field`messages[].content`	Type`string\|content_part[]\|null`	RequirementOptional	Values & limits	Default—
Field`messages[].tool_calls`	Type`tool_call[]`	RequirementOptional	Values & limits	Default—
Field`messages[].tool_call_id`	Type`string`	RequirementOptional	Values & limits Applies when: role=tool; use actual returned ID	Default—
Field`messages[].name`	Type`string`	RequirementOptional	Values & limits	Default—
Field`messages[].reasoning_content`	Type`string`	RequirementOptional	Values & limits Applies when: Round-trip actual returned reasoning where this model uses it	Default—
Field`messages[].reasoning_details`	Type`object\|array`	RequirementOptional	Values & limits Model-specific	Default—
Field`max_tokens`	Type`integer`	RequirementOptional	Values & limits Minimum: 1 Model-specific	Default—
Field`max_completion_tokens`	Type`integer`	RequirementOptional	Values & limits Minimum: 1 Model-specific	Default—
Field`stream`	Type`boolean`	RequirementOptional	Values & limits	Defaultfalse
Field`stream_options.include_usage`	Type`boolean`	RequirementOptional	Values & limits Model-specific	Default—
Field`temperature`	Type`number`	RequirementOptional	Values & limits Model-specific	Default—
Field`top_p`	Type`number`	RequirementOptional	Values & limits Model-specific	Default—
Field`stop`	Type`string\|string[]`	RequirementOptional	Values & limits Model-specific	Default—
Field`tools`	Type`function_tool[]`	RequirementOptional	Values & limits Model-specific	Default—
Field`tools[].type`	Type`string`	RequirementOptional	Values & limits function Model-specific	Default—
Field`tools[].function.name`	Type`string`	RequirementRequired	Values & limits Applies when: function tool supplied	Default—
Field`tools[].function.description`	Type`string`	RequirementOptional	Values & limits	Default—
Field`tools[].function.parameters`	Type`JSON_schema`	RequirementOptional	Values & limits	Default—
Field`tool_choice`	Type`string\|object`	RequirementOptional	Values & limits Model-specific	Default—
Field`parallel_tool_calls`	Type`boolean`	RequirementOptional	Values & limits Model-specific	Default—
Field`response_format`	Type`object`	RequirementOptional	Values & limits Model-specific	Default—
Field`reasoning_effort`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`reasoning`	Type`object`	RequirementOptional	Values & limits Model-specific	Default—
Field`service_tier`	Type`string`	RequirementOptional	Values & limits Model-specific	Default—
Field`instructions`	Type`string`	RequirementOptional	Values & limits Compatibility field	Default—
Field`functions`	Type`function[]`	RequirementOptional	Values & limits Model-specific	Default—
Field`function_call`	Type`string\|object`	RequirementOptional	Values & limits Model-specific	Default—
Field`prompt_cache_options`	Type`object`	RequirementOptional	Values & limits Model-specific	Default—
Field`modalities`	Type`string[]`	RequirementOptional	Values & limits text	Default—
Field`provider`	Type`object`	RequirementOptional	Values & limits Conditions: provider.options is rejected on this Ultra text route	Default—
Field`cache_control.ttl`	Type`string`	RequirementOptional	Values & limits Conditions: 1h is rejected in actual prompt-cache locations	Default—

Input material combinations

Text · UTF8 text

messages[].content

Method parameters and lifecycle

Parameter	Contract
Parameter`content_type`	Contractapplication/json
Parameter`required`	Contractmodel, messages
Parameter`material_types`	Contracttext
Parameter`messages`	Contractmessage array with role/content shape
Parameter`file_material`	Contractactual UTF-8 document inserted as literal text; no file ID inferred
Parameter`optional_controls`	Contractstream, temperature, top_p, stop, max_tokens, max_completion_tokens, reasoning, response_format, tools, tool_choice
Parameter`control_scope`	Contractmodel-specific; user function tools differ from hosted tools
Parameter`output_modalities`	Contracttext
Parameter`hosted_operations`	Contractfalse
Parameter`multimodal_input_binding`	Contractnull

Lifecycle: synchronous_or_streamed

Send exact model ID with messages.

Context length is not an output cap.

A text file may supply literal text; image/audio/file-object inputs need exact binding.

Pricing

Tariff references do not add request options. Supported parameters are listed for the selected method.

Fast mode: Standard rate When fast mode is selected
Flex mode: Standard rate When flex mode is selected
Maximum reasoning effort: Standard rate When maximum reasoning effort uses the default adjustment
Reasoning effort · high: Standard rate When reasoning effort is high
Reasoning effort · low: Standard rate When reasoning effort is low
Reasoning effort · medium: Standard rate When reasoning effort is medium
Reasoning effort · xhigh: Standard rate When reasoning effort is xhigh

Ailoot rates

Prices by configuration

Match each charge to the conditions shown. Use one rate for each set of alternative configurations.

Configuration	Rate schedule	Context tokens, more than	Context tokens, up to and including	Charge
ConfigurationBase token rates	Rate scheduleBase rate	Context tokens, more than—	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationRequest-length tier 1	Rate schedule—	Context tokens, more than0	Context tokens, up to and including200,000	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationRequest-length tier 2	Rate schedule—	Context tokens, more than200,000	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.008 / 1K tokens Output · Output tokens $0.024 / 1K tokens Input · Cache read $0.002 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens

Example requests

Ailoot Ultra · OpenAI Chat

curlPython SDKPython stream

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

Receive and save results

Ailoot Ultra · OpenAI Chat

json or SSE

Keep all completed results

Keep every complete returned response, file and content part.

Keep every choice and its content/tool calls/reasoning. In SSE assemble deltas by choice/tool index, retain the final finish reason and usage.

If the original response needs checking

Keep request/response IDs and headers. No generic text job retrieval URL is supplied.

Response fields

Field	Type
Field`choices[].index`	Typeinteger
Field`choices[].message.content`	Typestring\|null
Field`choices[].message.tool_calls`	Typetool_call[]
Field`choices[].message.reasoning_content`	Typestring
Field`choices[].message.reasoning_details`	Typeobject\|array
Field`choices[].finish_reason`	Typestring\|null
Field`usage`	Typeobject

Errors and next steps

Response	Condition	Next step
Response400 · `invalid_request_error`	ConditionInvalid required fields, material representation or parameter value	Next stepCorrect the indicated fields before a new creation request.

Aliases

Model aliases

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

Method path aliases

/chat/completions

Related caller IDs

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

Model ID

grok-4.6
x-ai/grok-4.6

Overview

Grok 4.6 is designed for sustained work on code, research and interactive projects. Accepts text and images and supports 500,000 tokens of context and four reasoning levels.

Accepted inputs: Text
Results: json · sse

Available in Ailoot · inputs & methods

Ailoot Ultra · Anthropic Messages POST /v1/messages

Input types: text
Output types: json, sse
Output format: JSON or SSE

Field	Type	Requirement	Values & limits	Default
Field`model`	Type`string`	RequirementRequired	Values & limits x-ai/grok-4.6	Default—
Field`messages`	Type`message[]`	RequirementRequired	Values & limits	Default—
Field`messages[].role`	Type`string`	RequirementRequired	Values & limits user, assistant	Default—
Field`messages[].content`	Type`string`	RequirementRequired	Values & limits	Default—
Field`max_tokens`	Type`integer`	RequirementRequired	Values & limits	Default—
Field`stream`	Type`boolean`	RequirementOptional	Values & limits	Defaultfalse

Input material combinations

Text · UTF-8 text

messages[].content string

Method parameters and lifecycle

Parameter	Contract
Parameter`content_type`	Contractapplication/json
Parameter`required`	Contractmodel, messages, max_tokens
Parameter`optional_controls`	Contractstream
Parameter`material_types`	Contracttext
Parameter`text_file_material`	ContractRead the actual UTF-8 document and put its text in the indicated input or message content string.

Lifecycle: synchronous_or_streamed

Pricing

Tariff references do not add request options. Supported parameters are listed for the selected method.

Fast mode: Standard rate When fast mode is selected
Flex mode: Standard rate When flex mode is selected
Maximum reasoning effort: Standard rate When maximum reasoning effort uses the default adjustment
Reasoning effort · high: Standard rate When reasoning effort is high
Reasoning effort · low: Standard rate When reasoning effort is low
Reasoning effort · medium: Standard rate When reasoning effort is medium
Reasoning effort · xhigh: Standard rate When reasoning effort is xhigh

Ailoot rates

Prices by configuration

Match each charge to the conditions shown. Use one rate for each set of alternative configurations.

Configuration	Rate schedule	Context tokens, more than	Context tokens, up to and including	Charge
ConfigurationBase token rates	Rate scheduleBase rate	Context tokens, more than—	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationRequest-length tier 1	Rate schedule—	Context tokens, more than0	Context tokens, up to and including200,000	Charge Input · Input tokens $0.004 / 1K tokens Output · Output tokens $0.012 / 1K tokens Input · Cache read $0.001 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens
ConfigurationRequest-length tier 2	Rate schedule—	Context tokens, more than200,000	Context tokens, up to and includingNo upper bound	Charge Input · Input tokens $0.008 / 1K tokens Output · Output tokens $0.024 / 1K tokens Input · Cache read $0.002 / 1K tokens Input · Cache write — / 1K tokens Input · Cache write, 1 hour — / 1K tokens

Example requests

Ailoot Ultra · Anthropic Messages

Complete minimal JSON bodycurl · use your UTF-8 documentPython · save the complete result

{
  "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))

Receive and save results

Ailoot Ultra · Anthropic Messages

JSON or SSE

Keep all completed results

Keep every complete returned response, file and content part.

Keep all content blocks, thinking signatures and actual tool-use IDs. Assemble all SSE block deltas; a first text block is not the complete output.

If the original response needs checking

Keep request/response IDs and headers. No generic text job retrieval URL is supplied.

Response fields

Field	Type
Field`id`	Typestring
Field`model`	Typestring
Field`content[]`	Typetext\|thinking\|tool_use\|other content block
Field`stop_reason`	Typestring\|null
Field`usage`	Typeobject

Errors and next steps

Response	Condition	Next step
Response400 · `invalid_request_error`	ConditionInvalid required fields, material representation or parameter value	Next stepCorrect the indicated fields before a new creation request.

Aliases

Model aliases

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

Method path aliases

/chat/completions

Related caller IDs

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

FAQ · SpaceXAI: Grok 4.6

What inputs and results are available?

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

Which fields does the request use?

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

What limits apply?

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