Grok 4.7 vs Grok 4.6 : même prix, même contexte, quelles différences et comment choisir

TL;DR : pour le codage complexe et les tâches agentiques, choisissez Grok 4.7 ; pour les tâches légères où vous voulez économiser des tokens, choisissez Grok 4.6. Les deux générations sont exactement au même prix sur HiAPI (entrée 0,84 $ / sortie 2,52 $ par million de tokens) avec le même contexte de 500K ; seul le type de tâche est décisif. Grok 4.7 est déjà disponible sur HiAPI, ouvrez la page du modèle pour l'essayer directement ; les nouveaux utilisateurs reçoivent 200 crédits à l'inscription.

Vue d'ensemble : où se situent les différences entre les deux générations

Dimension	Grok 4.7	Grok 4.6
Prix sur la plateforme (par million de tokens, entrée/sortie)	0,84 $ / 2,52 $	0,84 $ / 2,52 $ (même prix)
Contexte	500K	500K
Capacités de codage (Terminal-Bench 4.0, chiffres officiels)	38,0 %	20,3 %
Positionnement	Recommandation par défaut officielle, axée sur le codage et les tâches agentiques	Flagship de la génération précédente, toujours en vente
Consommation de tokens (tiers traictory.com, effort élevé sans plafond)	Environ 81K/tâche, environ le double de 4.6	Plus faible
Niveaux de raisonnement	low / medium / high / xhigh, high par défaut	Identique
Date de coupure des connaissances	2026-05	Plus ancienne

Prix, contexte et niveaux de raisonnement sont identiques ; la vraie ligne de partage se situe dans les capacités de codage et les habitudes de sortie. Voici deux tests concrets réalisés avec le même prompt.

Même prompt (1) : exercice de codage d'un cache LRU

Test réalisé le 2026-10-29 dans l'environnement de production HiAPI, avec les mêmes paramètres des deux côtés (niveau de raisonnement high par défaut, plafond max_tokens), une exécution chacun :

Prompt :

