Comment utiliser l'API Mistral Large 4

Mistral Large 4 a été mis en ligne sur l’API Mistral le 6 octobre 2026, trois semaines avant la publication de ses poids ouverts. Si vous souhaitez essayer dès maintenant le modèle « Le Chonk » de 1 000 milliards de paramètres, l’API est le seul moyen d’y accéder — et actuellement le moins cher : Mistral le propose à 0,68 $ par million de jetons d’entrée et 2,09 $ par million de jetons de sortie pendant l’aperçu public, soit la moitié du prix catalogue de 1,36 $ / 4,18 $.

Essayez Apidog dès aujourd’hui

Ce guide vous fait passer de zéro à un premier appel fonctionnel en environ cinq minutes. Il couvre ensuite les points d’intégration qui demandent le plus d’attention : blocs de raisonnement, images, appels de fonctions, sortie JSON et coût. Enregistrez et rejouez vos requêtes dans Apidog pour comparer Large 4 au modèle que vous utilisez déjà.

Nouveau sur ce modèle ? Commencez par Mistral est de retour : Le Chonk bat GPT-6 Astra et Claude en cybersécurité pour les benchmarks et le contexte derrière le titre cyber.

Ce dont vous avez besoin

Élément	Valeur
Base URL	https://api.mistral.ai/v1
Auth	Authorization: Bearer $MISTRAL_API_KEY
Model ID	mistral-large-4 (alias mistral-large-4-0)
Endpoint principal	POST /v1/chat/completions
Fenêtre de contexte	1M tokens
Types d’entrée	Texte, images
SDK Python	pip install mistralai
SDK TypeScript	npm install @mistralai/mistralai

Étape 1 : obtenir une clé API

1. Connectez-vous à Mistral Studio — anciennement La Plateforme.
2. Ouvrez Clés API, puis créez une clé.
3. Donnez-lui un nom explicite, par exemple local-dev ou ci-staging.
4. Copiez la clé immédiatement : elle ne sera plus affichée.
5. Exportez-la dans votre shell :

export MISTRAL_API_KEY="your-key-here"

Ne placez pas cette clé dans votre dépôt Git. Si vous l’utilisez dans plusieurs outils ou environnements, consultez ces bonnes pratiques de gestion des clés API pour la rotation et la portée des clés.

Étape 2 : effectuer votre premier appel

Commencez avec curl pour isoler les problèmes d’authentification ou de SDK :

curl https://api.mistral.ai/v1/chat/completions \
  -H "Authorization: Bearer $MISTRAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-large-4",
    "messages": [
      {
        "role": "user",
        "content": "Give me three edge cases to test on a pagination API."
      }
    ]
  }'

Une réponse réussie contient notamment :

• choices[0].message.content : la réponse du modèle ;
• usage.prompt_tokens : les jetons d’entrée ;
• usage.completion_tokens : les jetons de sortie ;
• usage.total_tokens : le total facturé.

Diagnostic rapide :

• 401 Unauthorized : clé incorrecte, absente ou non exportée ;
• 404 sur le modèle : vérifiez l’ID mistral-large-4 ;
• 422 Unprocessable Entity : le JSON envoyé ne respecte pas le format attendu.

Le même appel en Python

Installez le SDK :

pip install mistralai

Puis exécutez :

import os
from mistralai import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

response = client.chat.complete(
    model="mistral-large-4",
    messages=[
        {
            "role": "user",
            "content": "Give me three edge cases to test on a pagination API.",
        }
    ],
)

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

Le même appel en TypeScript

Installez le SDK :

npm install @mistralai/mistralai

Puis appelez le modèle :

import { Mistral } from "@mistralai/mistralai";

const client = new Mistral({ apiKey: process.env.MISTRAL_API_KEY });

const response = await client.chat.complete({
  model: "mistral-large-4",
  messages: [
    {
      role: "user",
      content: "Give me three edge cases to test on a pagination API.",
    },
  ],
});

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

Étape 3 : enregistrer la requête dans Apidog

Dès que vous comparez plusieurs modèles, les commandes curl deviennent difficiles à maintenir. Configurez une requête réutilisable dans Apidog :

1. Créez une requête HTTP : POST https://api.mistral.ai/v1/chat/completions.
2. Ajoutez une variable d’environnement MISTRAL_API_KEY.
3. Ajoutez l’en-tête :

   Authorization: Bearer {{MISTRAL_API_KEY}}

1. Collez le corps JSON de l’étape précédente.
2. Cliquez sur Envoyer.
3. Dupliquez la requête, remplacez model par votre modèle actuel — par exemple mistral-medium-3-5 — puis exécutez les deux requêtes avec le même prompt.

