models

DeepSeek: DeepSeek V3.1

Markdown · JSON

DeepSeek: DeepSeek V3.1

DeepSeek V3.1 is a hybrid text model with thinking and direct-response modes in one edition. Its 128K context and improved tool-use profile support coding, document analysis and application-supplied search, with text or proposed tool calls as the result.

About the model

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

DeepSeek V3.1 is DeepSeek’s hybrid text model: the same named edition supports thinking and non-thinking responses through different chat-template settings. The producer highlights improved tool use, agent tasks and reasoning efficiency over its earlier model. It accepts written instructions and text context and generates an answer, code or tool-call content. The original V3.1 identity is separate from Terminus, V3.2 and the V4 family.

The model card lists 671 billion total parameters, 37 billion active parameters and a 128K context for both its base and post-trained editions. V3.1 builds on the original V3 base with extended training on long documents before post-training. Its mixture-of-experts and latent-attention structure follows the V3 architecture. These design facts explain the long-context text profile without turning the context figure into a separate maximum-output specification.

Non-thinking mode prepares a direct response, while thinking mode starts a reasoning phase before the answer. The producer template uses a closing thinking marker for direct replies and an opening thinking marker for the current reasoning turn. In a multi-turn conversation, earlier reasoning content is dropped while final replies and the closing marker remain in the context. This is the original V3.1 history rule, distinct from the later V3.2 rule that preserves reasoning across tool-related messages.

Standard tool calling is documented in non-thinking mode. The application supplies function names, descriptions and parameter schemas; the model returns a selected tool name and JSON arguments in the producer’s tool-call representation. The application executes the operation and returns its result. Give tools specific purposes and keep the returned observation linked to the call, so the next model step has evidence rather than an assumption that an action occurred.

Thinking-mode search uses a separate specialised search-agent format. DeepSeek documents a user-provided search tool for questions requiring external or current information, with repeated calls and observations over several turns. Search is therefore part of the surrounding workflow, not an assertion that a text response independently browsed the web. Define the question, the source criteria and the final answer you need before the search task starts.

For coding, supply the relevant fragment or files, observed behaviour, expected behaviour and constraints to preserve. An illustrative brief is: “Identify the cause of this failure for the supplied input, propose a focused correction and explain the condition that the change handles.” For a document task, label source sections and ask for a comparison against explicit requirements. Require the final answer to distinguish the source-supported conclusion from a proposed next action.

The producer trains V3.1 using the UE8M0 FP8 scale format for weights and activations. Its local recommendations also identify precision-sensitive parameters that must be handled correctly. These are characteristics of the published producer reference, not a claim about every application’s selected precision or implementation. A derivative, a quantized variant and the later Terminus checkpoint remain separate choices from the named original V3.1 edition.

Prepare longer work with a clear question, source labels and a defined final artifact. Budget conversation, source text, reasoning and output within the documented context and keep only relevant evidence as the task grows. For an agent, specify the allowed actions and the criterion that marks the result complete. The useful deliverable is a reviewable textual answer, code proposal or source-backed analysis tied to the input and the observations the application actually returned.

Ailoot Ultra · OpenAI Chat POST /v1/chat/completions deepseek-v3.1-thinking

deepseek-v3.1-thinking

DeepSeek /deepseek-v3.1-thinking

Overview

DeepSeek V3.1 is a hybrid text model with thinking and direct-response modes in one edition. Its 128K context and improved tool-use profile support coding, document analysis and application-supplied search, with text or proposed tool calls as the result.

Accepted inputs
Text
Results
Text

Available in Ailoot · inputs & methods

Ailoot Ultra · OpenAI Chat POST /v1/chat/completions
Input types
text
Output types
text
Output format
json or SSE
FieldTypeRequirementValues & limitsDefault
FieldmodelTypestringRequirementRequiredValues & limits
deepseek-v3.1-thinking
Default—
FieldmessagesTypemessage[]RequirementRequiredValues & limits
Minimum items: 1
Default—
Fieldmessages[].roleTypestringRequirementRequiredValues & limits
Model-specific
Default—
Fieldmessages[].contentTypestringRequirementOptionalValues & limits
Applies when: Text conversation
Default—
FieldstreamTypebooleanRequirementOptionalValues & limitsDefaultfalse
Input material combinations

