claude-opus-4-5-20251101

Claude Opus 4.5 著重複雜開發、研究及多步驟工具工作。協助分析含義不明的任務，並準備文件、試算表及簡報內容。

Ailoot · Anthropic Messages POST /v1/messages claude-opus-4-5-20251101
Ailoot · OpenAI Responses POST /v1/responses claude-opus-4-5-20251101
Ailoot · OpenAI Chat POST /v1/chat/completions claude-opus-4-5-20251101
Ailoot Ultra · OpenAI Chat POST /v1/chat/completions claude-opus-4-5-20251101
Ailoot Ultra · Anthropic Messages POST /v1/messages claude-opus-4-5-20251101

關於模型

此說明介紹模型的能力。Ailoot 可用的輸入、輸出與選項，依所選方法列於下方。

Claude Opus 4.5 是 Anthropic 的模型，用於理解含義不明的需求、選擇動作計畫，並連續工作直到完成結果。主要用途包括程式設計、代理工作、電腦操作及深入研究。日常專業工作中，也可協助處理試算表與簡報。

從問題分析到執行

工程任務中，Opus 4.5 可分析系統多個部分的關係、找出複雜錯誤原因、討論取捨，並準備程式碼變更。Anthropic 為長時間工作特別著重動作規劃、工具使用及子任務協調。適合先研究素材，再選擇動作並檢查結果的流程。

檔案讀取與編輯、命令執行、資訊搜尋及介面操作工具，須由應用程式提供。模型推理下一步並形成可用工具呼叫；實際執行取決於連接的環境。同樣地，準備試算表或簡報可包含內容與程式碼，但產出完成檔案須使用對應工具。

兩種不同的工作控制項

Opus 4.5 支援以 budget_tokens 手動設定預算的 extended thinking。啟用後，模型會在最終回應前分析任務。應用程式提供對應支援時，也可在工具呼叫之間進行推理，於下一個動作前利用取得的結果。

方法支援相關設定時，手動 budget_tokens 預算至少為 1024 個 Token，通常須小於 max_tokens。工具之間的推理有例外：預算可超過 max_tokens，因為它涵蓋同一輪的多個分析區塊。此例外須由應用程式支援該模式。

effort 參數控制整體處理程度：提供 low、medium 及 high，標準為 high。啟用或停用推理時都可使用。推理預算與投入量有不同用途：前者引導內部分析量，後者影響整體回應工作。此版本沒有自適應模式。

文字與視覺素材

輸入為文字與圖片，模型輸出文字。脈絡為200 千個 Token，回應長度上限為64 千個 Token。大量素材可用於研究、文件分析及開發，但結果須符合此特定版本的限制。

模型開發商的一般視覺輸入格式為 JPEG/PNG/GIF/WebP，動畫使用第一個影格。原生分析時，長邊為 1568 像素，使用 1568 個視覺 Token；較大圖片會在分析前縮小。檔案與參數支援取決於應用程式的方法。

可靠的內建知識界線為五月 2025 年。最新資訊須透過提供的素材或應用程式工具取得。Anthropic 訓練模型抵抗藏在外來內容中的惡意指令，但這仍無法排除錯誤結論：計畫、變更及結論都須在實際任務中檢查。

實用任務

英文技術範例

Fix a mutation-dependent retry bug

Review this Python function: def ready(items):
    for item in items:
        if item["done"]:
            items.remove(item)
    return items
With two adjacent completed items, one remains. Propose a minimal correction that preserves the input list, and provide tests for adjacent completed items, no completed items and an empty list.

預期結果

A corrected Python function, a brief bug explanation and three executable test cases.

檢查結果

Check that iteration does not mutate the source list and that the test with two adjacent completed items removes both from the result.

Ailoot · Anthropic Messages POST /v1/messages claude-opus-4-5-20251101

claude-opus-4-5-20251101

Anthropic /claude-opus-4-5-20251101

入門

Claude Opus 4.5 著重複雜開發、研究及多步驟工具工作。協助分析含義不明的任務，並準備文件、試算表及簡報內容。

