Claude Opus 4.5 is an Anthropic model for tasks that require interpreting ambiguous requirements, choosing a plan of action and systematically carrying work through to a result. Its main stated uses are coding, agentic work, computer use and in-depth research. In everyday professional work, the model can help with spreadsheets and presentations.
In an engineering task, Opus 4.5 can consider relationships between several parts of a system, look for the cause of a complex bug, discuss trade-offs and prepare code changes. For sustained work, Anthropic specifically highlights action planning, tool use and coordination of subtasks. This is suited to a workflow where material first needs to be examined, actions then selected and their results checked.
Tools for reading and editing files, running commands, searching for information and interacting with interfaces must be provided by the application. The model reasons about what to do and produces calls to the available tools; actual execution depends on the connected environment. Similarly, preparing a spreadsheet or presentation can include content and code, but producing the finished file requires the appropriate tool.
Opus 4.5 supports extended thinking with a manual budget_tokens budget. When this mode is enabled, the model analyzes the task before its final answer. With appropriate application support, it can also reason between tool calls, incorporating the returned results before its next action.
When the method supports these settings, the manual budget_tokens budget starts at 1024 tokens and should normally be less than max_tokens. There is an exception for reasoning between tools: the budget can exceed max_tokens because it covers multiple analysis blocks in a single turn. This exception requires application support for that mode.
The effort parameter controls the overall level of work: low, medium and high are available, with high as the default. It works both with and without reasoning enabled. Reasoning budget and effort serve different functions: the first guides the amount of internal analysis, while the second affects work on the response overall. This version has no adaptive mode.
Input consists of text and images, and the model produces text as output. Context is 200 thousand tokens, and maximum response length is 64 thousand tokens. A large body of material can be used for research, document analysis and development, but the result must fit within the limits of this specific version.
The manufacturer's standard visual input formats are JPEG/PNG/GIF/WebP, using the first frame of an animation. For native analysis, the longer dimension is 1568 pixels, with 1568 visual tokens; larger images are downscaled before analysis. File and parameter support depends on the application's method.
The reliable built-in knowledge cutoff is May 2025. Current information requires supplied material or application tools. Anthropic trained the model to resist malicious instructions hidden in external content, but this does not rule out incorrect conclusions: plans, changes and findings need to be checked in their actual task.
", "aboutText": "Claude Opus 4.5 is an Anthropic model for tasks that require interpreting ambiguous requirements, choosing a plan of action and systematically carrying work through to a result. Its main stated uses are coding, agentic work, computer use and in-depth research. In everyday professional work, the model can help with spreadsheets and presentations.\n\n### From analyzing a problem to execution\n\nIn an engineering task, Opus 4.5 can consider relationships between several parts of a system, look for the cause of a complex bug, discuss trade-offs and prepare code changes. For sustained work, Anthropic specifically highlights action planning, tool use and coordination of subtasks. This is suited to a workflow where material first needs to be examined, actions then selected and their results checked.\n\nTools for reading and editing files, running commands, searching for information and interacting with interfaces must be provided by the application. The model reasons about what to do and produces calls to the available tools; actual execution depends on the connected environment. Similarly, preparing a spreadsheet or presentation can include content and code, but producing the finished file requires the appropriate tool.\n\n### Two different controls for work\n\nOpus 4.5 supports **extended thinking** with a manual `budget_tokens` budget. When this mode is enabled, the model analyzes the task before its final answer. With appropriate application support, it can also reason between tool calls, incorporating the returned results before its next action.\n\nWhen the method supports these settings, the manual `budget_tokens` budget starts at **1024 tokens** and should normally be less than `max_tokens`. There is an exception for reasoning between tools: the budget can exceed `max_tokens` because it covers multiple analysis blocks in a single turn. This exception requires application support for that mode.\n\nThe `effort` parameter controls the overall level of work: `low`, `medium` and `high` are available, with `high` as the default. It works both with and without reasoning enabled. Reasoning budget and effort serve different functions: the first guides the amount of internal analysis, while the second affects work on the response overall. This version has no adaptive mode.\n\n### Text and visual material\n\nInput consists of **text and images**, and the model produces **text** as output. Context is **200 thousand tokens**, and maximum response length is **64 thousand tokens**. A large body of material can be used for research, document analysis and development, but the result must fit within the limits of this specific version.\n\nThe manufacturer's standard visual input formats are JPEG/PNG/GIF/WebP, using the first frame of an animation. For native analysis, the longer dimension is 1568 pixels, with 1568 visual tokens; larger images are downscaled before analysis. File and parameter support depends on the application's method.\n\nThe reliable built-in knowledge cutoff is **May 2025**. Current information requires supplied material or application tools. Anthropic trained the model to resist malicious instructions hidden in external content, but this does not rule out incorrect conclusions: plans, changes and findings need to be checked in their actual task.", "editorialOverlay": { "copy_fields": null, "copy_sha256": null, "copy_source": null, "html_sha256": "2160871874402981f863f161f708a2c479ec3bd42400524cbb4c4e341a386f62", "module_sha256": "ee9dc1c50b1e6a8fb7fa062030fcb4646b9aaaeb08be513b723a5a92a7290f06", "raw_model_unchanged": true, "schema": "ailoot-native-model-editorial-v1" }, "locale": "en", "methods": [ { "html": "anthropic/claude-opus-4.5:batchClaude Opus 4.5 is intended for complex development, research and multi-step tool use. Helps analyze ambiguous tasks and prepare content for documents, spreadsheets and presentations.
This description covers the model’s capabilities. Available in Ailoot inputs, outputs and options are listed for the selected method below.
Claude Opus 4.5 is an Anthropic model for tasks that require interpreting ambiguous requirements, choosing a plan of action and systematically carrying work through to a result. Its main stated uses are coding, agentic work, computer use and in-depth research. In everyday professional work, the model can help with spreadsheets and presentations.
In an engineering task, Opus 4.5 can consider relationships between several parts of a system, look for the cause of a complex bug, discuss trade-offs and prepare code changes. For sustained work, Anthropic specifically highlights action planning, tool use and coordination of subtasks. This is suited to a workflow where material first needs to be examined, actions then selected and their results checked.
Tools for reading and editing files, running commands, searching for information and interacting with interfaces must be provided by the application. The model reasons about what to do and produces calls to the available tools; actual execution depends on the connected environment. Similarly, preparing a spreadsheet or presentation can include content and code, but producing the finished file requires the appropriate tool.
Opus 4.5 supports extended thinking with a manual budget_tokens budget. When this mode is enabled, the model analyzes the task before its final answer. With appropriate application support, it can also reason between tool calls, incorporating the returned results before its next action.
When the method supports these settings, the manual budget_tokens budget starts at 1024 tokens and should normally be less than max_tokens. There is an exception for reasoning between tools: the budget can exceed max_tokens because it covers multiple analysis blocks in a single turn. This exception requires application support for that mode.
The effort parameter controls the overall level of work: low, medium and high are available, with high as the default. It works both with and without reasoning enabled. Reasoning budget and effort serve different functions: the first guides the amount of internal analysis, while the second affects work on the response overall. This version has no adaptive mode.
Input consists of text and images, and the model produces text as output. Context is 200 thousand tokens, and maximum response length is 64 thousand tokens. A large body of material can be used for research, document analysis and development, but the result must fit within the limits of this specific version.
The manufacturer's standard visual input formats are JPEG/PNG/GIF/WebP, using the first frame of an animation. For native analysis, the longer dimension is 1568 pixels, with 1568 visual tokens; larger images are downscaled before analysis. File and parameter support depends on the application's method.
The reliable built-in knowledge cutoff is May 2025. Current information requires supplied material or application tools. Anthropic trained the model to resist malicious instructions hidden in external content, but this does not rule out incorrect conclusions: plans, changes and findings need to be checked in their actual task.
POST /v1/batchestexttext| Field | Type | Requirement | Values & limits | Default |
|---|---|---|---|---|
Fieldendpoint | Typestring | RequirementRequired | Values & limits /v1/chat/completions | Default— |
Fieldmodel | Typestring | RequirementRequired | Values & limits anthropic/claude-opus-4.5:batch | Default— |
Fieldrequests | Typebatch_item[] | RequirementRequired | Values & limits Minimum items: 1 | Default— |
Fieldrequests[].custom_id | Typestring | RequirementRequired | Values & limits | Default— |
Fieldrequests[].body.messages | Typemessage[] | RequirementRequired | Values & limits | Default— |
Fieldcompletion_window | Typestring | RequirementOptional | Values & limits 24h | Default— |
Fieldprovider | Typeobject|null | RequirementOptional | Values & limits | Default— |
Fieldrequests[].body.model | Typestring | RequirementOptional | Values & limits anthropic/claude-opus-4.5:batch, anthropic/claude-opus-4.5 | Default— |
Fieldprovider.only | Typestring[] | RequirementOptional | Values & limits anthropic | Default— |
Fieldprovider.allow_fallbacks | Typeboolean|null | RequirementOptional | Values & limits false, null | Default— |
| Parameter | Contract |
|---|---|
Parametercontent_type | Contractapplication/json |
Parameterrequired | Contractendpoint, model, requests |
Parametermaterial_types | Contracttext |
Parameterrepresentation | Contractinline requests[]; each item has custom_id and body |
Parameterrequest_endpoint_profile | Contract/v1/chat/completions |
Parameterfile_material | ContractCaller may read actual UTF-8 JSONL locally into requests[]. No upload purpose, input_file_id or file reference is used. Missing/empty customer material stops preparation before POST. |
Parameterserialization_order | Contractendpoint, model, provider (if supplied), completion_window (if supplied), requests last |
Parameteroptional_controls | Contractprovider.only, provider.allow_fallbacks, completion_window |
Parameterschema_scope | ContractText Chat Completions bodies in the documented inline Batch envelope. |
Lifecycle: asynchronous
GET /v1/batches/{operation_id} · actual original create response.id; same user/key/group
Tariff references do not add request options. Supported parameters are listed for the selected method.
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.005 / 1K tokens Output · Output tokens $0.025 / 1K tokens Input · Cache read $0.0005 / 1K tokens Input · Cache write $0.00625 / 1K tokens Input · Cache write, 1 hour $0.01 / 1K tokens |
| ConfigurationRequest-length tier 1 | Rate schedule— | Context tokens, more than0 | Context tokens, up to and includingNo upper bound | Charge Input · Input tokens $0.005 / 1K tokens Output · Output tokens $0.025 / 1K tokens Input · Cache read $0.0005 / 1K tokens Input · Cache write $0.00625 / 1K tokens Input · Cache write, 1 hour $0.01 / 1K tokens |
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 →
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\npython3 - <<'PY_REQUEST'\nimport json\nfrom pathlib import Path\nbody=json.loads('{"endpoint":"/v1/chat/completions","model":"anthropic/claude-opus-4.5:batch","requests":[{"custom_id":"req-0001","body":{"messages":[{"role":"user","content":"Hello!"}],"max_tokens":16}}]}')\nPath("batch-request.json").write_text(json.dumps(body,ensure_ascii=False),encoding="utf-8")\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/batches \\\n -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @batch-request.json -D batch-response-headers.txt -o batch-create-response.json\nimport json, os\nfrom pathlib import Path\nfrom urllib.request import Request, urlopen\n\ndef prepare_requests(customer_path):\n path = Path(customer_path)\n if not path.is_file(): raise ValueError("Customer JSONL file is missing")\n items = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]\n if not items: raise ValueError("Customer JSONL contains no requests")\n ids = set()\n for item in items:\n if set(item) != {"custom_id", "body"}: raise ValueError("Each item needs custom_id and body")\n cid = item["custom_id"]\n if not isinstance(cid, str) or not cid.strip() or cid in ids: raise ValueError("custom_id must be nonempty and unique")\n ids.add(cid)\n if not isinstance(item["body"], dict) or not item["body"].get("messages"): raise ValueError("Supply actual text messages")\n supplied_model = item["body"].get("model")\n if supplied_model is not None and supplied_model not in ['anthropic/claude-opus-4.5:batch', 'anthropic/claude-opus-4.5']: raise ValueError("body.model must be an exact documented caller or wire ID")\n return {"endpoint":"/v1/chat/completions", "model":"anthropic/claude-opus-4.5:batch", "requests":items}\n\nif __name__ == "__main__":\n material = os.environ.get("AILOOT_BATCH_REQUESTS_JSONL", "")\n if not material: raise SystemExit("Set AILOOT_BATCH_REQUESTS_JSONL to your actual customer file")\n body = prepare_requests(material)\n key = os.environ.get("AILOOT_API_KEY", "")\n if not key: raise SystemExit("Set AILOOT_API_KEY")\n request = Request("https://api.ailoot.ai/v1/batches", data=json.dumps(body, ensure_ascii=False).encode("utf-8"), headers={"Authorization":"Bearer " + key, "Content-Type":"application/json"}, method="POST")\n with urlopen(request) as response:\n raw = response.read()\n Path("batch-create-response.json").write_bytes(raw)\n print(raw.decode("utf-8"))\nimport json\nfrom pathlib import Path\nraw = Path("batch-status-response.json").read_bytes()\nresponse = json.loads(raw)\nif response.get("status") != "completed":\n raise SystemExit("Keep the original operation; read its status without resubmitting")\nresults = response.get("results")\nif not isinstance(results, list) or not results:\n raise SystemExit("Preserve the original response; completed results are missing")\nPath("batch-results.jsonl").write_text("".join(json.dumps(item, ensure_ascii=False) + "\\n" for item in results), encoding="utf-8")\n# Preserve batch-status-response.json with aggregate usage and every result/error.\ninline results[].response.body JSON
GET /v1/batches/{operation_id}set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\nBATCH_OPERATION_ID="$(python3 - <<'PY_ID'\nimport json\nfrom pathlib import Path\nfrom urllib.parse import quote\nresponse = json.loads(Path("batch-create-response.json").read_text(encoding="utf-8"))\noperation = response.get("id")\nif not isinstance(operation, str) or not operation: raise SystemExit("No actual original operation ID; preserve the response and do not resubmit")\nprint(quote(operation, safe=""))\nPY_ID\n)"\ncurl --fail-with-body --silent --show-error "https://api.ailoot.ai/v1/batches/$BATCH_OPERATION_ID" \\\n -H "Authorization: Bearer $AILOOT_API_KEY" -o batch-status-response.json\nKeep every complete returned response, file and content part.
Preserve the full original status JSON, every result/custom_id and complete response or error body. Save completed results[] as JSONL without filtering.
Preserve the original operation ID. 503 result_pending_check has X-Should-Retry:false; never resubmit an unknown original batch.
| Field | Type |
|---|---|
Fieldresults[].custom_id | Typestring |
Fieldresults[].response.body.choices[].message.content | Typestring|null |
Fieldresults[].error | Typeobject|null |
Fieldusage | Typeobject|null |
Fieldid | Typestring |
Fieldmodel | Typestring |
Fieldendpoint | Typestring |
Fieldstatus | Typestring |
Fieldrequest_counts | Typeobject |
Fieldresults[].id | Typestring |
Fieldresults[].response.status_code | Typeinteger |
Fieldresults[].response.request_id | Typestring |
| Response | Condition | Next step |
|---|---|---|
Response400 · invalid_request_error | ConditionInvalid documented inline envelope, duplicate keys, item identity, or configured model capabilities conflict. | Next stepCorrect the indicated fields before any new submission. |
Response401 · authentication_error | ConditionInvalid API key. | Next stepUse the authorized Ailoot key. |
Response403 · permission_error | ConditionBatch group unavailable. | Next stepCheck key/group entitlement. |
Response422 · invalid_request_error | ConditionBatch uses balance billing; subscription creation is rejected. | Next stepUse the authorized balance-billed group. |
Response422 · price_unavailable | ConditionBatch input cannot be quoted. | Next stepPreserve response; use documented family input. |
Response402 · billing_error | ConditionBatch reserve unavailable. | Next stepResolve admission before a new request. |
Response503 · price_unavailable | ConditionBatch method price/native rates unavailable. | Next stepPreserve response; do not substitute prices. |
Response503 · api_error | ConditionExact supplier route unavailable. | Next stepPreserve response for route repair. |
Response503 · result_pending_check | ConditionOriginal result requires checking; X-Should-Retry:false. | Next stepKeep original operation_id/id and read its status; never repeat original POST. |
Response404 · not_found | ConditionBatch status operation absent or owned by another identity. | Next stepUse exact original id and same user/key/group. |
Ailoot Ultra anthropic/claude-opus-4.5:batch
Use the method paths shown above.