Comment utiliser l'API MiniMax M3 ?

MiniMax M3 est un modèle de raisonnement et de codage de pointe avec une fenêtre contextuelle allant jusqu'à 1 000 000 de jetons. Ce chiffre est le titre principal. Vous pouvez lui fournir un référentiel entier, une semaine de journaux, ou un long document de conception et lui demander de raisonner sur l'ensemble en un seul appel. Si vous souhaitez connaître les bases du modèle et sa place, lisez d'abord ce qu'est MiniMax M3.

Ce guide est la version pratique. Vous obtiendrez une clé API, enverrez votre première requête de trois manières différentes et testerez chaque étape dans Apidog afin de visualiser la requête et la réponse brutes avant d'intégrer quoi que ce soit dans votre propre code. Téléchargez Apidog si vous souhaitez suivre.

La référence officielle se trouve dans la documentation API de MiniMax. Gardez-la ouverte dans un onglet.

Ce dont vous aurez besoin

Un compte MiniMax sur platform.minimax.io.
Une clé API (nous en générons une ci-dessous).
Un moyen de paiement pour l'utilisation : des crédits pay-as-you-go ou un plan de jetons par abonnement. Les deux fonctionnent pour les mêmes points d'accès.

Vous n'avez besoin de rien d'autre d'installé pour les exemples curl. Pour les exemples SDK, vous aurez besoin de Python 3.8+ ou Node 18+.

Étape 1 : Obtenez votre clé API

Connectez-vous sur platform.minimax.io, ouvrez la section Clés API de votre compte et créez une nouvelle clé. MiniMax émet deux types d'identifiants, et la différence est importante :

Une clé API standard est facturée sur votre solde prépayé (pay-as-you-go).
Une clé d'abonnement utilise les crédits de jetons de votre plan (Plus, Max ou Ultra). Lorsque les jetons du plan sont épuisés, les appels utilisant cette clé s'arrêtent jusqu'à ce que le plan soit renouvelé ou que vous passiez à une clé prépayée.

Choisissez celle qui correspond à votre mode de facturation. Copiez la clé une fois et stockez-la. Vous ne la reverrez plus.

Ne collez jamais la clé directement dans le code source. Exportez-la plutôt comme variable d'environnement :

export MINIMAX_API_KEY="your-key-here"

Cela évite que le secret ne se retrouve dans votre historique git et dans tout fichier que vous pourriez partager. Si vous travaillez également avec des clés API dans votre éditeur, les mêmes règles d'hygiène s'appliquent. Nous avons couvert les fuites courantes dans la sécurité des clés API des extensions VS Code.

Étape 2 : Envoyez votre première requête

L'URL de base est https://api.minimax.io/v1 et le chat se trouve à POST https://api.minimax.io/v1/chat/completions. L'authentification est un jeton Bearer : Authorization: Bearer $MINIMAX_API_KEY. La chaîne d'identification du modèle est MiniMax-M3.

Voici le plus petit appel utile avec curl. La tâche est réelle, demandant au modèle de refactoriser une fonction :

curl https://api.minimax.io/v1/chat/completions \
 -H "Authorization: Bearer $MINIMAX_API_KEY" \
 -H "Content-Type: application/json" \
 -d '{"model":"MiniMax-M3","messages":[{"role":"user","content":"Refactor this function to be async."}]}'

Vous avez trois façons d'appeler M3. MiniMax recommande le SDK Anthropic, mais le SDK OpenAI et le protocole HTTP brut fonctionnent tous deux avec le même point d'accès. Utilisez celui que votre pile technologique utilise déjà.

Voici le SDK OpenAI en Python. Le seul changement par rapport à une configuration OpenAI normale est le base_url :

from openai import OpenAI

client = OpenAI(
 base_url="https://api.minimax.io/v1",
 api_key="YOUR_API_KEY",
)

response = client.chat.completions.create(
 model="MiniMax-M3",
 messages=[
 {"role": "user", "content": "Refactor this function to be async."}
 ],
)

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

Et la même idée en Node, juste en redirigeant l'URL de base :

import OpenAI from "openai";

const client = new OpenAI({
 baseURL: "https://api.minimax.io/v1",
 apiKey: process.env.MINIMAX_API_KEY,
});

const response = await client.chat.completions.create({
 model: "MiniMax-M3",
 messages: [
 { role: "user", content: "Refactor this function to be async." },
 ],
});

console.log(response.choices[0].message.content);

Si vous avez utilisé l'API Qwen 3.7, ce modèle vous est familier. La plupart des modèles de pointe exposent désormais une interface compatible OpenAI, de sorte que le coût de migration se résume à une seule ligne. La documentation du SDK OpenAI pour Python et la documentation du SDK Anthropic couvrent toutes les options client.

Étape 3 : Testez et inspectez-le dans Apidog

Avant d'intégrer cet appel dans une application, envoyez-le manuellement et lisez la réponse brute. C'est là que Apidog prend toute sa place.

