ES ▾
Obtener clave de API

uncensoredgrok.comGuía

API de Grok para desarrolladores: una opción compatible con OpenAI

Si buscabas una API de Grok para desarrolladores, aquí tienes lo que ofrece este sitio y lo que no. Es una API de texto independiente compatible con OpenAI, no el servicio de xAI, y funciona con cualquier SDK de OpenAI.

Actualizado

Ilustración isométrica de un terminal transmitiendo bloques de datos a un cubo de servidor, que representa una API de LLM para desarrolladores
uncensoredgrok.com2026-10-06

Lo que obtienes y lo que no

Seamos precisos primero, porque el nombre del sitio puede inducir a error. Esta no es la API oficial de xAI ni de Grok. Es una API alojada delante de un único modelo de pesos abiertos, ejecutada por un proveedor independiente y ajustada para responder sin rechazos de contenido para uso adulto lícito. Tampoco es un enrutador entre varios proveedores. Si necesitas los modelos propios de xAI, ve a xAI y revisa sus términos y precios actuales.

Lo que resulta útil es un flujo de trabajo de desarrollador estándar. La API usa el formato de completaciones de chat de OpenAI, por lo que las bibliotecas de cliente que ya usas siguen funcionando. Cambias dos valores, la base URL y la clave, y pasas uncensored como ID de modelo. Existen dos endpoints: POST /v1/chat/completions y GET /v1/models. La autenticación usa el encabezado estándar Authorization: Bearer.

El servicio es solo de texto. No hay generación de imágenes, audio ni video, ni embeddings ni ajuste fino. La ventana de contexto es de 100.000 tokens, contados entre prompt y respuesta juntos, y max_tokens es opcional. Hay un límite estricto de contenido: nada que implique contenido sexual con menores de edad, nunca.

Si eso coincide con lo que estás construyendo, el resto de esta página cubre los detalles que preguntan los desarrolladores: la primera petición, streaming, salida estructurada, herramientas, límites y coste.

Tu primera petición

Crea una cuenta desde la página de clave de API, copia la clave y envía una petición. El registro funciona con Google o con correo electrónico y contraseña. Los usuarios nuevos pueden reclamar $0,50 de crédito de prueba con un solo clic en esa página, uno por persona, válido durante siete días. La clave de prueba tiene límites más bajos que una clave completa: 2 peticiones simultáneas y 60 peticiones por minuto.

Empieza con curl, porque elimina cualquier otra variable:

curl https://api.uncensoredgrok.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise assistant."},
      {"role": "user", "content": "Explain idempotency keys in two sentences."}
    ]
  }'

La misma llamada con el SDK oficial de Python:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.uncensoredgrok.com/v1",
    api_key="YOUR_KEY",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Explain idempotency keys in two sentences."}],
    temperature=0.7,
)
print(resp.choices[0].message.content)

Una llamada a GET /v1/models es una forma barata de comprobar que tu clave y base URL son correctas antes de depurar cualquier otra cosa. Cada respuesta incluye los encabezados X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests y X-RateLimit-Limit-Concurrency. Registra el ID de petición con tus propios registros y vigila el encabezado de saldo si ejecutas trabajos sin supervisión.

Los parámetros de muestreo como temperature, top_p, stop, seed y las penalizaciones de frecuencia y presencia se pasan directamente al modelo. Las notas completas sobre los parámetros están en la página de documentación.

Streaming

Establece stream: true y la respuesta llega como eventos enviados por el servidor, un fragmento por grupo de tokens, con el uso reportado al final del streaming. Para una interfaz de chat, esto marca la diferencia entre una pantalla que espera y una pantalla que escribe.

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a haiku about retries."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if getattr(chunk, "usage", None):
        print("\ntokens:", chunk.usage)

En Node el patrón es el mismo:

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.uncensoredgrok.com/v1",
  apiKey: process.env.API_KEY,
});

const stream = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Write a haiku about retries." }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

Un detalle importa para la planificación de capacidad. Una petición en streaming mantiene su slot de concurrencia hasta que termina el streaming. Si un cliente abre un streaming y luego se detiene, ese slot sigue ocupado, así que cierra los streaming que ya no leas.

Modo JSON y llamadas a funciones

Para una salida estructurada, pasa response_format con el tipo json_object. También indica en el prompt que quieres JSON y nombra las claves que esperas. El modo JSON ayuda al modelo a producir texto analizable, pero aún debes validar el resultado en tu código y manejar un análisis fallido.

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply with JSON only: {\"title\": string, \"tags\": [string]}"},
        {"role": "user", "content": "Summarize: a guide to rate limiting for API clients."},
    ],
)
import json
data = json.loads(resp.choices[0].message.content)

Llamadas a funciones

Las llamadas a funciones siguen la estructura de OpenAI. Envías tools y opcionalmente tool_choice. El modelo responde con tool_calls, ejecutas la función y envías el resultado de vuelta como un mensaje con role: "tool". Las llamadas a funciones también pueden transmitirse en streaming.

import json

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up an order by id",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1042?"}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)
msg = first.choices[0].message

if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = {"order_id": args["order_id"], "status": "shipped"}
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        })
    final = client.chat.completions.create(
        model="uncensored", messages=messages, tools=tools
    )
    print(final.choices[0].message.content)

Analiza siempre la cadena de argumentos de forma defensiva. Los modelos a veces devuelven argumentos que no son JSON válido, y un try/except alrededor de json.loads con un reintento es un seguro barato.

Límites de peticiones, 429 y reintentos