接受的輸入: 文字 · 圖片
結果: 文字

Ailoot 可用 · 輸入與方法

Ailoot · Anthropic Messages POST /v1/messages

輸入: text, image
輸出: text
上下文: 200,000 tokens
輸出上限: 65,536 tokens
輸出格式: json 或 SSE

欄位	類型	要求	值與限制	預設值
欄位`model`	類型`string`	要求必填	值與限制 claude-opus-4-5-20251101	預設值—
欄位`messages`	類型`message[]`	要求必填	值與限制項目數下限: 1	預設值—
欄位`messages[].role`	類型`string`	要求必填	值與限制 user, assistant	預設值—
欄位`messages[].content`	類型`string\|content_block[]`	要求必填	值與限制	預設值—
欄位`system`	類型`string\|content_block[]`	要求選填	值與限制	預設值—
欄位`max_tokens`	類型`integer`	要求必填	值與限制最小值: 1 限制適用對象: 所選模型／卡片的確切上限	預設值—
欄位`stream`	類型`boolean`	要求選填	值與限制	預設值false
欄位`temperature`	類型`number`	要求選填	值與限制依模型而定	預設值—
欄位`top_p`	類型`number`	要求選填	值與限制依模型而定	預設值—
欄位`stop_sequences`	類型`string[]`	要求選填	值與限制依模型而定	預設值—
欄位`tools`	類型`tool[]`	要求選填	值與限制依模型而定	預設值—
欄位`tools[].name`	類型`string`	要求選填	值與限制適用條件: 已提供工具	預設值—
欄位`tools[].description`	類型`string`	要求選填	值與限制	預設值—
欄位`tools[].input_schema`	類型`JSON_schema`	要求選填	值與限制	預設值—
欄位`tool_choice`	類型`object`	要求選填	值與限制依模型而定	預設值—
欄位`thinking.type`	類型`string`	要求選填	值與限制依模型而定	預設值—
欄位`thinking.budget_tokens`	類型`integer`	要求選填	值與限制依模型而定	預設值—
欄位`output_config.effort`	類型`string`	要求選填	值與限制依模型而定	預設值—
欄位`metadata`	類型`object`	要求選填	值與限制	預設值—
欄位`cache_control`	類型`object`	要求選填	值與限制依模型而定	預設值—

輸入素材組合

文字 · UTF8 文字

messages[].content 或 type=text 區塊

文字 + 圖片

{type:image,source:{type:base64,media_type,data}} 或 type=url 的來源

方法參數與生命週期

參數	規格
參數`material_types`	規格text, image
參數`required`	規格model, messages, max_tokens
參數`optional_controls`	規格null
參數`content_type`	規格application/json
參數`text_file_material`	規格實際 UTF-8 內容以文字插入；檔案 ID／URLs 需要另有精確支援

生命週期： exact retained published method

方法結構與 ID 均為精確值；供應商能力與准入狀態分開。

方案

Ailoot 方法費率

Ailoot Anthropic MessagesPOST /v1/messages

輸入: US$0.005 / 1K
輸出: US$0.025 / 1K
讀取快取: US$0.0005 / 1K
寫入快取: US$0.00625 / 1K
寫入快取，5 分鐘: US$0.00625 / 1K tokens
寫入快取，1 小時: US$0.01 / 1K tokens
web_search_call: US$0.01 每次呼叫
最大呼叫次數 web_search_call: 8

Ailoot 會在請求前預留估算金額。取得結果後，依實測用量結算最終費用。串流結算採用最終用量紀錄。預留金額與結算的運作方式 →

請求範例

Ailoot · Anthropic Messages

文字範例輸入，圖片Python SDKNode.js SDKPython 串流

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": "claude-opus-4-5-20251101", "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": "claude-opus-4-5-20251101", "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="claude-opus-4-5-20251101",
    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: "claude-opus-4-5-20251101",
  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='claude-opus-4-5-20251101',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")

接收並儲存結果

Ailoot · Anthropic Messages

json 或 SSE

保留所有已完成的結果

請保留所有完整傳回的回應、檔案與內容區塊。

