Prix MiMo-V2-Pro & Omni et Comment Utiliser l'API

En bref

La tarification MiMo-V2-Pro commence à 1 $/1M de jetons d'entrée et 3 $/1M de jetons de sortie (contexte ≤256K). La tarification MiMo-V2-Omni prend en charge les entrées multimodales (texte, image, audio et vidéo) dans un modèle unifié. Les deux modèles sont accessibles via une API compatible OpenAI à l'adresse platform.xiaomimimo.com. Utilisez Apidog pour tester l'API visuellement, ou Python pour vos intégrations en production, et accompagnez toujours votre intégration d'un test unitaire.

Essayez Apidog dès aujourd'hui

Introduction

Xiaomi a lancé trois nouveaux modèles d'IA le 18 mars 2026 et la communauté des développeurs l'a vite remarqué. MiMo-V2-Pro et MiMo-V2-Omni sont les deux versions phares : l'une taillée pour le raisonnement agentique profond, l'autre pour la compréhension multimodale. Ce guide vous détaille la tarification MiMo-V2-Pro, la tarification Omni et surtout comment utiliser l'API dans votre stack. Vous trouverez ici tous les niveaux de tarification, un aperçu des capacités de l'API, et deux méthodes concrètes d'intégration : un workflow graphique avec Apidog et une approche Python avec test unitaire.

💡Avant d'écrire du code pour l'API MiMo-V2-Pro ou Omni, téléchargez Apidog gratuitement. Vous pouvez tester visuellement les requêtes, valider les réponses, ajouter des assertions de test unitaire et déboguer l'utilisation des jetons instantanément, tout cela sans consommer de jetons ni écrire une seule ligne de Python.

Détail de la tarification MiMo-V2-Pro et MiMo-V2-Omni

Comprendre la tarification MiMo-V2-Pro et la tarification Omni est fondamental avant de consommer l'API. Les deux s'appuient sur une tarification échelonnée par jetons – une structure adaptée à la production.

Tarification MiMo-V2-Pro : échelonnée par longueur de contexte

La tarification MiMo-V2-Pro est divisée selon la fenêtre de contexte par requête :

Longueur du contexte	Entrée (par 1M de jetons)	Sortie (par 1M de jetons)
≤ 256K jetons	$1.00	$3.00
256K – 1M jetons	$2.00	$6.00

La structure reflète la fenêtre de contexte de 1 million de jetons du modèle. Pour la plupart des usages sous 256K, la tarification MiMo-V2-Pro est très compétitive. Pour les traitements à long contexte (bases de code, séquences étendues), le palier supérieur s'applique.

Tarification MiMo-V2-Omni

La tarification Omni est similaire, mais tient compte des jetons générés par le texte, les images, l'audio et la vidéo. Ces modalités sont tokenisées et facturées ensemble.

Pour les tâches purement textuelles, la tarification Omni est calquée sur Pro. Pour le multimodal, le volume de jetons sera plus élevé selon la richesse des données.

Comparaison des tarifs de la famille MiMo-V2

Voici un récapitulatif des tarifs :

Modèle	Entrée (par 1M de jetons)	Sortie (par 1M de jetons)	Fenêtre de contexte	Modalités
MiMo-V2-Pro	$1.00 / $2.00*	$3.00 / $6.00*	1M de jetons	Texte
MiMo-V2-Omni	~$1.00*	~$3.00*	256K jetons	Texte, Image, Audio, Vidéo
MiMo-V2-Flash	$0.10	$0.30	256K jetons	Texte

Échelonné ou approximatif : vérifiez les tarifs actuels sur platform.xiaomimimo.com

• MiMo-V2-Flash = le plus économique pour du texte simple.
• MiMo-V2-Pro = pour du raisonnement avancé et de longs contextes.
• MiMo-V2-Omni = pour des pipelines multimodaux (texte, image, audio, vidéo) en un seul appel API.

Capacités de l'API MiMo-V2-Pro et Omni

Avant de voir comment utiliser l'API, voici les points clés de chaque modèle.

MiMo-V2-Pro (raisonnement profond) :

• 1 trillion de paramètres (42B actifs)
• 1M jetons de contexte — parfait pour des bases de code ou des séquences complexes
• Prédiction multi-jetons (MTP) pour des réponses plus rapides
• Optimisé pour le raisonnement autonome, l'exécution d'outils et l'ingénierie logicielle
• Classé #1 sur 160 modèles dans sa catégorie de prix
• Excellents scores sur SWE-Bench et benchmarks de code

MiMo-V2-Omni (multimodal unifié) :

• Traitement natif texte, image, audio, vidéo
• Encodeurs d'image et d'audio intégrés à l'architecture
• Idéal pour l’OCR, la transcription, l’analyse vidéo, le raisonnement transmodal

