Xiaomi MiMo v2.5 vs Pro API: Price, Model IDs and Selection

Last updated: August 6, 2026

For most teams evaluating the Xiaomi MiMo API, start with xiaomi/mimo-v2.5 and move a task to xiaomi/mimo-v2.5-pro only after Pro proves a large accepted-result improvement. On LumeAPI, standard MiMo costs $0.15 input and $0.30 output per million tokens; Pro costs $0.50 and $0.90. For a 2,000-input/500-output-token request, Pro costs about 3.22 times as much.

LumeAPI is an independent third-party API gateway, not Xiaomi. Xiaomi's native IDs omit the xiaomi/ prefix, while LumeAPI's catalog IDs include it. Pricing and availability are dated checks, not permanent guarantees.

Short path: Copy the exact namespaced ID from the MiMo v2.5 model page, compare it with MiMo v2.5 Pro, and test both on the same accepted-result rubric before upgrading.

Quick Answer

In short

MiMo v2.5 standard and Pro use the same OpenAI-style Chat Completions route on LumeAPI, but they target different cost envelopes. Standard costs $0.00045 for a representative 2,000-input/500-output-token attempt; Pro costs $0.00145. If standard already achieves a 50% accepted-result rate, Pro would need an impossible 161.1% rate to match its token-only cost per success. Pro makes economic sense only on task groups where standard fails often, Pro succeeds much more often, or expensive human review dominates model spend.

Use the correct MiMo model ID

The model name changes depending on which endpoint you call. This is the most likely integration mistake for a user moving between Xiaomi documentation, a model page and LumeAPI.

The slash is part of the LumeAPI model ID. Do not copy the hyphenated web path into the request body, and do not send Xiaomi's unprefixed native ID to LumeAPI unless the live /v1/models response explicitly lists it.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["LUMEAPI_KEY"],
    base_url="https://api.lumeapi.site/v1",
    timeout=30.0,
    max_retries=0,
)

requested = os.environ.get("MIMO_MODEL", "xiaomi/mimo-v2.5")
available = {item.id for item in client.models.list().data}
if requested not in available:
    raise RuntimeError(f"MiMo model is not enabled: {requested}")

This deployment check also catches allowlist or availability changes before traffic reaches the chat endpoint. Do not silently replace Pro with standard after a missing-model response; that would change the quality contract without telling the caller.

MiMo API price comparison

The following LumeAPI catalog rates were checked on August 6, 2026. Both were displayed at the same values as the reference list rate, so this comparison assumes no gateway discount.

For one request with 2,000 input and 500 output tokens:

• Standard: (2,000 × $0.15 + 500 × $0.30) / 1,000,000 = $0.00045
• Pro: (2,000 × $0.50 + 500 × $0.90) / 1,000,000 = $0.00145
• Pro/standard ratio: $0.00145 / $0.00045 = 3.22×

For 10 million input and 2 million output tokens, standard costs $2.10 and Pro costs $6.80. Actual spend also depends on output length, retries, tool loops and upstream billing rules. Retrieve usage records after a test instead of assuming every prompt consumes its token limit.

The Pro break-even calculator

The correct upgrade question is not “Is Pro smarter?” It is “Does Pro reduce the cost of an accepted business result?” Use:

cost per accepted result = per-attempt cost / acceptance rate

For the representative token mix, Pro needs an acceptance rate 3.22 times the standard model's rate to match token-only cost per accepted result.

This table is the key selection boundary. If standard passes fewer than one-third of a difficult task set and Pro passes almost all of it, Pro can be economical. If standard already succeeds 40% or more, Pro cannot recover its price premium through acceptance alone. It may still win if a failure is dangerous or reviewer labor is expensive, but that value must be measured separately.

Use this calculator with your own workload:

from dataclasses import dataclass

@dataclass(frozen=True)
class Candidate:
    model: str
    input_rate: float
    output_rate: float
    accepted: int
    attempts: int


def economics(candidate: Candidate, input_tokens: int, output_tokens: int) -> dict[str, float]:
    if candidate.attempts <= 0 or not 0 < candidate.accepted <= candidate.attempts:
        raise ValueError("accepted must be between 1 and attempts")
    attempt_cost = (
        input_tokens * candidate.input_rate
        + output_tokens * candidate.output_rate
    ) / 1_000_000
    acceptance = candidate.accepted / candidate.attempts
    return {
        "attempt_cost": attempt_cost,
        "acceptance_rate": acceptance,
        "cost_per_accepted": attempt_cost / acceptance,
    }


standard = Candidate("xiaomi/mimo-v2.5", 0.15, 0.30, 30, 100)
pro = Candidate("xiaomi/mimo-v2.5-pro", 0.50, 0.90, 90, 100)

print(economics(standard, 2_000, 500))
print(economics(pro, 2_000, 500))

The acceptance counts are illustrative inputs, not measured claims about MiMo. With 30% versus 90%, standard remains slightly cheaper per accepted result: $0.00150 versus about $0.00161.

Choose by user task, not tier name

Do not use one overall leaderboard score to route every request. The user task, failure severity and downstream labor determine whether a quality gain matters.

A five-step evaluation that answers the buying question