保留所有內容區塊、思考簽章與實際工具使用 ID。組合所有 SSE 區塊增量；第一個文字區塊不是完整輸出。

需要檢查原始回應時

保留請求／回應 ID 與標頭。未提供通用的文字工作擷取 URL。

回應欄位

欄位	類型
欄位`id`	類型string
欄位`model`	類型string
欄位`content[]`	類型text\|thinking\|tool_use\|other content block
欄位`stop_reason`	類型string\|null
欄位`usage`	類型object

錯誤與後續步驟

回應	條件	下一步
回應400 · `invalid_request_error`	條件必要欄位、素材表示方式或參數值無效	下一步提出新的建立請求前，先修正指定欄位。

別名

模型別名

Ailoot claude-opus-4-5-20251101
Ailoot Ultra claude-opus-4-5-20251101

方法路徑別名

/chat/completions

入門

Claude Opus 4.5 著重複雜開發、研究及多步驟工具工作。協助分析含義不明的任務，並準備文件、試算表及簡報內容。

接受的輸入: 文字 · 圖片
結果: 文字

Ailoot 可用 · 輸入與方法

Ailoot · OpenAI Responses POST /v1/responses

輸入: text, image
輸出: text
上下文: 200,000 tokens
輸出上限: 65,536 tokens
輸出格式: json 或 SSE

欄位	類型	要求	值與限制	預設值
欄位`model`	類型`string`	要求必填	值與限制 claude-opus-4-5-20251101	預設值—
欄位`input`	類型`string\|input_item[]`	要求必填	值與限制	預設值—
欄位`instructions`	類型`string`	要求選填	值與限制	預設值—
欄位`input[].type`	類型`string`	要求選填	值與限制 message, reasoning, function_call, function_call_output	預設值—
欄位`input[].content`	類型`string\|content_part[]`	要求選填	值與限制	預設值—
欄位`input[].call_id`	類型`string`	要求選填	值與限制適用條件: function_call_output；保留實際回傳的 call_id	預設值—
欄位`input[].output`	類型`string\|content_part[]`	要求選填	值與限制適用條件: function_call_output	預設值—
欄位`max_output_tokens`	類型`integer`	要求選填	值與限制最小值: 1 依模型而定	預設值—
欄位`stream`	類型`boolean`	要求選填	值與限制	預設值false
欄位`temperature`	類型`number`	要求選填	值與限制依模型而定	預設值—
欄位`top_p`	類型`number`	要求選填	值與限制依模型而定	預設值—
欄位`tools`	類型`tool[]`	要求選填	值與限制依模型而定	預設值—
欄位`tool_choice`	類型`string\|object`	要求選填	值與限制依模型而定	預設值—
欄位`parallel_tool_calls`	類型`boolean`	要求選填	值與限制依模型而定	預設值—
欄位`reasoning.effort`	類型`string`	要求選填	值與限制依模型而定	預設值—
欄位`reasoning.summary`	類型`string`	要求選填	值與限制依模型而定	預設值—
欄位`text.format`	類型`object`	要求選填	值與限制依模型而定	預設值—
欄位`text.verbosity`	類型`string`	要求選填	值與限制依模型而定	預設值—
欄位`include`	類型`string[]`	要求選填	值與限制依模型而定	預設值—
欄位`store`	類型`boolean`	要求選填	值與限制依模型而定	預設值—
欄位`previous_response_id`	類型`string`	要求選填	值與限制 ID 要求: 僅限支援的延續流程實際回傳的回應 ID 依模型而定	預設值—
欄位`service_tier`	類型`string`	要求選填	值與限制依模型而定	預設值—
欄位`prompt_cache_key`	類型`string`	要求選填	值與限制依模型而定	預設值—
欄位`prompt_cache_options`	類型`object`	要求選填	值與限制依模型而定	預設值—

輸入素材組合

文字 · UTF8 文字

輸入文字或 input_text 部分

文字 + 圖片

{type:input_image,image_url}

方法參數與生命週期

