Comment utiliser l'API MiniMax M3 ?

MiniMax M3 est un modèle de raisonnement et de codage avec une fenêtre de contexte allant jusqu’à 1 000 000 de jetons. En pratique, vous pouvez lui transmettre un dépôt complet, une semaine de journaux ou un long document de conception, puis lui demander de raisonner sur l’ensemble en un seul appel. Pour le contexte général sur le modèle, commencez par ce qu’est MiniMax M3.

Essayez Apidog aujourd’hui

Ce guide se concentre sur l’implémentation : générer une clé API, envoyer une première requête avec curl, Python et Node.js, puis inspecter les requêtes/réponses dans Apidog avant d’intégrer l’appel dans votre code. Vous pouvez aussi télécharger Apidog pour suivre les étapes.

La référence officielle reste la documentation API de MiniMax. Gardez-la ouverte pendant l’intégration.

Ce dont vous aurez besoin

• Un compte MiniMax sur platform.minimax.io.
• Une clé API MiniMax.
• Un mode de paiement actif : crédits pay-as-you-go ou plan de jetons par abonnement.
• Pour les SDK :
  • Python 3.8+ pour l’exemple Python.
  • Node.js 18+ pour l’exemple JavaScript.

Les exemples curl ne nécessitent aucune dépendance supplémentaire.

Étape 1 : créer et stocker votre clé API

Connectez-vous à platform.minimax.io, ouvrez la section des clés API, puis créez une nouvelle clé.

MiniMax propose deux types d’identifiants :

• Clé API standard : facturée sur votre solde prépayé.
• Clé d’abonnement : consomme les crédits de jetons de votre plan Plus, Max ou Ultra. Quand les crédits du plan sont épuisés, les appels via cette clé s’arrêtent jusqu’au renouvellement ou au changement de clé.

Copiez la clé une seule fois et stockez-la dans une variable d’environnement :

export MINIMAX_API_KEY="your-key-here"

Évitez de coller la clé directement dans votre code source, dans un fichier partagé ou dans un dépôt Git. Les mêmes règles s’appliquent si vous manipulez des secrets dans votre éditeur. Pour les risques courants, voir la sécurité des clés API des extensions VS Code.

Étape 2 : envoyer une première requête HTTP

L’URL de base est :

https://api.minimax.io/v1

Le point d’accès chat est :

POST https://api.minimax.io/v1/chat/completions

L’authentification utilise un jeton Bearer :

Authorization: Bearer $MINIMAX_API_KEY

Le nom du modèle est :

MiniMax-M3

Voici un appel minimal avec curl :

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."
      }
    ]
  }'

Si la clé est valide, vous recevez une réponse JSON contenant le message généré par le modèle.

Étape 3 : appeler MiniMax M3 avec le SDK OpenAI

MiniMax expose une interface compatible avec le SDK OpenAI. Le changement principal est le base_url.

Python

from openai import OpenAI
import os