Les deux sont accessibles sur la plateforme API officielle platform.xiaomimimo.com, via des endpoints compatibles OpenAI. Vous pouvez adapter n'importe quelle intégration OpenAI existante — seuls base_url et model changent.

Comment utiliser l'API avec Apidog

Apidog est la méthode la plus rapide pour explorer comment utiliser l'API sans écrire de code. Il fournit une interface graphique pour envoyer des requêtes, inspecter les réponses et automatiser les tests unitaires. Téléchargez Apidog gratuitement pour démarrer.

Configuration des requêtes API MiMo-V2-Pro et Omni dans Apidog

Procédez ainsi :

1. Ouvrez Apidog et créez un projet, par exemple Tests API MiMo-V2.

2. Nouvelle requête HTTP :

   • Méthode : POST
   • URL : https://api.xiaomimimo.com/v1/chat/completions

3. Ajoutez les en-têtes :

Clé	Valeur
Authorization	Bearer YOUR_MIMO_API_KEY
Content-Type	application/json

1. Définissez le corps (JSON) pour MiMo-V2-Pro :

{
  "model": "mimo-v2-pro",
  "messages": [
    {
      "role": "user",
      "content": "Écrivez une fonction Python qui vérifie si un nombre est premier, et expliquez comment vous la testeriez unitairement."
    }
  ],
  "temperature": 0.6,
  "max_tokens": 512
}

Pour MiMo-V2-Omni, changez "model" et ajoutez une image :

{
  "model": "mimo-v2-omni",
  "messages": [
    {
      "role": "user",
      "content": [
        { "type": "text", "text": "Décrivez ce que vous voyez sur cette image." },
        { "type": "image_url", "image_url": { "url": "https://example.com/diagram.png" } }
      ]
    }
  ],
  "max_tokens": 300
}

1. Cliquez sur Envoyer. Apidog affiche la réponse entière avec le nombre de jetons utilisés, parfait pour suivre les coûts MiMo-V2-Pro/Omni en direct.

Écriture de tests unitaires pour l'API MiMo-V2-Pro et Omni dans Apidog

Apidog intègre un moteur de scripts de test. Après chaque requête, utilisez l’onglet Tests pour ajouter ces assertions :

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

// Test 2 : Bon modèle retourné
pm.test("Model ID is correct", function () {
  const json = pm.response.json();
  pm.expect(json.model).to.include("mimo-v2");
});

// Test 3 : Réponse assistant présente
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;
});

// Test 4 : Utilisation des jetons signalée
pm.test("Token usage is present", function () {
  const json = pm.response.json();
  pm.expect(json.usage.total_tokens).to.be.above(0);
});

Ces scripts couvrent : statut HTTP, identification du modèle, présence de contenu, et suivi des jetons. Apidog exécute ces tests automatiquement à chaque requête. Vous pouvez sauvegarder la collection et l’exécuter en CI avec le runner CLI d’Apidog.

Comment utiliser l'API avec Python

Pour la production, implémentez l’API en Python avec une suite complète de tests unitaires via pytest.

Installation

pip install openai pytest

L'API MiMo est compatible OpenAI, donc le SDK openai fonctionne directement.

Appel API de base (MiMo-V2-Pro)

# mimo_client.py
from openai import OpenAI

# Configurez le client OpenAI pour pointer vers l'API MiMo
client = OpenAI(
    api_key="YOUR_MIMO_API_KEY",
    base_url="https://api.xiaomimimo.com/v1"
)

def ask_mimo_pro(prompt: str) -> dict:
    """Appelle l'API MiMo-V2-Pro et renvoie une réponse structurée."""
    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("Qu'est-ce qu'un test unitaire et pourquoi est-il important ?")
    print(result["content"])

    # Estimez le coût (palier ≤256K)
    input_cost = (result["prompt_tokens"] / 1_000_000) * 1.00
    output_cost = (result["completion_tokens"] / 1_000_000) * 3.00
    print(f"Coût estimé : ${input_cost + output_cost:.6f}")

Test unitaire pour l’API MiMo-V2-Pro

# test_mimo_client.py
import pytest
from unittest.mock import patch, MagicMock
from mimo_client import ask_mimo_pro

@pytest.fixture
def mock_mimo_response():
    """Simule la réponse de l'API MiMo-V2-Pro."""
    mock = MagicMock()
    mock.choices[0].message.content = (
        "Un test unitaire vérifie qu'une seule fonction se comporte correctement de manière isolée."
    )
    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):
    """Test : l'API renvoie bien du contenu."""
    mock_create.return_value = mock_mimo_response
    result = ask_mimo_pro("Qu'est-ce qu'un test unitaire ?")
    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):
    """Test : vérifie le modèle mimo-v2-pro utilisé."""
    mock_create.return_value = mock_mimo_response
    result = ask_mimo_pro("Bonjour")
    assert result["model"] == "mimo-v2-pro"