1. Select one real workflow, such as repairing a failing unit test or extracting a purchase-order schema.
2. Freeze at least 50 representative, sanitized inputs and a pass/fail rubric.
3. Run both exact model IDs with the same prompts, parameters, tools and retry limit.
4. Record tokens, latency, attempts, accepted outputs, reviewer minutes and severe errors.
5. Choose by total cost per accepted result, with separate safety and latency guardrails.

For coding, “looks plausible” is not accepted. Run the test suite and a static check. For extraction, validate the schema and business rules. For an agent, require the final task state and ensure protected side effects occur at most once.

Call MiMo v2.5 through LumeAPI

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["LUMEAPI_KEY"],
    base_url="https://api.lumeapi.site/v1",
    timeout=45.0,
)

response = client.chat.completions.create(
    model="xiaomi/mimo-v2.5",
    messages=[
        {"role": "system", "content": "Return a concise answer and state assumptions."},
        {"role": "user", "content": "Explain why this unit test is flaky."},
    ],
    max_tokens=600,
)

print(response.choices[0].message.content)
print(response.usage)

To test Pro, change only the model to xiaomi/mimo-v2.5-pro and keep the rest of the evaluation fixed. For production, decide retry behavior explicitly; SDK retries can hide additional paid attempts and distort latency.

Compatibility boundaries to test

Xiaomi describes MiMo v2.5 as a full-modal foundation model in its own materials. The LumeAPI pages used for this guide document the models on an OpenAI-compatible Chat Completions route. Do not infer that every native Xiaomi modality, reasoning control, Responses API field or tool behavior is available through this route.

Before launch, test the exact capability you need:

• Text and streaming response shape
• Structured JSON behavior and validation failures
• Tool definitions and tool-call result loops
• Maximum practical prompt and output size
• Timeout and retry behavior
• Safety refusals on your domain prompts
• Current allowlist and exact model availability

If native full-modal input is essential, verify it in the current LumeAPI model documentation or use Xiaomi's native documentation and endpoint. A compatible JSON envelope is not proof of feature parity.

A realistic production scenario

A team processes 500,000 short code-review requests per month, each averaging 2,000 input and 500 output tokens. One attempt per request costs roughly $225 on standard or $725 on Pro. A 100-task evaluation produces 55 accepted standard outputs and 88 accepted Pro outputs.

At those illustrative rates, standard costs about $0.000818 per accepted result; Pro costs about $0.001648. Pro is roughly twice as expensive per success even though it accepts more tasks. If every rejected result consumes ten minutes of engineering review, however, the extra accepted outputs may save far more than $500. Add reviewer minutes and severe-defect costs to the decision instead of treating token spend as the whole business case.

What most guides get wrong

Many MiMo pages stop at a model card, a copied benchmark table or one curl request. That leaves users to discover three production problems themselves: the provider namespace in LumeAPI IDs, the difference between a page URL and a request model string, and the large acceptance-rate improvement Pro needs to justify its price.

Other comparisons assume Pro should receive every hard prompt without defining “hard.” That creates an expensive, unobservable router. Define task classes and promotion criteria before routing traffic.

Expert take

Use standard MiMo as an economical experiment and baseline. Pro is not the automatic production choice: at the representative workload it must deliver more than three times the accepted-result rate to tie token-only economics. The strongest rollout is a controlled task-level evaluation with exact IDs, visible fallback policy and reviewer-cost accounting. If you cannot state the acceptance rubric, you are not ready to pay for the upgrade.

FAQ

What is the Xiaomi MiMo API model ID on LumeAPI?

Use xiaomi/mimo-v2.5 or xiaomi/mimo-v2.5-pro. Keep the slash. The model page URL uses hyphens and is not the JSON model value.

Why does Xiaomi documentation show a different ID?

Xiaomi's native model list uses mimo-v2.5 and mimo-v2.5-pro. LumeAPI adds the xiaomi/ namespace to distinguish providers in one catalog.

Is MiMo v2.5 Pro three times better?

The price ratio does not imply a quality ratio. Test accepted business results. Pro costs about 3.22 times more for the representative 2,000/500-token mix.

Does LumeAPI discount MiMo?

At the rates checked August 6, 2026, the LumeAPI pages showed $0.15/$0.30 for standard and $0.50/$0.90 for Pro, matching the displayed reference prices. Recheck the live catalog before purchase.

Can I reuse the OpenAI Python SDK?

Yes for the documented compatible Chat Completions shape: set the LumeAPI base URL, use a LumeAPI key and supply the exact namespaced model ID. Test advanced features per model.

Sources and verification

• Xiaomi official model-list documentation for native IDs and ownership.
• Xiaomi MiMo v2.5 open-source announcement for the provider's description of the model family.
• LumeAPI MiMo v2.5 model page and MiMo v2.5 Pro model page for namespaced IDs, compatible endpoint and current catalog prices.
• LumeAPI MiMo integration documentation for route-specific request guidance.

The three Python blocks were syntax-checked on August 6, 2026. All break-even tables are reproducible arithmetic from the stated price and token assumptions. No live key, paid generation, unpublished quality measurement or latency claim was used.