MiMo-V2.6-Flash Batch API batch inference workflow

One-sentence takeaway

mimo-v2.6-flash can process large-scale requests asynchronously through an OpenAI-compatible Batch API: prepare a JSONL file, upload the file, create a batch job, query its status, and download successful or error results. The official documentation says batch inference costs 50% of the real-time API price.

Use cases

• Suitable tasks: Tasks that do not require real-time responses, such as model evaluation, regression testing, data labeling, content moderation, batch summarization, translation, structured extraction, and academic research.

• Unsuitable tasks: Real-time Q&A, tasks that require streaming output, and tasks that expect automatic retry or resumption within the original job; the official documentation states that the Batch API supports neither streaming output nor in-job retry or recovery.

• Applicable model version: mimo-v2.6-flash; the model name must be lowercase for batch calls. The page also lists mimo-v2.6-pro, but this article does not attribute Pro examples, results, or performance to Flash, and the page does not mention MiMo-V2.6-Flash-RL.

• Applicable client, Agent, or API: Xiaomi MiMo Batch API; the API is compatible with the OpenAI protocol and can be used with Curl or the OpenAI Python SDK. Console uploads currently support only the OpenAI Chat Completions file format, while the API also supports the Responses and Anthropic Messages formats.

• Recommended reasoning tier and parameters: The source does not provide a Flash-specific reasoning tier. The API example uses endpoint="/v1/chat/completions" and completion_window="24h"; when creating a job in the console, the maximum wait time can be set to 1–14 days.

Ready-to-use content

The following is a minimal example using mimo-v2.6-flash in the official JSONL file format. Each line is an independent request; custom_id must be unique within the same file. For an actual task, only replace content.

{"custom_id":"request-1","method":"POST","url":"/v1/chat/completions","body":{"model":"mimo-v2.6-flash","messages":[{"role":"user","content":"Hello"}]}}

Minimal configuration skeleton for the API workflow:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://batch-api-${region}.xiaomimimo.com/v1",
)

file = client.files.create(
    file=open("input.jsonl", "rb"),
    purpose="batch",
)

batch = client.batches.create(
    input_file_id=file.id,
    endpoint="/v1/chat/completions",
    completion_window="24h",
)

batch = client.batches.retrieve(batch.id)
if batch.output_file_id:
    result = client.files.content(batch.output_file_id)
    with open("output.jsonl", "wb") as f:
        f.write(result.content)

Test or workflow steps

flowchart LR
  A[Account and identity verification] --> B[Prepare JSONL]
  B --> C[Upload file]
  C --> D[Create Batch job]
  D --> E[Query status and progress]
  E -->|completed| F[Download successful file]
  E -->|Failed requests| G[Download error file and resubmit failed items]

1. Complete the prerequisites: Register a MiMo Open Platform account, complete identity verification, add balance, create an API Key, and obtain the Base URL from the Batch Inference page. The Batch API charges the account's cash balance based on actual token usage and does not use the Token Plan quota.

2. Prepare the input file: Use JSONL, with one JSON request per line; the default maximum size for a single file is 128 MB, and a file can contain requests for only one batch endpoint. Each request must have a unique string custom_id within the file; body must be a valid JSON object for the underlying model-calling API.

3. Upload the file: Send purpose=batch and the local file to https://batch-api-${region}.xiaomimimo.com/v1/files. Files are retained for 30 days by default.

4. Create the job: Submit input_file_id, endpoint, and completion_window="24h" to /v1/batches. The console workflow also requires a job description; after submission, the system schedules the job automatically according to off-peak resources, so it is not guaranteed to start immediately.

5. Query and manage: Query the status and request_counts through /v1/batches/{batch_id}. The statuses listed in the documentation include validating, in_progress, completed, failed, cancelling, and cancelled; an In Progress job can be cancelled, and cancellation is asynchronous.

6. Download results: After the job is completed, download the successful file corresponding to output_file_id; if failed requests exist, also download the error file corresponding to error_file_id. Both files contain custom_id for matching them to input requests.

7. Handle failures: The Batch API does not support retry/resume within a job. Check the error file, create a new JSONL file, and submit only the failed requests again; partially successful requests are still billed normally.

8. Back up promptly: Input and result files are retained for 30 days by default, after which they are automatically deleted and cannot be recovered.

Original evidence and data

• Official support: The page explicitly lists mimo-v2.6-flash and requires the model name in batch calls to be lowercase; it also lists mimo-v2.6-pro, which does not constitute an evaluation result for Flash.

• Protocol and interfaces: The Batch API is compatible with the OpenAI Batch protocol; the API file format supports /v1/chat/completions, /v1/responses, and /anthropic/v1/messages, while console uploads currently support only the Completions format.

• Pricing claim: The official source says Batch Inference costs 50% of the real-time API price. The Flash prices listed on the page are:

  • Mainland China: input (cache hit) ¥0.01, input (cache miss) ¥0.50, output ¥1.00, per million tokens.

  • Overseas: input (cache hit) $0.0014, input (cache miss) $0.07, output $0.14, per million tokens.

• File constraints: The default maximum file size is 128 MB; each custom_id must be unique within the file; each file can correspond to only one batch endpoint.

• Result association: The successful file returns request results line by line, and the error file returns failure reasons line by line; both preserve the input custom_id unchanged.

• Lifecycle: Files and results are retained for 30 days by default; the API job creation example uses completion_window set to 24h, while the console specifies a maximum wait-time range of 1–14 days.

• Billing boundaries: Only successfully completed requests are billed; requests that fail during file parsing or execution are not billed; requests completed before cancellation are billed normally. If the balance becomes insufficient while a job is running, the completed portion generates a successful file and is billed, while the unexecuted portion generates an error file and is not billed.

• Page date: The body displays Update Time September 21, 2026.

Scope and limitations

• This is an official workflow and pricing note, not an independent accuracy, latency, or throughput evaluation of Flash; the source does not provide Flash-specific sample size, test harness, parameter comparisons, or measured results.

• “50% of the real-time API price” is a vendor pricing statement; actual costs still depend on input cache hits, input token usage, and output token usage.

• Batch jobs are offline asynchronous processes; ordinary API real-time responses or streaming protocols cannot be applied directly to the Batch API.

• completion_window="24h" is the value in the API documentation example and field description; the console's 1–14-day setting is a separate interface parameter, so it cannot be used to infer that the API allows the same range to be set arbitrarily.

• Requests, capabilities, or results for mimo-v2.6-pro shown on the page should not be extrapolated to Flash beyond the listed pricing; the page also provides no Batch API evidence for MiMo-V2.6-Flash-RL.

Reproduction notes

1. Open the original source and confirm that the page's Batch API support list includes mimo-v2.6-flash, then record the page update time.

2. Prepare a JSONL file containing only mimo-v2.6-flash requests, ensure that custom_id values are unique, keep the file below 128 MB, and use only one endpoint in the same file.

3. Use a valid MiMo API Key to call the file upload, Batch creation, status query, and result download interfaces; this article did not perform a real API submission and does not claim to have Flash runtime results.

4. After downloading the successful and error files, match inputs and outputs using custom_id, separately count successful, failed, and billed requests, and complete the backup within the 30-day retention period.