client = OpenAI(
    base_url="https://api.minimax.io/v1",
    api_key=os.environ["MINIMAX_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)

Node.js

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 déjà utilisé l’API Qwen 3.7, le modèle d’intégration est similaire : vous remplacez principalement l’URL de base et le nom du modèle.

Références utiles :

• SDK OpenAI Python
• SDK Anthropic Python

MiniMax recommande le SDK Anthropic, mais HTTP brut, SDK OpenAI et SDK Anthropic peuvent tous cibler le même point d’accès.

Étape 4 : tester l’appel dans Apidog

Avant d’intégrer l’appel dans votre application, testez-le manuellement dans Apidog. Cela permet de valider les en-têtes, le corps JSON et la forme exacte de la réponse.

Procédure :

1. Créez une nouvelle requête HTTP.
2. Définissez la méthode sur POST.
3. Utilisez l’URL suivante :

   https://api.minimax.io/v1/chat/completions

1. Ouvrez le panneau des environnements.
2. Ajoutez une variable :

   MINIMAX_API_KEY

1. Stockez votre clé comme valeur de cette variable.
2. Dans les en-têtes, ajoutez :

   Authorization: Bearer {{MINIMAX_API_KEY}}
   Content-Type: application/json

1. Dans le corps, sélectionnez JSON brut et collez :

   {
     "model": "MiniMax-M3",
     "messages": [
       {
         "role": "user",
         "content": "Refactor this function to be async."
       }
     ]
   }

1. Cliquez sur Envoyer.
2. Inspectez la réponse brute.

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

Cette étape évite de déboguer à l’aveugle dans votre application. Vous pouvez aussi partager la requête avec votre équipe sans exposer la clé, car le secret reste dans une variable d’environnement locale.

Si vous activez le streaming plus tard, Apidog permet également de visualiser les événements envoyés par le serveur au fur et à mesure de leur arrivée.

Étape 5 : activer la réflexion avec reasoning_split

MiniMax M3 est un modèle de raisonnement. Par défaut, il renvoie une réponse finale. Vous pouvez aussi demander la séparation du raisonnement intermédiaire avec reasoning_split.

Avec le SDK OpenAI, passez cette option dans extra_body :

from openai import OpenAI
import os

client = OpenAI(
    base_url="https://api.minimax.io/v1",
    api_key=os.environ["MINIMAX_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
    },
)

reasoning = response.choices[0].message.reasoning_details[0]["text"]
final_answer = response.choices[0].message.content

print("Raisonnement :")
print(reasoning)

print("Réponse finale :")
print(final_answer)

Quand reasoning_split est activé :

• Le raisonnement est disponible dans :

  response.choices[0].message.reasoning_details[0]["text"]

• La réponse finale reste dans :

  response.choices[0].message.content

Utilisez cette option pour les tâches complexes :

• refactorisation en plusieurs étapes ;
• analyse de bugs ;
• revue de conception ;
• vérification d’un raisonnement avant exécution.

Désactivez-la pour les appels simples ou sensibles à la latence, car les jetons de raisonnement peuvent augmenter le coût et le temps de réponse.

Étape 6 : utiliser le contexte de 1 million de jetons

La grande fenêtre de contexte est l’un des principaux cas d’usage de MiniMax M3. Vous pouvez, par exemple, envoyer un fichier journal complet et poser une question sur l’ensemble.

from openai import OpenAI
import os

client = OpenAI(
    base_url="https://api.minimax.io/v1",
    api_key=os.environ["MINIMAX_API_KEY"],
)

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": (
                "Find the root cause of the 502 spike at 14:20 UTC.\n\n"
                f"{log_text}"
            ),
        }
    ],
)

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

Attention au seuil de facturation : MiniMax applique un tarif standard jusqu’à 512K jetons d’entrée. Au-delà de 512K jetons d’entrée, un tarif de contexte long plus élevé s’applique.

Conséquence pratique : ne poussez pas automatiquement 1 million de jetons dans chaque requête. Réduisez l’entrée aux fichiers, logs ou sections réellement nécessaires.

Dans une boucle d’agent, cette optimisation devient critique : chaque appel accumule du coût. Pour aller plus loin, voir comment réduire les coûts de jetons des agents.

Étape 7 : utiliser l’appel d’outils

MiniMax M3 prend en charge l’appel d’outils. Vous déclarez les fonctions disponibles, puis votre application exécute les appels demandés par le modèle.

Exemple de déclaration d’un outil run_tests :

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,
)

Si le modèle décide d’appeler un outil, la réponse contient un tableau tool_calls. Votre application doit alors :

1. Lire le nom de l’outil et ses arguments.
2. Exécuter la fonction correspondante côté serveur.
3. Ajouter le résultat comme message tool.
4. Rappeler l’API pour permettre au modèle de continuer.

C’est souvent dans cette boucle multi-tours que les bugs d’agents apparaissent : mauvais format d’arguments, résultat d’outil incomplet, état perdu entre deux appels, etc.

Pour les patterns et pièges courants, voir câblage d’outils de flux de travail agentique.

Dans Apidog, vous pouvez enregistrer chaque étape comme requête séparée :

• requête initiale ;
• réponse avec tool_calls ;
• résultat d’outil ;
• requête de suivi.

Cela facilite le débogage de bout en bout sans dépendre uniquement de votre runtime d’agent.