Écris une classe de cache LRU en Python, avec get et put en O(1), prise en charge du TTL (invalidation automatique à l'expiration) et thread-safe. Fournis uniquement le code et une notice d'utilisation de 5 lignes maximum.

Réponse de Grok 4.7 (39,7 s, 3285 tokens produits, environ 0,011 $) :

class LRUCache:
    def __init__(self, capacity: int, default_ttl: Optional[float] = None):
        if capacity <= 0:
            raise ValueError("capacity must be positive")
        self.capacity = capacity
        self.default_ttl = default_ttl
        self._data: OrderedDict[Hashable, tuple[Any, Optional[float]]] = OrderedDict()
        self._lock = threading.Lock()

    def get(self, key: Hashable, default: Any = None) -> Any:
        with self._lock:
            item = self._data.get(key)
            if item is None:
                return default
            value, expire_at = item
            if expire_at is not None and time.monotonic() >= expire_at:
                del self._data[key]
                return default
            self._data.move_to_end(key)
            return value

    def put(self, key: Hashable, value: Any, ttl: Optional[float] = None) -> None:
        with self._lock:
            ttl = self.default_ttl if ttl is None else ttl
            if ttl is not None and ttl <= 0:
                self._data.pop(key, None)
                return
            expire_at = None if ttl is None else time.monotonic() + ttl
            if key in self._data:
                self._data.move_to_end(key)
            elif len(self._data) >= self.capacity:
                self._data.popitem(last=False)
            self._data[key] = (value, expire_at)

(Texte complet avec les imports et un exemple d'utilisation ; ce qui précède en constitue le corps principal ; 4.7 utilise time.monotonic() pour le TTL et permet de passer une valeur par défaut à get.)

Réponse de Grok 4.6 (61,9 s, 3915 tokens produits, environ 0,012 $) :

class LRUCache:
    def __init__(self, capacity, default_ttl=None):
        if not isinstance(capacity, int) or capacity < 1:
            raise ValueError("capacity must be positive int")
        self.capacity = capacity
        self.default_ttl = default_ttl
        self._cache = OrderedDict()
        self._lock = threading.Lock()

    def get(self, key):
        with self._lock:
            if key not in self._cache:
                return None
            value, expire_at = self._cache[key]
            if expire_at is not None and time.time() > expire_at:
                del self._cache[key]
                return None
            self._cache.move_to_end(key)
            return value

    def put(self, key, value, ttl=None):
        with self._lock:
            now = time.time()
            expire_at = None
            effective_ttl = ttl if ttl is not None else self.default_ttl
            if effective_ttl is not None:
                expire_at = now + effective_ttl
                if expire_at <= now:
                    if key in self._cache:
                        del self._cache[key]
                    return
            if key in self._cache:
                self._cache.move_to_end(key)
            elif len(self._cache) >= self.capacity:
                self._cache.popitem(last=False)
            self._cache[key] = (value, expire_at)

Les deux codes satisfont pleinement les exigences : implémentation O(1) avec OrderedDict, expiration paresseuse du TTL, thread-safe via threading.Lock, tous deux directement exécutables.

Même prompt (2) : problème de raisonnement du réservoir qui se remplit

Un réservoir : le tuyau d'entrée seul le remplit en 6 heures, le tuyau de vidange seul le vide en 8 heures. Le réservoir est actuellement vide ; on ouvre simultanément le tuyau d'entrée et le tuyau de vidange. Au bout de combien d'heures le réservoir sera-t-il exactement plein ? Écris le raisonnement avant de donner la réponse.

	Grok 4.7	Grok 4.6
Durée / tokens produits	8,3 s / 573	18,5 s / 637
Réponse	24 heures	24 heures

Les deux ont rédigé en LaTeX le raisonnement complet 1/6 − 1/8 = 1/24 → 1 ÷ 1/24 = 24, avec une conclusion et une dérivation équivalentes.

Les différences visibles

• Sur l'exercice de codage, 4.7 est 22 secondes plus rapide (39,7 s vs 61,9 s) et produit même moins de tokens (3285 vs 3915)
• Sur le problème de raisonnement, les deux répondent correctement avec un raisonnement équivalent
• En matière d'habitudes de sortie, 4.7 privilégie davantage les titres structurés et les formules LaTeX, avec un style plus concis ; 4.6 utilise aussi LaTeX, mais un peu plus verbeux (637 vs 573 tokens)
• Dans ce test avec plafond (max_tokens limité), 4.7 n'a pas produit plus de tokens que 4.6. Les « environ 81K tokens par tâche, environ 2 fois 4.6 » de traictory.com correspondent à un effort élevé sans plafond : les deux jeux de données ne sont pas contradictoires et ne doivent pas être mélangés
• Selon les chiffres officiels, Terminal-Bench 4.0 passe de 20,3 % à 38,0 %, ce qui va dans le sens de ce que l'on ressent sur l'exercice de codage ci-dessus
• Ces deux comparaisons et 5 autres scénarios exécutés en conditions réelles (dépannage, revue de code, conception de solution, etc.), soit 9 requêtes au total, se sont toutes terminées normalement (finish=stop), sans troncature

Comment choisir selon le scénario

• Pour du codage complexe et des tâches agentiques de longue durée, choisissez Grok 4.7
• Pour des questions-réponses légères du quotidien, des conversions de format ou des scripts simples, choisissez Grok 4.6 : la sortie n'est pas dégradée et vous économisez des tokens
• Si vous utilisez déjà 4.6 de manière stable, inutile de migrer de force ; essayez d'abord 4.7 sur les nouvelles tâches et revenez en arrière si besoin
• Si vous êtes sensible au budget tout en voulant les capacités de 4.7 : les deux générations sont au même prix, ce qui diffère c'est la consommation ; utiliser 4.6 pour les tâches légères, c'est faire des économies

Coût de bascule : un seul champ à modifier

Les deux générations passent par la même interface /v1/chat/completions, avec des paramètres identiques ; il suffit de remplacer model de grok-4.6 par grok-4.7, le reste du code ne change pas :

import requests

resp = requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={"Authorization": "Bearer $HIAPI_API_KEY"},
    json={
        "model": "grok-4.7",  # modifier ici
        "messages": [{"role": "user", "content": "votre tâche"}],
    },
)

Questions fréquentes

Grok 4.7 est-il plus cher que 4.6 ? Pas au niveau du prix unitaire : sur HiAPI, les deux générations sont au même prix, entrée 0,84 $ / sortie 2,52 $ par million de tokens. Le rapport de traictory.com indique qu'en effort élevé sans plafond, 4.7 consomme environ 81K tokens par tâche, soit environ le double de 4.6 ; cela concerne la consommation, pas le prix unitaire. Dans nos tests avec plafond max_tokens, 4.7 n'a pas consommé plus que 4.6.

Quelles sont les faiblesses connues de 4.7 ? Certains utilisateurs de la communauté Cursor signalent que 4.7 produit occasionnellement des hallucinations, des erreurs de fusion de code et une consommation de tokens élevée ; certains sont revenus à 4.6. Pour les tâches simples, continuer avec 4.6 reste une alternative sûre.

Y a-t-il des différences de contexte ou de niveaux de raisonnement ? Non. Les deux générations ont un contexte de 500K et quatre niveaux de raisonnement low / medium / high / xhigh, avec high par défaut.

Où peut-on l'essayer directement ? Essayez en ligne sur la page du modèle Grok 4.7 ; les nouveaux utilisateurs reçoivent 200 crédits à l'inscription. Pour les détails de prix, lisez Tarifs de l'API Grok 4.7 ; pour l'intégration, consultez le Guide de l'API Grok 4.7 ; pour les prompts par scénario, voir Exemples de prompts Grok 4.7 ; si vous utilisez encore l'ancienne version, comparez avec la page du modèle Grok 4.6.