MiMo Official API: Non-Quantized Provider & Unquantized Documentation

For “MiMo official API non quantized official provider unquantized documentation,” the practical answer is: Xiaomi is the official MiMo API provider, but its public documentation does not guarantee that the standard mimo-v2.5 or mimo-v2.5-pro API endpoints run unquantized weights. If your requirement is specifically an unquantized official provider, there is no official serving-precision commitment you can rely on; Xiaomi explicitly describes one separate UltraSpeed offering as using FP4 quantization, while the ordinary API pages document capabilities, model IDs, limits, and price—not inference weight precision.

Is There an Official Non-Quantized MiMo API Provider?

Yes, Xiaomi operates the official provider. The Xiaomi MiMo API Open Platform exposes API keys, model discovery, billing, OpenAI-compatible chat completions, an Anthropic-compatible messages interface, and—in the current documentation—an OpenAI Responses API. The model-list endpoint identifies mimo-v2.5 and mimo-v2.5-pro as models owned by Xiaomi. That establishes provenance: you are calling Xiaomi’s service rather than a reseller’s route.

But “official provider” and “unquantized provider” answer different questions. Official tells you who runs the endpoint. Unquantized tells you about the numeric representation used during serving: for example, whether weights or some inference path uses BF16, FP16, FP8, FP4, or another compressed form. An API can be official while the vendor changes kernels, weight formats, KV-cache handling, routing, or hardware behind the endpoint. Unless the provider documents a precision guarantee for a named endpoint, infer neither full precision nor a particular quantization level from the provider’s identity.

The distinction matters here because Xiaomi’s model page explicitly says MiMo-V2.5-Pro-UltraSpeed combines “FP4 lossless quantization” with a decoding optimization. That is useful evidence that Xiaomi will document a serving-related quantization claim when it chooses to make one. It is not evidence that the standard mimo-v2.5-pro API is unquantized; the normal product entry has pricing and model characteristics but no equivalent precision statement.

What Does MiMo’s Official API Documentation Actually Confirm?

The official documentation confirms the implementation details engineers can configure and test. For pay-as-you-go access, create an API key in the MiMo console and send it as either api-key or a Bearer token. Xiaomi distinguishes pay-as-you-go keys (sk-...) from Token Plan keys (tp-...); they are separate credentials and cannot be substituted for each other. Token Plan users should use the base URL shown in their plan page, because Xiaomi provides plan-specific OpenAI- and Anthropic-compatible URLs.

For ordinary API calls, the documented OpenAI-compatible base URL is https://api.xiaomimimo.com/v1. Xiaomi’s current model discovery endpoint is therefore the best first verification step in CI, a provider adapter, or a new tool configuration: do not hard-code a blog post’s model list and assume it remains valid. As of the documentation update dated July 17, 2026, it returns mimo-v2.5, mimo-v2.5-pro, plus speech-oriented V2.5 models.

curl https://api.xiaomimimo.com/v1/models \
  -H "api-key: $MIMO_API_KEY"

curl https://api.xiaomimimo.com/v1/chat/completions \
  -H "api-key: $MIMO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mimo-v2.5-pro",
    "messages": [
      {"role": "user", "content": "Explain this failing test and propose a patch."}
    ]
  }'

The V2.5 documentation also gives useful product-level constraints. mimo-v2.5-pro is documented for text generation, deep thinking, streaming, function calling, structured output, and web search, with a 1M-token context window and 128K maximum output. mimo-v2.5 adds full-modal understanding to the list. These capabilities are meaningful for selecting an endpoint, but they still do not specify its internal inference precision.

How Do You Verify Whether a Hosted MiMo Endpoint Is Unquantized?

You cannot verify this from model behavior alone. A few coding tasks, benchmark prompts, token probabilities, or outputs that resemble another deployment can indicate a regression, configuration error, or routing difference—but they cannot prove bit width. Even self-hosted comparisons are vulnerable to differences in prompts, sampling, tokenizer revisions, runtime versions, tool schemas, speculative decoding, and system prompts.

Instead, use an evidence hierarchy. First, look for an explicit precision statement attached to the exact model ID and endpoint you intend to buy. Second, look for a provider contract, release note, or support response that makes a stable commitment about the serving configuration. Third, if your requirement is reproducibility rather than merely quality, run weights yourself from a published artifact whose dtype and files you can inspect. If none of those exists, record the deployment as “precision undisclosed,” not “unquantized.”

