Usa Groq GPT-OSS 120B con el SDK de OpenAI: URL base, precios y caché

El endpoint compatible con OpenAI de Groq es un cambio real de una sola línea: establece base_url en https://api.groq.com/openai/v1 y sigue usando el SDK de OpenAI. A 17 de junio de 2026, Groq lista openai/gpt-oss-120b a 0,15 $ por 1 M de tokens de entrada sin caché, 0,075 $ por 1 M de tokens de entrada en caché y 0,60 $ por 1 M de tokens de salida en su página de precios (Precios de Groq).

Esa es la parte útil. La trampa es asumir que “compatible con OpenAI” significa “comportamiento idéntico y facturación idéntica”. No es así. Aun así tienes que elegir el ID de modelo de Groq, vigilar los aciertos de caché, evitar parámetros de OpenAI no admitidos y contabilizar por separado las llamadas a herramientas integradas.

Qué estás cambiando realmente

La documentación de Groq dice que su API es “mayormente compatible con las bibliotecas cliente de OpenAI” y muestra la configuración exacta del cliente de OpenAI: pasa tu clave de Groq y establece base_url="https://api.groq.com/openai/v1" (Compatibilidad de Groq con OpenAI).

Instala el SDK de OpenAI para Python:

pip install openai
export GROQ_API_KEY="gsk_..."

Luego llama a GPT-OSS 120B a través de Groq:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["GROQ_API_KEY"],
    base_url="https://api.groq.com/openai/v1",
)

response = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    messages=[
        {"role": "system", "content": "You are a concise senior backend engineer."},
        {"role": "user", "content": "Write a PostgreSQL index plan for a slow user_events query."},
    ],
)

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

La diferencia importante es el model. En la propia plataforma de OpenAI podrías usar el nombre de un modelo alojado por OpenAI. En Groq, GPT-OSS se referencia como openai/gpt-oss-120b o openai/gpt-oss-20b.

OpenAI lanzó gpt-oss-120b y gpt-oss-20b el 5 de agosto de 2025 como modelos de razonamiento de pesos abiertos bajo Apache 2.0 (OpenAI). OpenAI afirma que gpt-oss-120b tiene 117 B de parámetros totales, 5,1 B de parámetros activos por token, 128 expertos, 4 expertos activos por token y soporte nativo para longitudes de contexto de hasta 128 k (OpenAI). La página del modelo de Groq lista la ventana de contexto del openai/gpt-oss-120b alojado como 131.072 tokens y el máximo de tokens de salida como 65.536 (ficha del modelo de Groq).

Elige 120B o 20B

Usa 120B cuando la calidad importe más que el coste bruto: planificación de agentes, tareas de programación más difíciles, extracción compleja o razonamiento de varios pasos. Usa 20B cuando necesites throughput más barato para enrutamiento, resumen, clasificación, asistentes breves o trabajos en segundo plano de gran volumen.

ID de modelo de Groq	Velocidad listada	Entrada sin caché	Entrada en caché	Salida
openai/gpt-oss-120b	500 TPS	0,15 $ / 1 M	0,075 $ / 1 M	0,60 $ / 1 M
openai/gpt-oss-20b	1.000 TPS	0,075 $ / 1 M	0,0375 $ / 1 M	0,30 $ / 1 M

Esos precios vienen de la tabla de precios actual de Groq y de la tabla de caché de prompts (Precios de Groq). El modelo 20B cuesta exactamente la mitad por token que el 120B según lo listado. Eso lo convierte en un buen valor por defecto para flujos de trabajo de “probar primero”. Si la calidad de la respuesta no es suficiente, promociona esa ruta a 120B.

Aquí tienes un pequeño conmutador que puedes mantener en la configuración:

import os
from openai import OpenAI

MODEL = os.getenv("GROQ_MODEL", "openai/gpt-oss-20b")

