Skip to main content
POST
Responses API with Seed 2.1 Turbo (native multi-turn / explicit cache)
Use the Playground on the right: put Bearer sk-your-api-key in Authorization, fill in input, and send. In the response output array, type: "reasoning" items are thinking summaries — type: "message" is the actual answer.
For multi-turn conversations, pass the previous response’s id (resp_ prefix) as the next call’s previous_response_id — no need to resend history. Explicit caching and thinking control are covered in the Seed 2.1 Turbo Overview.
  • A small max_output_tokens gets eaten by thinking, returning status: "incomplete" with empty text — start at 1500
  • Explicit caching caching: {"type": "enabled"} only hits when chained via previous_response_id; merely repeating the same prefix never hits (and disables the implicit prefix cache too)

Parameter Quick Reference

Response Highlights

  • When status is incomplete, check incomplete_details.reason (usually length: thinking ate the budget)
  • Thinking spend: usage.output_tokens_details.reasoning_tokens
  • Cache hits: usage.input_tokens_details.cached_tokens (chained turn 2 hit the full prior context in our tests, roughly halving latency)
  • The response caching field echoes the cache mode actually in effect

Authorizations

Authorization
string
header
required

API Key from the APIYI console

Body

application/json
model
enum<string>
default:dola-seed-2-1-turbo-260628
required

Model ID, fixed to dola-seed-2-1-turbo-260628

Available options:
dola-seed-2-1-turbo-260628
input
string
required

Input content. Either a string or a message array ([{role, content}, ...], including function_call_output items)

Example:

"Introduce yourself in one sentence"

max_output_tokens
integer
default:1500

Max output tokens (thinking included). Too small yields incomplete with empty text - use 1500+

reasoning
object

Thinking depth control. Measured: effort low ~371, high ~1317 reasoning tokens

previous_response_id
string

Previous response id (resp_ prefix) for native multi-turn; combine with caching.enabled for explicit cache hits

caching
object

Explicit cache switch. enabled only hits when chained via previous_response_id

store
boolean

Whether to store this response for later previous_response_id reference

stream
boolean
default:false

Stream via SSE (response.created → response.output_text.delta → response.completed)

text
object

Structured output. Supports {"format": {"type": "json_schema", name, strict, schema}}

tools
object[]

Function-calling tool list (flat Responses format: {type, name, description, parameters})

Response

Generation succeeded. The output array contains reasoning and message items

id
string

Response ID (resp_ prefix), usable as the next turn's previous_response_id

status
string

completed / incomplete (incomplete when thinking eats the token budget)

output
object[]

Output items: reasoning (thinking summary), message (text), function_call, etc.

usage
object

Usage. output_tokens_details.reasoning_tokens = thinking spend; input_tokens_details.cached_tokens = cache hits

caching
object

The cache mode actually in effect for this request