DEV Community

Preecha
Preecha

Posted on

MiMo-V2-Pro & Omni Pricing and How to Use the API

TL;DR

MiMo-V2-Pro costs $1/1M input tokens and $3/1M output tokens for requests up to 256K context. MiMo-V2-Omni supports text, image, audio, and video inputs through a unified model. Both are available through an OpenAI-compatible API at platform.xiaomimimo.com. Use Apidog to inspect requests visually, then use Python and mocked unit tests for production integrations.

Try Apidog today

Introduction

Xiaomi released three AI models on March 18, 2026. The two flagship models are:

  • MiMo-V2-Pro for deep reasoning, agent workflows, coding, and long-context tasks.
  • MiMo-V2-Omni for multimodal workflows involving text, images, audio, and video.

This guide covers pricing, API setup, request validation in Apidog, a Python integration, and unit tests that avoid API spend in CI.

Before writing code, download Apidog for free. You can send requests, inspect response payloads, validate token usage, and add assertions before integrating the API into your application.

MiMo-V2-Pro Pricing and MiMo-V2-Omni Pricing

Start by estimating request costs. Both models use token-based pricing, and MiMo-V2-Pro pricing changes based on context length.

MiMo-V2-Pro Pricing by Context Length

Context length Input price per 1M tokens Output price per 1M tokens
≤ 256K tokens $1.00 $3.00
256K–1M tokens $2.00 $6.00

MiMo-V2-Pro supports a 1M-token context window. Requests that remain under 256K tokens use the lower tier. The higher tier applies to long-context workloads such as full-codebase analysis or extended planning sequences.

For example, estimate the cost of a request with 20,000 input tokens and 5,000 output tokens in the lower tier:

Input cost  = (20,000 / 1,000,000) × $1.00 = $0.020
Output cost = (5,000 / 1,000,000) × $3.00 = $0.015
Total cost  = $0.035
Enter fullscreen mode Exit fullscreen mode

MiMo-V2-Omni Pricing

MiMo-V2-Omni uses a similar pricing structure, with multimodal token usage as an additional consideration.

The model natively processes:

  • Text
  • Images
  • Audio
  • Video

Image and audio inputs are tokenized alongside text. As a result, multimodal requests can consume more tokens than text-only requests. Measure token usage from API responses and use current rates from platform.xiaomimimo.com when estimating cost.

MiMo-V2 Family Pricing Comparison

Model Input price per 1M tokens Output price per 1M tokens Context window Modalities
MiMo-V2-Pro $1.00 / $2.00* $3.00 / $6.00* 1M tokens Text
MiMo-V2-Omni ~$1.00* ~$3.00* 256K tokens Text, image, audio, video
MiMo-V2-Flash $0.10 $0.30 256K tokens Text

* Tiered or approximate. Verify current rates at platform.xiaomimimo.com.

Choose the model based on the workload:

  • Use MiMo-V2-Flash for low-cost text tasks.
  • Use MiMo-V2-Pro for long-context reasoning, planning, and code tasks.
  • Use MiMo-V2-Omni when one request needs text plus images, audio, or video.

MiMo-V2-Pro and MiMo-V2-Omni API Capabilities

MiMo-V2-Pro

MiMo-V2-Pro is Xiaomi's flagship reasoning model. Its published capabilities include:

  • 1 trillion total parameters and 42 billion active parameters
  • 1M-token context window
  • Multi-Token Prediction (MTP) for faster inference
  • Support for autonomous multi-step reasoning, tool execution, and software-engineering tasks
  • #1 ranking among 160 models in its price tier on the Artificial Analysis Intelligence Index, with a score of 49 versus a median of 13
  • Strong SWE-Bench and coding benchmark performance

Use it for text-only workflows that require planning, code generation, debugging, or multi-step reasoning.

MiMo-V2-Omni

MiMo-V2-Omni is Xiaomi's multimodal foundation model. It supports:

  • Text, images, audio, and video
  • Integrated image and audio encoders
  • Document understanding
  • Audio transcription
  • Video analysis
  • Cross-modal reasoning

Use it when a workflow needs to reason over more than text.

Both models are available from platform.xiaomimimo.com through OpenAI-compatible endpoints. If your application already uses the OpenAI SDK, you can typically switch the base_url and model name rather than adopting a new SDK.

Test MiMo API Requests with Apidog

Use Apidog to validate the endpoint, headers, request body, response format, and token usage before implementing application code.

1. Create a Request

Create a project such as MiMo-V2 API Tests, then add a new HTTP request.

  • Method: POST
  • URL: https://api.xiaomimimo.com/v1/chat/completions

2. Configure Headers

Add these headers:

Key Value
Authorization Bearer YOUR_MIMO_API_KEY
Content-Type application/json

3. Send a MiMo-V2-Pro Request

In Body → JSON, add:

{
  "model": "mimo-v2-pro",
  "messages": [
    {
      "role": "user",
      "content": "Write a Python function that checks if a number is prime, and explain how you would unit test it."
    }
  ],
  "temperature": 0.6,
  "max_tokens": 512
}
Enter fullscreen mode Exit fullscreen mode