client = OpenAI(
    api_key=os.environ["GROQ_API_KEY"],
    base_url="https://api.groq.com/openai/v1",
)

def ask(prompt: str) -> str:
    response = client.chat.completions.create(
        model=MODEL,
        messages=[
            {"role": "system", "content": "Answer with practical developer steps."},
            {"role": "user", "content": prompt},
        ],
    )
    return response.choices[0].message.content

print(ask("Give me a minimal Redis rate limiter design."))

Ejecútalo con 20B:

GROQ_MODEL=openai/gpt-oss-20b python app.py

Ejecútalo con 120B:

GROQ_MODEL=openai/gpt-oss-120b python app.py

Valora las solicitudes con aciertos de caché

La caché de prompts de Groq es automática para los modelos compatibles, incluidos openai/gpt-oss-20b y openai/gpt-oss-120b. Groq dice que no se requieren cambios de código, que los aciertos de caché usan coincidencia exacta de prefijos, que las partes en caché reciben un descuento del 50 % en tokens de entrada y que los datos en caché caducan automáticamente tras 2 horas sin uso (Caché de prompts de Groq).

La regla práctica: pon primero el texto estable.

Buen orden:

1. Prompt de sistema
2. Definiciones de herramientas
3. Ejemplos few-shot
4. Documentos o esquemas compartidos
5. Entrada específica del usuario
6. Marcas de tiempo, IDs, datos por solicitud

Mal orden: poner una marca de tiempo, un ID de solicitud o un campo específico del usuario antes de un prompt compartido de 20.000 tokens. Eso rompe el prefijo.

Aquí tienes un helper de coste para GPT-OSS 120B:

def groq_gpt_oss_120b_cost(prompt_tokens, cached_tokens, completion_tokens):
    uncached_tokens = max(prompt_tokens - cached_tokens, 0)

    return (
        uncached_tokens / 1_000_000 * 0.15
        + cached_tokens / 1_000_000 * 0.075
        + completion_tokens / 1_000_000 * 0.60
    )

Y aquí tienes una llamada ejecutable que imprime el uso de caché si Groq lo devuelve:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["GROQ_API_KEY"],
    base_url="https://api.groq.com/openai/v1",
)

STATIC_POLICY = """
You are an internal code review assistant.
Always check correctness, security, performance, and migration risk.
Return JSON with keys: summary, risks, suggested_patch.
"""

def review(diff: str):
    response = client.chat.completions.create(
        model="openai/gpt-oss-120b",
        messages=[
            {"role": "system", "content": STATIC_POLICY},
            {"role": "user", "content": diff},
        ],
        response_format={"type": "json_object"},
    )

    usage = response.usage
    details = getattr(usage, "prompt_tokens_details", None)
    cached = getattr(details, "cached_tokens", 0) if details else 0

    print("prompt_tokens:", usage.prompt_tokens)
    print("cached_tokens:", cached)
    print("completion_tokens:", usage.completion_tokens)
    print("estimated_cost_usd:", groq_gpt_oss_120b_cost(
        usage.prompt_tokens,
        cached,
        usage.completion_tokens,
    ))

    return response.choices[0].message.content

La documentación de caché de Groq muestra cached_tokens bajo usage.prompt_tokens_details y define la tasa de aciertos de caché como cached_tokens / prompt_tokens × 100% (Caché de prompts de Groq). No asumas que cada segunda solicitud será más barata. Los prefijos exactos importan.

Cuenta las llamadas a herramientas por separado

Los precios por token no son toda la factura si activas herramientas integradas. La página de precios de Groq lista por separado las herramientas integradas para GPT-OSS: la búsqueda básica de Browser Search cuesta 5 $ / 1000 solicitudes, Browser Search visit website cuesta 1 $ / 1000 solicitudes y Code Execution Python cuesta 0,18 $ / hora (Precios de Groq).