Text · UTF8 text

messages[].content

Method parameters and lifecycle
ParameterContract
Parametercontent_typeContractapplication/json
ParameterrequiredContractmodel, messages
Parametermaterial_typesContracttext
ParametermessagesContractmessage array with role/content shape
Parameterfile_materialContractactual UTF-8 document inserted as literal text; no file ID inferred
Parameteroptional_controlsContractstream
Parametercontrol_scopeContractText conversation; stream is a boolean and defaults to false.
Parameteroutput_modalitiesContracttext
Parameterhosted_operationsContractfalse
Parametermultimodal_input_bindingContractnull

Method aliases: /chat/completions

Lifecycle: synchronous_or_streamed

Send exact model ID with messages.

Context length is not an output cap.

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

Pricing

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

Fast mode
Not specified When fast mode is selected
Flex mode
Not specified When flex mode is selected
Maximum reasoning effort
Not specified When maximum reasoning effort uses the default adjustment

Ailoot rates

Prices by configuration

ConfigurationRate scheduleCharge
ConfigurationBase token ratesRate scheduleBase rateCharge
Input · Input tokens $0.000572 / 1K tokens
Output · Output tokens $0.0023 / 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 →

Example requests

Ailoot Ultra · OpenAI Chat

curlPython SDK
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model":"deepseek-v3.1-thinking","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="deepseek-v3.1-thinking", messages=[{"role":"user","content":"hello"}], stream=False)
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

save_result(result.to_dict(mode="json"))

Receive and save results

Ailoot Ultra · OpenAI Chat

json or SSE

Keep all completed results

Keep every complete returned response, file and content part.

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

If the original response needs checking

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

Response fields
FieldType
Fieldchoices[].indexTypeinteger
Fieldchoices[].message.contentTypestring|null
Fieldchoices[].message.tool_callsTypetool_call[]
Fieldchoices[].message.reasoning_contentTypestring
Fieldchoices[].message.reasoning_detailsTypeobject|array
Fieldchoices[].finish_reasonTypestring|null
FieldusageTypeobject
Errors and next steps
ResponseConditionNext step
Response400 · invalid_request_errorConditionInvalid required fields, material representation or parameter valueNext stepCorrect the indicated fields before a new creation request.

Aliases

Model aliases

Ailoot Ultra deepseek-v3.1-thinking

Method path aliases

/chat/completions

Related caller IDs

deepseek-v3.1-thinking

FAQ · DeepSeek: DeepSeek V3.1
What inputs and results are available?

POST /v1/chat/completions · deepseek-v3.1-thinking: text → text

Which fields does the request use?

POST /v1/chat/completions · deepseek-v3.1-thinking: model, messages, stream

What limits apply?

POST /v1/chat/completions · deepseek-v3.1-thinking: messages.min_items: 1

More details

Connect Ailoot to Claude Code, OpenCode, Hermes or your own app.

The company and its project portfolio

The company and its project portfolio: millions of customers; monthly sales in the billions.

Buy tokens at a discount.

Subscription discounts for regular use. Promo codes offer up to 50% off token purchases.

Subscription
Choose a discounted plan for your regular requests.
Promo code: up to 50% off
Enter your code at checkout. The price updates to reflect the current promotion.
Spending in your history
The model, tokens and amount are recorded for each request.

Choose a subscription · View model prices

Connect the API to a product you sell.

Use Ailoot in SaaS, apps and bots under its official service offer and licence agreement. Request a reseller licence for resale.

Commercial application
Add text, image, video and audio generation to paid features in your service.
Reseller licence
Send a description of your project and how you provide access. Request written terms for use and resale.
Documents on the website
The service offer, licence agreement and data processing policy are available before you connect.

Request a reseller licence · Service offer and licence agreement