Create Response · MOSS API

For MOSS-VL, see Create Response (VL).

Model	Input	Execution mode
Nex N2.6	Supports plain text. Use `input_image` for images, and pass video through `video_url` (MP4, WebM). `file_id` is not supported yet.	Synchronous or SSE streaming. The client sends the multi-turn history.
MOSS-VL	A text instruction and an image or video must both be provided. Media supports a URL or `file_id`.	Synchronous.

Authentication and setup

All valid MOSS API Keys can call it. Use Authorization: Bearer <API Key> and Content-Type: application/json.

Production HTTP requests use https://api.mosi.cn. Before running the examples, set MOSS_API_ORIGIN to https://api.mosi.cn and MOSS_API_KEY to your MOSS API key. Set the OpenAI SDK base_url to https://api.mosi.cn/v1.

Request parameters

FieldTypeUsageDescription

model: stringRequired

Use nex-n2.6 or the pinned snapshot nex-n2.6-2026-11-05.

input: string or arrayRequired

For text-only input, pass a string. For multi-turn requests, pass the history in an array. Use input_image for images and video_url for MP4 or WebM video.

max_output_tokens: integerOptional

Output token budget. The production default is 8,192 and the maximum is 131,072.

store: booleanOptional

Set to false for stateless requests.

stream: booleanOptional

Set to true to stream the response.

version: stringOptional

Optional. If supplied, use 2026-11-05 and make sure it matches the snapshot selected by model.

Responses is stateless. Include conversation history in input. previous_response_id, conversation, background: true, server-side sessions, files, and asset library references are currently unsupported. Public media URLs must be accessible to MOSS. The entire request body, including encoded media, must be at most 10 MiB.

Response fields

FieldTypeDescription

model: string

The model snapshot used to generate the response.

status: string

completed means the response finished. incomplete means the output is incomplete.

output: array<object>

Read content with type set to output_text from the message item's content array.

incomplete_details.reason: string

Set to max_output_tokens when the output reaches the budget.

usage: object

Token usage. On successful streaming completion, read it from response.usage in response.completed.

Termination states

For multi-turn requests, the client sends the relevant history. Use store: false and omit previous_response_id.

Result	Client behavior
`completed` / `response.completed`	Successful completion. Use the accumulated text and the usage supplied in the response.
`incomplete` / `response.incomplete`	Keep any generated content and available `usage`. If the reason is `max_output_tokens`, report that the output reached its budget or adjust the budget and retry.
`error` / `response.failed`	Treat this as failure. Before streaming starts, check the HTTP response. After streaming starts, handle the failure event.

Request example

curl -X POST "$MOSS_API_ORIGIN/v1/responses" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $MOSS_API_KEY" \
  -d '{
  "model": "nex-n2.6",
  "input": "Reply with only the result of 17 × 23.",
  "max_output_tokens": 1024,
  "store": false
}'

import os
import requests

url = os.environ["MOSS_API_ORIGIN"].rstrip("/") + "/v1/responses"
headers = {
    "Content-Type": 'application/json',
    "Authorization": "Bearer " + os.environ["MOSS_API_KEY"],
}

payload = {'model': 'nex-n2.6',
 'input': 'Reply with only the result of 17 × 23.',
 'max_output_tokens': 1024,
 'store': False}

response = requests.post(url, headers=headers, json=payload, timeout=(10, 120))
response.raise_for_status()
print(response.text)

async function main() {
  const origin = process.env.MOSS_API_ORIGIN;
  if (!origin) throw new Error("Set MOSS_API_ORIGIN");
  const url = origin.replace(/\/+$/, "") + "/v1/responses";
  const apiKey = process.env.MOSS_API_KEY;
  if (!apiKey) throw new Error("Set MOSS_API_KEY");
  const headers: Record<string, string> = {
    "Content-Type": "application/json",
    "Authorization": "Bearer " + apiKey,
  };

  const payload = {
    "model": "nex-n2.6",
    "input": "Reply with only the result of 17 × 23.",
    "max_output_tokens": 1024,
    "store": false
  };

  const response = await fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(payload),
  });
  if (!response.ok) {
    throw new Error("HTTP " + response.status + ": " + await response.text());
  }
  console.log(await response.text());
}

main().catch((error: unknown) => {
  console.error(error);
  process.exitCode = 1;
});

