Grok 4.7 vs Grok 4.6: gleicher Preis, gleicher Kontext – wo liegt der Unterschied und wie wählt man?

TL;DR: Für komplexes Coding und agentische Aufgaben wählen Sie Grok 4.7, für leichte Aufgaben mit Token-Ersparnis Grok 4.6. Beide Generationen kosten bei HiAPI exakt gleich viel (Eingabe $0.84 / Ausgabe $2.52 pro Million Token) und haben denselben 500K-Kontext – entscheidend ist allein der Aufgabentyp. Grok 4.7 ist bereits bei HiAPI verfügbar: Modellseite öffnen und direkt ausprobieren. Neue Nutzer erhalten bei der Registrierung 200 Credits geschenkt.

Auf einen Blick: Wo die beiden Generationen sich unterscheiden

Dimension	Grok 4.7	Grok 4.6
Plattformpreis (pro Million Token, Eingabe/Ausgabe)	$0.84 / $2.52	$0.84 / $2.52 (gleicher Preis)
Kontext	500K	500K
Coding-Fähigkeit (Terminal-Bench 4.0, offizielle Angabe)	38,0 %	20,3 %
Positionierung	Offiziell empfohlene Standardwahl, Fokus auf Coding und agentische Aufgaben	Flaggschiff der Vorgängergeneration, weiterhin erhältlich
Token-Verbrauch (Drittanbieter traictory.com, hoher Effort ohne Obergrenze)	Ca. 81K pro Aufgabe, etwa doppelt so viel wie 4.6	Niedriger
Reasoning-Stufen	low / medium / high / xhigh, Standard high	Wie links
Wissensstand	2026-05	Früher

Preis, Kontext und Reasoning-Stufen sind völlig identisch; die eigentliche Trennlinie sind Coding-Fähigkeit und Ausgabeverhalten. Im Folgenden sprechen zwei Tests mit identischen Prompts für sich.

Derselbe Prompt (1): LRU-Cache-Coding-Aufgabe

Am 29.10.2026 in der HiAPI-Produktionsumgebung getestet, beide mit gleichen Parametern (Reasoning-Stufe standardmäßig high, max_tokens als Obergrenze), je ein Durchlauf:

Prompt:

Schreibe eine Python-Klasse für einen LRU-Cache mit O(1) für get und put, TTL-Unterstützung (automatisches Verfallen) und Thread-Sicherheit. Gib nur den Code und eine Gebrauchsanweisung von höchstens 5 Zeilen an.

Antwort von Grok 4.7 (39,7 s, 3285 Ausgabe-Token, ca. $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)

(Volltext inklusive Import und Nutzungsbeispiel, oben steht der Hauptteil; 4.7 verwendet time.monotonic() für die TTL und unterstützt einen Standardwert bei get.)

Antwort von Grok 4.6 (61,9 s, 3915 Ausgabe-Token, ca. $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)

Beide Codes erfüllen die Anforderungen vollständig: O(1) mit OrderedDict, verzögertes Verfallen der TTL, Thread-Sicherheit mit threading.Lock – beide laufen direkt.

Derselbe Prompt (2): Logikaufgabe mit Wasserbecken

Ein Wasserbecken: Das Zulaufrohr allein füllt es in 6 Stunden, das Ablaufrohr allein leert es in 8 Stunden. Das Becken ist leer; nun werden Zulauf und Ablauf gleichzeitig geöffnet. Nach wie vielen Stunden ist das Becken genau voll? Bitte zuerst den Rechenweg darlegen, dann die Antwort geben.

	Grok 4.7	Grok 4.6
Zeit / Ausgabe-Token	8,3 s / 573	18,5 s / 637
Antwort	24 Stunden	24 Stunden

Beide schreiben den vollständigen Rechenweg 1/6 − 1/8 = 1/24 → 1 ÷ 1/24 = 24 in LaTeX; Ergebnis und Herleitung sind äquivalent.

Sichtbare Unterschiede