Étape 8 : envoyer une entrée multimodale

MiniMax M3 peut aussi traiter des entrées multimodales. Pour les images, vous passez le contenu image dans le tableau messages, à côté du texte, avec le format de parties de contenu attendu par l’API.

Les noms de champs multimodaux peuvent évoluer plus vite que les points d’accès texte. Consultez donc la référence de l’API avant d’implémenter ce format en production.

Streaming des réponses

Pour recevoir la réponse progressivement, ajoutez stream: true dans le corps de la requête :

{
  "model": "MiniMax-M3",
  "stream": true,
  "messages": [
    {
      "role": "user",
      "content": "Refactor this function to be async."
    }
  ]
}

L’API renvoie alors des événements envoyés par le serveur. Les SDK exposent généralement un itérateur permettant de lire les fragments au fur et à mesure.

Testez le streaming dans Apidog avant d’écrire le parsing côté application. Vous verrez exactement la structure des événements reçus.

Tarification et niveaux de service

Deux éléments influencent le coût et la priorité de traitement.

Les plans de jetons définissent votre budget de crédits :

• Plus : 20 $
• Max : 50 $
• Ultra : 120 $

Chaque plan fournit un pool de crédits de jetons utilisé par votre clé d’abonnement. En pay-as-you-go, une clé API standard consomme votre solde prépayé.

Les niveaux de service définissent la priorité de planification :

• standard : niveau par défaut, adapté à la plupart des charges.
• priority : pour le trafic sensible à la latence ou lié à des SLA.

Ajoutez à cela le seuil de 512K jetons d’entrée : sous ce seuil, le tarif standard s’applique ; au-dessus, le tarif de contexte long s’applique.

Pour les prix à jour, consultez la page de tarification et de modèle MiniMax et la documentation API.

FAQ

Existe-t-il un moyen gratuit d’essayer MiniMax M3 ?

Oui. Vous pouvez tester le modèle sans vous engager sur un plan. Les options sont détaillées dans comment utiliser MiniMax M3 gratuitement.

Quels SDK fonctionnent avec l’API ?

Trois options sont possibles :

• HTTP brut ;
• SDK OpenAI ;
• SDK Anthropic.

MiniMax recommande le SDK Anthropic, mais les trois peuvent appeler :

https://api.minimax.io/v1/chat/completions

Avec les SDK OpenAI ou Anthropic, pointez simplement le base_url vers MiniMax.

Comment gérer les erreurs 429 ?

Une erreur 429 indique une limite de débit. Les limites dépendent de votre compte et du niveau de service utilisé (standard ou priority).

Stratégies recommandées :

• ajouter une logique de retry avec backoff ;
• réduire le parallélisme ;
• déplacer le trafic critique vers le niveau priority si nécessaire ;
• vérifier les limites actuelles dans votre tableau de bord et la documentation API.

Comment le seuil de 512K affecte-t-il la facture ?

Les appels avec 512K jetons d’entrée ou moins sont facturés au tarif standard. Au-delà, le tarif de contexte long s’applique.

Réduisez donc le contexte à ce qui est utile, surtout dans les agents qui appellent le modèle plusieurs fois.

Puis-je auto-héberger les poids ?

Ce guide couvre l’API hébergée, qui est le chemin le plus direct pour démarrer. Pour l’auto-hébergement, consultez la page du modèle, car la disponibilité des poids et les conditions de licence peuvent évoluer.

Conclusion

Vous avez maintenant le flux complet pour utiliser MiniMax M3 :

• créer une clé API ;
• la stocker dans une variable d’environnement ;
• envoyer une requête avec curl ;
• utiliser le SDK OpenAI en Python ou Node.js ;
• tester la requête dans Apidog ;
• activer reasoning_split si nécessaire ;
• gérer le contexte long ;
• préparer l’appel d’outils.

Le meilleur prochain pas : créez la requête dans Apidog, utilisez Bearer {{MINIMAX_API_KEY}}, envoyez une invite simple, puis inspectez la réponse brute. Une fois le format validé, l’intégration dans votre application devient beaucoup plus rapide.