1. Ask the provider to identify the exact endpoint, model revision, and declared serving precision.
2. Ask whether the claim applies to weights, activations, KV cache, or the entire inference stack; “unquantized” is otherwise underspecified.
3. Get the answer in a support ticket or contract if it is a production requirement, rather than relying on a community claim or model-picker label.
4. Run your own acceptance suite against the endpoint and pin the model ID, while treating output quality as operational validation—not proof of precision.
5. Define a fallback policy: another hosted endpoint, a self-hosted deployment, or a different model when the provider changes an undocumented serving detail.

Does MiMo’s Official API Use FP4 or Other Quantization?

For MiMo-V2.5-Pro-UltraSpeed, Xiaomi says yes: its product page describes FP4 lossless quantization. That claim is limited to the named UltraSpeed offer. It should not be generalized to every MiMo-V2.5-Pro request, and it also should not be recast as a claim that every other endpoint is full-precision or unquantized.

For the standard mimo-v2.5-pro and mimo-v2.5 official API entries, Xiaomi publishes parameters such as context limits, functionality, rate limits, and token prices. The ordinary Pro entry lists $0.435 per million uncached input tokens, $0.0036 per million cached-input tokens, and $0.87 per million output tokens; the ordinary V2.5 entry lists lower prices. Those are commercial characteristics, not a dtype specification. Price is especially poor evidence of precision because it also reflects batching, routing, cache efficiency, hardware utilization, and margins.

Which MiMo API Should You Use for Coding Agents?

Start with mimo-v2.5-pro if you need the official text-focused flagship endpoint and its documented tool calling, structured output, deep-thinking, or long-context capabilities. Use mimo-v2.5 when multimodal input matters: Xiaomi documents image, audio, and video understanding for that model. For either choice, send a small verification request after setup and test the exact tool-call and multi-turn path your agent uses.

There is one integration detail that trips up agent builders: in thinking-mode, multi-turn tool workflows, Xiaomi says to preserve prior reasoning_content when the assistant response includes tool calls. Dropping it can produce a 400 error. That is a protocol compatibility issue, not a model-quality issue, but it is exactly the kind of fact that turns a seemingly successful one-shot API test into a broken coding-agent session.

If you are configuring an OpenAI-compatible client, the important fields are straightforward: the provider base URL, a Xiaomi API key, and the exact MiMo model ID. Keep those configuration values separate from your belief about quantization. The official API is a sensible choice when provenance and first-party documentation matter; it is not the right choice when your procurement or research requirement is a published guarantee of unquantized serving.

What to Do If You Need a Real Unquantized Guarantee

Treat it as an infrastructure requirement, not a dropdown preference. Write the requirement precisely—for example, “BF16 model weights at inference, no weight quantization, model revision X”—then require the hosting party to confirm it for the endpoint and term you are buying. If the response is vague, assume the condition is not guaranteed. For many engineering teams, the stronger option is to use inspectable weights in a deployment they control, accepting the operational cost of GPUs, runtime configuration, monitoring, scaling, and upgrades.

That conclusion is not anti-API. Hosted APIs can be faster to integrate and easier to operate, and the MiMo platform documents substantial functionality beyond plain text completion. It is simply a reminder that “official,” “open weight,” “unquantized download,” and “unquantized hosted inference” are four separate properties. Match the one you need to the evidence actually published.

Use MiMo’s Official API in Cline

If your goal is to try the official MiMo endpoint in an engineering workflow rather than build an adapter from scratch, Cline is an open-source AI coding agent available as a VS Code extension and CLI. Its documentation says it can be configured with OpenAI-compatible providers by supplying a base URL, API key, and model ID—the three pieces Xiaomi publishes for its normal API and Token Plan integrations.

Cline is free for individual developers; you can bring your own provider API key or use Cline’s provider, with inference charged on a usage basis rather than a subscription for the open-source version. That makes it useful for testing MiMo in real repository work: configure Xiaomi’s official endpoint, run your own coding tasks and tool-call flows, and evaluate the result without pretending the client can establish a serving-precision guarantee that Xiaomi has not documented.