ERNIE X1 Turbo is Baidu’s reasoning-model profile for questions requiring extended analysis, logical problem solving and tool-connected text work. The maker identifies Turbo as an enhanced version of the X1 line. Its documented 32K producer profile remains separate from ERNIE X1.1 Preview and ERNIE 5.0 Thinking, which have different input and generation budgets.
Supply the question, given values, constraints and the kind of result needed. A mathematical task can request a solution whose decisive calculation can be checked; a planning task can compare alternatives against stated conditions. Keep assumptions separate from supplied facts and identify what remains unknown. This gives the reasoning process a bounded problem rather than permission to invent missing requirements.
For a technical question, include the relevant source passage or code fragment and the behavior to investigate. Ask for a concrete counterexample or explanation if two implementations differ. The useful artifact should make the conclusion and its governing conditions clear. Check important values and the proposed behavior against the source instead of treating a lengthy generated analysis as proof of correctness.
The producer’s AI Studio model table lists a 32K context, a 24K maximum input and a final-output setting from 2 to 16,384 tokens, with 2K as the documented default. It separately lists a 16K thinking length for X1 Turbo. These fields have distinct roles; choose the source material and requested final artifact accordingly rather than interpreting the context number as a promise of an equally long answer.
Keep the final answer separate from any reasoning material returned by the producer flow. A comparison can place the recommendation first and retain the conditions that establish it. A code-related response can identify the exact input case and expected result. Preserve the original question and evidence with the completed artifact so a follow-up can examine one unresolved step.
The manufacturer’s feature index lists X1 Turbo for function calling and search-enhanced tasks. Define any application function’s purpose and arguments, then return the actual result when the model requests it. The model supplies a structured request; the surrounding application performs the operation. A proposed lookup is separate from a retrieved record, and a requested action is separate from a completed outcome.
For a source-based question, keep the retrieved material with the answer and check whether it establishes the claim. A dynamic fact should come from current evidence rather than an unsupported memory-based response. Treat the function and search integration as the producer’s connected workflow, with the actual returned evidence determining what the answer can responsibly conclude.
The 32K X1 Turbo profile is a reasoning text workflow, not the broader native multimodal generation specification of another ERNIE family. Its input, final-output and thinking budgets remain those of the selected producer profile. A useful handoff can contain the solution, comparison or tool-informed answer together with the source passages and completed operation results. This supports a focused continuation while preserving the original task and its uncertainty.
", "aboutText": "ERNIE X1 Turbo is Baidu’s reasoning-model profile for questions requiring extended analysis, logical problem solving and tool-connected text work. The maker identifies Turbo as an enhanced version of the X1 line. Its documented 32K producer profile remains separate from ERNIE X1.1 Preview and ERNIE 5.0 Thinking, which have different input and generation budgets.\n\n### Prepare a complete reasoning problem\n\nSupply the question, given values, constraints and the kind of result needed. A mathematical task can request a solution whose decisive calculation can be checked; a planning task can compare alternatives against stated conditions. Keep assumptions separate from supplied facts and identify what remains unknown. This gives the reasoning process a bounded problem rather than permission to invent missing requirements.\n\nFor a technical question, include the relevant source passage or code fragment and the behavior to investigate. Ask for a concrete counterexample or explanation if two implementations differ. The useful artifact should make the conclusion and its governing conditions clear. Check important values and the proposed behavior against the source instead of treating a lengthy generated analysis as proof of correctness.\n\n### Context, final output and thinking budgets\n\nThe producer’s AI Studio model table lists a 32K context, a 24K maximum input and a final-output setting from 2 to 16,384 tokens, with 2K as the documented default. It separately lists a 16K thinking length for X1 Turbo. These fields have distinct roles; choose the source material and requested final artifact accordingly rather than interpreting the context number as a promise of an equally long answer.\n\nKeep the final answer separate from any reasoning material returned by the producer flow. A comparison can place the recommendation first and retain the conditions that establish it. A code-related response can identify the exact input case and expected result. Preserve the original question and evidence with the completed artifact so a follow-up can examine one unresolved step.\n\n### Functions and current information\n\nThe manufacturer’s feature index lists X1 Turbo for function calling and search-enhanced tasks. Define any application function’s purpose and arguments, then return the actual result when the model requests it. The model supplies a structured request; the surrounding application performs the operation. A proposed lookup is separate from a retrieved record, and a requested action is separate from a completed outcome.\n\nFor a source-based question, keep the retrieved material with the answer and check whether it establishes the claim. A dynamic fact should come from current evidence rather than an unsupported memory-based response. Treat the function and search integration as the producer’s connected workflow, with the actual returned evidence determining what the answer can responsibly conclude.\n\n### Keep the X1 Turbo edition with the result\n\nThe 32K X1 Turbo profile is a reasoning text workflow, not the broader native multimodal generation specification of another ERNIE family. Its input, final-output and thinking budgets remain those of the selected producer profile. A useful handoff can contain the solution, comparison or tool-informed answer together with the source passages and completed operation results. This supports a focused continuation while preserving the original task and its uncertainty.", "editorialOverlay": { "copy_fields": null, "copy_sha256": null, "copy_source": null, "html_sha256": "6ce59fd29f3505351619989da8acad42afd7ce835c310fba4b7d713ad1bb0446", "module_sha256": "ee9dc1c50b1e6a8fb7fa062030fcb4646b9aaaeb08be513b723a5a92a7290f06", "raw_model_unchanged": true, "schema": "ailoot-native-model-editorial-v1" }, "locale": "en", "methods": [ { "html": "ernie-x1-turbo-32kERNIE X1 Turbo is Baidu’s reasoning profile for mathematical, logical and tool-connected text tasks. Its AI Studio specification distinguishes 32K context, 24K maximum input, final-output settings up to 16,384 tokens and a separate 16K thinking length.
This description covers the model’s capabilities. Available in Ailoot inputs, outputs and options are listed for the selected method below.
ERNIE X1 Turbo is Baidu’s reasoning-model profile for questions requiring extended analysis, logical problem solving and tool-connected text work. The maker identifies Turbo as an enhanced version of the X1 line. Its documented 32K producer profile remains separate from ERNIE X1.1 Preview and ERNIE 5.0 Thinking, which have different input and generation budgets.
Supply the question, given values, constraints and the kind of result needed. A mathematical task can request a solution whose decisive calculation can be checked; a planning task can compare alternatives against stated conditions. Keep assumptions separate from supplied facts and identify what remains unknown. This gives the reasoning process a bounded problem rather than permission to invent missing requirements.
For a technical question, include the relevant source passage or code fragment and the behavior to investigate. Ask for a concrete counterexample or explanation if two implementations differ. The useful artifact should make the conclusion and its governing conditions clear. Check important values and the proposed behavior against the source instead of treating a lengthy generated analysis as proof of correctness.
The producer’s AI Studio model table lists a 32K context, a 24K maximum input and a final-output setting from 2 to 16,384 tokens, with 2K as the documented default. It separately lists a 16K thinking length for X1 Turbo. These fields have distinct roles; choose the source material and requested final artifact accordingly rather than interpreting the context number as a promise of an equally long answer.
Keep the final answer separate from any reasoning material returned by the producer flow. A comparison can place the recommendation first and retain the conditions that establish it. A code-related response can identify the exact input case and expected result. Preserve the original question and evidence with the completed artifact so a follow-up can examine one unresolved step.
The manufacturer’s feature index lists X1 Turbo for function calling and search-enhanced tasks. Define any application function’s purpose and arguments, then return the actual result when the model requests it. The model supplies a structured request; the surrounding application performs the operation. A proposed lookup is separate from a retrieved record, and a requested action is separate from a completed outcome.
For a source-based question, keep the retrieved material with the answer and check whether it establishes the claim. A dynamic fact should come from current evidence rather than an unsupported memory-based response. Treat the function and search integration as the producer’s connected workflow, with the actual returned evidence determining what the answer can responsibly conclude.
The 32K X1 Turbo profile is a reasoning text workflow, not the broader native multimodal generation specification of another ERNIE family. Its input, final-output and thinking budgets remain those of the selected producer profile. A useful handoff can contain the solution, comparison or tool-informed answer together with the source passages and completed operation results. This supports a focused continuation while preserving the original task and its uncertainty.
POST /v1/chat/completionstexttext| Field | Type | Requirement | Values & limits | Default |
|---|---|---|---|---|
Fieldmodel | Typestring | RequirementRequired | Values & limits ernie-x1-turbo-32k | Default— |
Fieldmessages | Typemessage[] | RequirementRequired | Values & limits Minimum items: 1 | Default— |
Fieldmessages[].role | Typestring | RequirementRequired | Values & limits Model-specific | Default— |
Fieldmessages[].content | Typestring | RequirementOptional | Values & limits Applies when: Text conversation | Default— |
Fieldstream | Typeboolean | RequirementOptional | Values & limits | Defaultfalse |
Text · UTF8 text
messages[].content
| Parameter | Contract |
|---|---|
Parametercontent_type | Contractapplication/json |
Parameterrequired | Contractmodel, messages |
Parametermaterial_types | Contracttext |
Parametermessages | Contractmessage array with role/content shape |
Parameterfile_material | Contractactual UTF-8 document inserted as literal text; no file ID inferred |
Parameteroptional_controls | Contractstream |
Parametercontrol_scope | ContractText conversation; stream is a boolean and defaults to false. |
Parameteroutput_modalities | Contracttext |
Parameterhosted_operations | Contractfalse |
Parametermultimodal_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.
Tariff references do not add request options. Supported parameters are listed for the selected method.
| Configuration | Rate schedule | Charge |
|---|---|---|
| ConfigurationBase token rates | Rate scheduleBase rate | Charge Input · Input tokens $0.00033 / 1K tokens Output · Output tokens $0.00132 / 1K tokens Input · Cache read $0 / 1K tokens Input · Cache write $0 / 1K tokens Input · Cache write, 1 hour — / 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,os\nfrom pathlib import Path\np=json.loads('{"model":"ernie-x1-turbo-32k","messages":[{"role":"user","content":"hello"}],"stream":false}')\n\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \\\n -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nr=json.loads(Path("result.json").read_text())\nfor x in r.get("choices",[]):\n if x.get("message",{}).get("content"): print(x["message"]["content"])\nPY_RESULT\nfrom openai import OpenAI\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nresult=client.chat.completions.create(model="ernie-x1-turbo-32k", messages=[{"role":"user","content":"hello"}], stream=False)\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n 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\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(result.to_dict(mode="json"))\njson or SSE
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.
Keep request/response IDs and headers. No generic text job retrieval URL is supplied.
| Field | Type |
|---|---|
Fieldchoices[].index | Typeinteger |
Fieldchoices[].message.content | Typestring|null |
Fieldchoices[].message.tool_calls | Typetool_call[] |
Fieldchoices[].message.reasoning_content | Typestring |
Fieldchoices[].message.reasoning_details | Typeobject|array |
Fieldchoices[].finish_reason | Typestring|null |
Fieldusage | Typeobject |
| 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. |
Ailoot Ultra ernie-x1-turbo-32k
/chat/completions
ernie-x1-turbo-32kERNIE X1 Turbo is Baidu’s reasoning profile for mathematical, logical and tool-connected text tasks. Its AI Studio specification distinguishes 32K context, 24K maximum input, final-output settings up to 16,384 tokens and a separate 16K thinking length.
This description covers the model’s capabilities. Available in Ailoot inputs, outputs and options are listed for the selected method below.
ERNIE X1 Turbo is Baidu’s reasoning-model profile for questions requiring extended analysis, logical problem solving and tool-connected text work. The maker identifies Turbo as an enhanced version of the X1 line. Its documented 32K producer profile remains separate from ERNIE X1.1 Preview and ERNIE 5.0 Thinking, which have different input and generation budgets.
Supply the question, given values, constraints and the kind of result needed. A mathematical task can request a solution whose decisive calculation can be checked; a planning task can compare alternatives against stated conditions. Keep assumptions separate from supplied facts and identify what remains unknown. This gives the reasoning process a bounded problem rather than permission to invent missing requirements.
For a technical question, include the relevant source passage or code fragment and the behavior to investigate. Ask for a concrete counterexample or explanation if two implementations differ. The useful artifact should make the conclusion and its governing conditions clear. Check important values and the proposed behavior against the source instead of treating a lengthy generated analysis as proof of correctness.
The producer’s AI Studio model table lists a 32K context, a 24K maximum input and a final-output setting from 2 to 16,384 tokens, with 2K as the documented default. It separately lists a 16K thinking length for X1 Turbo. These fields have distinct roles; choose the source material and requested final artifact accordingly rather than interpreting the context number as a promise of an equally long answer.
Keep the final answer separate from any reasoning material returned by the producer flow. A comparison can place the recommendation first and retain the conditions that establish it. A code-related response can identify the exact input case and expected result. Preserve the original question and evidence with the completed artifact so a follow-up can examine one unresolved step.
The manufacturer’s feature index lists X1 Turbo for function calling and search-enhanced tasks. Define any application function’s purpose and arguments, then return the actual result when the model requests it. The model supplies a structured request; the surrounding application performs the operation. A proposed lookup is separate from a retrieved record, and a requested action is separate from a completed outcome.
For a source-based question, keep the retrieved material with the answer and check whether it establishes the claim. A dynamic fact should come from current evidence rather than an unsupported memory-based response. Treat the function and search integration as the producer’s connected workflow, with the actual returned evidence determining what the answer can responsibly conclude.
The 32K X1 Turbo profile is a reasoning text workflow, not the broader native multimodal generation specification of another ERNIE family. Its input, final-output and thinking budgets remain those of the selected producer profile. A useful handoff can contain the solution, comparison or tool-informed answer together with the source passages and completed operation results. This supports a focused continuation while preserving the original task and its uncertainty.
POST /v1/messagestextjson, sse| Field | Type | Requirement | Values & limits | Default |
|---|---|---|---|---|
Fieldmodel | Typestring | RequirementRequired | Values & limits ernie-x1-turbo-32k | Default— |
Fieldmessages | Typemessage[] | RequirementRequired | Values & limits | Default— |
Fieldmessages[].role | Typestring | RequirementRequired | Values & limits user, assistant | Default— |
Fieldmessages[].content | Typestring | RequirementRequired | Values & limits | Default— |
Fieldmax_tokens | Typeinteger | RequirementRequired | Values & limits | Default— |
Fieldstream | Typeboolean | RequirementOptional | Values & limits | Defaultfalse |
Text · UTF-8 text
messages[].content string
| Parameter | Contract |
|---|---|
Parametercontent_type | Contractapplication/json |
Parameterrequired | Contractmodel, messages, max_tokens |
Parameteroptional_controls | Contractstream |
Parametermaterial_types | Contracttext |
Parametertext_file_material | ContractRead the actual UTF-8 document and put its text in the indicated input or message content string. |
Lifecycle: synchronous_or_streamed
Tariff references do not add request options. Supported parameters are listed for the selected method.
| Configuration | Rate schedule | Charge |
|---|---|---|
| ConfigurationBase token rates | Rate scheduleBase rate | Charge Input · Input tokens $0.00033 / 1K tokens Output · Output tokens $0.00132 / 1K tokens Input · Cache read $0 / 1K tokens Input · Cache write $0 / 1K tokens Input · Cache write, 1 hour — / 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 →
{\n "model": "ernie-x1-turbo-32k",\n "max_tokens": 128,\n "messages": [\n {\n "role": "user",\n "content": "Summarize the incident report."\n }\n ],\n "stream": false\n}set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'ernie-x1-turbo-32k', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nPath('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \\\n -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nPY_RESULT\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'ernie-x1-turbo-32k', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nfrom urllib.request import Request, urlopen\nfrom urllib.error import HTTPError\n\napi_key = os.environ['AILOOT_API_KEY']\nif not api_key.strip():\n raise SystemExit('Set AILOOT_API_KEY before making a request')\nheaders = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}\nheaders['x-api-key'] = api_key\nrequest = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')\ntry:\n with urlopen(request, timeout=120) as response:\n raw = response.read()\n Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')\nexcept HTTPError as error:\n Path('result.json').write_bytes(error.read())\n Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')\n raise\nPath('result.json').write_bytes(raw)\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nJSON or SSE
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.
Keep request/response IDs and headers. No generic text job retrieval URL is supplied.
| Field | Type |
|---|---|
Fieldid | Typestring |
Fieldmodel | Typestring |
Fieldcontent[] | Typetext|thinking|tool_use|other content block |
Fieldstop_reason | Typestring|null |
Fieldusage | Typeobject |
| 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. |
Ailoot Ultra ernie-x1-turbo-32k
/chat/completions