@patch("mimo_client.client.chat.completions.create")
def test_token_usage_for_pricing(mock_create, mock_mimo_response):
    """Test : présence de l'utilisation des jetons pour la tarification."""
    mock_create.return_value = mock_mimo_response
    result = ask_mimo_pro("Bonjour")
    assert result["total_tokens"] > 0
    assert result["prompt_tokens"] + result["completion_tokens"] == result["total_tokens"]

Lancez les tests unitaires :

pytest test_mimo_client.py -v

Résultat attendu :

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

Simuler l'API dans vos tests unitaires garantit zéro consommation de jetons en CI, ce qui est crucial lorsque la tarification MiMo-V2-Pro s'applique à chaque appel.

Meilleures pratiques pour l'API MiMo-V2-Pro et Omni

Pour une intégration robuste et économique :

1. Suivi des jetons : Enregistrez prompt_tokens et completion_tokens à chaque appel. À 1 $/1M et 3 $/1M, limitez la verbosité des prompts.
2. Prototypage avec Apidog : Avant d'écrire du code, prototypez vos prompts et validez les réponses dans Apidog. Évitez la consommation de jetons inutile.
3. Tests unitaires partout : Ajoutez un test unitaire pour chaque fonction qui appelle l’API. Mockez les réponses pour des suites rapides et gratuites.
4. Choix du modèle adapté : MiMo-V2-Pro pour du texte/raisonnement complexe, MiMo-V2-Omni pour le multimodal. Ne payez pas Omni pour du texte seul.
5. Gardez le contexte sous 256K : Les coûts doublent au-dessus de ce seuil. Pour du RAG, ne passez que les fragments essentiels.
6. Utilisez le SDK OpenAI : Les endpoints sont compatibles, intégrez-les sans changer de stack, en adaptant juste base_url et model.

Conclusion

La tarification MiMo-V2-Pro à 1 $/1M d'entrée et 3 $/1M de sortie en fait l’un des modèles de raisonnement les plus rentables du marché. La tarification Omni étend cette compétitivité au multimodal (texte, image, audio, vidéo) via un seul endpoint.

Que vous découvriez comment utiliser l’API via Apidog ou que vous passiez en production avec des tests unitaires Python, MiMo-V2-Pro et MiMo-V2-Omni s’intègrent parfaitement à vos workflows modernes. Démarrez par Apidog pour valider vos requêtes, puis automatisez en toute confiance.

Essayez Apidog gratuitement — aucune carte de crédit requise.

FAQ

Qu'est-ce que la tarification MiMo-V2-Pro ?

1 $/1M de jetons d'entrée et 3 $/1M de jetons de sortie jusqu'à 256K de contexte. Entre 256K et 1M jetons : 2 $/1M d'entrée et 6 $/1M de sortie.

Qu'est-ce que la tarification MiMo-V2-Omni ?

Comparable à Pro pour le texte. Les entrées multimodales (image, audio, vidéo) sont tokenisées et facturées en plus. Consultez platform.xiaomimimo.com pour les tarifs à jour.

Comment utiliser l’API MiMo-V2-Pro ?

Utilisez le SDK Python OpenAI en configurant base_url="https://api.xiaomimimo.com/v1" et model="mimo-v2-pro". API 100% compatible OpenAI. Testez visuellement dans Apidog avant d’écrire du code.

Comment écrire un test unitaire pour l’API MiMo ?

Mockez le client API avec unittest.mock en Python et vérifiez la structure de la réponse. Dans Apidog, ajoutez des assertions JavaScript dans l’onglet Tests après chaque requête.

Quelle est la différence entre MiMo-V2-Pro et MiMo-V2-Omni ?

MiMo-V2-Pro : raisonnement textuel, 1T params, 1M jetons de contexte. MiMo-V2-Omni : multimodal natif (texte, image, audio, vidéo).

Comment la tarification MiMo-V2-Pro se compare-t-elle à celle de MiMo-V2-Flash ?

Flash coûte 0,10 $/1M en entrée, 0,30 $/1M en sortie, mais Pro offre un raisonnement et une fenêtre de contexte bien supérieurs. Choisissez selon la complexité.

Où puis-je accéder à l’API MiMo ?

Sur platform.xiaomimimo.com. MiMo-V2-Pro et MiMo-V2-Omni sont aussi disponibles chez des tiers comme OpenRouter et Vercel AI Gateway.