參數	規格
參數`material_types`	規格text, image
參數`required`	規格model, input
參數`optional_controls`	規格null
參數`content_type`	規格application/json
參數`text_file_material`	規格實際 UTF-8 內容以文字插入；檔案 ID／URLs 需要另有精確支援

生命週期： exact retained published method

方法結構與 ID 均為精確值；供應商能力與准入狀態分開。

方案

Ailoot 方法費率

Ailoot OpenAI ResponsesPOST /v1/responses

輸入: US$0.005 / 1K
輸出: US$0.025 / 1K
讀取快取: US$0.0005 / 1K
寫入快取: US$0.00625 / 1K
寫入快取，5 分鐘: US$0.00625 / 1K tokens
寫入快取，1 小時: US$0.01 / 1K tokens
web_search_call: US$0.01 每次呼叫
最大呼叫次數 web_search_call: 8

Ailoot 會在請求前預留估算金額。取得結果後，依實測用量結算最終費用。串流結算採用最終用量紀錄。預留金額與結算的運作方式 →

請求範例

Ailoot · OpenAI Responses

文字範例輸入，圖片Python SDKNode.js SDKPython 串流

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": "claude-opus-4-5-20251101", "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": "claude-opus-4-5-20251101", "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="claude-opus-4-5-20251101", 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: "claude-opus-4-5-20251101", 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="claude-opus-4-5-20251101", 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")

接收並儲存結果

Ailoot · OpenAI Responses

json 或 SSE

保留所有已完成的結果

請保留所有完整傳回的回應、檔案與內容區塊。

保留每個輸出項目與內容部分、實際函式 call_id、加密推理與用量。串流時保留完整事件／項目身分。

需要檢查原始回應時

保留請求／回應 ID 與標頭。未提供通用的文字工作擷取 URL。

回應欄位

欄位	類型
欄位`id`	類型string
欄位`status`	類型string
欄位`output[]`	類型message\|reasoning\|function_call\|other item
欄位`output[].content[]`	類型content part
欄位`usage`	類型object

錯誤與後續步驟

回應	條件	下一步
回應400 · `invalid_request_error`	條件必要欄位、素材表示方式或參數值無效	下一步提出新的建立請求前，先修正指定欄位。

別名

模型別名

Ailoot claude-opus-4-5-20251101
Ailoot Ultra claude-opus-4-5-20251101

方法路徑別名

/chat/completions

入門

Claude Opus 4.5 著重複雜開發、研究及多步驟工具工作。協助分析含義不明的任務，並準備文件、試算表及簡報內容。

接受的輸入: 文字 · 圖片
結果: 文字

Ailoot 可用 · 輸入與方法

Ailoot · OpenAI Chat POST /v1/chat/completions

輸入: text, image
輸出: text
上下文: 200,000 tokens
輸出上限: 65,536 tokens
輸出格式: json 或 SSE

