Grok 4.7 vs Grok 4.6: mismo precio y misma ventana de contexto, ¿en qué se diferencian y cómo elegir?

TL;DR: para tareas complejas de programación y agentic, elige Grok 4.7; para tareas ligeras en las que quieras ahorrar tokens, elige Grok 4.6. Ambas generaciones tienen exactamente el mismo precio en HiAPI ($0.84 de entrada / $2.52 de salida por millón de tokens) y la misma ventana de contexto de 500K; lo único decisivo es el tipo de tarea. Grok 4.7 ya está disponible en HiAPI; abre la página del modelo para probarlo directamente. Los nuevos usuarios reciben 200 créditos al registrarse.

De un vistazo: en qué se diferencian las dos generaciones

Dimensión	Grok 4.7	Grok 4.6
Precio en la plataforma (por millón de tokens, entrada/salida)	$0.84 / $2.52	$0.84 / $2.52 (mismo precio)
Contexto	500K	500K
Capacidad de programación (Terminal-Bench 4.0, datos oficiales)	38.0%	20.3%
Posicionamiento	Recomendación predeterminada oficial, enfocado en programación y tareas agentic	Buque insignia de la generación anterior, a la venta
Consumo de tokens (tercero traictory.com, effort alto sin límite)	Unos 81K por tarea, aproximadamente el doble que 4.6	Menor
Niveles de razonamiento	low / medium / high / xhigh, por defecto high	Igual que a la izquierda
Fecha de corte del conocimiento	2026-05	Anterior

El precio, el contexto y los niveles de razonamiento son idénticos; la verdadera línea divisoria está en la capacidad de programación y los hábitos de salida. A continuación, dos pruebas reales con el mismo prompt para ilustrarlo.

El mismo prompt (1): problema de programación de caché LRU

Prueba real en el entorno de producción de HiAPI el 2026-10-29, con los mismos parámetros en ambos lados (nivel de razonamiento predeterminado high, límite max_tokens) y una ejecución por cada uno:

Prompt:

Escribe una clase de caché LRU en Python que requiera get y put en O(1), admita TTL (expiración automática) y sea segura para hilos. Proporciona solo el código y una guía de uso de no más de 5 líneas.

Respuesta de Grok 4.7 (39.7 s, 3285 tokens de salida, unos $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)

(El texto completo incluye import y un ejemplo de uso; lo anterior es el cuerpo principal; 4.7 usa time.monotonic() para el TTL y admite un valor predeterminado en get).

Respuesta de Grok 4.6 (61.9 s, 3915 tokens de salida, unos $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)

Ambos códigos cumplen completamente los requisitos: implementación O(1) con OrderedDict, expiración perezosa de TTL y seguridad para hilos con threading.Lock; ambos son ejecutables directamente.

El mismo prompt (2): problema de razonamiento de llenado de piscina

Una piscina se llena en 6 horas si se abre solo el tubo de entrada, y se vacía en 8 horas si se abre solo el desagüe. Ahora la piscina está vacía; si se abren simultáneamente el tubo de entrada y el desagüe, ¿en cuántas horas se llenará exactamente la piscina? Escribe el proceso de razonamiento antes de dar la respuesta.

	Grok 4.7	Grok 4.6
Tiempo / tokens de salida	8.3 s / 573	18.5 s / 637
Respuesta	24 horas	24 horas

Ambos escriben con LaTeX el proceso completo de 1/6 − 1/8 = 1/24 → 1 ÷ 1/24 = 24; la conclusión y la derivación son equivalentes.

Diferencias visibles

• En el problema de programación, 4.7 es 22 segundos más rápido (39.7 s vs 61.9 s) y, sin embargo, su salida es más corta (3285 vs 3915 tokens)
• En el problema de razonamiento, ambos aciertan y el proceso es equivalente
• En cuanto a hábitos de salida, 4.7 prefiere más los títulos estructurados y las fórmulas LaTeX, con una redacción más compacta; 4.6 también usa LaTeX, pero es un poco más verboso (637 vs 573 tokens)
• En esta prueba real con límite (max_tokens), los tokens de salida de 4.7 no fueron más que los de 4.6. La afirmación del tercero traictory.com de «unos 81K tokens por tarea, aproximadamente el doble que 4.6» corresponde a un criterio de effort alto y sin límite; ambos conjuntos de datos no se contradicen, pero no deben mezclarse
• Los datos oficiales de Terminal-Bench 4.0 pasan del 20.3% al 38.0%, lo que coincide con la tendencia observada en el problema de programación anterior
• Estas dos comparaciones y otras 5 pruebas reales de escenarios (solución de problemas, revisión de código, diseño de soluciones, etc.), 9 solicitudes en total, finalizaron todas correctamente (finish=stop), sin truncamiento

Cómo elegir según el escenario

• Para programación compleja y tareas agentic de larga duración, elige Grok 4.7
• Para preguntas y respuestas ligeras del día a día, conversión de formatos y scripts sencillos, elige Grok 4.6: la salida no se reduce y además ahorras tokens
• Si ya usas 4.6 y funciona de forma estable, no es necesario migrar a la fuerza; prueba primero 4.7 con las nuevas tareas y vuelve a 4.6 cuando quieras si no te convence
• Si te preocupa el presupuesto pero quieres la capacidad de 4.7: ambas generaciones tienen el mismo precio y la diferencia está en el consumo; usar 4.6 para tareas ligeras es precisamente lo que ahorra dinero

Coste de cambio: solo modificar un campo

Ambas generaciones usan la misma interfaz /v1/chat/completions, con parámetros completamente idénticos; basta con cambiar model de grok-4.6 a grok-4.7 sin tocar el resto del código:

import requests

resp = requests.post(
    "https://api.hiapi.ai/v1/chat/completions",
    headers={"Authorization": "Bearer $HIAPI_API_KEY"},
    json={
        "model": "grok-4.7",  # 改这里
        "messages": [{"role": "user", "content": "你的任务"}],
    },
)

Preguntas frecuentes

¿Grok 4.7 es más caro que 4.6? No lo es en precio unitario: en HiAPI ambas generaciones tienen el mismo precio, $0.84 de entrada / $2.52 de salida por millón de tokens. El tercero traictory.com informa que 4.7, en condiciones de effort alto y sin límite, consume unos 81K tokens por tarea, aproximadamente el doble que 4.6; se refiere al volumen de consumo, no al precio unitario. En nuestras pruebas reales con límite max_tokens, 4.7 no consumió más que 4.6.

¿Qué puntos débiles conocidos tiene 4.7? Algunos usuarios de la comunidad de Cursor han informado que 4.7 ocasionalmente alucina, comete errores al fusionar código y consume muchos tokens; algunos usuarios han vuelto a 4.6. Seguir usando 4.6 para tareas sencillas es una alternativa segura.

¿Hay diferencias en el contexto y los niveles de razonamiento? No. Ambas generaciones tienen 500K de contexto y cuatro niveles de razonamiento low / medium / high / xhigh, con high por defecto.

¿Dónde se puede probar directamente? En la página del modelo Grok 4.7 puedes probarlo en línea; los nuevos usuarios reciben 200 créditos al registrarse. Para ver los detalles de precios, lee Precios de la API de Grok 4.7; para empezar a integrarlo, consulta la Guía de la API de Grok 4.7; para prompts por escenario, visita Ejemplos de prompts de Grok 4.7; si sigues usando la versión anterior, puedes comparar con la página del modelo Grok 4.6.