Créez une nouvelle requête HTTP et définissez la méthode sur POST avec l'URL https://api.minimax.io/v1/chat/completions.
Ouvrez le panneau Environnements et ajoutez une variable nommée MINIMAX_API_KEY avec votre clé comme valeur. Stockez-la comme variable d'environnement afin qu'elle ne se retrouve jamais dans le corps de la requête ou dans votre collection partagée.
Dans les en-têtes de la requête, ajoutez Authorization avec la valeur Bearer {{MINIMAX_API_KEY}}. Apidog substitue la variable au moment de l'envoi.
Définissez le corps sur JSON brut et collez la même charge utile que dans l'exemple curl.
Cliquez sur Envoyer et observez le panneau de réponse.

[Capture d'écran : la requête et la réponse MiniMax-M3 dans Apidog]

Stocker le jeton comme variable d'environnement signifie que vous pouvez partager la requête avec vos coéquipiers sans divulguer le secret, et vous pouvez échanger les clés (prépayée ou abonnement) en modifiant une seule variable. Lorsque vous activez le streaming plus tard, Apidog affiche les événements envoyés par le serveur au fur et à mesure de leur arrivée, ce qui vous permet de confirmer le format du flux avant d'écrire tout code d'analyse. L'inspection manuelle de la réponse permet de détecter rapidement les surprises de schéma, ce qui est tout l'intérêt de tester un point d'accès avant de lui faire confiance.

Étape 4 : Activer et désactiver la réflexion

M3 est un modèle de raisonnement. Par défaut, il renvoie une réponse finale. Vous pouvez également lui demander d'exposer son raisonnement intermédiaire, ce qui est utile lorsque vous souhaitez déboguer pourquoi il est arrivé à une conclusion ou intégrer le raisonnement dans une étape de révision.

Avec le SDK OpenAI, passez reasoning_split via extra_body :

from openai import OpenAI

client = OpenAI(
 base_url="https://api.minimax.io/v1",
 api_key="YOUR_API_KEY",
)

response = client.chat.completions.create(
 model="MiniMax-M3",
 messages=[
 {"role": "user", "content": "Refactor this function to be async."}
 ],
 extra_body={"reasoning_split": True},
)

print(response.choices[0].message.reasoning_details[0]["text"]) # la réflexion
print(response.choices[0].message.content) # la réponse finale

Lorsque reasoning_split est activé, le texte de réflexion est renvoyé à response.choices[0].message.reasoning_details[0]["text"] et la réponse finale reste à response.choices[0].message.content. Gardez les deux séparés dans votre interface utilisateur. Affichez la réponse aux utilisateurs et conservez le raisonnement pour les journaux ou une étape de vérification.

Activez la réflexion pour les problèmes complexes : refactorisations en plusieurs étapes, chasses aux bugs délicates, tout ce pour quoi vous souhaitez auditer la chaîne. Désactivez-la pour les appels simples et sensibles à la latence, où les jetons de raisonnement supplémentaires coûtent du temps et de l'argent que vous n'avez pas besoin de dépenser.

Étape 5 : Travaillez avec le contexte de 1 million de jetons

La grande fenêtre contextuelle est la raison d'opter pour M3. Vous pouvez coller un fichier journal entier et poser une seule question sur l'ensemble :

with open("production-2026-05-30.log") as f:
 log_text = f.read()

response = client.chat.completions.create(
 model="MiniMax-M3",
 messages=[
 {
 "role": "user",
 "content": f"Find the root cause of the 502 spike at 14:20 UTC.\n\n{log_text}",
 }
 ],
)

La limite de facturation que vous devez connaître. MiniMax facture un taux standard pour les appels avec 512K jetons d'entrée ou moins, et un taux de contexte long plus élevé une fois que l'entrée dépasse 512K jetons. Ainsi, le passage d'une invite de 400K jetons à une invite de 600K jetons n'est pas linéaire. Il franchit un seuil de tarification.

La leçon pratique : ne jetez pas un million de jetons dans le contexte par habitude. Envoyez la partie dont le modèle a besoin. Si vous enchaînez de nombreux appels dans un agent, la réduction du contexte par appel est l'un des plus grands leviers sur votre facture. Nous approfondissons ce sujet dans comment réduire les coûts de jetons des agents.

Étape 6 : Appel d'outils et entrée multimodale

M3 gère l'appel d'outils et l'entrée multimodale, il peut donc piloter des agents et lire des images, pas seulement du texte.

Pour l'appel d'outils, vous déclarez les outils que le modèle est autorisé à invoquer, puis vous gérez l'appel qu'il renvoie :

tools = [
 {
 "type": "function",
 "function": {
 "name": "run_tests",
 "description": "Run the test suite for a given module path.",
 "parameters": {
 "type": "object",
 "properties": {
 "module": {"type": "string"},
 },
 "required": ["module"],
 },
 },
 }
]

response = client.chat.completions.create(
 model="MiniMax-M3",
 messages=[
 {"role": "user", "content": "Fix the failing test in auth/session.py and confirm it passes."}
 ],
 tools=tools,
)

Lorsque le modèle décide d'appeler un outil, la réponse contient un tableau tool_calls. Votre code exécute la fonction, ajoute le résultat comme message tool et rappelle l'API pour que le modèle puisse continuer. Réussir cette interaction est l'endroit où se situent la plupart des bugs des agents. Les modèles de câblage et les modes de défaillance méritent d'être lus avant de déployer : câblage d'outils de flux de travail agentique.

Apidog aide également ici. Vous pouvez rejouer l'intégralité de l'échange multi-tours (la requête initiale, la réponse d'appel d'outil, votre résultat d'outil, le suivi) en tant que requêtes enregistrées séparées, afin de pouvoir vérifier chaque étape de bout en bout au lieu de deviner à l'intérieur de votre environnement d'exécution d'agent.

Pour les entrées multimodales, vous passez le contenu de l'image dans le même tableau de messages, à côté de votre invite de texte, en suivant le format standard des parties de contenu. Consultez la référence de l'API pour connaître les noms exacts des champs, car ceux-ci évoluent plus rapidement que les points d'accès textuels.

Tarification et niveaux

Deux leviers distincts contrôlent ce que vous payez et la vitesse à laquelle vous êtes servi.

Les plans de jetons définissent votre budget de crédits. Les niveaux d'abonnement sont Plus à 20 $, Max à 50 $ et Ultra à 120 $, chacun regroupant un plus grand pool de crédits de jetons consommés par votre clé d'abonnement. Le paiement à l'usage (pay-as-you-go) facture une clé API standard sur votre solde à la place.

Les niveaux de service définissent la priorité de planification. Il y en a deux : standard (par défaut) et priority. Le niveau Standard convient à la plupart des charges de travail. Le niveau Priorité est destiné au trafic sensible à la latence ou lié à des SLA qui ne peut pas rester dans une file d'attente derrière les autres.

Ajoutez cela au taux standard par rapport au taux de contexte long de l'Étape 5, et votre coût réel dépendra de la taille de l'entrée, du plan et du niveau combinés. Pour les chiffres actuels par jeton, consultez la page de tarification et de modèle MiniMax et la documentation API, car les tarifs publiés peuvent changer.

FAQ

Existe-t-il un moyen gratuit d'essayer M3 ? Oui. Vous pouvez tester le modèle sans vous engager sur un plan, et il existe quelques méthodes sans frais. Nous les avons rassemblées dans comment utiliser MiniMax M3 gratuitement.

Quels SDK fonctionnent avec l'API ? Trois options : HTTP brut, le SDK Anthropic et le SDK OpenAI. MiniMax recommande le SDK Anthropic, mais les trois atteignent le même point d'accès https://api.minimax.io/v1/chat/completions. Pour les clients OpenAI et Anthropic, il vous suffit de modifier le base_url pour qu'il pointe vers MiniMax.

Comment diffuser les réponses ? Ajoutez "stream": true au corps de votre requête. L'API renvoie des événements envoyés par le serveur, et les deux SDK exposent un itérateur sur lequel vous bouclez pour lire les fragments au fur et à mesure de leur arrivée. Testez d'abord le flux dans Apidog pour visualiser le format des événements avant de les analyser.

Quelle est la limite de débit ? Les limites dépendent du niveau de votre compte et de l'utilisation du service standard ou priority. Si vous rencontrez un 429, patientez et réessayez, ou déplacez le trafic sensible à la latence vers le niveau de priorité. Les chiffres actuels sont disponibles sur le tableau de bord de votre compte et dans la documentation de l'API.

Comment le seuil de 512K affecte-t-il ma facture ? Les appels avec une entrée de 512K jetons ou moins sont facturés au taux standard. Au-delà de 512K jetons d'entrée, le taux plus élevé pour le contexte long s'applique. Réduisez votre invite aux jetons dont le modèle a réellement besoin, en particulier dans les boucles d'agents où le coût s'accumule sur plusieurs appels.

Puis-je auto-héberger les poids au lieu d'appeler l'API ? L'API hébergée est le chemin couvert par ce guide, et c'est le moyen le plus rapide de commencer. L'auto-hébergement dépend de ce que MiniMax publie pour M3 à un moment donné, alors consultez la page du modèle pour connaître la situation actuelle concernant le poids et la licence.

Conclusion

Vous avez maintenant tout ce qu'il faut pour appeler MiniMax M3 : une clé API stockée comme variable d'environnement, des requêtes curl, Python et Node fonctionnelles, un interrupteur de réflexion, le seuil de facturation de 512K, et le processus d'appel d'outils. Le moyen le plus rapide de s'y familiariser est d'effectuer un véritable appel manuellement. Déposez le point d'accès dans Apidog, stockez votre jeton bearer comme variable d'environnement, envoyez l'invite de refactorisation et lisez la réponse. Une fois que vous avez vu la forme brute, l'intégrer dans votre code prend quelques minutes.

bouton