欄位	類型	要求	值與限制	預設值
欄位`model`	類型`string`	要求必填	值與限制 claude-opus-4-5-20251101	預設值—
欄位`messages`	類型`message[]`	要求必填	值與限制項目數下限: 1	預設值—
欄位`messages[].role`	類型`string`	要求必填	值與限制範例：system, user, assistant, tool, function 條件: 這些角色由原始碼中的相容型別明確表示；確切角色集合仍依模型而定。依模型而定	預設值—
欄位`messages[].content`	類型`string\|content_part[]\|null`	要求選填	值與限制	預設值—
欄位`messages[].tool_calls`	類型`tool_call[]`	要求選填	值與限制	預設值—
欄位`messages[].tool_call_id`	類型`string`	要求選填	值與限制適用條件: role=tool；使用實際回傳的 ID	預設值—
欄位`messages[].name`	類型`string`	要求選填	值與限制	預設值—
欄位`messages[].reasoning_content`	類型`string`	要求選填	值與限制適用條件: 此模型使用推理內容時，將實際回傳的推理內容帶回後續請求	預設值—
欄位`messages[].reasoning_details`	類型`object\|array`	要求選填	值與限制依模型而定	預設值—
欄位`max_tokens`	類型`integer`	要求選填	值與限制最小值: 1 依模型而定	預設值—
欄位`max_completion_tokens`	類型`integer`	要求選填	值與限制最小值: 1 依模型而定	預設值—
欄位`stream`	類型`boolean`	要求選填	值與限制	預設值false
欄位`stream_options.include_usage`	類型`boolean`	要求選填	值與限制依模型而定	預設值—
欄位`temperature`	類型`number`	要求選填	值與限制依模型而定	預設值—
欄位`top_p`	類型`number`	要求選填	值與限制依模型而定	預設值—
欄位`stop`	類型`string\|string[]`	要求選填	值與限制依模型而定	預設值—
欄位`tools`	類型`function_tool[]`	要求選填	值與限制依模型而定	預設值—
欄位`tools[].type`	類型`string`	要求選填	值與限制依模型而定	預設值—
欄位`tools[].function.name`	類型`string`	要求必填	值與限制適用條件: 已提供函式工具	預設值—
欄位`tools[].function.description`	類型`string`	要求選填	值與限制	預設值—
欄位`tools[].function.parameters`	類型`JSON_schema`	要求選填	值與限制	預設值—
欄位`tool_choice`	類型`string\|object`	要求選填	值與限制依模型而定	預設值—
欄位`parallel_tool_calls`	類型`boolean`	要求選填	值與限制依模型而定	預設值—
欄位`response_format`	類型`object`	要求選填	值與限制依模型而定	預設值—
欄位`reasoning_effort`	類型`string`	要求選填	值與限制依模型而定	預設值—
欄位`reasoning`	類型`object`	要求選填	值與限制依模型而定	預設值—
欄位`service_tier`	類型`string`	要求選填	值與限制依模型而定	預設值—
欄位`instructions`	類型`string`	要求選填	值與限制相容性欄位	預設值—
欄位`functions`	類型`function[]`	要求選填	值與限制依模型而定	預設值—
欄位`function_call`	類型`string\|object`	要求選填	值與限制依模型而定	預設值—
欄位`prompt_cache_options`	類型`object`	要求選填	值與限制依模型而定	預設值—

輸入素材組合

文字 · UTF8 文字

messages[].content

文字 + 圖片

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

方法參數與生命週期

參數	規格
參數`material_types`	規格text, image
參數`required`	規格model, messages
參數`optional_controls`	規格null
參數`content_type`	規格application/json
參數`text_file_material`	規格實際 UTF-8 內容以文字插入；檔案 ID／URLs 需要另有精確支援

生命週期： exact retained published method

方法結構與 ID 均為精確值；供應商能力與准入狀態分開。

方案

Ailoot 方法費率

Ailoot OpenAI ChatPOST /v1/chat/completions

輸入: US$0.005 / 1K
輸出: US$0.025 / 1K
讀取快取: US$0.0005 / 1K
寫入快取: US$0.00625 / 1K
寫入快取，5 分鐘: US$0.00625 / 1K tokens
寫入快取，1 小時: US$0.01 / 1K tokens
web_search_call: US$0.01 每次呼叫
最大呼叫次數 web_search_call: 8

Ailoot 會在請求前預留估算金額。取得結果後，依實測用量結算最終費用。串流結算採用最終用量紀錄。預留金額與結算的運作方式 →

請求範例

Ailoot · OpenAI Chat

文字範例輸入，圖片Python SDKNode.js SDKPython 串流

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": "claude-opus-4-5-20251101", "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": "claude-opus-4-5-20251101", "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="claude-opus-4-5-20251101",
    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: "claude-opus-4-5-20251101",
  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='claude-opus-4-5-20251101',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")

接收並儲存結果

Ailoot · OpenAI Chat

json 或 SSE

保留所有已完成的結果

請保留所有完整傳回的回應、檔案與內容區塊。

保留每個候選項及其內容／工具呼叫／推理。SSE 中依候選項／工具索引組合增量，保留最終完成原因與用量。

需要檢查原始回應時

保留請求／回應 ID 與標頭。未提供通用的文字工作擷取 URL。

回應欄位