Una clave completa permite 8 peticiones simultáneas y 300 peticiones por minuto. Una clave de prueba permite 2 y 60. El cuerpo máximo de la petición es de 8 MB. Cuando superas un límite, obtienes HTTP 429, y el código de error indica qué límite: rate_limited significa demasiadas peticiones por minuto, concurrency significa demasiadas a la vez. En caso de sobrecarga temporal, la API también devuelve 429 con un encabezado Retry-After: 5.

Esto te da una regla de reintento sencilla: en 429, espera Retry-After si está presente, de lo contrario retrocede exponencialmente con jitter y limita los intentos.

import time, random
from openai import OpenAI, RateLimitError

client = OpenAI(base_url="https://api.uncensoredgrok.com/v1", api_key="YOUR_KEY", max_retries=0)

def ask(messages, attempts=5):
    for i in range(attempts):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError as e:
            wait = float(e.response.headers.get("Retry-After", 2 ** i))
            time.sleep(wait + random.random())
    raise RuntimeError("still rate limited")

Si ejecutas trabajos por lotes, limita tu grupo de trabajadores a 8 con una clave completa. Ocho trabajadores que mantienen cada uno una petición es el límite, y un noveno solo te dará 429 con el código concurrency. Las peticiones fallidas o rechazadas no se cobran, por lo que reintentar no te cuesta dinero.

Hábitos que ahorran tiempo en producción

Algunas prácticas dan frutos rápidamente una vez que funciona la primera petición. Guarda la clave en una variable de entorno o en un gestor de secretos, y asigna a cada entorno su propia clave para que puedas rotar una sin tocar las demás. Registra el valor X-Request-Id junto con tu ID de seguimiento; si algo parece incorrecto en una respuesta, ese ID es lo que debes citar.

Configura un tiempo de espera en el cliente. Las generaciones largas son normales cuando permites una respuesta grande, así que elige un tiempo de espera que se ajuste a tu respuesta más larga esperada y usa streaming para cualquier cosa en la que una persona esté esperando. Limita max_tokens en las rutas visibles para el usuario aunque el parámetro sea opcional, porque un límite pone un tope tanto a la latencia como al gasto.

Mantén bajo control el historial de conversación que envías. La ventana es de 100.000 tokens, pero la entrada se cobra en cada llamada, así que recortar turnos antiguos o resumirlos es la optimización más barata que tienes. Por último, fija tus parámetros de muestreo. Establecer seed junto con una temperatura fija te da ejecuciones más repetibles cuando comparas variantes de prompt, aunque no debes tratarlo como una garantía de salida idéntica.

Lo que cuesta

La tarifa es $0,15 por cada 1M de tokens de entrada y $0,50 por cada 1M de tokens de salida, desde el crédito prepago. No hay suscripción y el crédito no caduca. Un ejemplo práctico lo hace concreto. Toma una petición con 2.000 tokens de entrada y 500 tokens de salida:

  • Entrada: 2.000 / 1.000.000 x $0,15 = $0,0003
  • Salida: 500 / 1.000.000 x $0,50 = $0,00025
  • Total: $0,00055 por petición, así que 1.000 peticiones de este tamaño cuestan $0,55.

Por tanto, el crédito de prueba de $0,50 cubre aproximadamente 900 peticiones de ese tamaño. Las recargas van de $20 a $500 en cualquier cantidad entera, con un bono del 5% a partir de $50, 10% a partir de $100 y 15% a partir de $200. Una recarga de $100, por ejemplo, acredita $110. El pago es solo con cripto en este sitio: USDT en TRC20 o USDC en Base. La página de precios tiene la tabla actual.

Los prompts no se usan para entrenamiento. Si estás sopesando esto frente a otro endpoint, el artículo existente sobre pago por token y la ventana de contexto de 100k cubre cómo se comporta la medición en conversaciones largas.

Cuando otra opción encaja mejor

Sé honesto sobre la adecuación. Si necesitas generación de imágenes, embeddings, voz o un modelo ajustado, esta API no los ofrece. Si tu equipo de contratos o cumplimiento requiere un proveedor de primera parte, usa ese proveedor. Si necesitas una identidad de modelo garantizada de un laboratorio específico, este no es el producto adecuado, ya que ejecuta un único modelo de pesos abiertos de un proveedor independiente.

Donde sí encaja es en una aplicación que ya habla el protocolo de OpenAI y necesita un modelo de texto que responda peticiones adultas lícitas sin rechazarlas: herramientas de escritura, aplicaciones de roleplay y compañía para adultos, etiquetado de datos que toca temas difíciles, y kits de prueba. Apunta tu cliente existente a la nueva base URL y compara la salida con tus propios prompts antes de comprometer el crédito.

Preguntas y respuestas

uncensoredgrok.comPreguntas y respuestas
¿Es esta la API oficial de Grok?

No. Es una API independiente compatible con OpenAI detrás de un único modelo de pesos abiertos. No la gestiona xAI ni es un enrutador entre proveedores.

¿Qué ID de modelo uso?

Usa uncensored como valor del modelo en cada petición. Una petición GET a /v1/models muestra qué puede ver la clave.

¿Admite streaming y llamadas a funciones?

Sí. El streaming funciona mediante SSE con stream: true, y las llamadas a funciones admiten tools, tool_choice y tool_calls en streaming, con los resultados enviados como mensajes de role tool.

¿Cómo pago?

En este sitio recargas solo con cripto, USDT en TRC20 o USDC en Base, en cualquier cantidad entera de $20 a $500.

¿Cuáles son los límites de velocidad?

Una clave completa admite 8 peticiones simultáneas y 300 peticiones por minuto. Una clave de prueba admite 2 y 60. Al superar un límite, recibirás HTTP 429.

uncensoredgrok.com2026-10-06

Tu clave está a un formulario de distancia

Crea una cuenta, copia la clave, cambia la base URL. Esa es toda la configuración.

Obtener clave de API