Click Send and inspect:

  • HTTP status
  • choices[0].message.content
  • Returned model ID
  • usage.prompt_tokens
  • usage.completion_tokens
  • usage.total_tokens

4. Send a MiMo-V2-Omni Request

Change the model name and provide multimodal content:

{
  "model": "mimo-v2-omni",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Describe what you see in this image."
        },
        {
          "type": "image_url",
          "image_url": {
            "url": "https://example.com/diagram.png"
          }
        }
      ]
    }
  ],
  "max_tokens": 300
}
Enter fullscreen mode Exit fullscreen mode

This lets you confirm that your image input format and response schema work before implementing the request in code.

Add Response Assertions in Apidog

Open the Tests tab and add assertions for the response contract:

// HTTP status is successful
pm.test("Status code is 200", function () {
  pm.response.to.have.status(200);
});

// Returned model is a MiMo model
pm.test("Model ID is correct", function () {
  const json = pm.response.json();
  pm.expect(json.model).to.include("mimo-v2");
});

// Response includes assistant content
pm.test("Assistant message is present", function () {
  const json = pm.response.json();
  pm.expect(json.choices[0].message.content)
    .to.be.a("string")
    .and.not.empty;
});

// Usage is present for cost tracking
pm.test("Token usage is present", function () {
  const json = pm.response.json();
  pm.expect(json.usage.total_tokens).to.be.above(0);
});
Enter fullscreen mode Exit fullscreen mode

These checks validate four important integration points:

  1. The API endpoint is reachable.
  2. The expected model handled the request.
  3. The response contains usable assistant content.
  4. Token usage is available for pricing analysis.

Save the request collection and run it with Apidog's CLI runner in CI when you need request-level regression coverage.

Use the MiMo API with Python

For production code, use the OpenAI Python SDK with MiMo's API base URL.

Install Dependencies 

pip install openai pytest
Enter fullscreen mode Exit fullscreen mode

Create a MiMo-V2-Pro Client

Create mimo_client.py:

from openai import OpenAI

# Point the OpenAI client at the MiMo API.
client = OpenAI(
    api_key="YOUR_MIMO_API_KEY",
    base_url="https://api.xiaomimimo.com/v1"
)

def ask_mimo_pro(prompt: str) -> dict:
    """Call MiMo-V2-Pro and return the fields needed by the application."""
    response = client.chat.completions.create(
        model="mimo-v2-pro",
        messages=[
            {
                "role": "user",
                "content": prompt,
            }
        ],
        temperature=0.6,
        max_tokens=512,
    )

    return {
        "content": response.choices[0].message.content,
        "model": response.model,
        "prompt_tokens": response.usage.prompt_tokens,
        "completion_tokens": response.usage.completion_tokens,
        "total_tokens": response.usage.total_tokens,
    }

if __name__ == "__main__":
    result = ask_mimo_pro("What is a unit test and why does it matter?")
    print(result["content"])

    # Estimate cost using the MiMo-V2-Pro ≤256K pricing tier.
    input_cost = (result["prompt_tokens"] / 1_000_000) * 1.00
    output_cost = (result["completion_tokens"] / 1_000_000) * 3.00

    print(f"Estimated cost: ${input_cost + output_cost:.6f}")
Enter fullscreen mode Exit fullscreen mode

Run it:

python mimo_client.py
Enter fullscreen mode Exit fullscreen mode

For deployment, store YOUR_MIMO_API_KEY in an environment variable or your platform's secret manager rather than committing it to source control.

Unit Test the MiMo Python Integration

Do not call the live API in normal unit tests. Mock the SDK call so tests are fast and do not consume tokens.

Create test_mimo_client.py:

import pytest
from unittest.mock import MagicMock, patch

from mimo_client import ask_mimo_pro

@pytest.fixture
def mock_mimo_response():
    """Mock a MiMo-V2-Pro API response."""
    mock = MagicMock()
    mock.choices[0].message.content = (
        "A unit test verifies a single function behaves correctly in isolation."
    )
    mock.model = "mimo-v2-pro"
    mock.usage.prompt_tokens = 20
    mock.usage.completion_tokens = 30
    mock.usage.total_tokens = 50
    return mock

@patch("mimo_client.client.chat.completions.create")
def test_returns_content(mock_create, mock_mimo_response):
    """The wrapper returns non-empty assistant content."""
    mock_create.return_value = mock_mimo_response

    result = ask_mimo_pro("What is a unit test?")

    assert isinstance(result["content"], str)
    assert len(result["content"]) > 0

@patch("mimo_client.client.chat.completions.create")
def test_correct_model(mock_create, mock_mimo_response):
    """The response identifies MiMo-V2-Pro."""
    mock_create.return_value = mock_mimo_response

    result = ask_mimo_pro("Hello")

    assert result["model"] == "mimo-v2-pro"

@patch("mimo_client.client.chat.completions.create")
def test_token_usage_for_pricing(mock_create, mock_mimo_response):
    """Token fields are available for cost tracking."""
    mock_create.return_value = mock_mimo_response

    result = ask_mimo_pro("Hello")

    assert result["total_tokens"] > 0
    assert (
        result["prompt_tokens"] + result["completion_tokens"]
        == result["total_tokens"]
    )