欄位	類型
欄位`choices[].index`	類型integer
欄位`choices[].message.content`	類型string\|null
欄位`choices[].message.tool_calls`	類型tool_call[]
欄位`choices[].message.reasoning_content`	類型string
欄位`choices[].message.reasoning_details`	類型object\|array
欄位`choices[].finish_reason`	類型string\|null
欄位`usage`	類型object

錯誤與後續步驟

回應	條件	下一步
回應400 · `invalid_request_error`	條件必要欄位、素材表示方式或參數值無效	下一步提出新的建立請求前，先修正指定欄位。

別名

模型別名

Ailoot claude-opus-4-5-20251101
Ailoot Ultra claude-opus-4-5-20251101

方法路徑別名

/chat/completions

入門

Claude Opus 4.5 著重複雜開發、研究及多步驟工具工作。協助分析含義不明的任務，並準備文件、試算表及簡報內容。

接受的輸入: 文字
結果: 文字

Ailoot 可用 · 輸入與方法

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

輸入: text
輸出: text
輸出格式: json 或 SSE

欄位	類型	要求	值與限制	預設值
欄位`model`	類型`string`	要求必填	值與限制 claude-opus-4-5-20251101	預設值—
欄位`messages`	類型`message[]`	要求必填	值與限制項目數下限: 1	預設值—
欄位`messages[].role`	類型`string`	要求必填	值與限制依模型而定	預設值—
欄位`messages[].content`	類型`string`	要求選填	值與限制適用條件: 文字對話	預設值—
欄位`stream`	類型`boolean`	要求選填	值與限制	預設值false

輸入素材組合

文字 · UTF8 文字

messages[].content

方法參數與生命週期

參數	規格
參數`content_type`	規格application/json
參數`required`	規格model, messages
參數`material_types`	規格text
參數`messages`	規格具有 role/content 結構的訊息陣列
參數`file_material`	規格實際 UTF-8 文件以原文文字插入；不推定檔案 ID
參數`optional_controls`	規格stream
參數`control_scope`	規格文字對話；stream 是布林值，預設為 false。
參數`output_modalities`	規格text
參數`hosted_operations`	規格false
參數`multimodal_input_binding`	規格null

方法別名： /chat/completions

生命週期： synchronous_or_streamed

將確切模型 ID 與 messages 一併送出。

上下文長度不是輸出上限。

文字檔案可提供原文文字；圖片／音訊／檔案物件輸入需要精確綁定。

方案

費率資訊不會增加請求選項。支援的參數列於所選方法中。

快速模式: 未指定選取快速模式時
flex 模式: 未指定選取 flex 模式時
最高推理強度: 未指定最高推理強度採用 default 調整值時

Ailoot 費率

各設定的價格

設定	費率表	費用
設定詞元基本費率	費率表基本費率	費用輸入 · 輸入 Token $0.01 / 1K Token 輸出 · 輸出 Token $0.05 / 1K Token 輸入 · 讀取快取 $0.001 / 1K Token 輸入 · 寫入快取 $0.0125 / 1K Token 輸入 · 寫入快取，1 小時 — / 1K Token

Ailoot 會在請求前預留估算金額。取得結果後，依實測用量結算最終費用。串流結算採用最終用量紀錄。預留金額與結算的運作方式 →

請求範例

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":"claude-opus-4-5-20251101","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="claude-opus-4-5-20251101", 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"))

接收並儲存結果

Ailoot Ultra · OpenAI Chat

json 或 SSE

保留所有已完成的結果

請保留所有完整傳回的回應、檔案與內容區塊。

保留每個候選項及其內容／工具呼叫／推理。SSE 中依候選項／工具索引組合增量，保留最終完成原因與用量。

需要檢查原始回應時

保留請求／回應 ID 與標頭。未提供通用的文字工作擷取 URL。

回應欄位

欄位	類型
欄位`choices[].index`	類型integer
欄位`choices[].message.content`	類型string\|null
欄位`choices[].message.tool_calls`	類型tool_call[]
欄位`choices[].message.reasoning_content`	類型string
欄位`choices[].message.reasoning_details`	類型object\|array
欄位`choices[].finish_reason`	類型string\|null
欄位`usage`	類型object