Vous obtenez ainsi deux requêtes comparables. Apidog affiche le statut, le corps de réponse, le temps d’exécution et la taille de chaque réponse.

Ajoutez aussi une assertion post-réponse pour vérifier que choices[0].message.content n’est pas vide. Vous aurez alors un test de validation simple à réexécuter lorsque Mistral met à jour l’aperçu.

Étape 4 : activer ou désactiver le raisonnement

Large 4 est un modèle hybride : le même modèle peut répondre rapidement ou produire un raisonnement étape par étape. Contrôlez ce comportement avec reasoning_effort.

Valeur	Comportement	Cas d’usage
"none"	Pensée minimale, sans bloc de raisonnement dans la réponse	Chat, extraction, classification, flux sensibles à la latence
"high"	Bloc de raisonnement complet avant la réponse finale	Débogage, planification multi-étapes, mathématiques, revue de code

Exemple avec raisonnement élevé :

curl https://api.mistral.ai/v1/chat/completions \
  -H "Authorization: Bearer $MISTRAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-large-4",
    "messages": [
      {
        "role": "user",
        "content": "Our API returns 200 with an empty body under load. List likely causes in order of probability."
      }
    ],
    "reasoning_effort": "high"
  }'

Avec reasoning_effort: "high", message.content n’est plus nécessairement une chaîne. Il devient une liste de blocs :

• un bloc thinking pour la trace de raisonnement ;
• un bloc text pour la réponse finale.

Ne supposez donc pas que response.choices[0].message.content peut toujours être affiché directement. Extrayez explicitement le texte final :

response = client.chat.complete(
    model="mistral-large-4",
    messages=[
        {
            "role": "user",
            "content": "Why would a 200 response have an empty body?",
        }
    ],
    reasoning_effort="high",
)

content = response.choices[0].message.content

if isinstance(content, str):
    answer = content
else:
    answer = "".join(block.text for block in content if block.type == "text")

print(answer)

Les jetons de réflexion sont facturés comme des jetons de sortie. Utilisez "none" par défaut, puis passez à "high" uniquement pour les requêtes qui exigent un raisonnement approfondi.

Étape 5 : envoyer une image

Large 4 est nativement multimodal, avec un encodeur de vision de 1,6 milliard de paramètres. Envoyez une image sous forme de partie de contenu, à côté du texte :

curl https://api.mistral.ai/v1/chat/completions \
  -H "Authorization: Bearer $MISTRAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-large-4",
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "This is a screenshot of our API error dashboard. Which endpoint is failing most and what is the error code?"
          },
          {
            "type": "image_url",
            "image_url": "https://example.com/dashboard.png"
          }
        ]
      }
    ]
  }'

Pour un fichier local, utilisez une URL de données base64 :

{
  "type": "image_url",
  "image_url": "data:image/png;base64,<encoded>"
}

Mistral indique que Large 4 atteint 42 % au benchmark de mise à la terre visuelle Dense 200, devant les 41 % de GPT-6 Astra. Les captures de tableaux de bord, graphiques et états d’interface sont donc des cas d’usage pertinents.

Étape 6 : utiliser l’appel de fonction

L’appel de fonction permet au modèle de choisir un outil, puis à votre application d’exécuter réellement l’opération. C’est là que les benchmarks d’agent de Large 4 — 59,9 % sur AutomationBench — deviennent utiles.

Définissez d’abord vos outils :

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_order_status",
            "description": "Look up the status of an order by its ID.",
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {
                        "type": "string",
                        "description": "The order ID, e.g. ORD-1042",
                    }
                },
                "required": ["order_id"],
            },
        },
    }
]

messages = [
    {
        "role": "user",
        "content": "Where is order ORD-1042?",
    }
]

response = client.chat.complete(
    model="mistral-large-4",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

tool_call = response.choices[0].message.tool_calls[0]

print(tool_call.function.name)
print(tool_call.function.arguments)

Exécutez ensuite vous-même la fonction demandée, puis renvoyez son résultat au modèle avec le même tool_call_id :

import json

result = {
    "order_id": "ORD-1042",
    "status": "shipped",
    "eta": "2026-10-09",
}

messages.append(response.choices[0].message)

messages.append(
    {
        "role": "tool",
        "name": "get_order_status",
        "content": json.dumps(result),
        "tool_call_id": tool_call.id,
    }
)

final = client.chat.complete(
    model="mistral-large-4",
    messages=messages,
    tools=tools,
)

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

Le schéma d’outil est un JSON Schema. Si votre API possède déjà une spécification OpenAPI, réutilisez le schéma de requête de chaque opération dans parameters.

Concevoir et maintenir la spécification dans Apidog permet de garder les définitions d’outils et votre API réelle synchronisées.

Étape 7 : obtenir du JSON en sortie

Pour une sortie exploitable par une machine, définissez response_format :

curl https://api.mistral.ai/v1/chat/completions \
  -H "Authorization: Bearer $MISTRAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-large-4",
    "messages": [
      {
        "role": "user",
        "content": "Extract method, path and status code from: GET /v1/users/42 returned 404. Reply in JSON."
      }
    ],
    "response_format": {
      "type": "json_object"
    }
  }'