Enter fullscreen mode Exit fullscreen mode

Run the test suite:

pytest test_mimo_client.py -v
Enter fullscreen mode Exit fullscreen mode

Expected output:

test_mimo_client.py::test_returns_content        PASSED
test_mimo_client.py::test_correct_model          PASSED
test_mimo_client.py::test_token_usage_for_pricing PASSED

3 passed in 0.28s
Enter fullscreen mode Exit fullscreen mode

Mocking the API client gives you code-level coverage without generating token costs during CI runs.

Production Best Practices

1. Log Token Usage Per Request

Record prompt_tokens, completion_tokens, and total_tokens for every API call.

For MiMo-V2-Pro's lower tier:

  • Input tokens cost $1/1M.
  • Output tokens cost $3/1M.

Verbose prompts and large generated responses can increase cost quickly. Keep system prompts focused and set reasonable output limits.

2. Validate Requests Before Coding

Use Apidog to prototype requests before adding SDK code. Validate:

  • Authentication headers
  • Model IDs
  • Request-body schema
  • Multimodal input structure
  • Response fields
  • Token usage payloads

This reduces time spent debugging malformed requests in application code.

3. Separate Unit Tests from Live API Tests

Use unittest.mock and pytest for unit tests. Reserve live API calls for manual checks or explicitly marked integration tests.

A practical split is:

  • Unit tests: mock the API client.
  • Apidog tests: validate request and response contracts.
  • Integration tests: call the real endpoint only when required.

4. Match the Model to the Workload

Use MiMo-V2-Pro for:

  • Code generation and review
  • Multi-step reasoning
  • Planning workflows
  • Long-context text analysis

Use MiMo-V2-Omni for:

  • Image understanding
  • Audio transcription
  • Video analysis
  • Cross-modal workflows

Avoid using a multimodal model for text-only workloads when a text model is sufficient.

5. Stay Under 256K Context When Possible

MiMo-V2-Pro pricing doubles in the 256K–1M context tier. For retrieval-augmented generation workflows, retrieve only the most relevant chunks instead of including every available document.

6. Reuse Existing OpenAI SDK Patterns

Because the MiMo API is OpenAI-compatible, existing OpenAI SDK code can often be adapted by changing:

base_url="https://api.xiaomimimo.com/v1"
Enter fullscreen mode Exit fullscreen mode

and selecting the appropriate MiMo model:

model="mimo-v2-pro"
Enter fullscreen mode Exit fullscreen mode

Conclusion

MiMo-V2-Pro costs $1/1M input tokens and $3/1M output tokens for contexts up to 256K tokens, with higher rates for 256K–1M-token requests. MiMo-V2-Omni extends the API to multimodal inputs, including text, images, audio, and video.

A practical implementation workflow is:

  1. Prototype the request in Apidog.
  2. Add response and token-usage assertions.
  3. Implement the request with the OpenAI Python SDK.
  4. Mock the API client in pytest tests.
  5. Monitor token usage in production.

Start by validating the endpoint and payload format, then move the tested request into your application code.

FAQ

What is MiMo-V2-Pro pricing?

MiMo-V2-Pro costs $1/1M input tokens and $3/1M output tokens for contexts up to 256K tokens. For contexts between 256K and 1M tokens, it costs $2/1M input tokens and $6/1M output tokens.

What is MiMo-V2-Omni pricing?

MiMo-V2-Omni pricing is comparable to MiMo-V2-Pro for text inputs. Images, audio, and video are tokenized and billed alongside text. Check platform.xiaomimimo.com for current rates.

How do I use the MiMo-V2-Pro API?

Use the OpenAI Python SDK with:

base_url="https://api.xiaomimimo.com/v1"
Enter fullscreen mode Exit fullscreen mode

Then send a chat completion request with:

model="mimo-v2-pro"
Enter fullscreen mode Exit fullscreen mode

Use Apidog to validate the request format and response before integrating it into your application.

How do I write a unit test for the MiMo API?

Mock client.chat.completions.create with unittest.mock, then assert on your wrapper function's returned content, model ID, and token usage. In Apidog, add JavaScript assertions in the Tests tab.

What is the difference between MiMo-V2-Pro and MiMo-V2-Omni?

MiMo-V2-Pro is a text-only reasoning model with 1T parameters and a 1M-token context window. MiMo-V2-Omni is a multimodal model that natively handles text, images, audio, and video.

How does MiMo-V2-Pro compare with MiMo-V2-Flash?

MiMo-V2-Flash costs $0.10/1M input tokens and $0.30/1M output tokens. MiMo-V2-Pro costs more but provides stronger reasoning and a 1M-token context window. Choose based on the complexity and context requirements of the task.

Where can I access the MiMo API?

The MiMo API is available at platform.xiaomimimo.com. MiMo-V2-Pro and MiMo-V2-Omni are also accessible through third-party providers such as OpenRouter and Vercel AI Gateway.

Top comments (0)