• Bei der Coding-Aufgabe ist 4.7 22 Sekunden schneller (39,7 s vs. 61,9 s) und gibt sogar weniger Token aus (3285 vs. 3915)
• Bei der Logikaufgabe antworten beide korrekt und mit äquivalentem Rechenweg
• Beim Ausgabestil nutzt 4.7 lieber strukturierte Überschriften und LaTeX-Formeln und formuliert kompakter; 4.6 nutzt ebenfalls LaTeX, ist aber etwas umständlicher (637 vs. 573 Token)
• In diesem capped-Test (max_tokens als Obergrenze) hat 4.7 nicht mehr Ausgabe-Token als 4.6. Die Angabe von Drittanbieter traictory.com („ca. 81K Token pro Aufgabe, etwa 2-mal 4.6“) bezieht sich auf hohen Effort ohne Obergrenze; die beiden Datensätze widersprechen sich nicht und sollten nicht vermischt werden
• Laut offiziellen Angaben steigt Terminal-Bench 4.0 von 20,3 % auf 38,0 %, was zur Erfahrung bei der Coding-Aufgabe oben passt
• Diese beiden Vergleiche und fünf weitere Praxisszenarien (Fehlersuche, Code-Review, Lösungsdesign usw.) – insgesamt 9 Anfragen – endeten alle normal (finish=stop), ohne Kürzung

Auswahl nach Szenario

• Für komplexes Coding und langlaufende agentische Aufgaben: Grok 4.7 wählen
• Für alltägliche leichte Fragen, Formatkonvertierung, einfache Skripte: Grok 4.6 wählen – die Ausgabe wird nicht schlechter und spart Token
• Wer bereits stabil 4.6 nutzt, muss nicht zwingend wechseln; neue Aufgaben zuerst mit 4.7 testen und bei Unzufriedenheit jederzeit zurückwechseln
• Budgetbewusst und dennoch die Fähigkeiten von 4.7 gewünscht: Beide Generationen kosten gleich viel, der Unterschied liegt im Verbrauch – bei leichten Aufgaben spart 4.6 Geld

Wechselkosten: nur ein Feld ändern

Beide Generationen nutzen dieselbe Schnittstelle /v1/chat/completions mit identischen Parametern. Ändern Sie einfach model von grok-4.6 auf grok-4.7, der restliche Code bleibt unverändert:

import requests

resp = requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={"Authorization": "Bearer $HIAPI_API_KEY"},
    json={
        "model": "grok-4.7",  # hier ändern
        "messages": [{"role": "user", "content": "Deine Aufgabe"}],
    },
)

Häufige Fragen

Ist Grok 4.7 teurer als 4.6? Nicht beim Stückpreis: Bei HiAPI kosten beide Generationen gleich viel, Eingabe $0.84 / Ausgabe $2.52 pro Million Token. Der Bericht von Drittanbieter traictory.com, wonach 4.7 bei hohem Effort ohne Obergrenze ca. 81K Token pro Aufgabe und damit etwa doppelt so viel wie 4.6 verbraucht, meint den Verbrauch, nicht den Stückpreis; in unserem Test mit max_tokens-Obergrenze lag 4.7 nicht über 4.6.

Welche bekannten Schwächen hat 4.7? In der Cursor-Community berichten einige Nutzer, dass 4.7 gelegentlich halluziniert, Fehler beim Zusammenführen von Code macht und viel Token verbraucht; manche sind zu 4.6 zurückgekehrt. Für einfache Aufgaben ist 4.6 die solide Alternative.

Gibt es Unterschiede bei Kontext und Reasoning-Stufen? Nein. Beide Generationen haben 500K Kontext und vier Reasoning-Stufen (low / medium / high / xhigh), Standard ist high.

Wo kann man es direkt ausprobieren? Auf der Grok 4.7 Modellseite online testen; neue Nutzer erhalten bei der Registrierung 200 Credits. Für Preisdetails lesen Sie Grok 4.7 API-Preise, für den Einstieg in die Integration den Grok 4.7 API-Leitfaden, Szenario-Prompts finden Sie in den Grok 4.7 Prompt-Beispielen; wer noch die alte Version nutzt, kann die Grok 4.6 Modellseite zum Vergleich heranziehen.