Response excerpt. On successful completion, status is completed.

{
  "object": "response",
  "model": "nex-n2.6-2026-11-05",
  "status": "completed",
  "usage": {
    "input_tokens": 22,
    "input_tokens_details": {
      "cached_tokens": 0,
      "cache_write_tokens": 0
    },
    "output_tokens": 23,
    "output_tokens_details": {
      "reasoning_tokens": 19
    },
    "total_tokens": 45
  },
  "output": [
    {
      "type": "message",
      "role": "assistant",
      "content": [
        {
          "type": "output_text",
          "text": "\n\n391"
        }
      ]
    }
  ]
}

Add stream: true to the request body. Concatenate delta from response.output_text.delta events. response.completed marks successful completion. On response.incomplete, keep any generated content and returned usage. Treat error or response.failed as failure. Check the HTTP status first. Once streaming starts, check for error events and the expected termination marker. Treat an early disconnect as an incomplete response.

curl -N -X POST "$MOSS_API_ORIGIN/v1/responses" \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $MOSS_API_KEY" \
  -d '{
  "model": "nex-n2.6",
  "input": "Reply with only the result of 17 × 23.",
  "max_output_tokens": 1024,
  "store": false,
  "stream": true
}'

import os
import requests

url = os.environ["MOSS_API_ORIGIN"].rstrip("/") + "/v1/responses"
headers = {
    "Content-Type": 'application/json',
    "Authorization": "Bearer " + os.environ["MOSS_API_KEY"],
}

payload = {'model': 'nex-n2.6',
 'input': 'Reply with only the result of 17 × 23.',
 'max_output_tokens': 1024,
 'store': False,
 'stream': True}

with requests.post(url, headers=headers, json=payload, stream=True, timeout=(10, 120)) as response:
    response.raise_for_status()
    response.encoding = "utf-8"
    for line in response.iter_lines(chunk_size=1, decode_unicode=True):
        print(line, flush=True)

async function main() {
  const origin = process.env.MOSS_API_ORIGIN;
  if (!origin) throw new Error("Set MOSS_API_ORIGIN");
  const url = origin.replace(/\/+$/, "") + "/v1/responses";
  const apiKey = process.env.MOSS_API_KEY;
  if (!apiKey) throw new Error("Set MOSS_API_KEY");
  const headers: Record<string, string> = {
    "Content-Type": "application/json",
    "Authorization": "Bearer " + apiKey,
  };

  const payload = {
    "model": "nex-n2.6",
    "input": "Reply with only the result of 17 × 23.",
    "max_output_tokens": 1024,
    "store": false,
    "stream": true
  };

  const response = await fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(payload),
  });
  if (!response.ok) {
    throw new Error("HTTP " + response.status + ": " + await response.text());
  }
  if (!response.body) throw new Error("Missing response body");
  const reader = response.body.getReader();
  const decoder = new TextDecoder();
  try {
    while (true) {
      const { value, done } = await reader.read();
      if (done) break;
      process.stdout.write(decoder.decode(value, { stream: true }));
    }
    process.stdout.write(decoder.decode());
  } finally {
    reader.releaseLock();
  }
}

main().catch((error: unknown) => {
  console.error(error);
  process.exitCode = 1;
});

Streaming response excerpt. On successful completion, read usage from response.usage in response.completed.

data: {"type":"response.output_text.delta","sequence_number":23,"output_index":1,"content_index":0,"delta":"39"}

data: {"type":"response.completed","sequence_number":28,"response":{"object":"response","model":"nex-n2.6-2026-11-05","status":"completed","usage":{"input_tokens":22,"input_tokens_details":{"cached_tokens":0,"cache_write_tokens":0},"output_tokens":18,"output_tokens_details":{"reasoning_tokens":14},"total_tokens":40},"output":[{"type":"message","role":"assistant","content":[{"type":"output_text","text":"\n\n391"}]}]}}

Response excerpt when the output reaches its budget. Text and usage vary with the actual response.

{
  "status": "incomplete",
  "incomplete_details": {
    "reason": "max_output_tokens"
  }
}

Use max_output_tokens to control the output budget. Start with 1,024 as shown in the example and adjust it for your use case.

Authentication and setup

Request parameters

Response fields

Termination states

Related documentation