Mentionnez explicitement JSON dans le prompt et ajoutez response_format.

Pour une structure stricte, Mistral prend également en charge :

{
  "type": "json_schema",
  "json_schema": {
    "...": "votre schéma complet"
  }
}

Dans Apidog, ajoutez une assertion de schéma JSON sur la réponse. Une réponse qui diverge du contrat échouera immédiatement, plutôt que de casser silencieusement un service en aval.

Ce que ça coûte

Utilisation	Prix d’aperçu	Prix catalogue
Entrée, par 1M de jetons	$0.68	$1.36
Entrée en cache, par 1M de jetons	$0.07	$0.14
Sortie, par 1M de jetons	$2.09	$4.18

Exemple : un agent effectue 10 000 appels par jour, avec 3 000 jetons d’entrée et 500 jetons de sortie par appel.

• Entrée : 30M de jetons par jour. Si 2 500 des 3 000 jetons sont en cache, cela représente 25M de jetons mis en cache à 0,07 $ et 5M de jetons frais à 0,68 $, soit environ 5,15 $/jour.
• Sortie : 5M de jetons à 2,09 $, soit environ 10,45 $/jour.
• Total : environ 15,60 $/jour au tarif d’aperçu, contre environ 31 $ au tarif catalogue.

La même charge de travail sur GPT-6 Astra — 10 $ / 50 $ par million avant les remises de mise en cache — coûterait plusieurs centaines de dollars par jour. Mistral n’a pas précisé quand la tarification d’aperçu prendra fin : budgétez donc selon le prix catalogue.

Erreurs courantes

Erreur	Cause probable	Solution
401 Unauthorized	Clé manquante ou incorrecte	Vérifiez echo $MISTRAL_API_KEY et le préfixe Bearer
404 / modèle invalide	Faute de frappe dans l’ID	Utilisez exactement mistral-large-4
422 Unprocessable Entity	Corps mal formé, souvent un schéma tools invalide	Validez le JSON Schema dans parameters pour chaque outil
429 Too Many Requests	Limite de débit liée à votre niveau d’espace de travail	Attendez, réessayez ou augmentez les limites dans Studio
La réponse s’affiche comme une liste	reasoning_effort: "high" retourne des blocs	Extrayez le bloc text comme indiqué à l’étape 4

FAQ

Mistral Large 4 est-il compatible avec OpenAI ?

La forme de la requête est très proche : model, messages, tools, tool_choice et response_format fonctionnent comme attendu. Utilisez les SDK Mistral ou HTTP directement pour plus de sécurité. La sortie de raisonnement utilise toutefois le format de blocs propre à Mistral.

Quand pourrai-je l’exécuter localement ?

Mistral annonce que les poids seront livrés d’ici fin octobre 2026. Avec un total de 1,05 milliard de paramètres, il nécessite du matériel serveur multi-GPU. En attendant, ce guide sur l’exécution de Mistral 3 en local couvre les outils adaptés aux modèles plus petits.

L’aperçu est-il suffisamment stable pour la production ?

Pas encore. Le modèle est étiqueté « aperçu public » et peut changer avant la publication des poids. Épinglez vos tests, réexécutez-les lors des mises à jour du modèle et gardez un modèle de secours configuré.

Puis-je utiliser Large 4 avec mon code Mistral existant ?

Oui. L’URL de base, l’authentification et les SDK sont les mêmes. Changez simplement la valeur de model pour mistral-large-4. Si vous migrez depuis Medium 3.5, consultez ce guide API Mistral Medium 3.5 pour les parties transférables.

Conclusion

Vous pouvez obtenir un premier appel fonctionnel en cinq minutes. Ensuite, consacrez votre temps à exécuter vos prompts réels sur Large 4 et sur votre modèle actuel, côte à côte.

Enregistrez les deux requêtes dans Apidog, ajoutez des assertions sur le statut et la structure de réponse, puis comparez qualité, latence et consommation de jetons. Vous saurez rapidement si Le Chonk mérite une place dans votre pile technologique tant que le prix d’aperçu reste à moitié prix.