Eso cambia cómo diseñas agentes. Un bot de soporte que llama a búsqueda una vez por mensaje de usuario tiene una forma de coste distinta a la de un resumidor que solo usa tokens de prompt. La caché ayuda con esquemas de herramientas repetidos, pero no hace que las llamadas a herramientas externas sean gratis.

Comprueba también la compatibilidad antes de copiar y pegar código de OpenAI. La documentación de compatibilidad de Groq con OpenAI lista campos no admitidos que pueden devolver 400, incluidos logprobs, logit_bias, top_logprobs, messages[].name y valores de n distintos de 1 (Compatibilidad de Groq con OpenAI). Groq también dice que temperature=0 se convierte a 1e-8.

Una solicitud mínima segura se ve así:

response = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    temperature=0.2,
    messages=[
        {"role": "system", "content": "Be precise. If unsure, say so."},
        {"role": "user", "content": "Explain this stack trace and suggest a fix: ..."},
    ],
)

Evita migrar toda tu app en un solo commit. Pon la configuración del proveedor detrás de variables de entorno:

LLM_BASE_URL=https://api.groq.com/openai/v1
LLM_API_KEY=$GROQ_API_KEY
LLM_MODEL=openai/gpt-oss-120b

Luego conéctalas al SDK:

client = OpenAI(
    api_key=os.environ["LLM_API_KEY"],
    base_url=os.environ["LLM_BASE_URL"],
)

response = client.chat.completions.create(
    model=os.environ["LLM_MODEL"],
    messages=[{"role": "user", "content": "Summarize this incident report."}],
)

Una vía de escape práctica multiproveedor

Si vas a integrar esto en producción, no hardcodees supuestos del proveedor por toda tu base de código. Mantén base_url, api_key y model en la configuración. Eso hace que Groq sea fácil de probar, y también vuelve aburrido el enrutamiento entre proveedores.

Para equipos que quieren un único endpoint compatible con OpenAI para Claude, GPT y Gemini, onehop es la vía sencilla: cambia la URL base a https://api.onehop.ai/v1. Es compatible con OpenAI/Anthropic, tiene precios más bajos que los proveedores first-party y las cuentas nuevas reciben 10 $ gratis sin tarjeta.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["ONEHOP_API_KEY"],
    base_url="https://api.onehop.ai/v1",
)

response = client.chat.completions.create(
    model=os.environ["ONEHOP_MODEL"],
    messages=[
        {"role": "user", "content": "Compare this API design against common REST mistakes."}
    ],
)

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

Usa Groq cuando quieras específicamente inferencia rápida de GPT-OSS y el stack de herramientas/caché de Groq. Usa onehop cuando quieras una única superficie de integración para Claude, GPT, Gemini y otros modelos alojados sin reescribir código cliente. Puedes llamar a Claude y otros modelos en onehop o registrarte para obtener 10 $ de crédito gratis.

Checklist de producción

Antes de lanzar, repasa este checklist:

• Fija el ID de modelo: openai/gpt-oss-120b para calidad, openai/gpt-oss-20b para menor coste.
• Mantén primero las secciones estables del prompt para que Groq pueda reutilizar prefijos en caché.
• Registra prompt_tokens, cached_tokens y completion_tokens en cada solicitud.
• Añade contabilidad separada para Browser Search, Visit Website y Code Execution.
• Elimina parámetros de OpenAI no admitidos antes de enrutar tráfico a Groq.
• Mantén base_url configurable para poder probar Groq, APIs first-party o onehop sin tocar la lógica de negocio.

Toda la migración puede ser una línea. La migración fiable son tres líneas más contabilidad: URL base, ID de modelo y telemetría de costes. Empieza por ahí y luego decide si la calidad de 120B merece el gasto en tokens de salida para cada ruta de tu app. Si quieres el mismo patrón de URL base para un acceso más amplio a modelos, llama a Claude y otros modelos en onehop y regístrate para obtener 10 $ de crédito gratis.