錯誤與後續步驟

回應	條件	下一步
回應400 · `invalid_request_error`	條件必要欄位、素材表示方式或參數值無效	下一步提出新的建立請求前，先修正指定欄位。

別名

模型別名

Ailoot claude-opus-4-5-20251101
Ailoot Ultra claude-opus-4-5-20251101

方法路徑別名

/chat/completions

入門

Claude Opus 4.5 著重複雜開發、研究及多步驟工具工作。協助分析含義不明的任務，並準備文件、試算表及簡報內容。

接受的輸入: 文字
結果: json · sse

Ailoot 可用 · 輸入與方法

Ailoot Ultra · Anthropic Messages POST /v1/messages

輸入: text
輸出: json, sse
輸出格式: JSON 或 SSE

欄位	類型	要求	值與限制	預設值
欄位`model`	類型`string`	要求必填	值與限制 claude-opus-4-5-20251101	預設值—
欄位`messages`	類型`message[]`	要求必填	值與限制	預設值—
欄位`messages[].role`	類型`string`	要求必填	值與限制 user, assistant	預設值—
欄位`messages[].content`	類型`string`	要求必填	值與限制	預設值—
欄位`max_tokens`	類型`integer`	要求必填	值與限制	預設值—
欄位`stream`	類型`boolean`	要求選填	值與限制	預設值false

輸入素材組合

文字 · UTF-8 文字

messages[].content 字串

方法參數與生命週期

參數	規格
參數`content_type`	規格application/json
參數`required`	規格model, messages, max_tokens
參數`optional_controls`	規格stream
參數`material_types`	規格text
參數`text_file_material`	規格讀取實際 UTF-8 文件，將文字放入指定的 input 或訊息內容字串。

生命週期： synchronous_or_streamed

方案

費率資訊不會增加請求選項。支援的參數列於所選方法中。

快速模式: 未指定選取快速模式時
flex 模式: 未指定選取 flex 模式時
最高推理強度: 未指定最高推理強度採用 default 調整值時

Ailoot 費率

各設定的價格

設定	費率表	費用
設定詞元基本費率	費率表基本費率	費用輸入 · 輸入 Token $0.01 / 1K Token 輸出 · 輸出 Token $0.05 / 1K Token 輸入 · 讀取快取 $0.001 / 1K Token 輸入 · 寫入快取 $0.0125 / 1K Token 輸入 · 寫入快取，1 小時 — / 1K Token

Ailoot 會在請求前預留估算金額。取得結果後，依實測用量結算最終費用。串流結算採用最終用量紀錄。預留金額與結算的運作方式 →

請求範例

Ailoot Ultra · Anthropic Messages

完整的最小 JSON 請求主體curl · 使用您的 UTF-8 文件Python · 儲存完整結果

{
  "model": "claude-opus-4-5-20251101",
  "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': 'claude-opus-4-5-20251101', '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': 'claude-opus-4-5-20251101', '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))

接收並儲存結果

Ailoot Ultra · Anthropic Messages

JSON 或 SSE

保留所有已完成的結果

請保留所有完整傳回的回應、檔案與內容區塊。

保留所有內容區塊、思考簽章與實際工具使用 ID。組合所有 SSE 區塊增量；第一個文字區塊不是完整輸出。

需要檢查原始回應時

保留請求／回應 ID 與標頭。未提供通用的文字工作擷取 URL。

回應欄位

欄位	類型
欄位`id`	類型string
欄位`model`	類型string
欄位`content[]`	類型text\|thinking\|tool_use\|other content block
欄位`stop_reason`	類型string\|null
欄位`usage`	類型object

錯誤與後續步驟

回應	條件	下一步
回應400 · `invalid_request_error`	條件必要欄位、素材表示方式或參數值無效	下一步提出新的建立請求前，先修正指定欄位。

別名

模型別名

Ailoot claude-opus-4-5-20251101
Ailoot Ultra claude-opus-4-5-20251101

方法路徑別名

/chat/completions

claude-opus-4-5-20251101