DEV Community: Roobia

Gemini 3.7 Flash Precios Explicados: Asegura tus Tarifas Antes de que se Dupliquen

Roobia — Fri, 14 Aug 2026 07:58:21 +0000

Google lanzó Gemini 3.7 Flash el 13 de agosto de 2026, tres semanas después de 3.6 Flash, y lo presenta como “nuestro modelo de caballo de batalla más inteligente”. Para presupuestar una API, el dato clave no está en los benchmarks: la tarifa introductoria de $0.75 por millón de tokens de entrada y $3.75 por millón de tokens de salida vence el 31 de diciembre de 2026. Desde el 1 de enero de 2027, ambas tarifas se duplican.

Prueba Apidog hoy

Esto duplica el coste de cualquier carga de trabajo que permanezca en el modelo. Un chatbot que cuesta $790 al mes hoy costará $1,575 en enero, aunque no cambien su código, tráfico ni prompts. Planifique los dos niveles de precio desde el inicio.

Esta guía muestra cómo calcular costes para cargas reales, controlar tokens por endpoint y reducir gasto antes del cambio de tarifa. Si todavía no ha enviado su primera solicitud, consulte la guía de inicio rápido de la API de Gemini 3.7 Flash. Una vez que haga llamadas, Apidog permite inspeccionar los recuentos de usageMetadata en cada respuesta para validar las estimaciones con tráfico real.

En resumen

Tarifa introductoria: $0.75 por 1M de tokens de entrada y $3.75 por 1M de tokens de salida, hasta el 31 de diciembre de 2026.
Tarifa estándar: desde el 1 de enero de 2027, $1.50 de entrada y $7.50 de salida. Exactamente el doble.
El precio introductorio es la mitad de lo que costó Gemini 3.6 Flash en su lanzamiento.
El modelo acepta texto, imagen, vídeo, audio y PDF, con contexto de 1M de tokens y un máximo de salida de 64k tokens.
Un chatbot con 10,000 solicitudes diarias cuesta aproximadamente $26.25/día con tarifa introductoria y $52.50/día con tarifa estándar.
Las principales palancas de ahorro son: limitar salida, caché de contexto, lotes y enrutamiento a modelos más pequeños.

Los dos niveles de precios

Gemini 3.7 Flash se lanzó con un descuento temporal, no con un precio permanente.

Nivel	Ventana	Entrada por 1M de tokens	Salida por 1M de tokens
Introductorio	13 de agosto de 2026 al 31 de diciembre de 2026	$0.75	$3.75
Estándar	Desde el 1 de enero de 2027	$1.50	$7.50

Hay dos implicaciones prácticas:

La tarifa introductoria es la mitad del precio de lanzamiento de Gemini 3.6 Flash. Si evalúa actualizar desde 3.6, use la guía de migración de 3.6 a 3.7 Flash para planificar pruebas de regresión.
Los tokens de salida cuestan 5 veces más que los tokens de entrada. Reducir una respuesta demasiado larga suele generar más ahorro que recortar un prompt de sistema.

Estas tarifas corresponden a la API de Gemini facturada mediante una clave de AI Studio. Vertex AI usa la facturación de Google Cloud y sus propias SKU. Además, el caché de contexto y el procesamiento por lotes tienen cargos específicos. Confirme los importes vigentes en la página oficial de precios antes de cerrar un presupuesto.

Cómo calcular el coste de una carga real

Use esta fórmula para cada endpoint:

coste_diario =
  (tokens_entrada_diarios / 1_000_000 × precio_entrada)
  +
  (tokens_salida_diarios / 1_000_000 × precio_salida)

Después, multiplique el resultado por los días de operación del mes.

Carga de trabajo 1: chatbot de soporte

Suposiciones:

10,000 solicitudes al día.
2,000 tokens de entrada por solicitud.
300 tokens de salida por solicitud.

Elemento	Tokens diarios	Coste introductorio/día	Coste estándar/día
Entrada	20M	$15.00	$30.00
Salida	3M	$11.25	$22.50
Total	23M	$26.25	$52.50

En un mes de 30 días:

Tarifa introductoria: aproximadamente $788/mes.
Tarifa estándar: aproximadamente $1,575/mes.

La implementación más útil aquí es definir un límite de salida específico para el endpoint de soporte:

{
  "generationConfig": {
    "maxOutputTokens": 500
  }
}

Una respuesta de soporte rara vez requiere decenas de miles de tokens. Dejar el máximo en 64k aumenta innecesariamente el riesgo de una generación costosa.

Carga de trabajo 2: pipeline de documentos PDF

Gemini 3.7 Flash procesa PDFs de forma nativa. Su benchmark GDP.pdf subió del 22.0% al 34.0% respecto a 3.6 Flash, por lo que la extracción documental es una carga prevista para este modelo.

Suposiciones:

500 documentos al día.
40,000 tokens de entrada por documento.
1,000 tokens de salida por resumen estructurado.

Elemento	Tokens diarios	Coste introductorio/día	Coste estándar/día
Entrada	20M	$15.00	$30.00
Salida	0.5M	$1.88	$3.75
Total	20.5M	$16.88	$33.75

Resultado mensual aproximado:

Ahora: $506/mes.
Desde enero: $1,013/mes.

En este perfil domina la entrada, porque los documentos son largos y los resúmenes son cortos. Priorice caché de contexto si reenvía instrucciones o documentos de referencia estáticos, y procese por lotes los trabajos no interactivos.

Carga de trabajo 3: bucle de agente

Los agentes multiplican llamadas y contexto. Suposiciones:

200 tareas al día.
12 llamadas al modelo por tarea.
8,000 tokens de entrada por llamada.
400 tokens de salida por llamada.

Elemento	Tokens diarios	Coste introductorio/día	Coste estándar/día
Entrada	19.2M	$14.40	$28.80
Salida	0.96M	$3.60	$7.20
Total	20.16M	$18.00	$36.00

Resultado mensual aproximado:

Tarifa introductoria: $540/mes.
Tarifa estándar: $1,080/mes.

En un agente, vigile dos métricas por separado:

coste_por_tarea = llamadas_por_tarea × coste_medio_por_llamada
tokens_de_contexto = tokens_prompt + historial + resultados_de_herramientas

Si una tarea pasa de 12 a 20 llamadas, su coste sube aproximadamente un 67%, incluso si el precio por token no cambia.

El límite de salida de 64k fija un peor caso por llamada de aproximadamente $0.24 con tarifa introductoria y $0.48 con tarifa estándar. No es ilimitado, pero un bucle de reintentos que alcance ese máximo repetidamente puede encarecerse rápido.

Cómo se compara el precio de 3.7 Flash

Las comparaciones entre proveedores cambian con frecuencia, así que use estos datos como posicionamiento, no como una tabla permanente de precios.

Gemini 3.7 Flash ocupa el nivel de “caballo de batalla”: es más barato que modelos de vanguardia como Gemini Pro, los modelos grandes de Claude o el nivel insignia de OpenAI, mientras ofrece benchmarks como 65.3% en DeepSWE v1.1 y un Elo de 1588 en WebDev Arena.

La tesis de Google es que gran parte del tráfico de producción no necesita un modelo de máxima capacidad. El descuento introductorio ofrece cuatro meses para validar esa hipótesis en sus propias rutas, prompts y cargas.

El contexto competitivo también importa. Los proveedores económicos pueden cambiar sus tarifas; DeepSeek, por ejemplo, aumentó sus precios de API. Consulte la guía de aumento de precios y optimización de costes de DeepSeek para un caso similar.

La diferencia entre un prototipo y una carga sostenida es importante:

Un experimento que pasa de $3 a $6 apenas afecta al presupuesto.
Una pipeline que pasa de $10,000 a $20,000 mensuales requiere planificación financiera antes del cambio.

Cinco formas de reducir el gasto en tokens

1. Limite la salida por endpoint

Configure maxOutputTokens según el caso de uso:

{
  "generationConfig": {
    "maxOutputTokens": 500
  }
}

Ejemplos prácticos:

Chat de soporte: 300–500 tokens.
Clasificación: 50–150 tokens.
Resumen estructurado: defina un límite alineado con el esquema.
Agentes: aplique límites por paso, no solo por tarea completa.

Este cambio tiene alto impacto porque los tokens de salida cuestan 5 veces más que los de entrada.

2. Almacene en caché el contexto estático

Si cada solicitud incluye el mismo prompt de sistema, documentación de políticas o instrucciones de formato, no reenvíe ese contenido a precio completo miles de veces.

Por ejemplo, si su chatbot tiene 1,500 tokens estáticos en cada petición:

10,000 solicitudes/día × 1,500 tokens = 15M tokens estáticos/día

El caché de contexto puede reducir ese coste repetido. Revise la documentación de la API de Gemini para confirmar la configuración y tarifas actuales.

3. Use lotes para trabajo no interactivo

La extracción de documentos, resúmenes nocturnos y enriquecimiento de datos no necesitan respuestas en tiempo real.

Flujo recomendado:

Almacene los documentos pendientes.
Agrúpelos en trabajos por lote.
Ejecute el procesamiento fuera de horas pico.
Registre tokens y resultados por documento.
Reintente solo los elementos fallidos.

El procesamiento por lotes intercambia latencia por una tarifa reducida cuando el caso de uso lo permite.

4. Enrute por complejidad

No todas las solicitudes necesitan Gemini 3.7 Flash. Use modelos más ligeros para:

Clasificación.
Enrutamiento.
Extracción corta.
Validación de formatos.
Transformaciones simples.

Reserve 3.7 Flash para tareas que realmente usan su capacidad: planificación de varios pasos, depuración compleja y cadenas de llamadas a herramientas.

5. Prototype con el nivel gratuito

Use la cuota gratuita de AI Studio para fijar:

Prompts.
Esquemas de respuesta.
Límites de salida.
Casos de error.
Cargas representativas.

La guía de acceso gratuito e ilimitado a la API de Gemini explica el alcance de la ruta gratuita y sus límites.

Rastree el gasto por endpoint con Apidog

Las estimaciones sirven para presupuestar; los datos por solicitud permiten mantener el gasto bajo control.

Cada respuesta de Gemini incluye usageMetadata, con recuentos de tokens de prompt y salida. Puede convertir esos valores en una señal de coste dentro de sus pruebas de API.

En Apidog, implemente este flujo:

Guarde una solicitud por endpoint de producción: chat, resumen de documento y paso de agente.
Vincule la clave a una variable de entorno llamada GEMINI_API_KEY.
Cree escenarios con cargas útiles representativas.
Extraiga usageMetadata.promptTokenCount y usageMetadata.candidatesTokenCount.
Añada aserciones de presupuesto de tokens.
Ejecute esos escenarios en cada cambio de prompt, esquema o lógica de herramientas.

Ejemplo de umbrales que puede aplicar:

chat:
  promptTokenCount <= 2500
  candidatesTokenCount <= 500

resumen_pdf:
  promptTokenCount <= 45000
  candidatesTokenCount <= 1200

Si una modificación del prompt lleva el endpoint de chat de 2,000 a más de 2,500 tokens de entrada, el escenario puede fallar antes del despliegue. Así detecta una regresión de coste antes de que se convierta en una factura.

Multiplique los tokens observados por la tarifa actual:

coste_entrada = promptTokenCount / 1_000_000 × precio_entrada
coste_salida = candidatesTokenCount / 1_000_000 × precio_salida
coste_total = coste_entrada + coste_salida

La guía de pruebas de API para ingenieros de QA muestra cómo estructurar escenarios con aserciones en un servicio completo.

Preguntas frecuentes

¿Cuándo se duplica el precio de Gemini 3.7 Flash?

El 1 de enero de 2027. La tarifa introductoria de $0.75 por 1M de tokens de entrada y $3.75 por 1M de tokens de salida estará vigente hasta el 31 de diciembre de 2026. Después pasará a $1.50 y $7.50.

¿Es Gemini 3.7 Flash más barato que Gemini 3.6 Flash?

En su lanzamiento, sí. El precio introductorio de 3.7 Flash es la mitad del precio de lanzamiento de 3.6 Flash, mientras que DeepSWE v1.1 pasó de 49.0% a 65.3%. Consulte la referencia rápida de Gemini 3.7 Flash para comparar especificaciones y benchmarks.

¿Se aplica el precio introductorio en Vertex AI?

Las tarifas de esta guía corresponden a la API de Gemini facturada mediante una clave de AI Studio. Vertex AI usa la facturación de Google Cloud, sus propias SKU y términos empresariales. Verifique los precios en su consola de GCP y en la página oficial de precios.

¿Qué cuenta como token de entrada?

Todo lo que envía: texto, imágenes, vídeo, audio y páginas PDF se convierten en tokens y se facturan como entrada. Los documentos largos y las peticiones con mucho contenido multimedia suelen ser los principales generadores de costes inesperados.

Después de cada llamada, revise usageMetadata para obtener el recuento real.

¿Cómo estimo tokens antes de enviar una solicitud?

Use el endpoint countTokens para medir una carga útil sin generar una respuesta, o envíe un conjunto de solicitudes representativas y lea usageMetadata.

Mida siempre con contenido real. Las estimaciones basadas en tokenizadores de otros proveedores no se trasladan necesariamente entre familias de modelos.

Dónde encaja 3.7 Flash en su pila

Gemini 3.7 Flash tiene un descuento introductorio con una fecha de finalización conocida. La estrategia práctica es:

Mueva al modelo el tráfico de “caballo de batalla” que sea adecuado.
Mida tokens reales por endpoint.
Añada límites de salida y presupuestos de tokens.
Identifique rutas que pueden usar un modelo más ligero.
Calcule la factura con tarifa estándar antes de enero de 2027.

La medición necesita herramientas. Descargue Apidog para centralizar solicitudes de Gemini, entornos, aserciones de tokens y verificaciones de costes, y convertir la factura de enero en una cifra prevista.

¿Qué hay de nuevo en Gemini 3.7 Flash? Características, Benchmarks y Acceso a la API

Roobia — Fri, 14 Aug 2026 07:56:39 +0000

Gemini 3.7 Flash es el modelo de IA de uso general más reciente de Google, lanzado el 13 de agosto de 2026, tres semanas después de Gemini 3.6 Flash. Mantiene una ventana de contexto de 1M de tokens y entrada multimodal, pero mejora de forma notable en benchmarks de codificación y agentes. Su precio introductorio para la API es de $0.75 por 1M de tokens de entrada.

Prueba Apidog hoy

La cadencia de lanzamiento importa: mientras Gemini 3.5 Pro sigue retrasado, Google está entregando mejoras primero en Flash. DeepSWE sube 16.3 puntos, AutomationBench pasa de 17.0% a 30.4% y el precio inicial es la mitad del precio de lanzamiento de Gemini 3.6 Flash.

En este artículo verás qué cambió, cómo estimar costos, dónde usar el modelo y cómo hacer una primera llamada con curl. Para profundizar en el endpoint, consulta el inicio rápido de la API de Gemini 3.7 Flash. También puedes usar Apidog para comparar respuestas con tus prompts actuales antes de migrar.

En resumen

Gemini 3.7 Flash se lanzó el 13 de agosto de 2026. ID del modelo: gemini-3.7-flash.
DeepSWE v1.1 sube de 49.0% a 65.3%; AutomationBench, de 17.0% a 30.4%; WebDev Arena, de 1538 a 1588 Elo.
El precio introductorio es de $0.75 por 1M de tokens de entrada y $3.75 por 1M de tokens de salida.
Las tarifas estándar, $1.50 / $7.50, entran en vigor el 1 de enero de 2027.
Conserva contexto de 1M de tokens, salida de hasta 64k tokens, entrada multimodal, llamada a funciones, búsqueda como herramienta y uso de computadora.
Está disponible en la API de Gemini, AI Studio, Gemini, Gemini Spark, Google Antigravity, Android Studio y Gemini Enterprise, en más de 160 países.

Qué es Gemini 3.7 Flash

Flash es el nivel medio de Gemini: más económico y rápido que Pro, y más capaz que Flash-Lite para cargas de trabajo de alto volumen. Gemini 3.7 Flash es el tercer lanzamiento Flash de la línea 3.x.

El anuncio oficial lo posiciona principalmente para codificación y agentes, no solo para chat.

La especificación base se mantiene respecto a Gemini 3.6 Flash:

Contexto: 1M de tokens de entrada y hasta 64k tokens de salida.
Entrada multimodal: texto, imagen, video, audio y PDF.
Salida: texto.
Herramientas: llamada a funciones, búsqueda como herramienta y uso de computadora.
Seguridad: incluye salvaguardas CBRN y cibernéticas actualizadas.

El cambio está en el comportamiento. Google afirma mejores resultados al depurar, generar código desplegable, adaptarse a fallos de herramientas, pedir aclaraciones y seguir restricciones de formato.

Mejoras en benchmarks: Gemini 3.6 vs. 3.7 Flash

Benchmark	Gemini 3.6 Flash	Gemini 3.7 Flash	Cambio
DeepSWE v1.1 (codificación agéntica)	49.0%	65.3%	+16.3 pts
FrontierCode 1.1 Main	34.4%	43.6%	+9.2 pts
WebDev Arena (Elo)	1538	1588	+50 Elo
GDP.pdf (razonamiento documental)	22.0%	34.0%	+12.0 pts
AutomationBench (tareas de agente)	17.0%	30.4%	+13.4 pts

También obtiene:

90.7% en Harvey LAB-AA, un benchmark de razonamiento legal.
97.0% en recuperación de contexto largo 128k-needle.

Los mayores incrementos aparecen en tareas de varios pasos. Esto es especialmente relevante si ejecutas agentes que deben inspeccionar archivos, usar herramientas, corregir errores o recuperar información desde documentos extensos.

La cobertura del lanzamiento destaca DeepSWE como el salto principal. Para comparar cómo estas diferencias de benchmarks se trasladan a cargas de trabajo reales entre modelos, consulta esta comparación de Grok 4.6 vs GPT 5.6 vs Claude.

Qué probar en codificación y agentes

No migres solo por un benchmark. Ejecuta pruebas con tareas representativas de tu aplicación.

Prioriza estos casos:

Depuración multiarchivo

Pasa un error, el stack trace y los archivos implicados. Evalúa si el modelo identifica la causa raíz en vez de proponer un parche superficial.
Generación de código ejecutable

Pide una función con tests, validación de entradas y manejo de errores. Verifica si pasa CI sin una segunda iteración.
Recuperación ante fallos de herramientas

Simula respuestas fallidas de una función o una API. Comprueba si el agente reintenta con parámetros distintos, solicita contexto o entra en bucle.
Seguimiento de restricciones

Añade límites explícitos: formato JSON, longitud máxima, dependencias permitidas y operaciones prohibidas.
Prompts ambiguos

Evalúa si pregunta antes de asumir requisitos críticos.

Las capacidades de llamada a funciones, búsqueda como herramienta y uso de computadora se mantienen desde Gemini 3.6 Flash. Para flujos automatizados, prioriza APIs estructuradas cuando existan: son más rápidas y deterministas que controlar un navegador. El análisis de uso de computadora frente a APIs estructuradas explica cuándo usar cada enfoque.

Precios: tarifa introductoria hasta el 31 de diciembre de 2026

Período	Entrada por 1M de tokens	Salida por 1M de tokens
Hasta el 31 de diciembre de 2026	$0.75	$3.75
Desde el 1 de enero de 2027	$1.50	$7.50

La tarifa introductoria reduce a la mitad el precio de lanzamiento de Gemini 3.6 Flash. Sin embargo, el costo se duplica el 1 de enero de 2027.

Recomendación para presupuestar

Usa la tarifa estándar para proyectar costos a largo plazo:

costo_entrada = tokens_entrada / 1_000_000 * 1.50
costo_salida  = tokens_salida / 1_000_000 * 7.50
costo_total   = costo_entrada + costo_salida

Verifica siempre las tarifas actuales en la página oficial de precios antes de desplegar. Para ejemplos de cálculo en chatbots, pipelines de documentos y agentes, consulta el análisis de precios de Gemini 3.7 Flash.

Dónde puedes usarlo hoy

Gemini 3.7 Flash está disponible en más de 160 países mediante:

API de Gemini: usa una clave de AI Studio y el modelo gemini-3.7-flash.
Google AI Studio: prueba prompts desde el navegador.
Aplicación Gemini: interfaz de chat para consumidores.
Gemini Spark: para suscriptores de AI Pro y Ultra.
Google Antigravity: entorno de desarrollo agéntico.
Android Studio: asistencia de código integrada.
Gemini Enterprise: opción gestionada para organizaciones.

Para cargas empresariales, Vertex AI usa aiplatform.googleapis.com con OAuth, IAM y registro de auditoría. El modelo y el esquema de solicitud son los mismos; cambian la autenticación y las garantías operativas.

Por qué Google lanzó Flash antes que Gemini 3.5 Pro

El orden es inusual: Gemini 3.6 Flash llegó a finales de julio, Gemini 3.7 Flash tres semanas después y Gemini 3.5 Pro sigue sin fecha.

Según Axios, Google está lanzando deliberadamente actualizaciones de Flash antes de su próximo modelo insignia. Para equipos de producto, esto cambia la prioridad de evaluación: Flash ya no debe considerarse automáticamente la opción rezagada frente a Pro.

Si actualmente usas Gemini 3.6 Flash, la migración normalmente comienza con un cambio de ID de modelo y una pasada de regresión:

- gemini-3.6-flash
+ gemini-3.7-flash

La guía de migración de Gemini 3.6 a 3.7 Flash detalla el proceso.

Cómo probar la API en cinco minutos

Primero, crea una clave en Google AI Studio.

Después, expórtala como variable de entorno:

export GEMINI_API_KEY="AIza..."

Envía una solicitud a generateContent:

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.7-flash:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "parts": [{
        "text": "Review this function for bugs: def dedupe(items): return list(set(items))"
      }]
    }],
    "generationConfig": {
      "temperature": 0.4,
      "maxOutputTokens": 1024
    }
  }'

La respuesta incluye:

candidates: respuestas generadas.
content.parts: texto de la respuesta.
usageMetadata: número de tokens de entrada y salida.

Registra usageMetadata desde el inicio. Es la fuente de datos para medir costos reales y detectar prompts que consumen más tokens de lo previsto.

Para recibir resultados en streaming, reemplaza el endpoint:

:generateContent

por:

:streamGenerateContent?alt=sse

La API devolverá eventos SSE.

Comparar Gemini 3.6 Flash y 3.7 Flash

Una forma práctica de validar la migración es ejecutar exactamente los mismos prompts contra ambos modelos.

En Apidog:

Importa la especificación de la API de Gemini.
Guarda GEMINI_API_KEY como variable de entorno.
Usa una variable para el ID del modelo.
Ejecuta la misma colección con gemini-3.6-flash y gemini-3.7-flash.
Compara salida, latencia y usageMetadata.
Guarda respuestas esperadas como ejemplos para futuras pruebas de regresión.

Esto permite validar el seguimiento de instrucciones con tus propios prompts, en lugar de depender únicamente de benchmarks públicos.

Preguntas frecuentes

¿Es Gemini 3.7 Flash de uso gratuito?

La API de Gemini incluye un nivel gratuito a través de AI Studio con cuota diaria para prototipos. El uso de pago parte de $0.75 por 1M de tokens de entrada hasta el 31 de diciembre de 2026.

La guía de acceso gratuito a la API de Gemini cubre los límites y cómo trabajar dentro de ellos.

¿Cuál es la diferencia entre Gemini 3.6 Flash y 3.7 Flash?

Las especificaciones principales no cambian: mismo contexto, límite de salida, modalidades y herramientas. La diferencia está en el rendimiento:

DeepSWE: +16.3 puntos.
AutomationBench: +13.4 puntos.
WebDev Arena: +50 Elo.
Mejor depuración, seguimiento de instrucciones y planificación de varios pasos, según Google.

¿Gemini 3.7 Flash reemplaza a Gemini 3.5 Pro?

No. Pro sigue siendo el nivel insignia para las tareas de razonamiento más complejas. Gemini 3.7 Flash está orientado a producción de alto volumen, donde costo, latencia y calidad deben equilibrarse.

¿Qué ocurre con los precios el 1 de enero de 2027?

Finaliza la tarifa introductoria. Los precios pasan a $1.50 por 1M de tokens de entrada y $7.50 por 1M de tokens de salida.

¿Puede Gemini 3.7 Flash procesar imágenes y PDFs?

Sí. Admite texto, imágenes, video, audio y PDF en el array contents. La salida es texto. Google reporta una mejora en GDP.pdf, de 22.0% a 34.0%, para razonamiento documental.

Dónde encaja Gemini 3.7 Flash en tu pila

Gemini 3.7 Flash combina benchmarks de agentes más altos con compatibilidad práctica con Gemini 3.6 Flash y una tarifa introductoria reducida.

La ruta recomendada es simple:

Ejecuta tu suite de prompts contra gemini-3.7-flash.
Compara calidad, latencia y uso de tokens con tu modelo actual.
Prueba flujos de herramientas, recuperación ante fallos y tareas multiarchivo.
Proyecta costos usando la tarifa estándar de 2027.
Migra solo los casos donde la mejora sea medible.

Puedes descargar Apidog para centralizar esta comparación: guarda respuestas de Gemini 3.6 Flash como ejemplos, reproduce las mismas solicitudes con Gemini 3.7 Flash y valida los resultados con tu carga de trabajo real.

¿Cómo usar la API de Gemini 3.7 Flash?

Roobia — Fri, 14 Aug 2026 07:56:03 +0000

Google lanzó Gemini 3.7 Flash el 13 de agosto de 2026, tres semanas después de 3.6 Flash, y lo presenta como “nuestro modelo de caballo de batalla más inteligente”. Para desarrolladores, los puntos clave son: las puntuaciones de codificación agéntica aumentaron notablemente —DeepSWE v1.1 pasó de 49.0% a 65.3%—, el precio de introducción es la mitad del precio de lanzamiento de 3.6 Flash y la superficie de la API no cambió. Si ya consume Gemini, solo debe cambiar el ID del modelo. Si aún no lo usa, este es un punto de entrada económico para un modelo de esta capacidad.

Prueba Apidog hoy

Esta guía muestra cómo obtener una clave de API, hacer una primera llamada con cURL, migrarla a Python y Node.js, transmitir respuestas, ajustar generationConfig y probar prompts en Apidog antes de integrarlos en su aplicación. Según el anuncio oficial, el modelo ofrece 1 millón de tokens de contexto, 64k tokens de salida, entrada multimodal, llamada a funciones, búsqueda como herramienta y uso de computadora.

Si construyó con la generación anterior, la forma de la solicitud se mantiene desde nuestra guía de la API de vista previa de Gemini 3 Flash. Este artículo se centra en el flujo de trabajo de 3.7.

En resumen

ID del modelo: gemini-3.7-flash
Endpoint síncrono:

  POST https://generativelanguage.googleapis.com/v1beta/models/gemini-3.7-flash:generateContent

Autenticación: encabezado x-goog-api-key: <KEY>.
Precio de introducción: $0.75 por 1 millón de tokens de entrada y $3.75 por 1 millón de tokens de salida hasta el 31 de diciembre de 2026. Desde el 1 de enero de 2027, las tarifas pasan a $1.50 y $7.50.
Límites: 1 millón de tokens de entrada y 64k tokens de salida.
Entrada: texto, imagen, video, audio y PDF.
Salida: texto.
Streaming: use :streamGenerateContent?alt=sse.
Pruebas: valide las solicitudes en Apidog antes de escribir código de aplicación.

Para qué sirve Gemini 3.7 Flash

Los modelos Flash equilibran capacidad, velocidad y precio. Gemini 3.7 Flash reduce ese compromiso respecto a 3.6 Flash:

DeepSWE v1.1: 49.0% → 65.3%
FrontierCode 1.1 Main: 34.4% → 43.6%
AutomationBench: 17.0% → 30.4%
WebDev Arena Elo: 1538 → 1588

Use 3.7 Flash especialmente cuando:

Ejecute bucles de agentes: AutomationBench casi duplicó su puntuación. Es adecuado para flujos de varios pasos y llamadas frecuentes a herramientas.
Genere o depure código: las mejoras en DeepSWE y FrontierCode apuntan a mejores resultados en corrección de errores y generación de código desplegable.
Procese documentos: GDP.pdf pasó de 22.0% a 34.0%, y PDF es un tipo de entrada de primera clase.
Necesite multimodalidad con presupuesto limitado: texto, imágenes, video, audio y PDF usan el mismo array contents.

Para más detalles sobre capacidades, puntuaciones y salvaguardas, consulte novedades de Gemini 3.7 Flash. Como contexto, Gemini 3.5 Pro sigue retrasado y Axios informa que Google está enviando actualizaciones de Flash antes de su próximo modelo insignia.

Obtener una clave de API

Tiene dos rutas.

AI Studio: ruta rápida

Abra aistudio.google.com/apikey.
Haga clic en Obtener clave de API.
Seleccione un proyecto de Google Cloud.
Copie la clave generada.

La clave funciona con generativelanguage.googleapis.com. Gemini 3.7 Flash está disponible en más de 160 países.

Vertex AI: ruta de producción

Si su infraestructura está en GCP, use Vertex AI:

Autenticación mediante OAuth, cuentas de servicio o tokens de corta duración.
Endpoint bajo aiplatform.googleapis.com.
IAM, registros de auditoría y endpoints regionales.
Mismo ID de modelo y mismo cuerpo de solicitud; cambian la URL y el mecanismo de autenticación.

Use AI Studio para prototipos y migre a Vertex antes de enviar tráfico de producción.

Exporte la clave como variable de entorno:

export GEMINI_API_KEY="AIza..."

No codifique la clave en el repositorio ni la envíe como ?key= en producción. Las cadenas de consulta pueden quedar registradas en logs de servidores y proxies.

Endpoint y autenticación

Para una solicitud síncrona:

POST https://generativelanguage.googleapis.com/v1beta/models/gemini-3.7-flash:generateContent

Para streaming mediante Server-Sent Events:

POST https://generativelanguage.googleapis.com/v1beta/models/gemini-3.7-flash:streamGenerateContent?alt=sse

Envíe la clave en el encabezado:

x-goog-api-key: $GEMINI_API_KEY

Primera solicitud con cURL

Pruebe primero una solicitud simple antes de integrar un SDK:

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.7-flash:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [{
        "text": "Revisa este SQL en busca de riesgo de inyección: SELECT * FROM orders WHERE id = ${orderId}"
      }]
    }],
    "generationConfig": {
      "temperature": 0.3,
      "maxOutputTokens": 1024
    }
  }'

La respuesta contiene:

candidates: candidatos generados.
candidates[].content.parts: texto o llamadas a funciones.
candidates[].finishReason: motivo de finalización.
usageMetadata: consumo de tokens.

Revise usageMetadata en cada llamada. Los tokens de salida cuestan cinco veces más que los tokens de entrada durante la tarifa introductoria.

Gemini usa contents, role y parts; no usa el formato messages de OpenAI. Si migra desde otro proveedor, adapte ese esquema antes de depurar prompts.

Inicio rápido con Python

Instale o actualice el SDK:

pip install --upgrade google-generativeai

Cree una llamada con instrucción de sistema y configuración de generación:

import os
import google.generativeai as genai

genai.configure(api_key=os.environ["GEMINI_API_KEY"])

model = genai.GenerativeModel(
    model_name="gemini-3.7-flash",
    system_instruction=(
        "Eres un revisor de código. "
        "Marca los problemas como bloqueantes o no bloqueantes."
    ),
    generation_config={
        "temperature": 0.3,
        "max_output_tokens": 2048,
    },
)

response = model.generate_content(
    "Revisa esta ruta de Flask en busca de problemas de seguridad:\n\n"
    "@app.route('/user/<id>')\n"
    "def get_user(id):\n"
    "    return db.execute(f'SELECT * FROM users WHERE id = {id}')"
)

print(response.text)
print("tokens de entrada:", response.usage_metadata.prompt_token_count)
print("tokens de salida:", response.usage_metadata.candidates_token_count)

Enviar un PDF

La entrada multimodal usa el mismo array de contenido. Para enviar un PDF, súbalo mediante la API de Archivos y páselo como parte de la solicitud:

invoice = genai.upload_file("q3-invoice.pdf")

response = model.generate_content([
    invoice,
    "Extrae el número de factura, el total y la fecha de vencimiento como JSON.",
])

print(response.text)

Este patrón es útil para extracción estructurada de documentos complejos.

Inicio rápido con Node.js

Instale el SDK:

npm install @google/generative-ai

Use un esquema de respuesta para obtener JSON analizable:

import { GoogleGenerativeAI } from "@google/generative-ai";

const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

const model = genAI.getGenerativeModel({
  model: "gemini-3.7-flash",
  generationConfig: {
    temperature: 0.3,
    maxOutputTokens: 2048,
    responseMimeType: "application/json",
    responseSchema: {
      type: "object",
      properties: {
        severity: {
          type: "string",
          enum: ["blocking", "non-blocking"],
        },
        issues: {
          type: "array",
          items: { type: "string" },
        },
      },
      required: ["severity", "issues"],
    },
  },
});

const result = await model.generateContent(
  "Revisa este manejador de Express: " +
  "app.get('/search', (req, res) => res.send(eval(req.query.q)))"
);

console.log(JSON.parse(result.response.text()));

responseSchema solo funciona junto con:

responseMimeType: "application/json"

Use ambos para evitar que el código posterior tenga que procesar texto libre.

Streaming

Para interfaces de chat o respuestas visibles para el usuario, active streaming.

Python

stream = model.generate_content(
    "Explica el problema de consulta N+1 con un ejemplo ORM concreto.",
    stream=True,
)

for chunk in stream:
    if chunk.text:
        print(chunk.text, end="", flush=True)

flush=True permite imprimir cada fragmento inmediatamente.

HTTP con SSE

Use:

:streamGenerateContent?alt=sse

Cada línea data: contiene una carga parcial de candidates. El fragmento final incluye usageMetadata, por lo que el conteo de tokens solo es definitivo cuando termina la transmisión.

Ajustar `generationConfig`

Parámetro	Tipo	Uso práctico
`maxOutputTokens`	entero	Limita la salida hasta el máximo de 64k. Es la principal palanca de coste.
`temperature`	número	De 0 a 2. Use `0.2` a `0.4` para código y extracción; `0.7+` para contenido creativo.
`responseMimeType`	cadena	Use `application/json` para solicitar JSON.
`responseSchema`	objeto	Impone una estructura de salida junto con MIME JSON.
`topP`	número	Corte de muestreo de núcleo. Mantenga el valor predeterminado salvo que ajuste deliberadamente el muestreo.
`stopSequences`	array	Detiene la generación al encontrar delimitadores definidos.

No use 64k tokens de salida como valor predeterminado. Ajuste maxOutputTokens al tamaño real que necesita su caso de uso.

Para ejemplos de costes por carga de trabajo, consulte el desglose de precios de Gemini 3.7 Flash.

Además de generationConfig, el cuerpo admite:

tools
Declaraciones de funciones
Búsqueda como herramienta
Uso de computadora
toolConfig para forzar llamadas a herramientas

Para implementar estos flujos, consulte el tutorial de llamada a funciones de Gemini 3.7 Flash.

Pruebe el endpoint en Apidog antes de escribir código de aplicación

Iterar prompts dentro de un script suele ser lento: editar, ejecutar, revisar logs y repetir. Además, cada ejecución consume tokens. Un flujo más eficiente es validar primero la solicitud en un cliente API y portar al SDK solo cuando la respuesta sea correcta.

Configure Gemini en Apidog:

Cree un proyecto e importe la especificación OpenAPI desde la documentación de la API de Google.
Añada una variable de entorno llamada GEMINI_API_KEY.
Asigne la variable al encabezado x-goog-api-key.
Guarde el modelo en una variable, por ejemplo:

   GEMINI_MODEL=gemini-3.7-flash

Construya contents en el editor JSON y valide el cuerpo antes de enviarlo.
Pruebe el endpoint SSE para ver los fragmentos de streaming en vivo.
Guarde respuestas correctas como ejemplos para reutilizarlas en pruebas sin llamar continuamente a la API real.

También puede crear escenarios de prueba con aserciones sobre:

finishReason
Esquema de respuesta
usageMetadata
Conteos de tokens

Este enfoque convierte una prueba manual en una suite de regresión para cambios de prompt. Consulte la guía de pruebas de API para ingenieros de QA para aplicar el mismo patrón.

Manejo de errores y límites de velocidad

La API devuelve un objeto error de nivel superior con code, status y message.

Código	Estado	Significado	Acción recomendada
400	`INVALID_ARGUMENT`	Cuerpo mal formado, rol incorrecto o `contents` vacío.	Valide el JSON antes de enviar la solicitud.
401	`UNAUTHENTICATED`	Clave faltante o revocada.	Exporte de nuevo `GEMINI_API_KEY` y confirme que sigue activa.
403	`PERMISSION_DENIED`	El proyecto no tiene acceso o facturación.	Revise permisos, proyecto y estado de facturación.
429	`RESOURCE_EXHAUSTED`	Se alcanzó un límite de velocidad o cuota.	Reintente con espera aleatoria, agrupe solicitudes o actualice el nivel.
500	`INTERNAL`	Error transitorio del servidor.	Reintente con retroceso exponencial.
503	`UNAVAILABLE`	Servicio sobrecargado.	Reintente después de unos segundos; en Vertex, pruebe otra región.

Implemente reintentos para errores 429 y 5xx:

import random
import time

RETRYABLE_STATUS_CODES = {429, 500, 503}

def retry_with_backoff(call, max_attempts=5):
    for attempt in range(max_attempts):
        try:
            return call()
        except Exception as error:
            status_code = getattr(error, "status_code", None)

            if status_code not in RETRYABLE_STATUS_CODES:
                raise

            if attempt == max_attempts - 1:
                raise

            delay = min(2 ** attempt, 30) + random.uniform(0, 1)
            time.sleep(delay)

Mantenga además estas prácticas:

Configure alertas al 80% de la cuota.
Consulte los límites actuales en la página de precios y límites de la API de Gemini.
Guarde el ID del modelo en una variable de entorno para poder volver a gemini-3.6-flash sin desplegar código.

Preguntas frecuentes

¿Es Gemini 3.7 Flash de uso gratuito?

AI Studio ofrece un nivel gratuito con cuota diaria para prototipos. La tarifa de introducción pagada es de $0.75 por 1 millón de tokens de entrada hasta el 31 de diciembre de 2026.

Para conocer los niveles y sus límites, consulte la guía de acceso gratuito a la API de Gemini.

¿Cuál es la diferencia entre AI Studio y Vertex AI?

El modelo y el cuerpo de solicitud son los mismos.

AI Studio: clave de API y generativelanguage.googleapis.com.
Vertex AI: OAuth, aiplatform.googleapis.com, IAM, auditoría y endpoints regionales.

Empiece en AI Studio y migre a Vertex cuando tenga tráfico de producción.

¿Puedo enviar imágenes, audio y PDF?

Sí. Puede enviar texto, imagen, video, audio y PDF como partes del array contents, en línea como base64 o por referencia mediante la API de Archivos. La salida es texto.

¿Cuál es el tamaño de contexto y el límite de salida?

El modelo admite 1 millón de tokens de entrada y 64k de salida. Aunque la recuperación de contexto largo sea fiable, dividir entradas extensas puede reducir costes porque cada token de entrada se factura.

¿Debo actualizar desde Gemini 3.6 Flash?

Para agentes y cargas de trabajo de código, las mejoras de rendimiento justifican evaluar la actualización. El cambio básico es sustituir el ID del modelo.

Antes de enviar tráfico de producción, ejecute pruebas de regresión sobre sus prompts. Consulte la guía de migración de 3.6 a 3.7 Flash.

Dónde encaja 3.7 Flash en su pila

Gemini 3.7 Flash combina un precio de introducción inferior con mejoras en agentes, código y procesamiento documental. Una estrategia práctica es:

Dirigir nuevas pruebas de agentes, código y extracción de documentos a gemini-3.7-flash.
Limitar maxOutputTokens para controlar costes.
Validar prompts y respuestas en un cliente API.
Crear pruebas de regresión para finishReason, JSON estructurado y consumo de tokens.
Mantener gemini-3.6-flash como valor de reversión mediante una variable de entorno.

Empiece con la solicitud cURL, valide el contrato de respuesta y luego porte la integración a Python o Node.js. Descargue Apidog para importar la especificación de Gemini, configurar la clave una vez y probar solicitudes síncronas, streaming y llamadas a herramientas desde un mismo espacio de trabajo.

Grok 4.6 vs GPT-5.6 vs Claude Fable 5: ¿Qué modelo elegir para desarrolladores API?

Roobia — Thu, 13 Aug 2026 08:30:28 +0000

Grok 4.6 se lanzó el 12 de agosto con una propuesta que cambia la comparación entre modelos frontera: empata con GPT-5.6 Sol en el Índice de Análisis Artificial, pero cuesta $6 por millón de tokens de salida frente a los $30 de Sol. Muchas comparativas todavía usan Grok 4.5, que estaba más alejado de la frontera; para evaluar la decisión actual, hay que partir de los datos de Grok 4.6.

Prueba Apidog hoy

La decisión rápida es esta: GPT-5.6 Sol sigue siendo la opción más segura para agentes de código que trabajan a escala de repositorio; Claude Fable 5 lidera por poco el trabajo autónomo de largo horizonte; y Grok 4.6 es la alternativa de valor cuando necesitas capacidad cercana a frontera con menor coste. La elección depende de tu carga de trabajo, por lo que conviene comparar benchmarks, coste por tarea, compatibilidad de API y resultados en tu propio stack. Si quieres ejecutar esa prueba, Apidog permite trabajar con las tres APIs desde un único espacio de trabajo.

En resumen

Índice de inteligencia: Claude Fable 5 lidera con 62; Grok 4.6 y GPT-5.6 Sol empatan con 61.
Precio de salida por 1M de tokens: Grok 4.6 cuesta $6; Claude Opus 4.8, $25; GPT-5.6 Sol, $30.
Contexto: GPT-5.6 Sol ofrece 1.05M tokens, Claude Fable 5 ofrece 1M y Grok 4.6 ofrece 500K.
Codificación: Sol Max lidera DeepSWE (73.0% frente a 65.9% de Grok); Fable 5 Max lidera FrontierCode (63.6% frente a 61.3%).
Agentes: Fable 5 Max lidera APEX-Agents con 59.2%; Grok 4.6 (57.5%) supera ligeramente a Sol Max (56.7%).
Coste por tarea completada: Grok 4.6 registró $0.84 por tarea en Análisis Artificial.
Acción recomendada: ejecuta una evaluación con al menos 20 prompts reales antes de cambiar el modelo de producción.

Especificaciones y precios uno al lado del otro

	Grok 4.6	GPT-5.6 Sol	Claude Fable 5
Desarrollador	xAI	OpenAI	Anthropic
Índice de Inteligencia	61	61	62
Ventana de contexto	500K	1.05M	1M
Precio de entrada / 1M	$2	$12	$10
Precio de salida / 1M	$6	$30	$25*
Variante rápida/premium	2x precio	Nivel Sol Max	Nivel Fable 5 Max
Estilo de API	Compatible con OpenAI	Nativa de OpenAI	Anthropic Messages
Fecha de corte de conocimiento	Febrero 2026

*Precio de Claude mostrado para Opus 4.8; el precio del nivel Fable 5 varía según la configuración de esfuerzo. Consulta la guía de precios de GPT-5.6 y el desglose para reducir costes de Claude para ver las matrices completas.

La diferencia de precio es relevante especialmente en agentes. En chat, pagar menos por token reduce el coste unitario. En un agente, donde una tarea puede generar decenas de llamadas al modelo, transcripciones extensas y uso de herramientas, esa diferencia puede separar un presupuesto diario de $50 de uno de $250.

Benchmarks de codificación: Sol para profundidad, Grok para valor

Según los números de lanzamiento, cada modelo destaca en un tipo de tarea distinto:

Benchmark	Grok 4.6	GPT-5.6 Sol Max	Claude Fable 5 Max
DeepSWE v1.1 (correcciones a escala de repositorio)	65.9%	73.0%
FrontierCode v1.1 Extendido	61.3%	60.6%	63.6%
CursorBench v3.2	69.9%
APEX-Agents	57.5%	56.7%	59.2%
Terminal-Bench v2.1	88.4%

Interpreta estos resultados así:

El margen de GPT-5.6 Sol Max en DeepSWE importa. Sus 7 puntos de ventaja sobre Grok en correcciones a escala de repositorio son relevantes si tu agente modifica bases de código grandes y recibe poca supervisión. La comparación entre GPT-5.6 Sol y Claude Fable 5 cubre ese caso con más detalle.
Claude Fable 5 prioriza la consistencia. Lidera el índice compuesto, FrontierCode y APEX-Agents. Es un perfil útil para tareas autónomas largas, donde un error temprano puede invalidar una sesión de trabajo completa.
Grok 4.6 ofrece una relación coste/capacidad competitiva. Lidera CursorBench y Terminal-Bench, se mantiene cerca en otros benchmarks y tiene una tarifa mucho menor. Es un buen candidato para manejar el tráfico general y escalar las tareas complejas a Sol o Fable.

Los benchmarks de lanzamiento, especialmente los reportados por proveedores, deben leerse con precaución. Los benchmarks de Grok 4.5 ya requerían una lectura cuidadosa, y la misma regla aplica a todos los modelos.

Coste por tarea, no solo coste por token

El precio por token no captura toda la economía de un agente. Un modelo barato que falla una tarea puede generar costes adicionales de revisión, reintentos y reparación. Para tomar una decisión operativa, mide:

Tasa de éxito por tarea.
Tokens de entrada y salida.
Número de llamadas por tarea.
Latencia total.
Coste por tarea completada correctamente.

Análisis Artificial midió un promedio de $0.84 por tarea para Grok 4.6 en sus evaluaciones de agentes. Ese resultado combina precios bajos con un uso de tokens relativamente contenido.

Por ejemplo, supón que tu agente usa, por tarea completada, 500K tokens de entrada y 100K tokens de salida:

Modelo	Coste de entrada	Coste de salida	Por tarea
Grok 4.6	$1.00	$0.60	$1.60
Claude Opus 4.8	$5.00	$2.50	$7.50
GPT-5.6 Sol	$6.00	$3.00	$9.00

Con 1,000 tareas mensuales, Grok podría ahorrar aproximadamente entre $6,000 y $7,400 frente a las alternativas. Pero solo es un ahorro real si mantiene una tasa de éxito suficiente en tus tareas.

Ergonomía de la API: coste de integración

La capacidad del modelo es solo una parte de la implementación. La otra parte es cuánto código necesitas cambiar para probarlo, operarlo y reemplazarlo.

Grok 4.6: es compatible con el formato de OpenAI. Si ya usas un cliente estilo OpenAI, puedes cambiar el base_url a https://api.x.ai/v1 y reutilizar gran parte de tu integración.
GPT-5.6 Sol: tiene el ecosistema de integración más amplio, incluyendo la API de Respuestas, llamadas programáticas a herramientas y SDK oficiales. Consulta cómo usar la API de GPT-5.6 para revisar la estructura de niveles.
Claude Fable 5: utiliza la API de Mensajes de Anthropic. Tiene una estructura de solicitud diferente y un parámetro de esfuerzo para intercambiar coste por capacidad.

La migración suele ser más simple entre Grok y OpenAI porque comparten formato. Moverse hacia o desde Anthropic requiere una capa de adaptación adicional. Si planeas enrutar solicitudes entre modelos, considera esa diferencia desde el diseño de tu arquitectura.

Por ejemplo, una abstracción mínima en TypeScript puede aislar la selección de proveedor:

type Provider = "grok" | "openai" | "anthropic";

interface ModelRequest {
  provider: Provider;
  model: string;
  prompt: string;
}

async function runModel(request: ModelRequest) {
  switch (request.provider) {
    case "grok":
      return callOpenAICompatibleAPI({
        baseURL: "https://api.x.ai/v1",
        model: request.model,
        prompt: request.prompt,
      });

    case "openai":
      return callOpenAICompatibleAPI({
        baseURL: "https://api.openai.com/v1",
        model: request.model,
        prompt: request.prompt,
      });

    case "anthropic":
      return callAnthropicMessagesAPI({
        model: request.model,
        prompt: request.prompt,
      });
  }
}

La clave es normalizar tu entrada, salida, uso de tokens, llamadas a herramientas y errores antes de comparar resultados.

Ventanas de contexto: cuándo 500K es suficiente

GPT-5.6 Sol ofrece una ventana de 1.05M tokens, Claude Fable 5 ofrece 1M y Grok 4.6 ofrece 500K. Sobre el papel, la diferencia es grande. En producción, la pregunta útil es: ¿cuánto contexto necesita realmente cada tarea?

Una ventana de 500K tokens puede contener aproximadamente:

La base de código de un servicio mediano.
Un año de transcripciones de soporte.
Cientos de páginas de documentación o documentos legales.

Muchas tareas de agentes no se acercan a ese límite. Las cargas de trabajo que sí necesitan una ventana de alrededor de un millón de tokens suelen ser más específicas:

Análisis de monorepositorios completos.
Historiales muy largos de agentes sin resumir.
Procesamiento de conjuntos documentales grandes en una sola llamada.

No elijas solo por el tamaño de la ventana por dos motivos:

La calidad se degrada al llenar el contexto. Recuperar información con un contexto al 80% de capacidad suele rendir peor que hacerlo al 20%. La recuperación selectiva suele superar al relleno de contexto.
Los tokens de entrada afectan directamente al presupuesto. Llenar la ventana completa de Sol cuesta alrededor de $12.60 por solicitud al precio de lista, mientras que llenar la de Grok cuesta aproximadamente $1.

Si tus prompts superan habitualmente los 400K tokens, probablemente necesitas una estrategia de recuperación, resumen y caché; no solo un modelo con una ventana mayor.

Fechas de corte de conocimiento y madurez del ecosistema

Grok 4.6 tiene fecha de corte de conocimiento del 1 de febrero de 2026, la más reciente de las tres. Esto puede ayudar en agentes que trabajan con frameworks que cambian rápido, aunque una implementación sólida no debería depender exclusivamente del conocimiento paramétrico del modelo.

Para tareas técnicas, incorpora recuperación documental y herramientas:

1. Recupera documentación versionada desde tu fuente de verdad.
2. Selecciona solo los fragmentos relevantes.
3. Incluye versiones, enlaces y fechas en el contexto.
4. Pide al modelo que cite los fragmentos recuperados.
5. Valida la salida con pruebas, linters o esquemas.

En cuanto al ecosistema:

OpenAI tiene la superficie de integración de terceros más amplia.
Anthropic tiene una presencia fuerte en frameworks de agentes.
xAI aprovecha la compatibilidad con OpenAI para reducir la fricción de adopción.

Grok puede funcionar con clientes compatibles con completado de chat de OpenAI y está disponible a través de OpenRouter, Vercel y Cloudflare. A cambio, algunas capacidades de primera parte —como APIs por lotes, niveles de caché y controles detallados de uso— son menos maduras que las de proveedores establecidos.

Qué modelo usar según el trabajo

Agente de codificación autónomo a escala de repositorio: usa GPT-5.6 Sol si la prioridad principal es la calidad. Su ventaja en DeepSWE apunta a menos ejecuciones fallidas en bases de código grandes.
Trabajo de conocimiento de largo horizonte o sesiones de varias horas: usa Claude Fable 5 si priorizas consistencia. Lidera el índice compuesto y APEX-Agents.
Tráfico de agentes de alto volumen o producto sensible al coste: usa Grok 4.6 como modelo predeterminado y escala los casos más complejos a Sol o Fable.
Codificación interactiva en un IDE: Grok 4.6 es un candidato relevante por CursorBench y su variante rápida 2x. Fue entrenado tras usar sesiones reales de Cursor como datos de entrenamiento.

Prueba los tres en tu stack en una tarde

Los benchmarks miden promedios; no sustituyen una evaluación con tus prompts, herramientas y criterios de éxito. Puedes organizar una prueba reproducible con Apidog.

1. Crea un proyecto con tres entornos

Configura un entorno por proveedor:

xAI: https://api.x.ai/v1
OpenAI
Anthropic

Guarda las credenciales de cada proveedor en su entorno correspondiente. Así puedes cambiar de backend sin modificar manualmente cada solicitud.

2. Reúne 20 prompts reales

No evalúes con preguntas de demostración. Extrae tareas reales de tu producto:

Incidencias de soporte.
Solicitudes de generación de código.
Refactors representativos.
Extracción de datos.
Llamadas a herramientas.
Casos que ya sabes que son difíciles.

Incluye siempre el mismo prompt de sistema, definiciones de herramientas y datos de entrada para que la comparación sea justa.

3. Define aserciones medibles

Añade aserciones para comprobar lo que importa en producción:

La respuesta no está vacía.
El JSON generado es válido.
La salida cumple el esquema esperado.
La llamada a herramienta tiene los argumentos correctos.
La latencia está por debajo de tu umbral.
El objeto usage contiene el uso de tokens.

Para herramientas, valida contra un esquema en lugar de evaluar solo la prosa:

{
  "type": "object",
  "required": ["repository", "branch", "files"],
  "properties": {
    "repository": { "type": "string" },
    "branch": { "type": "string" },
    "files": {
      "type": "array",
      "items": { "type": "string" }
    }
  }
}

4. Ejecuta cada caso tres veces por modelo

Las salidas de los LLM varían. Una sola ejecución puede ocultar problemas de consistencia.

Ejecuta:

20 prompts × 3 ejecuciones × 3 modelos = 180 resultados

Después, exporta los resultados y calcula:

tasa_de_éxito = tareas_correctas / tareas_totales

coste_por_éxito = coste_total / tareas_correctas

latencia_p95 = percentil_95(latencias)

No compares solo coste por token. Compara coste por tarea correcta.

5. Conserva la suite de evaluación

No conviertas la selección de modelo en una decisión basada en una única prueba. Guarda los prompts, las aserciones y los resultados como una suite de regresión.

Cuando se publique una nueva versión de modelo:

Ejecuta de nuevo la misma suite.
Compara tasa de éxito, coste por éxito y latencia.
Revisa manualmente los casos con cambios significativos.
Ajusta las reglas de enrutamiento si hay una mejora clara.

Los equipos que mantienen un arnés de evaluación pueden cambiar de modelo mucho más rápido que los que deciden de nuevo basándose en anécdotas.

Preguntas frecuentes

¿Es Grok 4.6 mejor que GPT-5.6 Sol?

Empatan en el índice compuesto con 61. Sol lidera la codificación a escala de repositorio en DeepSWE (73.0% frente a 65.9%), mientras que Grok lidera CursorBench y Terminal-Bench y cuesta cinco veces menos en salida. La respuesta depende de si tus tareas se parecen más a DeepSWE o a una sesión de IDE.

¿Es Grok 4.6 mejor que Claude Fable 5?

Fable 5 lidera el índice (62 frente a 61), FrontierCode y APEX-Agents por márgenes reducidos. Grok destaca en precio. Para trabajo autónomo donde la precisión es crítica, Fable 5; para volumen sensible al coste, Grok.

¿Qué modelo de IA es el más barato en la frontera en 2026?

Grok 4.6, con $2/$6 por millón de tokens y un coste medido independientemente de $0.84 por tarea de agente. Los tokens de salida del competidor frontera más cercano cuestan aproximadamente cuatro veces más.

¿Debería cambiar mi agente de producción a Grok 4.6?

No solo por benchmarks. Ejecuta primero una comparación con tu carga de trabajo real. La diferencia de precio solo importa si la tasa de éxito se mantiene en tus tareas.

¿Puedo usar los tres modelos detrás de un único formato de API?

En gran medida, sí. Grok 4.6 usa de forma nativa el formato de completado de chat de OpenAI, por lo que puede compartir código cliente con GPT-5.6. Claude requiere la API de Mensajes de Anthropic o una pasarela como OpenRouter que normalice los tres modelos con un pequeño recargo.

¿Importa la ventana de contexto más pequeña de Grok 4.6?

Para la mayoría de las cargas de trabajo de agentes y chat, no. 500K tokens superan ampliamente el uso típico, y todos los modelos se degradan cerca de sus límites. Sí importa si procesas monorepositorios completos o conjuntos documentales masivos en una sola llamada, donde la ventana de 1.05M de Sol ofrece más margen.

¿Cómo quitar la marca de agua de Claude?

Roobia — Thu, 13 Aug 2026 06:28:52 +0000

A partir de agosto de 2026, cada bloque de texto generado por Claude incorpora una marca de agua invisible. No aparece en el corrector ortográfico, no se ve al inspeccionar el documento y sobrevive al copiar y pegar el contenido desde Claude a otra aplicación. Anthropic la diseñó para asociar el texto con el modelo que lo generó mediante patrones distribuidos en las propias elecciones de palabras.

Prueba Apidog hoy

Si eres propietario del contenido y necesitas limpiar caracteres ocultos o metadatos de archivos, el proyecto open source watermarks-remover ofrece scripts para inspeccionar y procesar texto, imágenes y documentos. Esta guía explica qué puede eliminar realmente, qué no puede garantizar y cómo ejecutar cada paso de forma verificable.

Este flujo está orientado a privacidad e higiene de archivos propios. Eliminar señales de procedencia para incumplir políticas académicas, contratos o requisitos de divulgación puede tener consecuencias legales, contractuales o disciplinarias.

TL;DR

Marca estadística de Claude: no es un carácter oculto. Claude sesga algunas elecciones de tokens según una clave secreta, dejando una firma estadística detectable en textos suficientemente largos.
Qué sobrevive: la señal estadística sobrevive al copiar y pegar, pero se degrada con edición intensa, parafraseo y traducción.
Texto corto y código: suelen contener una señal débil o insuficiente. Los formateadores y linters reducen todavía más la señal en código.
watermarks-remover: toolkit MIT para Python 3.10+ que trabaja en dos capas:
- Capa A: elimina Unicode invisible, espacios inusuales, controles bidireccionales y caracteres de etiqueta.
- Capa B: prepara una reescritura del texto para alterar la distribución de palabras. No es una garantía y puede degradar la prosa.
Archivos: limpia C2PA, EXIF, XMP y propiedades de documentos en PNG, JPEG, SVG, PDF, DOCX, ODT, HTML y Markdown.
Regla práctica: la limpieza determinista de caracteres y metadatos es comprobable. Eliminar una marca estadística implica modificar el texto visible.

Qué es realmente la marca de agua de Claude

La marca de agua de texto de Claude no consiste en espacios de ancho cero, glifos invisibles ni caracteres ocultos entre palabras.

En su lugar, la señal se distribuye en la selección de tokens. Durante la generación, el modelo puede elegir entre varias continuaciones estadísticamente similares. La marca de agua sesga algunas de esas elecciones usando una clave secreta. En un texto largo, el conjunto de elecciones forma una firma que un detector compatible puede identificar.

Esto tiene dos implicaciones prácticas:

Copiar y pegar no la elimina.

Como la señal está en las palabras elegidas y no en metadatos adjuntos, mover el texto entre aplicaciones conserva el patrón.
Editar el texto la degrada.

Reescribir frases, traducir, resumir o combinar el resultado con redacción propia modifica las elecciones de tokens y reduce la señal estadística.

Anthropic implementó este mecanismo a nivel de modelo a partir del 2 de agosto de 2026. Esto incluye aplicaciones de Claude, API, Claude Code y accesos de terceros mediante AWS, Google Cloud y Microsoft Foundry. Anthropic también ha indicado que ofrecerá una API de detección.

Para contexto sobre cambios en modelos y políticas de acceso de Anthropic, consulta Fable 5 Is Down for Everyone.

Una detección positiva indica que el texto podría haber pasado por Claude; no demuestra por sí sola fraude, autoría exclusiva ni incumplimiento. Corrección, traducción y resumen también pueden dejar rastros similares.

Dos sistemas de marcado, dos tratamientos distintos

watermarks-remover separa el trabajo por capas porque los caracteres invisibles, los metadatos de archivo y las marcas estadísticas no son el mismo problema.

Capa A: limpieza determinista de caracteres

Esta capa elimina contenido Unicode no visible o potencialmente problemático:

Espacios de ancho cero.
Espacios en blanco no estándar.
Controles de texto bidireccional.
Caracteres de etiqueta Unicode.

La limpieza se ejecuta sin modelos y no reescribe la prosa visible. Por eso es rápida, reproducible y fácil de verificar.

Capa B: reescritura estadística

La marca estadística de Claude está vinculada a la elección de palabras. No existe un byte, carácter o campo de metadatos que puedas borrar sin cambiar el texto.

Por ese motivo, la Capa B prepara una reescritura del contenido. El propio proyecto la presenta como un esfuerzo de buena fe, no como una garantía de eliminación. La reformulación puede:

Aplanar el estilo.
Alterar matices técnicos.
Introducir errores de precisión.
Requerir revisión humana completa.

Metadatos de archivos

El toolkit también elimina metadatos y propiedades incrustadas:

C2PA.
EXIF.
XMP.
Propiedades de documentos.

Los formatos compatibles incluyen PNG, JPEG, SVG, PDF, DOCX, ODT, HTML y Markdown.

C2PA es un manifiesto firmado de procedencia de la Coalition for Content Provenance and Authenticity. A diferencia de una marca estadística de texto, es un dato a nivel de archivo y normalmente se puede inspeccionar y eliminar de forma determinista.

El proyecto cubre mecanismos de Claude, Gemini/SynthID-Text, OpenAI y marcas de código abierto estilo Kirchenbauer con una arquitectura similar. Las marcas de agua en píxeles —por ejemplo, SynthID aplicado directamente a una imagen— no se eliminan con este flujo; el proyecto puede puntuarlas mediante una configuración externa de detección inversa.

Cuándo la señal ya suele ser débil

Antes de procesar contenido, evalúa si realmente necesitas hacerlo.

Pasajes cortos

Unas pocas oraciones suelen no aportar suficientes elecciones de tokens para que un detector alcance alta confianza estadística.

Código fuente

El código tiene opciones de tokens mucho más restringidas que la prosa. Además, herramientas como formateadores, linters y refactorizadores cambian el resultado antes de que llegue a producción.

Por eso, en código generado o asistido por Claude Code, la señal puede ser débil o irrelevante después de un flujo normal de desarrollo.

Texto ya editado

Si el borrador fue revisado, reestructurado o combinado con escritura propia, es posible que el patrón original ya se haya degradado.

Archivos con C2PA

Una conversión de formato, un guardado nuevo o una exportación pueden eliminar metadatos de procedencia. Aun así, conviene usar un proceso explícito e inspeccionable cuando necesitas consistencia.

Instalación de `watermarks-remover`

El proyecto funciona como una skill de agente y como un conjunto de scripts Python independientes.

Requisitos:

Python 3.10 o superior.
Los scripts principales usan la biblioteca estándar.
No necesitas instalar dependencias para la limpieza básica de texto y metadatos.

Clona el repositorio:

git clone https://github.com/guillaumemeyer/watermarks-remover.git
cd watermarks-remover

Si usas un entorno compatible con skills tipo Grok, enlaza la skill:

mkdir -p ~/.grok/skills
ln -sfn "$(pwd)/skills/remove-ai-marks" ~/.grok/skills/remove-ai-marks

Para ejecutar los scripts directamente, define una variable con la ruta:

export SCRIPTS="$(pwd)/skills/remove-ai-marks/scripts"

Herramientas opcionales:

c2patool para inspeccionar manifiestos C2PA.
exiftool para limpiar metadatos de imagen residuales.

No son necesarias para el flujo principal, pero pueden ayudar en tareas de auditoría.

Inspecciona antes de modificar

No proceses archivos a ciegas. Primero identifica qué contiene el archivo.

python3 "$SCRIPTS/inspect_file.py" draft.md

El inspector informa sobre caracteres invisibles, bloques de metadatos y manifiestos de procedencia sin modificar el contenido.

Úsalo como primer paso en cualquier flujo:

Inspecciona el archivo original.
Guarda el informe.
Limpia solo lo necesario.
Inspecciona la salida.
Conserva el original hasta completar la verificación.

Limpiar texto: Capa A

Para eliminar caracteres invisibles y controles Unicode sin alterar la prosa visible, usa clean_text.py.

python3 "$SCRIPTS/clean_text.py" draft.md -o draft.cleaned.md --stats

La opción --stats muestra un resumen de los elementos encontrados y eliminados.

Este comando puede eliminar:

Unicode invisible.
Espacios exóticos.
Controles bidireccionales.
Caracteres de etiqueta.

La opción -o escribe la salida en un archivo nuevo. Evita sobrescribir el original hasta verificar el resultado.

diff -u draft.md draft.cleaned.md

Para archivos de texto, un diff te ayuda a confirmar que los únicos cambios corresponden a caracteres no visibles o normalizaciones esperadas.

Limpiar metadatos de archivos

Para imágenes y documentos, usa clean_file.py.

python3 "$SCRIPTS/clean_file.py" photo.png -o photo.cleaned.png

El script admite PNG, JPEG, SVG, PDF, DOCX, ODT, HTML y Markdown, y procesa C2PA, EXIF, XMP y propiedades de documento.

Si tienes exiftool, puedes realizar una limpieza adicional de etiquetas de imagen:

exiftool -all= photo.cleaned.png

Ten en cuenta que este comando modifica metadatos. Ejecuta primero una inspección y conserva una copia del archivo original.

Capa B: reescritura y compensaciones

La marca estadística de texto no se elimina borrando caracteres. Requiere cambiar el contenido visible.

rewrite_text.py prepara un pase de reformulación:

python3 "$SCRIPTS/rewrite_text.py" draft.md --backend print-prompt --strength paraphrase

Con --backend print-prompt, el script imprime una instrucción de reescritura en lugar de enviar el texto directamente a un modelo. Esto te permite revisar y controlar el paso posterior.

La opción --strength ajusta la intensidad de la reformulación.

Antes de usar esta capa, considera sus costes:

Estilo: la redacción específica puede perder voz o intención.
Precisión: una paráfrasis de contenido técnico puede cambiar el significado.
Revisión: necesitas validar hechos, ejemplos, código, nombres de APIs y restricciones.
Coste: usar otro modelo para reescribir texto puede añadir consumo y complejidad al flujo.

Para la mayoría de flujos legítimos, la opción más razonable es:

Ejecutar la Capa A para higiene de texto.
Limpiar metadatos de archivo si es necesario.
Usar reescritura solo cuando exista una necesidad concreta y puedas revisar el resultado.

Verifica la salida

Después de limpiar un archivo, vuelve a inspeccionarlo:

python3 "$SCRIPTS/inspect_file.py" draft.cleaned.md

Para revisar específicamente C2PA:

c2patool photo.cleaned.png

La verificación de caracteres invisibles y metadatos es directa porque puedes inspeccionar el archivo resultante.

La verificación de una marca estadística de texto es diferente: no dispones de la clave privada de detección de Anthropic. Cuando la API de detección anunciada esté disponible, será la referencia para comprobar ese tipo de señal.

Si automatizas inspecciones de contenido o validaciones relacionadas con modelos, puedes integrarlas en pruebas repetibles de API. Herramientas como Apidog permiten estandarizar solicitudes, aserciones y ejecuciones de verificación. Para un patrón de pruebas de endpoints de agentes, consulta Cómo probar agentes de IA a través de una API.

Salvaguardias legales y éticas

El uso apropiado de estas herramientas se centra en privacidad e higiene de contenido propio, por ejemplo:

Eliminar caracteres de seguimiento de borradores propios.
Limpiar EXIF, XMP o propiedades de documentos antes de publicar.
Quitar metadatos de procedencia de archivos que posees y gestionas.
Normalizar texto antes de introducirlo en una canalización de publicación.

No es un mecanismo para evitar obligaciones de divulgación.

Evita usarlo para:

Deshonestidad académica: si una institución exige declarar el uso de IA o prohíbe entregas generadas por IA, ocultarlo puede constituir mala conducta.
Incumplimientos contractuales: clientes y plataformas pueden exigir transparencia sobre el uso de IA.
Falsa atribución: presentar contenido de IA como trabajo humano cuando ello engaña materialmente a otra parte.

Además, la detección no determina por sí sola la autoría: una señal positiva no prueba fraude y una señal ausente no prueba origen humano.

Si tu objetivo es controlar por completo la procedencia y las políticas de tus modelos, considera opciones autoalojadas. Consulta Los mejores LLM locales para ejecutar en 2026.

Preguntas frecuentes

¿Puedo buscar y eliminar caracteres ocultos de la marca de agua de Claude?

No. La marca estadística de texto no está formada por caracteres ocultos. Se basa en patrones de elección de palabras. La Capa A puede eliminar caracteres invisibles introducidos por otras herramientas, pero es un mecanismo distinto.

¿Copiar y pegar texto de Claude elimina la marca?

No. La señal estadística viaja con las palabras, no con un campo de metadatos adjunto al documento.

¿`watermarks-remover` es gratuito?

Sí. Es un proyecto open source con licencia MIT. Los scripts principales requieren Python 3.10+ y la biblioteca estándar.

¿Funciona con salida de Claude Code?

Los scripts pueden ejecutarse sobre archivos de código, pero la señal suele ser débil debido a las restricciones propias del lenguaje y a los cambios realizados por formateadores, linters y refactorizadores.

¿Elimina marcas de agua de imágenes como SynthID?

No elimina marcas aplicadas en el dominio de píxeles. Sí puede limpiar metadatos a nivel de archivo, incluidos C2PA, EXIF y XMP.

¿Es legal eliminar una marca de procedencia?

Depende del contexto. Limpiar metadatos o caracteres de contenido propio no es inherentemente ilegal, pero puede incumplir políticas académicas, contratos o términos de plataforma que exijan divulgar el uso de IA.

¿Cómo verifico que una marca estadística ha desaparecido?

No puedes confirmarlo de forma concluyente sin acceso a una clave o API de detección compatible. En cambio, la limpieza de Unicode, C2PA y otros metadatos sí puede verificarse con inspect_file.py, c2patool y herramientas de inspección de metadatos.

Cómo Probar y Depurar Peticiones API de Grok 4.6 (Streaming, Llamadas a Herramientas y Errores)

Roobia — Thu, 13 Aug 2026 05:59:01 +0000

Grok 4.6 está orientado a agentes de larga duración. Por eso, los fallos de integración suelen aparecer en los puntos más difíciles de depurar: una transmisión que se detiene a mitad de un token, una llamada a herramienta con argumentos JSON incompletos o límites de tasa que solo surgen bajo carga de producción. Esta guía muestra un flujo de trabajo práctico para validar solicitudes, inspeccionar SSE, depurar herramientas, aplicar reintentos y simular respuestas de Grok sin gastar tokens en CI.

Prueba Apidog hoy

Todo el flujo usa Apidog como entorno de trabajo para centralizar la representación de SSE, secretos por entorno, aserciones de respuesta y servidores simulados. Los principios se aplican también si configura estas piezas manualmente.

En resumen

Configure https://api.x.ai/v1 y XAI_API_KEY como variables de entorno; nunca guarde claves en solicitudes versionadas.
Inspeccione transmisiones SSE visualmente para distinguir bloqueos del servidor, proxy o cliente.
Compruebe que tool_calls[].function.arguments se pueda analizar como JSON y cumpla su esquema en cada ejecución.
Reintente 429 con retroceso exponencial y fluctuación; limite los reintentos de 5xx.
Registre usage en todas las respuestas para detectar aumentos de coste.
Simule el endpoint en CI y ejecute pruebas contra la API real en tareas programadas.
Promueva solicitudes de depuración a escenarios automatizados antes de desplegar.

Primero: configure un espacio de trabajo adecuado

curl sirve para un primer hola mundo, pero deja de ser útil cuando necesita comparar varias variantes de una solicitud fallida. Configure un proyecto reutilizable:

Cree un proyecto en Apidog, por ejemplo, Integración Grok 4.6.
Cree un entorno llamado xai-dev.
Añada estas variables:

   base_url = https://api.x.ai/v1
   api_key = <su clave>

Marque api_key como secreto.

Cree una solicitud:

   POST {{base_url}}/chat/completions
   Authorization: Bearer {{api_key}}
   Content-Type: application/json

Duplique el entorno como xai-prod e introduzca la clave de producción.

Así puede reutilizar las mismas solicitudes sin arriesgar la cuota de producción durante las pruebas de desarrollo.

Si todavía no ha generado una clave, la guía de inicio rápido de la API de Grok 4.6 cubre la configuración de console.x.ai y las primeras solicitudes con curl, Python y JavaScript.

Valide las solicitudes antes de culpar al modelo

Cuando una solicitud falla o devuelve una salida inesperada, compruebe primero lo básico.

1. Verifique el ID del modelo

Use el ID correcto para el proveedor que está llamando:

{
  "model": "grok-4-6"
}

En la API nativa se usa grok-4-6; los revendedores pueden usar otros identificadores, como x-ai/grok-4.6 en OpenRouter. Un 404 normalmente indica un ID o endpoint incorrecto, no una interrupción del modelo.

2. Revise parámetros y presupuesto de contexto

Errores como estos suelen devolver 400:

temperature fuera de rango.
max_tokens superior al espacio disponible.
Campos obligatorios ausentes.
Tipos incorrectos en el cuerpo JSON.

Revise el mensaje de error antes de modificar el prompt o la lógica del agente.

La ventana de contexto de Grok 4.6 es de 500K tokens. Aunque es amplia, una transcripción larga del agente combinada con una reserva grande de max_tokens puede provocar truncación. Registre el uso por solicitud:

const usage = response.usage;

console.log({
  promptTokens: usage?.prompt_tokens,
  completionTokens: usage?.completion_tokens,
  totalTokens: usage?.total_tokens,
});

Alerte cuando el consumo de entrada se acerque al límite que haya definido para su tarea.

3. Compruebe la estructura de `messages`

Mantenga una secuencia coherente de mensajes y evite contenido vacío o instrucciones duplicadas:

{
  "model": "grok-4-6",
  "messages": [
    {
      "role": "system",
      "content": "Responde de forma concisa y llama herramientas solo cuando sea necesario."
    },
    {
      "role": "user",
      "content": "Consulta el estado del pedido 1234."
    }
  ]
}

Un system prompt duplicado o un mensaje vacío puede degradar la salida sin generar un error HTTP.

La validación de solicitudes de Apidog ayuda a detectar tipos incorrectos y campos requeridos antes de enviar la solicitud, eliminando viajes de ida y vuelta innecesarios.

Depure la transmisión sin quedarse ciego

Las respuestas de Grok 4.6 se transmiten mediante eventos enviados por el servidor (SSE). En agentes, las respuestas pueden contener miles de tokens, por lo que debe distinguir entre una generación lenta y una transmisión rota.

1. Identifique un atasco real

Si los tokens dejan de llegar, en una terminal puede parecer que el modelo sigue procesando. En una vista SSE puede comprobar si:

dejaron de llegar fragmentos desde el servidor o la red;
los fragmentos siguen llegando, pero el cliente dejó de renderizarlos;
el proxy está almacenando la respuesta en búfer.

Esta distinción separa rápidamente un problema de infraestructura de un error en su cliente.

2. Compruebe `finish_reason`

Cuando la transmisión termina antes de lo esperado, inspeccione el último fragmento:

{
  "choices": [
    {
      "finish_reason": "length"
    }
  ]
}

length: se alcanzó max_tokens. Auméntelo si la tarea requiere una respuesta más extensa.
stop: el modelo terminó la respuesta de forma normal.

No trate una salida corta como un error del modelo sin comprobar primero este campo.

3. Revise el proxy inverso

Si funciona localmente pero se bloquea en pruebas o producción, revise la configuración del proxy. Por ejemplo, nginx suele necesitar desactivar el almacenamiento en búfer para rutas SSE:

location /chat/completions {
  proxy_buffering off;
  proxy_cache off;
  proxy_http_version 1.1;
}

Pruebe la misma solicitud desde Apidog contra el entorno local y contra el gateway. Si transmite desde su máquina pero no a través del gateway, el problema está en la infraestructura y no en xAI.

Llamadas a herramientas: donde las integraciones de agentes realmente fallan

La llamada a funciones es una pieza crítica en agentes. Los errores más frecuentes no están en el texto generado, sino en cómo el cliente procesa tool_calls.

Argumentos que no se pueden analizar

tool_calls[].function.arguments llega como una cadena JSON. Analícela de forma defensiva:

function parseToolArguments(rawArguments) {
  try {
    return JSON.parse(rawArguments);
  } catch (error) {
    console.error("Argumentos de herramienta inválidos", {
      rawArguments,
      error: error.message,
    });

    throw new Error("No se pudieron analizar los argumentos de la herramienta");
  }
}

Cuente estas fallas. Un aumento sostenido puede indicar que cambió el prompt, el esquema o el contexto de la conversación.

JSON válido con forma incorrecta

Que el JSON sea válido no significa que sea seguro de ejecutar. Valide el objeto contra el esquema esperado en cada llamada:

function validateGetOrderArgs(args) {
  if (typeof args.orderId !== "string" || args.orderId.length === 0) {
    throw new Error("orderId debe ser una cadena no vacía");
  }

  return args;
}

En producción, use la misma validación que usa en desarrollo. No ejecute una herramienta solo porque el modelo devolvió JSON sintácticamente correcto.

Herramientas desconocidas

Rechace explícitamente nombres que no estén permitidos:

const allowedTools = new Set(["get_order", "search_products"]);

function assertAllowedTool(name) {
  if (!allowedTools.has(name)) {
    throw new Error(`Herramienta no permitida: ${name}`);
  }
}

Esto evita que una función inexistente termine el bucle del agente con un KeyError o una excepción inesperada.

Ensamble fragmentos antes de analizar

En transmisiones SSE, los argumentos de una herramienta pueden llegar divididos en varios fragmentos. Acumúlelos por índice de llamada y analice solo al final:

const toolArgumentsByIndex = new Map();

for await (const chunk of stream) {
  for (const choice of chunk.choices ?? []) {
    for (const toolCall of choice.delta?.tool_calls ?? []) {
      const index = toolCall.index;
      const current = toolArgumentsByIndex.get(index) ?? "";
      const next = current + (toolCall.function?.arguments ?? "");

      toolArgumentsByIndex.set(index, next);
    }
  }
}

for (const [index, rawArguments] of toolArgumentsByIndex) {
  const args = parseToolArguments(rawArguments);
  console.log({ index, args });
}

Analizar antes de completar el ensamblaje produce un falso diagnóstico: parece que el modelo emitió JSON roto, pero el error está en el consumidor de la transmisión.

En Apidog, guarde una solicitud que devuelva llamadas a herramientas y añada aserciones para verificar que:

el nombre de la herramienta pertenece al conjunto permitido;
la cadena de argumentos se analiza correctamente;
el objeto resultante cumple el esquema esperado.

Ejecute el escenario varias veces. La no determinación de un LLM puede ocultar una tasa de fallo del 10 % en una única ejecución. Si usa servidores MCP en vez de llamadas a funciones directas, aplique la misma disciplina; consulte la guía para probar servidores MCP con Apidog.

Errores, reintentos y límites de tasa

Defina una política explícita para cada clase de error:

Estado	Significado	Política
`400`	Solicitud mal formada	No reintentar. Registre el error y corrija la solicitud.
`401`	Clave incorrecta o ausente	No reintentar. Verifique la variable de entorno y la clave en la consola.
`404`	Modelo o endpoint incorrecto	No reintentar. Verifique el modelo contra `/v1/models`.
`429`	Límite de tasa o cuota	Reintente con retroceso exponencial y fluctuación. Respete `Retry-After` si existe.
`5xx`	Error del servidor	Reintente hasta tres veces con retroceso y falle la tarea de forma visible después.
Tiempo de espera	Red lenta o generación extensa	Prefiera streaming y configure tiempos de espera de minutos para tareas de agente.

Un ejemplo de reintento para 429 y 5xx:

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function requestWithRetry(request, maxRetries = 3) {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    const response = await request();

    if (response.ok) {
      return response;
    }

    const retryable = response.status === 429 || response.status >= 500;

    if (!retryable || attempt === maxRetries) {
      throw new Error(`Solicitud fallida con estado ${response.status}`);
    }

    const retryAfter = Number(response.headers.get("retry-after"));
    const baseDelay = Number.isFinite(retryAfter)
      ? retryAfter * 1000
      : 1000 * 2 ** attempt;

    const jitter = Math.floor(Math.random() * 250);

    await sleep(baseDelay + jitter);
  }
}

Registre siempre el objeto usage. Con precios de $2/$6 por millón de tokens, el coste por solicitud puede ser bajo, pero los bucles de agentes multiplican llamadas y tokens. Una regresión introducida por un cambio de prompt suele aparecer antes en los registros de uso que en la factura. El análisis de precios de Grok explica el modelo de costes con más detalle.

Simule Grok en CI y pruebe la API real por separado

No llame al modelo en vivo en cada commit.

Una prueba de integración de agente con 30 llamadas reales cuesta dinero, tarda más de un minuto y puede fallar por una incidencia temporal del proveedor. Cuando eso ocurre con frecuencia, el equipo deja de confiar en la suite.

Separe las responsabilidades.

Simulaciones para la lógica

Use la simulación inteligente de Apidog para devolver respuestas con formato Grok que cubran casos como:

una finalización normal;
una llamada a herramienta válida;
un 429;
una respuesta 5xx;
una transmisión truncada;
argumentos JSON inválidos;
una herramienta desconocida.

Así ejecuta en cada commit, en segundos, la lógica de:

reintentos;
análisis JSON;
validación de esquemas;
manejo de finish_reason;
terminación del bucle del agente.

Simule especialmente las rutas de fallo. En muchos proyectos, el código de manejo de 429 no se ejecuta hasta que aparece el primer límite de tasa en producción.

Pruebas en vivo programadas

Ejecute las pruebas contra la API real:

cada noche;
antes de un lanzamiento;
cuando actualice el modelo;
cuando modifique herramientas o prompts críticos.

Estas pruebas detectan cambios reales del proveedor, como variaciones en el formato de llamadas a herramientas o nuevos límites de tasa, sin bloquear la cola de integración por la disponibilidad de xAI.

Los escenarios de Apidog cubren ambos casos: apunte el escenario al entorno simulado en CI y a xai-dev en la ejecución programada. Mantiene las mismas aserciones con dos destinos distintos.

Si ejecuta pruebas desde una terminal o una tubería, la CLI de Apidog permite lanzar los mismos escenarios sin interfaz gráfica.

Lista de verificación previa a producción

Antes de enviar tráfico real a Grok 4.6, confirme lo siguiente:

[ ] Las claves de API están en variables de entorno; desarrollo y producción usan entornos separados.
[ ] No hay claves en el control de versiones ni en solicitudes guardadas.
[ ] La transmisión maneja finish_reason: length, bloqueos y almacenamiento en búfer del proxy.
[ ] Los argumentos de llamadas a herramientas se ensamblan antes de analizarlos.
[ ] Los argumentos se analizan defensivamente y se validan contra un esquema en cada llamada.
[ ] Los nombres de herramienta se validan contra una lista permitida.
[ ] La política de reintentos para 429 y 5xx está implementada y probada mediante simulación.
[ ] El objeto usage se registra por solicitud y genera alertas ante desviaciones de coste.
[ ] CI usa simulaciones y la suite en vivo se ejecuta según un horario.
[ ] Toda la suite se puede volver a ejecutar con un único comando al actualizar el modelo.

Preguntas frecuentes

¿Cómo depuro una respuesta de transmisión de Grok 4.6 que se cuelga?

Reprodúzcala en la vista SSE de Apidog. Si los fragmentos dejaron de llegar, revise servidor, red, proxy y tiempos de espera. Si los fragmentos siguen llegando pero su interfaz no cambia, revise el consumo de la transmisión, el almacenamiento en búfer y el código asíncrono del cliente.

¿Por qué las llamadas a herramientas de Grok 4.6 a veces fallan al analizarse?

Los argumentos llegan como una cadena JSON y, en streaming, pueden estar distribuidos en varios fragmentos. Ensamble todos los fragmentos antes de ejecutar JSON.parse, capture errores de análisis y valide el objeto resultante contra su esquema.

¿Deberían mis pruebas llamar a la API real de Grok?

Sí, pero en un horario programado, por ejemplo cada noche o antes de un lanzamiento. Para cada commit, simule el endpoint para mantener CI rápido, determinista y sin coste por tokens.

¿Este flujo de trabajo funciona para otras API de LLM?

Sí. Como la API de Grok es compatible con OpenAI, puede reutilizar la estructura de proyecto y crear un entorno por proveedor. Esto permite probar GPT-5.6, Claude y Grok en paralelo con las mismas aserciones y escenarios.

¿Cómo usar la API DeepSeek V4 Pro 0813?

Roobia — Thu, 13 Aug 2026 04:26:58 +0000

DeepSeek V4 Pro salió de la fase de previsualización el 12 de agosto de 2026. La versión de disponibilidad general (GA), identificada como 0813, sirve el endpoint deepseek-v4-pro con una ventana de contexto de 1M de tokens, hasta 384K tokens de salida y un precio de entrada de $0.003625 por millón de tokens en aciertos de caché. Según Unite.AI, el modelo pasó cuatro meses en previsualización antes de convertirse en el buque insignia de DeepSeek.

Prueba Apidog hoy

Esta guía se centra en la implementación: configurar el SDK de OpenAI, elegir modos de pensamiento, procesar reasoning_content, habilitar streaming SSE, ejecutar llamadas a herramientas y estructurar prompts para maximizar la caché. Para conocer primero la arquitectura, consulta Qué es DeepSeek V4.

TL;DR

La instantánea GA 0813 está detrás del endpoint deepseek-v4-pro desde el 12 de agosto de 2026.
La API es compatible con OpenAI: configura el SDK openai con https://api.deepseek.com y usa model="deepseek-v4-pro".
Ofrece 1M de tokens de contexto, hasta 384K de salida y tres modos: non-think, think high y think max.
Los modos de pensamiento devuelven reasoning_content además de la respuesta final.
La entrada cuesta $0.435/M en fallo de caché y $0.003625/M en acierto de caché; la salida cuesta $0.87/M.
DeepSeek indicó el 6 de agosto que habrá un aumento “significativo” de precio, pero sin cifras ni fecha.
Prueba solicitudes, entornos y streaming SSE en Apidog antes de integrar el modelo en producción.

Qué cambia con la compilación GA 0813

La previsualización se abrió en abril de 2026. V4 Flash se lanzó en julio y V4 Pro alcanzó disponibilidad general el 12 de agosto como compilación 0813, siguiendo la convención de fechas de DeepSeek, como v3-0324.

Para desarrollo y producción, la GA cambia tres aspectos importantes:

La instantánea es estable. Las versiones preview pueden cambiar sin aviso e invalidar evaluaciones o ajustes de prompts. 0813 es un objetivo fijo hasta que DeepSeek publique otra instantánea.
El alias de producción apunta a la GA. En la API oficial usa deepseek-v4-pro. Si necesitas fijar explícitamente la instantánea, OpenRouter lista deepseek/deepseek-v4-pro-0813.
Todas las funciones están disponibles. Incluye modos de pensamiento, llamadas a funciones, salidas estructuradas, caché de prompts y compatibilidad con formatos OpenAI, Anthropic y Responses.

Bajo el capó, V4 Pro es un modelo de mezcla de expertos con 1.6T de parámetros totales y 49B activos por token. Sus esquemas de Atención Dispersa Comprimida y Atención Fuertemente Comprimida reducen el cálculo de inferencia por token al 27% de V3.2 y la caché KV al 10%. Esa reducción es relevante para hacer viable una ventana de 1M de tokens.

DeepSeek V4 Pro 0813: especificaciones

Especificación	DeepSeek V4 Pro 0813
Lanzamiento	GA el 12 de agosto de 2026, instantánea `0813`
Arquitectura	Mezcla de expertos, 1.6T parámetros totales, 49B activos por token
Atención	Atención Dispersa Comprimida + Atención Fuertemente Comprimida
Costo de inferencia frente a V3.2	27% del cálculo por token, 10% de la caché KV
Ventana de contexto	1.000.000 tokens
Salida máxima	384K tokens
Modos de pensamiento	sin pensamiento, pensamiento alto, pensamiento máximo
Precio de entrada	$0.435/M tokens en fallo de caché, $0.003625/M en acierto
Precio de salida	$0.87/M tokens
Formatos de API	Chat Completions de OpenAI, Messages de Anthropic, Responses de DeepSeek
ID del modelo	`deepseek-v4-pro`
Alternativa	`deepseek-v4-flash`: 284B total / 13B activos, $0.14/M de entrada y $0.28/M de salida

La ficha de DeepSeek informa resultados de SWE-bench Verified de 80.6%, Terminal Bench 2.0 de 67.9%, GPQA Diamond de 90.1% y LiveCodeBench de 93.5% para V4-Pro-Max. Son métricas auto-reportadas por el proveedor, así que ejecuta evaluaciones específicas de tu tarea antes de migrar una carga de trabajo importante.

Obtén una clave API y ejecuta tu primera solicitud

Sigue estos pasos:

Crea una cuenta en platform.deepseek.com y añade crédito. La API es prepago.
Abre la sección de claves API, genera una clave y cópiala inmediatamente.
Guarda la clave como variable de entorno:

export DEEPSEEK_API_KEY="sk-..."

La API es compatible con Chat Completions de OpenAI. Usa el paquete openai y apunta el cliente a DeepSeek. Tanto https://api.deepseek.com como https://api.deepseek.com/v1 funcionan como URL base; /v1 es una capa de compatibilidad de protocolo, no una versión del modelo.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com",
)

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "You are a concise technical assistant."},
        {"role": "user", "content": "Explain idempotency in REST APIs in two sentences."},
    ],
)

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

Registra response.usage desde la primera prueba. En este modelo, la diferencia entre un acierto y un fallo de caché puede cambiar significativamente el costo de una sesión larga.

Para una prueba rápida por HTTP:

curl https://api.deepseek.com/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -d '{
    "model": "deepseek-v4-pro",
    "messages": [
      {"role": "user", "content": "List three ways to version a REST API."}
    ]
  }'

Consulta la documentación oficial de DeepSeek para todos los parámetros, el endpoint compatible con Anthropic y la API Responses de DeepSeek.

Usa los tres modos de pensamiento

V4 Pro expone el razonamiento mediante un selector. El endpoint es el mismo; cambia el presupuesto de razonamiento según la tarea:

Sin pensamiento (non-think): respuesta directa. Úsalo para clasificación, extracción, formateo y resúmenes.
Pensamiento alto (think high): devuelve razonamiento en reasoning_content antes de la respuesta final. Es una opción práctica para programación, depuración y análisis de varios pasos.
Pensamiento máximo (think max): usa el mayor presupuesto de razonamiento. Resérvalo para problemas complejos donde la latencia y el costo adicional estén justificados.

Configura el modo con reasoning_effort:

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    reasoning_effort="high",  # "none" | "high" | "max"
    messages=[
        {
            "role": "user",
            "content": "Our API returns 502s under load but only behind the CDN. Walk through likely causes in order of probability.",
        },
    ],
)

message = response.choices[0].message

print("--- Reasoning ---")
print(message.reasoning_content)

print("--- Answer ---")
print(message.content)

Dos reglas prácticas:

No reenvíes reasoning_content como parte del historial de conversación. Conserva y reenvía solo content.
Los tokens de razonamiento se facturan como salida, a $0.87/M. No establezcas max como valor predeterminado sin medir costo y latencia.

Habilita respuestas en streaming

Con salidas de hasta 384K tokens y razonamiento extenso, evita esperar a recibir la respuesta completa. Activa stream=True y procesa tanto los deltas de razonamiento como los de contenido:

stream = client.chat.completions.create(
    model="deepseek-v4-pro",
    reasoning_effort="high",
    stream=True,
    messages=[
        {
            "role": "user",
            "content": "Design a rate limiter for a public API. Compare token bucket and sliding window.",
        },
    ],
)

for chunk in stream:
    if not chunk.choices:
        continue  # El chunk final puede incluir solo datos de usage.

    delta = chunk.choices[0].delta

    if getattr(delta, "reasoning_content", None):
        print(delta.reasoning_content, end="", flush=True)
    elif delta.content:
        print(delta.content, end="", flush=True)

En una interfaz, muestra la fase de razonamiento como un estado colapsado de “pensando” y cambia a la respuesta visible cuando empiecen a llegar deltas de content. El transporte usa eventos enviados por el servidor; consulta esta guía de streaming de respuestas API con SSE para revisar la mecánica.

Implementa llamadas a herramientas y salidas estructuradas

V4 Pro admite llamadas a funciones compatibles con OpenAI. Puedes reutilizar el patrón habitual de agentes:

Define herramientas.
Lee tool_calls.
Ejecuta la función en tu aplicación.
Añade el resultado al historial.
Repite hasta obtener una respuesta final.

Ejemplo de definición de herramienta:

tools = [{
    "type": "function",
    "function": {
        "name": "get_endpoint_status",
        "description": "Check the health of an internal API endpoint",
        "parameters": {
            "type": "object",
            "properties": {
                "endpoint": {
                    "type": "string",
                    "description": "Path, e.g. /v1/orders",
                },
            },
            "required": ["endpoint"],
        },
    },
}]

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "user", "content": "Is /v1/orders healthy right now?"}
    ],
    tools=tools,
)

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

Cuando necesites JSON parseable, usa el parámetro estándar response_format. Para la estructura completa de mensajes de herramientas y respuestas, revisa la documentación oficial.

Diseña prompts para aprovechar la caché

La caché de prompts es una de las características más importantes para la arquitectura. DeepSeek almacena automáticamente prefijos repetidos sin cabeceras especiales ni configuración de TTL:

Fallo de caché: $0.435/M tokens de entrada
Acierto de caché: $0.003625/M tokens de entrada

El descuento es de 120 veces para prefijos que la API ya ha procesado.

Supón un agente de código con 200K tokens de contexto de repositorio y 50 llamadas durante una sesión:

Sin caché: 50 × 200K × $0.435/M ≈ $4.35
Con caché automática: un fallo inicial de ≈ $0.087 más 49 aciertos de ≈ $0.0007 cada uno, para un total aproximado de ≈ $0.12

La sesión es aproximadamente 35 veces más barata si mantienes estable el inicio del prompt.

Estructura tus mensajes así:

[Contenido estable]
- Prompt del sistema
- Documentación
- Contexto del repositorio
- Políticas y reglas

[Contenido variable]
- Último mensaje del usuario
- Estado actual de la tarea
- Marcas de tiempo
- IDs de solicitud

Un cambio temprano invalida el prefijo de caché desde ese punto. Por ejemplo, añadir una marca de tiempo al prompt del sistema puede convertir cada llamada en un fallo de caché completo.

Una ventana de contexto de 1M cuesta aproximadamente $0.435 en un fallo, pero si se reutiliza como prefijo estable puede leerse por cerca de un tercio de centavo por llamada. Para más contexto, consulta Qué es el almacenamiento en caché de prompts.

Prueba `deepseek-v4-pro` en Apidog

Antes de integrar el modelo en producción, valida solicitudes, streaming y consumo con un cliente de API. Como DeepSeek es compatible con OpenAI, Apidog puede trabajar con el endpoint sin una configuración especial.

Importa la solicitud. Pega el comando curl anterior en Apidog para convertirlo en una solicitud editable con cabeceras, autenticación y cuerpo ya analizados.
Crea entornos para Pro y Flash. Guarda base_url, la clave API y el nombre del modelo como variables. Cambia entre deepseek-v4-pro y deepseek-v4-flash con un cambio de entorno.
Inspecciona SSE. Envía una solicitud con "stream": true para revisar cómo llegan primero los deltas de reasoning_content y después los de contenido.
Guarda una colección de regresión. Cuando DeepSeek publique otra instantánea, ejecuta las mismas solicitudes y compara respuestas, latencia y uso antes de actualizar.

El visor de respuestas también muestra usage en cada solicitud, útil para comprobar la proporción de aciertos de caché mientras ajustas prompts.

Precios actuales y aumento anunciado

Precios de lista para los endpoints V4:

Modelo	Entrada, fallo de caché	Entrada, acierto de caché	Salida
`deepseek-v4-pro`	$0.435/M	$0.003625/M	$0.87/M
`deepseek-v4-flash`	$0.14/M	—	$0.28/M

El 6 de agosto de 2026, DeepSeek avisó de un aumento “significativo” en el precio de la API. No publicó cifras ni fecha de aplicación.

Mientras no haya más detalles:

Mide el costo por tarea con datos reales de usage.
Maximiza los aciertos de caché manteniendo estables los prefijos.
Mantén V4 Flash como opción de enrutamiento para tareas simples y de alto volumen.
Reserva Pro para codificación agéntica, análisis de contexto largo y tareas que requieran razonamiento.

Consulta la guía de precios de la API DeepSeek V4 para un desglose más detallado.

Preguntas frecuentes

¿Funcionará mi código existente del SDK de OpenAI sin cambios?

Casi. Cambia base_url a https://api.deepseek.com, usa una clave de DeepSeek y establece model="deepseek-v4-pro". Chat Completions, streaming, herramientas y salidas estructuradas siguen formatos compatibles con OpenAI.

Si tu equipo usa Anthropic, puede utilizar el endpoint Messages compatible de DeepSeek.

¿Cuándo debería usar V4 Flash en lugar de V4 Pro?

Usa Flash para clasificación, extracción, chat simple y cargas sensibles a la latencia que no necesiten razonamiento profundo. Usa Pro para programación agéntica, análisis de contexto largo y tareas que aprovechen los modos de pensamiento.

Enruta por tipo de tarea y métricas reales, no por preferencia de modelo.

¿Puedo usar V4 Pro 0813 en Cursor?

Sí. Cursor acepta endpoints personalizados compatibles con OpenAI, por lo que puedes configurar la compilación GA como modelo personalizado. Consulta Cómo usar DeepSeek V4 Pro con Cursor.

Para terminar

Empieza con una clave API, una solicitud mínima, streaming y métricas de usage. Después, selecciona el modo de pensamiento según la tarea y estructura los prompts para mantener los prefijos estables.

El descuento de caché de 120 veces convierte el diseño del prompt en una decisión de arquitectura. Guarda una colección de pruebas en Apidog, vuelve a ejecutarla cuando llegue una nueva instantánea y mide el impacto de cualquier cambio de precio.

¿Cómo usar la API de Grok 4.6?

Roobia — Thu, 13 Aug 2026 03:13:38 +0000

xAI lanzó Grok 4.6 el 12 de agosto de 2026. Está orientado a desarrolladores que construyen agentes de larga duración y flujos de codificación de varios pasos. El modelo cuesta $2 por millón de tokens de entrada y $6 por millón de tokens de salida. Esta guía muestra cómo autenticarte, enviar solicitudes, consumir streaming y preparar pruebas antes de producción.

Prueba Apidog hoy

Al terminar tendrás una clave de API configurada, solicitudes funcionales con curl, Python y JavaScript, manejo de respuestas en streaming y una configuración repetible para validar los endpoints de Grok 4.6. Si prefieres construir y depurar solicitudes visualmente, Apidog permite gestionar el flujo completo.

TL;DR

Crea una clave en console.x.ai, guárdala como XAI_API_KEY y llama a https://api.x.ai/v1/chat/completions con grok-4-6.
La API es compatible con OpenAI: puedes reutilizar los SDK oficiales cambiando la URL base.
Grok 4.6 tiene una ventana de contexto de 500.000 tokens y fecha límite de conocimiento del 1 de febrero de 2026.
El precio es de $2 por millón de tokens de entrada y $6 por millón de tokens de salida. La variante rápida cuesta el doble.
También está disponible mediante OpenRouter, Vercel, Cloudflare, Cursor y Grok Build.
Puedes probar solicitudes, revisar streams SSE y simular endpoints para CI con Apidog.

Con qué estás trabajando

Antes de integrar el modelo, revisa las especificaciones que afectan coste, arquitectura y estrategia de pruebas.

Especificación	Grok 4.6
Fecha de lanzamiento	12 de agosto de 2026
Ventana de contexto	500.000 tokens
Fecha límite de conocimiento	1 de febrero de 2026
Precio de entrada	$2 / 1M de tokens
Precio de salida	$6 / 1M de tokens
Variante rápida	2x el precio
Estilo de API	REST compatible con OpenAI
Disponibilidad	API de xAI, OpenRouter, Vercel, Cloudflare, Cursor, Grok Build

Frente a Grok 4.5, xAI informa mejoras para tareas de agente: el modelo revisa su trabajo con más frecuencia en trayectorias largas y ofrece mejores primeras pasadas en proyectos interactivos y visuales. En benchmarks, pasó del 54% al 65,9% en DeepSWE v1.1 y del 47,1% al 57,5% en APEX-Agents.

Si ya integraste Grok 4.5, la superficie de integración no cambia. Consulta la guía de la API de Grok 4.5 y sustituye el nombre del modelo.

Paso 1: obtén tu clave de API

Ve a console.x.ai e inicia sesión o crea una cuenta de xAI.
Abre Claves de API desde la barra lateral.
Haz clic en Crear clave de API.
Usa un nombre por entorno, por ejemplo grok-dev o grok-prod.
Copia la clave inmediatamente: xAI la muestra una sola vez.

Guárdala en una variable de entorno, nunca directamente en el código:

export XAI_API_KEY="your-key-here"

Usa claves distintas para desarrollo y producción. Añade tus archivos de variables de entorno a .gitignore y revoca la clave desde la consola si se filtra.

Paso 2: envía tu primera solicitud con curl

La API de xAI utiliza el formato de completado de chat compatible con OpenAI.

curl https://api.x.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -d '{
    "model": "grok-4-6",
    "messages": [
      {
        "role": "system",
        "content": "You are a concise technical assistant."
      },
      {
        "role": "user",
        "content": "Explain idempotency in REST APIs in two sentences."
      }
    ]
  }'

Una respuesta correcta incluye:

choices: contiene la respuesta generada por el asistente.
usage: indica los tokens consumidos en entrada y salida.

Registra usage desde la primera integración. Es el dato que necesitarás para medir costes y detectar prompts que crecen sin control.

Si recibes model not found, comprueba qué modelos puede usar tu clave:

curl https://api.x.ai/v1/models \
  -H "Authorization: Bearer $XAI_API_KEY"

Los IDs de modelo pueden variar entre proveedores. Por ejemplo, OpenRouter usa x-ai/grok-4.6.

Paso 3: integra Grok 4.6 con Python y JavaScript

Como la API es compatible con OpenAI, puedes reutilizar el SDK oficial. Solo debes cambiar la clave y base_url.

Python

from openai import OpenAI
import os

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

response = client.chat.completions.create(
    model="grok-4-6",
    messages=[
        {
            "role": "system",
            "content": "You are a concise technical assistant."
        },
        {
            "role": "user",
            "content": "Write a Python function that validates an email address."
        },
    ],
)

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

JavaScript / TypeScript

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.XAI_API_KEY,
  baseURL: "https://api.x.ai/v1",
});

const response = await client.chat.completions.create({
  model: "grok-4-6",
  messages: [
    {
      role: "system",
      content: "You are a concise technical assistant.",
    },
    {
      role: "user",
      content: "Write a TypeScript type guard for a User object.",
    },
  ],
});

console.log(response.choices[0].message.content);
console.log(response.usage);

Esta compatibilidad reduce el coste de migración entre proveedores. Si ya utilizas la API de GPT-5.6, puedes alternar entre ambos modelos con una única variable de configuración.

const model = process.env.LLM_PROVIDER === "xai"
  ? "grok-4-6"
  : "gpt-5.6";

Paso 4: usa respuestas en streaming

Para interfaces orientadas al usuario, activa streaming. Esto permite renderizar la respuesta a medida que llega en lugar de esperar a que termine una salida larga.

stream = client.chat.completions.create(
    model="grok-4-6",
    messages=[
        {
            "role": "user",
            "content": "Refactor this function and explain each change: ..."
        }
    ],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

Las respuestas de streaming llegan mediante Server-Sent Events (SSE). Cada fragmento suele llegar como una línea data:.

Durante la depuración, valida lo siguiente:

Envía stream: true.
Comprueba que tu cliente procesa cada delta.
Desactiva el buffering en proxies inversos si el stream se queda bloqueado.
Prueba la respuesta SSE sin procesar antes de depurar la UI.
Verifica que el frontend conserva el contenido ya recibido si la conexión se interrumpe.

Apidog puede mostrar los fragmentos SSE en tiempo real, lo que facilita distinguir entre una pausa del modelo y un problema de buffering en tu cliente.

Paso 5: usa el contexto de 500K con cuidado

Una ventana de 500.000 tokens puede contener una base de código mediana o cientos de páginas de documentación. Sin embargo, no conviene enviar todo el contexto en cada solicitud.

Ten en cuenta estas dos reglas:

El coste escala con la entrada. A $2 por millón de tokens de entrada, una solicitud de 500K tokens cuesta aproximadamente $1 antes de generar una respuesta.
La posición del contexto importa. Coloca las instrucciones al principio, la documentación o el código de referencia en el medio y la pregunta concreta al final.

Para consultas repetidas sobre el mismo corpus:

Recupera solo los archivos o fragmentos relevantes.
Usa caché para resultados estables.
Resume documentos grandes antes de incluirlos en el prompt.
Mide los tokens enviados por endpoint y por tarea.

La variante rápida, con un coste de 2x, puede ser útil en experiencias interactivas sensibles a la latencia, como asistentes de programación. Para procesos por lotes, análisis nocturno o clasificación masiva, el nivel estándar suele ser más adecuado.

Consulta el desglose de precios de Grok 4.5 para cálculos y comparativas con GPT-5.6 y Claude; su estructura de precios sigue aplicando a 4.6.

Prueba la integración correctamente con Apidog

Un curl funcional no es una integración lista para producción. Necesitas solicitudes versionadas, variables por entorno y errores reproducibles.

Apidog puede ayudarte a estructurar ese flujo:

Crea un proyecto y define un entorno con estas variables:

   base_url = https://api.x.ai/v1
   XAI_API_KEY = tu-clave

Crea una solicitud POST a:

   {{base_url}}/chat/completions

Añade los encabezados:

   Content-Type: application/json
   Authorization: Bearer {{XAI_API_KEY}}

Guarda un cuerpo reutilizable:

   {
     "model": "grok-4-6",
     "messages": [
       {
         "role": "user",
         "content": "Resume este documento en tres puntos."
       }
     ]
   }

Inspecciona visualmente las respuestas en streaming para detectar truncamientos, pausas o fragmentos perdidos.
Añade aserciones de prueba para validar:
- Que choices[0].message.content no esté vacío.
- Que usage.total_tokens se mantenga dentro del presupuesto.
- Que la latencia cumpla con tu SLA.
Simula respuestas con forma de Grok para que frontend y agentes puedan desarrollarse contra un endpoint estable sin consumir tokens en cada ejecución de CI.

Esto es especialmente útil para agentes que realizan docenas de llamadas por tarea. Simula rutas felices y errores previsibles en CI; reserva las llamadas reales para pruebas de integración controladas.

Errores comunes y soluciones rápidas

Error	Causa probable	Solución
`401 No autorizado`	Encabezado `Authorization` faltante o malformado	Verifica el prefijo `Bearer` y confirma que la variable de entorno existe en el shell actual.
`404 modelo no encontrado`	ID de modelo incorrecto para el proveedor	Consulta `/v1/models`. Los revendedores usan IDs distintos, como `x-ai/grok-4.6` en OpenRouter.
`429 Demasiadas solicitudes`	Límite de tasa o cuota agotada	Implementa backoff exponencial y revisa el uso en console.x.ai.
Salida truncada	`max_tokens` es demasiado bajo para la tarea	Aumenta el límite de salida para tareas largas de agente.
Stream bloqueado	Buffering del cliente o un proxy elimina SSE	Confirma `stream: true`, desactiva buffering en el proxy y prueba el stream sin procesar en Apidog.

Preguntas frecuentes

¿La API de Grok 4.6 es compatible con OpenAI?

Sí. El endpoint de completado de chat acepta la misma forma de solicitud y los SDK oficiales de OpenAI funcionan apuntando base_url a https://api.x.ai/v1.

¿Cuánto cuesta la API de Grok 4.6?

Cuesta $2 por millón de tokens de entrada y $6 por millón de tokens de salida. La variante rápida cuesta el doble. No existe un cargo independiente por la ventana de 500K: pagas por los tokens enviados.

¿Necesito una integración nueva si uso Grok 4.5?

No. Cambia el nombre del modelo. El formato de solicitud, la autenticación y los endpoints no han cambiado desde Grok 4.5.

¿Puedo usar Grok 4.6 sin una cuenta de xAI?

Sí. Puedes acceder mediante OpenRouter, Vercel AI Gateway o Cloudflare, cada uno con su propio modelo de facturación. La API nativa suele ser la opción más económica a gran volumen.

¿Qué es Grok 4.6? Características, Rendimiento, Precios y Acceso a la API Explicados

Roobia — Thu, 13 Aug 2026 03:12:42 +0000

Grok 4.6 es el modelo de lenguaje de frontera de xAI, lanzado el 12 de agosto de 2026. Se basa en Grok 4.5 con un enfoque en agentes de larga duración, codificación agéntica y trabajo interactivo o visual. Ofrece una ventana de contexto de 500,000 tokens, con un precio de $2 por millón de tokens de entrada y $6 por millón de salida. En el Índice de Inteligencia de Artificial Analysis obtiene una puntuación de 61, igualando a GPT-5.6 Sol de OpenAI y quedando un punto por debajo de Claude Fable 5 de Anthropic.

Prueba Apidog hoy

En esta guía verás qué cambió respecto a Grok 4.5, cómo interpretar sus benchmarks, dónde usarlo y cómo evaluarlo si construyes integraciones con APIs de LLM. Si trabajas con esa última parte, Apidog ofrece un espacio de trabajo gratuito para diseñar, probar y simular llamadas a APIs de LLM antes de escribir un cliente.

En resumen

Lanzamiento: 12 de agosto de 2026, por xAI.
Enfoque: agentes de largo horizonte, codificación multi-paso y trabajo interactivo o visual. xAI indica que el modelo se auto-prueba y verifica su trabajo con mayor frecuencia antes de continuar.
Especificaciones: ventana de contexto de 500K y fecha límite de conocimiento del 1 de febrero de 2026.
Precios: $2 / 1M de tokens de entrada y $6 / 1M de salida. La variante rápida cuesta el doble. La primera semana incluye el doble de uso en Grok Build y Cursor.
Benchmarks: Índice de Inteligencia 61, empatado con GPT-5.6 Sol; mejoras frente a 4.5 en DeepSWE (54 → 65.9) y APEX-Agents (47.1 → 57.5).
Disponibilidad: API de xAI, Grok Build, Cursor, OpenRouter, Vercel y Cloudflare.

Grok 4.6 de un vistazo

Especificación	Grok 4.6
Desarrollador	xAI
Fecha de lanzamiento	12 de agosto de 2026
Ventana de contexto	500,000 tokens
Fecha límite de conocimiento	1 de febrero de 2026
Precio de entrada / salida	$2 / $6 por 1M de tokens
Variante rápida	2x el precio
Índice de Inteligencia	61 (GPT-5.6 Sol: 61, Claude Fable 5: 62)
Disponibilidad	API de xAI, Cursor, Grok Build, OpenRouter, Vercel, Cloudflare

Qué hay de nuevo frente a Grok 4.5

Grok 4.6 no representa una revelación arquitectónica: el cambio principal está en el entrenamiento. Según xAI, el modelo pasó por una fase de entrenamiento suplementario más larga que Grok 4.5, basada en tres componentes:

Datos curados y generados por modelos, orientados al razonamiento y a conceptos técnicos avanzados.
Conjuntos de datos de ingeniería de alta calidad, continuando el enfoque intensivo en codificación iniciado con sesiones reales de desarrollo.
Un optimizador y una receta de entrenamiento mejorados, con trayectorias de ajuste fino supervisado regeneradas para razonamiento y dominios específicos.

El cambio más visible para desarrolladores es la auto-verificación. Durante ejecuciones agénticas largas, Grok 4.6 puede comprobar su trabajo antes de continuar: ejecutar la prueba que acaba de escribir, releer el archivo que editó o validar una suposición antes de encadenar el siguiente paso.

xAI también informa de mejores resultados iniciales en proyectos interactivos y visuales, como paneles, aplicaciones pequeñas y tareas de interfaz de usuario.

Si te interesa el enfoque de entrenamiento de la versión anterior, consulta nuestro análisis sobre lo que significó el entrenamiento con sesiones de Cursor para los desarrolladores.

Benchmarks: qué números importan

Los benchmarks de lanzamiento reportados por proveedores requieren cautela, pero las mejoras entre Grok 4.5 y 4.6 son suficientemente grandes como para justificar una evaluación práctica.

Estas son las tres conclusiones principales:

La brecha en agentes se redujo. El aumento de 10.4 puntos en APEX-Agents deja a Grok 4.6 a 1.7 puntos de Fable 5 Max y ligeramente por delante de GPT-5.6 Sol Max (56.7%).
La codificación a escala de repositorio mejoró más. El incremento de casi 12 puntos en DeepSWE indica una mejora importante en cambios que abarcan varios archivos, aunque Sol Max sigue liderando ese benchmark.
Las mediciones independientes apoyan la narrativa de coste. Artificial Analysis registró un coste promedio de $0.84 por tarea en evaluaciones agénticas, el más bajo entre modelos de frontera, y un Elo de 1753 en GDPval-AA v2 para trabajo de conocimiento profesional.

Para interpretar los resultados de xAI con más contexto, consulta nuestro análisis de benchmarks de Grok 4.5.

Precios: una propuesta de valor en la frontera

Grok 4.6 mantiene el precio de Grok 4.5:

Entrada: $2 por 1M de tokens.
Salida: $6 por 1M de tokens.

Comparado con otros modelos de frontera:

Modelo	Precio de salida / 1M de tokens
Grok 4.6	$6
Claude Opus 4.8	$25
GPT-5.6 Sol	$30

Esto supone una diferencia de 5x en tokens de salida frente a GPT-5.6 Sol para un modelo que lo iguala en el índice compuesto de inteligencia.

Sin embargo, tokens baratos no implican automáticamente tareas más baratas. Si un modelo requiere más revisiones, reintentos o reparaciones, el coste total puede crecer. Por eso debes medir el coste por tarea sobre tus propios flujos, no solo el precio por token.

La variante rápida cuesta el doble, $4/$12 por 1M de tokens, y está orientada a casos interactivos sensibles a la latencia. Hasta el 19 de agosto, Grok Build y Cursor incluyen el doble de uso para probar el modelo.

Dónde puedes usar Grok 4.6 hoy

Puedes evaluar Grok 4.6 desde estas plataformas:

API de xAI, a través de console.x.ai, con compatibilidad con OpenAI. La guía de la API de Grok 4.5 se aplica directamente; solo debes cambiar el nombre del modelo.
Cursor, como opción de modelo dentro del IDE.
Grok Build, el espacio de trabajo agéntico de xAI, con el bono de uso doble durante la semana de lanzamiento.
OpenRouter, Vercel y Cloudflare, para equipos que enrutan varios modelos mediante una única puerta de enlace. En OpenRouter aparece como x-ai/grok-4.6.

No hay un lanzamiento de consumo separado que debas distinguir: esta versión está orientada principalmente a desarrolladores. La forma más rápida de evaluarla es mediante la API o desde un IDE que ya la integre.

Cómo probar Grok 4.6 con una API compatible con OpenAI

La compatibilidad con OpenAI permite reutilizar gran parte de un cliente existente. Cambia el endpoint a:

https://api.x.ai/v1

Después, ejecuta las mismas pruebas que ya usas con otros proveedores:

Envía una tarea representativa de producción.
Registra latencia, tokens de entrada y salida, errores y reintentos.
Evalúa la calidad de la respuesta con criterios verificables.
Repite la prueba con GPT, Claude y Grok usando el mismo prompt y las mismas herramientas.
Compara coste por tarea completada, no solo coste por token.

Para cargas de trabajo agénticas, incluye pruebas que cubran:

Edición de múltiples archivos.
Ejecución y reparación de pruebas.
Llamadas a herramientas o funciones.
Manejo de errores de herramientas.
Tareas largas con estado acumulado.

Limitaciones y preguntas abiertas

Una evaluación de la semana de lanzamiento debe incluir las advertencias junto a los resultados principales:

La mayoría de benchmarks son reportados por el proveedor. Artificial Analysis publicó puntuaciones independientes que concuerdan en términos generales, pero los resultados específicos de codificación, como DeepSWE, FrontierCode y CursorBench, proceden de la tabla de lanzamiento de xAI.
La ventana de contexto es menor que otras opciones de frontera. Los 500K tokens cubren muchas cargas de trabajo reales, pero GPT-5.6 Sol ofrece 1.05M y Claude Fable 5 ofrece 1M. La diferencia importa si procesas monorepos completos o conjuntos documentales muy grandes en una llamada.
Sol sigue liderando en codificación autónoma de repositorios grandes. La diferencia de 7 puntos en DeepSWE sugiere que GPT-5.6 Sol Max sigue siendo más fuerte para trabajo completamente autónomo sobre bases de código existentes.
El ecosistema de xAI es más joven. El procesamiento por lotes, los niveles de caché de prompts y los controles de uso todavía tienen menos madurez que sus equivalentes en OpenAI y Anthropic. La compatibilidad con OpenAI cubre gran parte de los casos, pero no todos.

Estas limitaciones no descartan a Grok 4.6. Definen mejor su posición: una opción competitiva de precio-rendimiento que debes evaluar con tus tareas reales.

Qué significa para los desarrolladores de API

La conclusión estratégica es clara: la frontera tiene ahora un competidor de precio real. Hasta este lanzamiento, igualar resultados de nivel GPT-5.6 Sol implicaba pagar entre $25 y $30 por millón de tokens de salida. Grok 4.6 anuncia ese precio en $6.

La diferencia es especialmente relevante en bucles agénticos. Un agente que realiza 40 llamadas por tarea percibe de inmediato una diferencia de 5x en el coste de salida.

En la práctica, la API compatible con OpenAI permite evaluarlo en una tarde:

Apunta tu cliente existente a https://api.x.ai/v1.
Ejecuta una carga de trabajo real.
Mide calidad, latencia, uso de tokens, errores y coste por tarea.
Compara los resultados con tus modelos actuales.

Puedes configurar esta comparación en Apidog para mantener solicitudes de GPT-5.6, Claude y Grok 4.6 en un único proyecto. Usa entornos por proveedor y añade aserciones para validar calidad de salida, uso de tokens y latencia antes de mover una carga de trabajo a producción.

El enfoque de Grok 4.6 en agentes también hace más importante validar las llamadas a herramientas. Si tu integración usa function calling, prueba las cargas útiles estructuradas que genera el modelo, no solo el texto de la respuesta.

Preguntas frecuentes

¿Qué es Grok 4.6 en una frase?

Es el modelo de frontera de xAI de agosto de 2026, optimizado para agentes de larga duración y codificación, con una ventana de contexto de 500K y benchmarks de nivel de frontera a aproximadamente una quinta parte del precio de salida de algunos competidores.

¿Es Grok 4.6 mejor que GPT-5.6?

Empatan en el Índice de Inteligencia de Artificial Analysis con 61 puntos. GPT-5.6 Sol Max lidera en codificación a escala de repositorio mediante DeepSWE; Grok 4.6 supera ligeramente en APEX-Agents y cuesta aproximadamente 5 veces menos por token de salida.

¿Cuál es la diferencia entre Grok 4.5 y Grok 4.6?

Mantienen el mismo precio y la misma API, pero Grok 4.6 obtiene mejoras de +11.9 puntos en DeepSWE y +10.4 en APEX-Agents, además de una mayor tendencia a auto-verificarse durante tareas largas.

¿Puedo probar Grok 4.6 gratis?

Grok Build y Cursor incluyen el doble de uso durante la semana de lanzamiento. Los métodos de nuestra guía para usar Grok 4.5 gratis se aplican en gran medida a Grok 4.6.

Tu API Elimina Metadatos C2PA: Cómo Detectarlo con una Prueba

Roobia — Wed, 12 Aug 2026 06:59:26 +0000

Claude ahora adjunta metadatos de procedencia C2PA firmados a los archivos que genera. También lo hacen los modelos de imagen de OpenAI, y también Gemini. Esto significa que una señal de procedencia real está llegando a su endpoint de carga por primera vez, y hay una buena probabilidad de que su pipeline la esté eliminando antes de que alguien la vea.

Pruebe Apidog hoy

No de forma maliciosa: ocurre por defecto. sharp().resize() genera un archivo limpio sin metadatos, salvo que indique lo contrario. Lo mismo sucede con ImageMagick, Pillow y la mayoría de los CDN de imágenes. El manifiesto entra, sale un JPEG más pequeño y sus registros no informan nada.

Este es un fallo comprobable. En este artículo verá cómo identificar dónde se pierden los metadatos, cómo probar su pipeline de extremo a extremo y cómo añadir una verificación permanente en CI. Apidog orquesta el flujo HTTP; c2patool verifica el archivo a nivel de bytes.

Qué se destruye realmente

Un manifiesto C2PA es un bloque firmado criptográficamente e incrustado en el contenedor del archivo. Registra quién firmó el activo y qué se afirmó sobre él. Como está firmado, cambiar los bytes sin volver a firmar invalida la firma de una forma detectable por cualquier verificador.

La clave está en el contenedor: si lo reescribe, el manifiesto puede desaparecer.

Operación	¿El manifiesto sobrevive por defecto?
Copia o movimiento byte a byte	Sí
`sharp().resize().toBuffer()`	No
ImageMagick `convert` / `magick`	No
Pillow `Image.save()`	No
PNG a WebP, JPEG a AVIF	No
Autooptimización de CDN de imágenes	Usualmente no
Captura de pantalla	No
Volver a guardar desde un editor de imágenes	No
Subida a S3 sin transformación	Sí

Todo lo que aparece como “No” es habitual en una aplicación web: miniaturas, variantes responsivas, negociación de formato o limpieza de EXIF por privacidad. Cada operación es razonable de forma aislada, pero puede terminar silenciosamente la cadena de procedencia.

También hay un conflicto práctico: -strip suele utilizarse para eliminar coordenadas GPS y números de serie de cámaras presentes en EXIF. Sin embargo, eliminar todos los metadatos también elimina el manifiesto C2PA. La solución es eliminar de forma selectiva los bloques que no quiere conservar, en lugar de borrar todos los metadatos.

Pruébelo en dos minutos

Antes de cambiar el pipeline, confirme el problema. Necesita un archivo con un manifiesto válido: puede usar una imagen generada por Claude o una muestra firmada de la Content Authenticity Initiative.

Instale la CLI de referencia:

cargo install c2patool

Compruebe que el fixture está firmado:

c2patool fixtures/signed-sample.png

Debería recibir un informe JSON con el generador de la reclamación y el estado de validación de la firma.

Ahora envíe el archivo por su pipeline real y recupérelo usando la misma URL que consume su frontend:

# Subir a través de su endpoint real
curl -sS -X POST https://api.example.com/v1/assets \
  -H "Authorization: Bearer $API_TOKEN" \
  -F "file=@fixtures/signed-sample.png" \
  -o /tmp/upload.json

# Recuperarlo a través de la URL que usaría su frontend
ASSET_URL=$(jq -r '.url' /tmp/upload.json)
curl -sS "$ASSET_URL" -o /tmp/roundtrip.png

# ¿Sobrevivió el manifiesto?
c2patool /tmp/roundtrip.png

Interprete el resultado:

Informe válido: el manifiesto sobrevivió.
Manifiesto no encontrado: alguna etapa del pipeline lo eliminó.
Error de validación: el manifiesto existe, pero la firma ya no coincide con los bytes.

El tercer caso es especialmente importante. Normalmente indica que una biblioteca preservó el bloque de metadatos mientras modificaba los píxeles. Para cualquier verificador posterior, eso parece una alteración del archivo.

Encuentre la etapa que lo elimina

Si la prueba de extremo a extremo falla, no adivine. Divida el pipeline y ejecute c2patool inmediatamente después de cada etapa:

Después de recibir la carga.
Después del redimensionamiento.
Después de convertir el formato.
Después de almacenar en el origen.
Después de recuperar desde el CDN.

Los sospechosos habituales son los siguientes.

1. Redimensionamiento o generación de miniaturas

Es el caso más probable. En sharp, los metadatos se eliminan salvo que los conserve explícitamente:

// Elimina el manifiesto C2PA
await sharp(input).resize(1200).toFile(output);

// Conserva el bloque de metadatos
await sharp(input).resize(1200).keepMetadata().toFile(output);

Conservar el bloque es necesario, pero no suficiente. Los píxeles cambiaron, por lo que la firma original ya no será válida para los bytes nuevos.

Para mantener una cadena de procedencia funcional:

Conserve los metadatos necesarios.
Aplique la transformación.
Vuelva a firmar la salida.
Registre la transformación como una aserción de acción, normalmente c2pa.resized.

Las bibliotecas c2pa para Rust, Python, JavaScript y C permiten implementar este flujo.

2. Conversión de formato

Servir AVIF o WebP crea un contenedor nuevo. La regla es la misma: preserve y vuelva a firmar, o acepte explícitamente que la cadena de procedencia termina en esa transformación.

3. CDN de imágenes

Muchos CDN reescriben imágenes en el momento de la entrega. Algunos preservan y vuelven a firmar Credenciales de Contenido de forma nativa; históricamente, la mayoría las eliminaban.

Pruebe siempre la URL de entrega real que visitan sus usuarios, no solo el archivo de origen. Una prueba contra el origen puede pasar aunque el CDN elimine el manifiesto.

4. Normalización durante la carga

Los servicios que recodifican archivos al recibirlos para estandarizar formatos suelen pasar desapercibidos. Con frecuencia, esta lógica vive en un repositorio de infraestructura separado del backend principal.

Conviértalo en una prueba permanente

Un único curl valida el estado actual, pero no evita que alguien introduzca una transformación en el próximo sprint. La verificación debe formar parte de CI.

Divida la prueba en dos capas:

Orquestación HTTP de ida y vuelta.
Verificación criptográfica del archivo recuperado.

Capa uno: viaje de ida y vuelta en Apidog

La orquestación es un escenario de API encadenado:

Subir un fixture firmado.
Extraer la URL devuelta.
Recuperar el activo por la ruta de entrega real.
Comprobar estado, tipo de contenido y tamaño.

En Apidog, cree un escenario con dos pasos.

Paso 1: POST /v1/assets

Cuerpo: multipart/form-data con el fixture firmado.
Aserciones: estado 201 y respuesta válida según su esquema.
Script posrespuesta para guardar la URL:

const body = pm.response.json();

pm.environment.set("ASSET_URL", body.url);

pm.test("upload returns a delivery URL", function () {
  pm.expect(body.url).to.be.a("string").and.to.include("https://");
});

La mecánica de carga es la misma que en la prueba de APIs de carga de archivos.

Paso 2: GET {{ASSET_URL}}

Aserciones: estado 200, Content-Type esperado y tamaño de respuesta cercano al archivo original.
Una caída importante de tamaño es una señal útil de recodificación.

const uploadedBytes = Number(pm.environment.get("FIXTURE_BYTES"));
const returnedBytes = pm.response.responseSize;

pm.test("asset was not silently re-encoded", function () {
  pm.expect(returnedBytes).to.be.above(uploadedBytes * 0.9);
});

El tamaño es una heurística, no una prueba criptográfica. Es útil para detectar fallos obvios de forma económica dentro de la misma suite HTTP. Consulte más patrones en aserción de APIs.

Capa dos: verificación a nivel de bytes en CI

Validar una firma exige analizar el contenedor del archivo. Ese trabajo corresponde a c2patool, no a un cliente HTTP.

Ejecute c2patool contra el archivo descargado por el escenario de ida y vuelta:

# .github/workflows/provenance.yml
name: provenance

on: [pull_request]

jobs:
  c2pa-round-trip:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Instalar c2patool
        run: cargo install c2patool

      - name: Instalar Apidog CLI
        run: npm install -g apidog-cli

      - name: Ejecutar el escenario de ida y vuelta
        run: |
          apidog run --access-token "$APIDOG_ACCESS_TOKEN" \
            -t "$SCENARIO_ID" \
            -e "$ENV_ID" \
            -r cli,html \
            --out-dir ./apidog-reports
        env:
          APIDOG_ACCESS_TOKEN: ${{ secrets.APIDOG_ACCESS_TOKEN }}
          SCENARIO_ID: ${{ vars.PROVENANCE_SCENARIO_ID }}
          ENV_ID: ${{ vars.APIDOG_ENV_ID }}

      - name: Verificar que el manifiesto sobrevivió
        run: |
          set -euo pipefail
          curl -sS "$ASSET_URL" -o /tmp/roundtrip.png
          c2patool /tmp/roundtrip.png > /tmp/report.json
          jq -e '.validation_status == null or (.validation_status | length) == 0' /tmp/report.json

set -euo pipefail es importante. Sin esta instrucción, un fallo de c2patool ante un archivo sin metadatos puede convertirse en una advertencia y dejar la compilación en verde: exactamente el fallo que esta prueba pretende evitar.

Para configurar escenarios en un pipeline, consulte la automatización de pruebas de API en GitHub Actions.

Capa tres opcional: endpoint de verificación

Si la procedencia es una característica de producto y no solo un control interno, añada un endpoint propio que ejecute una biblioteca c2pa y devuelva un resultado estructurado.

Así puede probarlo como JSON normal y el frontend recibe un estado explícito:

{
  "asset_id": "img_9f2c41",
  "provenance": {
    "status": "verified",
    "standard": "c2pa",
    "signer": "Anthropic",
    "signature_valid": true,
    "checked_at": "2026-08-11T09:14:22Z",
    "tool": "c2patool/0.9"
  }
}

Mantenga al menos tres estados:

verified: hay un manifiesto y la firma es válida.
absent: no se encontró ningún manifiesto.
invalid: existe un manifiesto, pero la firma no coincide con los bytes.

No reduzca absent e invalid a un booleano. Representan situaciones distintas y invalid es una señal mucho más relevante. Si el verificador puede no estar disponible, añada unchecked para no confundir una interrupción con un resultado limpio.

Documente esta respuesta en OpenAPI y valídela para evitar que los campos desaparezcan durante una refactorización. Consulte Cómo validar especificaciones OpenAPI.

Los cuatro fixtures que debe conservar

Una suite de procedencia necesita casos deliberadamente defectuosos, no solo un camino feliz.

Archivo firmado válido

Resultado esperado: verified. Detecta eliminación excesiva de metadatos.
Archivo sin metadatos

Use la misma imagen, pero elimine el manifiesto con exiftool -all=.

Resultado esperado: absent, no un error y nunca verified.
Archivo manipulado

Use un archivo firmado y altere un byte después de la firma.

Resultado esperado: invalid. Este caso demuestra que valida la firma y no solo la existencia de un bloque de metadatos.
Formato no compatible

Use un formato sin soporte de manifiestos.

Resultado esperado: absent de forma limpia, no un error 500.

Guarde los cuatro fixtures en el repositorio junto al escenario de prueba. Son pequeños, no deberían cambiar y convierten una prueba que “pasa” en una prueba que realmente valida el comportamiento esperado.

Por qué merece la pena

Hay tres motivos principales.

La afirmación de su producto. Si su interfaz muestra un distintivo de procedencia, pero el pipeline elimina manifiestos durante el redimensionamiento, ese distintivo será incorrecto para todos los activos transformados.
Cumplimiento. Si depende de C2PA para requisitos relacionados con el Artículo 50, un manifiesto eliminado significa que su control no funciona. La separación entre proveedor y desplegador se explica en el Artículo 50 de la Ley de IA de la UE para desarrolladores de API.
La señal de procedencia. C2PA solo aporta valor cuando la cadena se mantiene de extremo a extremo. Cada pipeline que elimina manifiestos silenciosamente reduce la utilidad del ecosistema, incluso cuando necesita verificar un activo usted mismo.

Descargue Apidog para crear el escenario de ida y vuelta contra sus endpoints y añada después la verificación con c2patool en CI.

Preguntas frecuentes

¿El redimensionamiento de una imagen elimina los metadatos C2PA?

Sí, por defecto en las bibliotecas más comunes. Conservar el bloque requiere una opción explícita y mantener una firma válida requiere volver a firmar la salida transformada.
¿Cómo verifico si un archivo tiene metadatos C2PA?

Ejecute c2patool <file> desde la línea de comandos o arrastre el archivo a la página de verificación de Content Credentials.
¿Puedo mantener los metadatos C2PA al redimensionar?

Sí, pero no basta con conservarlos. Debe preservar el bloque, volver a firmar la salida y registrar la transformación mediante una aserción de acción como c2pa.resized.
¿Los CDN eliminan las Credenciales de Contenido?

Muchos las eliminan cuando autooptimizan imágenes. Algunos las preservan y vuelven a firmar de forma nativa. Pruebe la URL de entrega real, no solo el origen.
¿Cuál es la diferencia entre un manifiesto eliminado y uno inválido?

absent significa que no hay manifiesto. invalid significa que existe, pero su firma no coincide con los bytes, lo que indica que el archivo cambió después de firmarse.
¿Puede Apidog verificar directamente una firma C2PA?

Apidog orquesta el viaje de ida y vuelta y puede validar respuestas HTTP o JSON de un endpoint de verificación. El análisis criptográfico de la firma corresponde a c2patool, ejecutado en CI o dentro de su propio servicio.
¿Debo eliminar EXIF por privacidad y conservar C2PA?

Sí. El enfoque correcto es selectivo: elimine los bloques EXIF específicos que no desea conservar y mantenga el manifiesto C2PA. Un -strip general elimina ambos.

La conclusión

Los metadatos de procedencia suelen llegar intactos a su API y perderse durante una transformación posterior sin que sus métricas lo detecten.

La implementación mínima es clara:

Añada un fixture firmado.
Súbalo por su endpoint real.
Descárguelo desde la URL de entrega real.
Verifíquelo con c2patool.
Haga fallar CI cuando el manifiesto esté ausente o sea inválido.

Con una configuración breve, convierte un distintivo de procedencia en su interfaz en una garantía que su pipeline aplica de verdad.

Apidog CLI: El cliente API en tu terminal

Roobia — Wed, 12 Aug 2026 06:41:15 +0000

Tu espacio de trabajo API vive en una GUI, pero tu jornada laboral ocurre en una terminal. Cada cambio de contexto cuesta tiempo y concentración; en CI o durante una sesión con un agente de IA, la GUI ni siquiera es una opción. La CLI de Apidog lleva toda la plataforma Apidog—pruebas, endpoints, esquemas, entornos, mocks y documentación—al prompt de shell que ya utilizas.

Prueba Apidog hoy

La CLI de Apidog no es otro curl. Para lanzar un GET puntual y revisar el JSON, curl y HTTPie son suficientes; la recopilación de clientes REST de terminal y TUI cubre ese caso. La CLI de Apidog está pensada para trabajar con tu espacio de trabajo API: ejecuta escenarios de prueba, lee y actualiza el contrato API y mueve especificaciones dentro y fuera del proyecto mediante comandos que puede invocar un script o un agente.

Qué significa “reside en tu terminal”

Las herramientas HTTP de terminal gestionan una solicitud cada vez. La CLI de Apidog opera a nivel de proyecto y agrupa sus más de cuarenta comandos en cinco áreas:

Tarea	Comandos
Ejecutar pruebas	`run`, `test-scenario`, `test-suite`, `test-case`, `test-data`, `test-report`
Gestionar el contrato	`endpoint`, `schema`, `folder`, `common-parameter`, `response-component`, `security-scheme`
Publicar documentación y mocks	`doc`, `docs-site`, `shared-doc`, `mock`
Configurar e integrar	`environment`, `variables`, `vault`, `database-connection`, `websocket`, `socketio`
Operar en equipo	`branch`, `merge-request`, `runner`, `scheduled-task`, `audit-log`, `import`, `export`

Todos los comandos admiten --help, devuelven JSON estructurado y, en la mayoría de los casos, incluyen agentHints.nextSteps con los siguientes pasos recomendados. Esto permite que una persona o un agente continúe el flujo sin tener que memorizar toda la CLI.

Instala la CLI

La CLI se distribuye como el paquete npm apidog-cli y funciona en macOS, Linux y Windows. Requiere Node.js 16 o posterior.

npm install -g apidog-cli
apidog --version

Inicia sesión con un token de acceso API. Puedes obtenerlo en la aplicación Apidog desde tu avatar → Configuración de la cuenta → Token de Acceso API.

apidog login --with-token <YOUR_TOKEN>

El token se guarda en ~/.apidog/config.toml. No lo incluyas en repositorios ni en los registros de CI. En una tubería, utiliza un secreto y pásalo mediante --access-token:

apidog run \
  --access-token "$APIDOG_TOKEN" \
  -t <scenario_id> \
  -e <env_id> \
  -r cli

Estas banderas globales cubren la mayoría de los casos:

--project: selecciona el proyecto.
--branch: selecciona la rama.
--access-token: sustituye la sesión guardada.
--api-base-url: apunta a una implementación de Apidog autoalojada.

Consulta la guía de autenticación de la CLI de Apidog para configurar tokens en CI.

Ejecuta las pruebas creadas visualmente

El flujo principal es crear un escenario de prueba en el editor visual de Apidog y ejecutarlo desde cualquier entorno con shell. Un escenario puede incluir:

Solicitudes encadenadas.
Variables extraídas de una respuesta y reutilizadas en la siguiente.
Aserciones sobre el estado HTTP y el cuerpo.
Datos de prueba desde archivos CSV o JSON.

En la pestaña CI/CD del escenario encontrarás el comando con los identificadores correspondientes:

apidog run -t <scenario_id> -e <env_id> -r cli

El proceso termina con código 0 cuando todas las aserciones pasan y con un código distinto de cero cuando alguna falla. Por eso puedes integrarlo directamente en CI sin añadir lógica adicional.

Para ejecutar el mismo escenario en distintos entornos, cambia -e:

apidog run -t <scenario_id> -e <development_env_id> -r cli
apidog run -t <scenario_id> -e <staging_env_id> -r cli

También puedes proporcionar un archivo CSV o JSON para repetir el escenario con cada fila. Este es el flujo de testing impulsado por datos sin duplicar pasos. Si partes desde cero, sigue el tutorial paso a paso de REST API.

Genera informes para CI

La CLI admite cuatro formatos de informe:

cli: muestra los resultados paso a paso en la terminal.
html: genera un informe HTML.
json: genera datos estructurados.
junit: genera resultados compatibles con paneles de CI.

Los formatos de archivo se guardan en apidog-reports/. Puedes combinarlos:

apidog run \
  -t <scenario_id> \
  -e <env_id> \
  -r cli,junit

La guía de informes de prueba muestra el contenido de cada formato.

Si las pruebas no deben depender de un portátil, los comandos runner y scheduled-task permiten gestionar runners autoalojados y ejecuciones programadas, la misma maquinaria utilizada por las pruebas API programadas en Apidog.

Gestiona el contrato API desde la terminal

La CLI que ejecuta tus pruebas también puede consultar y modificar la definición de tu API:

apidog endpoint list --project <project_id>
apidog schema get <schema_id>
apidog environment list
apidog mock list

Puedes consultar y editar endpoints, esquemas de datos, carpetas, entornos, variables, esquemas de seguridad y componentes reutilizables.

El comando mock gestiona las expectativas de simulación y los pares fijos de solicitud y respuesta que devuelve el servidor mock. Los comandos doc y docs-site gestionan la documentación publicada. Los endpoints de WebSocket y Socket.IO tienen sus propios grupos, mientras que database-connection cubre las configuraciones de base de datos utilizadas por los escenarios de prueba.

Importa y exporta especificaciones

La CLI admite OpenAPI 3.x, Swagger 2.0 y colecciones de Postman. Esto permite automatizar migraciones y sincronizaciones desde scripts:

apidog import openapi.json --project <project_id>
apidog export --format openapi

Puedes extraer una especificación de otro sistema, importarla en Apidog y versionar el intercambio junto con el resto del proyecto. Consulta la especificación de OpenAPI para conocer el estándar utilizado por gran parte del ecosistema.

Usa la CLI con agentes de IA

Las versiones de 2026 de la CLI están orientadas a que un agente de codificación pueda operar un espacio de trabajo API de forma controlada. Cuatro capacidades son especialmente útiles.

1. Salida estructurada

Cada comando devuelve JSON que un agente puede analizar. Además, agentHints.nextSteps sugiere qué ejecutar después, incluso cuando se produce un error.

2. Esquemas de entrada y validación

Los comandos cli-schema exponen la estructura JSON que esperan las operaciones de escritura:

apidog cli-schema list
apidog cli-schema get <command>
apidog cli-schema validate <payload.json>

El flujo recomendado para escribir de forma segura es:

Obtener el esquema del comando.
Generar el JSON.
Validar la carga útil.
Ejecutar create o update.

3. Habilidad empaquetada

El comando skill proporciona el conocimiento operativo de la CLI en un formato que los agentes pueden cargar directamente. Esta es la razón detrás de la habilidad de la CLI de Apidog.

Según las mediciones descritas por Apidog, los agentes que trabajan mediante el esquema de la CLI utilizaron aproximadamente un 30 % menos de llamadas a herramientas y un 25 % menos de tokens que los agentes que generaban cargas útiles por inferencia. Los datos están detallados en este análisis.

4. Puertas de permiso y ramas de IA

De forma predeterminada, las escrituras en una rama iniciadas por IA están bloqueadas hasta que un humano habilita los Permisos de Edición de IA Externa. Esta opción está disponible en el cliente Apidog 2.8.32 o posterior, dentro de Configuración del Proyecto → Configuración de Funciones → Configuración de Funciones de IA.

Otra opción es utilizar una rama de IA. El agente puede importar los recursos necesarios, realizar cambios aislados y devolverlos como una solicitud de fusión para revisión humana. Las ramas de IA sin cambios se autoarchivan después de 24 horas. Así, el contrato API sigue siendo revisable aunque el primer borrador lo genere un agente.

Límites de la CLI de Apidog

Elegir una herramienta resulta más sencillo cuando sus límites están claros.

No es un cliente HTTP interactivo

No está diseñada para escribir un POST ad hoc y mostrar una respuesta con formato. Para ese trabajo, utiliza curl, HTTPie o un cliente TUI.

No es de código abierto

El paquete es propietario, npm es el único canal de instalación y cualquier operación más allá de --help requiere una cuenta de Apidog. El nivel gratuito cubre el flujo de trabajo descrito aquí. Si necesitas una licencia auditable, un runner de código abierto puede ser una opción más adecuada.

No es independiente de Apidog

La CLI es la interfaz de terminal de la plataforma. Los escenarios, endpoints y entornos viven en tu proyecto de Apidog, no en archivos locales. Esa dependencia proporciona una fuente única de verdad para el diseño, las pruebas, los mocks y la documentación.

Dónde encaja frente a otras herramientas

La principal diferencia está en dónde se crean las pruebas:

Newman y la CLI de Postman ejecutan colecciones creadas en Postman.
Hurl y Bruno ejecutan pruebas definidas como archivos de texto.
La CLI de Apidog ejecuta escenarios creados en un editor visual que también contiene el contrato, los mocks y la documentación.

La comparación entre Apidog CLI y Newman profundiza en esas diferencias. También puedes consultar la recopilación de herramientas de prueba de API basadas en terminal.

Una configuración práctica para muchos equipos es:

Utilizar curl o xh para comprobaciones rápidas.
Crear escenarios reutilizables en Apidog.
Ejecutarlos en CI con apidog run.
Publicar informes JUnit como artefactos de la tubería.

El tutorial de GitHub Actions incluye una tubería lista para adaptar.

Preguntas frecuentes

¿Es gratuita la CLI de Apidog?

Sí. El paquete se instala gratuitamente desde npm y el nivel gratuito de Apidog cubre la creación y ejecución de escenarios mediante la CLI. Los planes de pago añaden características para equipos, no el acceso básico a la CLI.

¿Sustituye a curl o HTTPie?

No. Esas herramientas envían solicitudes ad hoc; la CLI de Apidog ejecuta escenarios guardados y gestiona recursos del proyecto. Puedes utilizar ambas categorías según el caso.

¿Puede ejecutarse sin interfaz gráfica en CI?

Sí. Utiliza --access-token con un secreto de CI, ejecuta apidog run con el ID del escenario y condiciona la construcción al código de salida. El runner no necesita la aplicación de escritorio.

¿Qué formatos puede importar y exportar?

OpenAPI 3.x, Swagger 2.0 y colecciones de Postman, en ambas direcciones.

¿Cómo utilizan los agentes de IA la CLI de forma segura?

Mediante el flujo esquema-validación-escritura y las puertas de permiso. cli-schema validate detecta cargas útiles mal formadas antes de aplicarlas, mientras que las ramas de IA mantienen los cambios aislados hasta que una persona los fusiona. Consulta cómo usar la CLI de Apidog en Claude Code para ver un ejemplo.

La terminal es donde ya ejecutas tus pruebas y donde trabajan tus agentes. Instala la CLI desde npm y ejecuta un escenario de principio a fin. Puedes descargar Apidog y consultar la referencia completa de la CLI de Apidog cuando necesites ir más allá de run.

Mejores Herramientas de Testing de API desde la Terminal en 2026

Roobia — Wed, 12 Aug 2026 04:26:04 +0000

Las pruebas de API ya no dependen de una interfaz gráfica. Hoy se ejecutan en contenedores de CI sin pantalla, entornos de staging accesibles solo por SSH y agentes de IA que operan mediante shell. En todos esos casos, una prueba debe poder instalarse, ejecutarse y devolver un código de salida desde la terminal.

Prueba Apidog hoy

Esta guía reúne herramientas que realizan pruebas reales desde la línea de comandos. Una herramienta «basada en terminal» debe permitir completar el ciclo desde un shell:

Instalarla con un gestor de paquetes.
Ejecutar pruebas con un comando.
Evaluar el resultado mediante el código de salida.
Generar resultados útiles para CI.

La clasificación prioriza aserciones integradas, flujos de varios pasos, informes para CI y estado de mantenimiento. Clientes manuales como curl también aparecen porque siguen siendo esenciales entre ejecuciones de pruebas. Para una comparación más amplia, incluidas herramientas GUI y alojadas, consulta las mejores herramientas gratuitas para pruebas de API.

Qué diferencia a una herramienta de prueba de un cliente

Un cliente de terminal envía una solicitud y muestra la respuesta. Una herramienta de pruebas evalúa esa respuesta y devuelve un veredicto que tu pipeline puede usar como compuerta de despliegue.

Busca estas cuatro capacidades:

Aserciones integradas: valida estados HTTP, encabezados y cuerpos sin depender de scripts improvisados con jq.
Códigos de salida útiles: 0 para éxito y un valor distinto de cero para fallo.
Repetibilidad: pruebas guardadas en archivos o proyectos versionables, no en el historial del shell.
Informes: salida legible en consola y formatos como JSON, JUnit o HTML para CI.

Con esos criterios, estas son diez herramientas prácticas para pruebas de API desde terminal.

1. Apidog CLI: crea visualmente y ejecuta sin interfaz gráfica

Apidog es una plataforma API que cubre diseño, pruebas, mocking y documentación. Su CLI, apidog-cli, permite ejecutar desde terminal los escenarios que creas en el editor visual.

El flujo de trabajo es:

Crea un escenario con solicitudes encadenadas, variables y aserciones.
Abre la pestaña CI/CD del escenario.
Copia el comando generado.
Ejecútalo localmente, en CI o desde un agente.

npm install -g apidog-cli
apidog login --with-token <YOUR_TOKEN>

# Copia el comando exacto desde la pestaña CI/CD del escenario
apidog run -t <scenario_id> -e <env_id> -r cli

No necesitas adivinar IDs: Apidog genera el comando desde el escenario. Puedes usar los reporteros cli, html, json y junit; los archivos se escriben en apidog-reports/.

Para pruebas controladas por datos, usa archivos CSV o JSON como fuente de iteraciones. La salida JSON estructurada incluye agentHints.nextSteps, útil para agentes de IA que deben decidir el siguiente paso sin interpretar capturas de pantalla.

Ideal para: equipos que diseñan escenarios complejos visualmente y necesitan ejecutarlos de forma idéntica en local, CI y entornos automatizados.

Límite honesto: no es de código abierto ni está pensado como cliente HTTP ad hoc. Los escenarios viven en proyectos de Apidog.

Consulta la guía completa de Apidog CLI para ver todos los comandos.

2. Hurl: pruebas HTTP de texto plano

Hurl ejecuta solicitudes HTTP definidas en archivos de texto y evalúa aserciones sobre las respuestas. Está construido en Rust sobre libcurl y se distribuye como binario único.

Crea un archivo .hurl versionable:

brew install hurl
# Alternativa: cargo install --locked hurl

cat > login.hurl <<'EOF'
POST https://api.example.com/login
{ "user": "acme", "pass": "s3cret" }

HTTP 200
[Asserts]
jsonpath "$.token" exists
EOF

hurl --test login.hurl

Usa --test en CI: Hurl devuelve un código distinto de cero si falla una aserción.

Ideal para: pruebas de humo y verificaciones de contrato que quieres revisar como texto en una pull request.

Límite honesto: se centra en HTTP. No cubre gRPC ni generación de carga, y la lógica compleja suele dividirse en más archivos .hurl.

3. Newman: ejecuta colecciones de Postman sin GUI

Newman es el ejecutor de línea de comandos de código abierto para colecciones de Postman. Si ya tienes solicitudes y pruebas definidas en Postman, exporta la colección y el entorno como JSON para ejecutarlos desde CI.

npm install -g newman

newman run collection.json -e staging.json

Newman falla con código distinto de cero cuando una prueba no pasa, por lo que funciona directamente como compuerta de CI.

Ideal para: equipos que ya trabajan con colecciones de Postman y quieren automatizarlas sin añadir una interfaz gráfica al pipeline.

Límite honesto: ejecuta exclusivamente colecciones con formato Postman. La creación de pruebas sigue ocurriendo en la GUI de Postman.

4. Postman CLI: ejecución vinculada a la nube de Postman

La CLI de Postman es el ejecutor oficial de código cerrado de Postman. A diferencia de Newman, inicia sesión en una cuenta y puede ejecutar colecciones por ID directamente desde un espacio de trabajo.

postman login --with-api-key <YOUR_API_KEY>

postman collection run <collection_id> -e <environment_id>

Los resultados se reportan a la nube de Postman.

Ideal para: equipos que quieren ejecutar colecciones vinculadas a su espacio de trabajo sin exportar JSON.

Límite honesto: requiere una cuenta de Postman, es de código cerrado y coexistir con Newman puede generar dudas sobre cuál adoptar.

La comparación Postman CLI vs Newman explica cuándo conviene cada opción.

5. Bruno CLI: colecciones nativas de Git con `bru`

Bruno guarda colecciones como archivos .bru de texto plano en carpetas normales. Esto permite revisar solicitudes y pruebas en pull requests como cualquier otro archivo del repositorio.

Instala y ejecuta una colección:

npm install -g @usebruno/cli

# Ejecuta las solicitudes de la colección actual
bru run --env staging

Bruno CLI puede generar informes JSON, JUnit y HTML para CI.

Ideal para: equipos que quieren colecciones locales, revisables en Git y ejecutables sin una cuenta en la nube.

Límite honesto: el enfoque basado en archivos favorece a desarrolladores; el ecosistema es más joven que el de Postman.

Consulta Bruno CLI vs Apidog CLI para comparar ambos enfoques.

6. Schemathesis: genera pruebas desde tu esquema

Schemathesis lee un esquema OpenAPI o GraphQL y genera casos de prueba usando pruebas basadas en propiedades sobre Hypothesis para Python.

En lugar de definir cada entrada manualmente, ejecuta pruebas para descubrir:

errores 500;
respuestas que incumplen el esquema;
casos límite no cubiertos por pruebas manuales;
violaciones del contrato documentado.

pip install schemathesis

schemathesis run https://api.example.com/openapi.json

Ideal para: APIs con una especificación sólida donde quieres encontrar errores inesperados antes de una versión.

Límite honesto: necesita un esquema real y preciso. En APIs grandes, puede producir resultados que tendrás que ajustar mediante opciones y hooks.

7. Step CI: flujos de varios pasos en YAML

Step CI permite describir un flujo de API en un archivo YAML. Puedes definir pasos, capturar valores y verificar respuestas sin escribir un script completo.

También cubre REST, GraphQL, gRPC, tRPC y SOAP, y puede validar contra esquemas OpenAPI.

npm install -g stepci

stepci run workflow.yml

Un caso típico es un flujo de autenticación:

Iniciar sesión.
Extraer el token.
Usarlo en una solicitud posterior.
Validar la respuesta final.

Ideal para: flujos declarativos de varios pasos sin scripting personalizado.

Límite honesto: requiere un entorno Node y su cadencia de lanzamientos se ha ralentizado. Revisa la actividad reciente del repositorio antes de basar un pipeline crítico en esta herramienta.

8. curl: la base que probablemente ya tienes

curl viene preinstalado en macOS, la mayoría de distribuciones Linux y versiones actuales de Windows. Es el cliente de referencia para solicitudes HTTP desde shell.

Puedes usarlo para una comprobación mínima de estado:

# Envía JSON e imprime solo el estado HTTP
curl -s -o /dev/null -w "%{http_code}\n" \
  -X POST https://api.example.com/orders \
  -H "Content-Type: application/json" \
  -d '{"sku":"A-102","qty":2}'

Para convertirlo en una prueba, debes añadir la lógica tú mismo: capturar el código, compararlo y devolver un fallo cuando sea necesario.

Ideal para: solicitudes puntuales, scripts pequeños y entornos donde no puedes instalar herramientas adicionales.

Límite honesto: no incluye aserciones integradas. Necesitarás combinarlo con shell, jq y control manual de códigos de salida.

Cuando curl deja de ser suficiente, consulta estas alternativas a curl para pruebas de API REST.

9. HTTPie y xh: solicitudes manuales legibles

HTTPie simplifica las solicitudes manuales desde terminal. Usa http como comando y permite enviar campos JSON como pares clave=valor.

xh implementa una sintaxis similar en Rust como binario estático, con inicio rápido y una opción --curl para imprimir la solicitud equivalente de curl.

http POST api.example.com/users name=acme plan=pro
xh   POST api.example.com/users name=acme plan=pro

Ideal para: explorar endpoints manualmente mientras construyes las pruebas automatizadas en otra herramienta.

Límite honesto: ambos son clientes, no ejecutores de pruebas. No realizan aserciones sobre la respuesta. HTTPie requiere Python; xh prioriza velocidad con un conjunto de características más reducido.

10. k6: cuando necesitas medir carga

k6 responde otra pregunta: no solo si una respuesta es correcta, sino si la API soporta tráfico bajo condiciones definidas.

Es un binario de Go programado con JavaScript. Puedes definir umbrales que convierten una prueba de carga en una compuerta de CI: si se supera un umbral, k6 devuelve un código distinto de cero.

brew install k6

k6 run load.js

Define VUs, duración y umbrales dentro del script load.js.

Ideal para: verificaciones de rendimiento versionadas junto con tus pruebas funcionales.

Límite honesto: es una herramienta de carga bajo AGPL-3.0, no un cliente de pruebas funcionales. Los escenarios significativos requieren aprender su API de JavaScript.

¿Prefieres algo interactivo?

Si quieres una interfaz tipo Postman dentro del shell, busca clientes TUI como atac y posting. Estos dibujan editores completos de solicitudes en la terminal, pero su objetivo es explorar APIs, no gestionar pipelines.

Consulta la guía de los mejores clientes API REST de terminal y TUI para profundizar en esa categoría.

Tabla comparativa

Herramienta	Tarea	Aserciones integradas	Instalación	Código abierto
Apidog CLI	Ejecutar escenarios creados visualmente en CI	Sí	`npm i -g apidog-cli`	No (capa gratuita)
Hurl	Pruebas HTTP de texto plano	Sí	`brew install hurl`	Apache-2.0
Newman	Colecciones de Postman sin interfaz gráfica	Sí	`npm i -g newman`	Apache-2.0
Postman CLI	Ejecuciones de Postman vinculadas a la nube	Sí	Instalador de Postman	No
Bruno CLI	Colecciones `.bru` nativas de Git	Sí	`npm i -g @usebruno/cli`	MIT
Schemathesis	Fuzzing a partir de un esquema	Generadas	`pip install schemathesis`	MIT
Step CI	Flujos YAML de varios pasos	Sí	`npm i -g stepci`	MPL-2.0
curl	Solicitudes brutas y scripting	DIY	Preinstalado	Sí
HTTPie / xh	Solicitudes manuales legibles	No	`brew install httpie` / `xh`	Sí
k6	Carga con umbrales de éxito/fallo	Umbrales	`brew install k6`	AGPL-3.0

Cómo elegir

Empieza por el tipo de trabajo que necesitas automatizar:

Ya tienes colecciones de Postman: usa Newman o Postman CLI.
Quieres archivos de prueba legibles y revisables en Git: usa Hurl o Bruno CLI.
Tienes una especificación OpenAPI precisa: añade Schemathesis para descubrir casos límite.
Necesitas flujos declarativos de varios pasos: prueba Step CI.
Solo necesitas una solicitud rápida o estás en un entorno restringido: usa curl.
Quieres explorar manualmente una API: usa HTTPie o xh.
Necesitas validar capacidad y rendimiento: usa k6.
Quieres diseñar escenarios visualmente y ejecutarlos en CI: usa Apidog CLI.

La CLI de Apidog es útil cuando quieres mantener diseño de API, datos simulados, documentación y escenarios de prueba en una sola plataforma. Consulta Apidog CLI: el cliente API que vive en tu terminal para ver ese flujo de trabajo.

Para entender cómo encajan estas herramientas en una estrategia mayor, revisa la guía de estrategias de pruebas de API.

Preguntas frecuentes

¿Puedo probar APIs completamente desde la terminal?

Sí. Puedes crear pruebas como archivos con Hurl, Bruno o Step CI, o definirlas en un editor visual con Apidog o Postman. Después, ejecútalas sin interfaz gráfica con su CLI. Los ejecutores devuelven códigos de salida que CI puede interpretar.

¿Cuál es la diferencia entre un cliente API de terminal y una herramienta de prueba?

Un cliente como curl, HTTPie o xh envía solicitudes y muestra respuestas. Una herramienta de pruebas como Apidog CLI, Hurl o Newman aplica aserciones y devuelve un código distinto de cero cuando algo falla. Los clientes sirven para explorar; las herramientas de prueba actúan como compuertas.

¿Cuáles se ejecutan en pipelines de CI?

Todos los ejecutores de esta lista:

apidog run
hurl --test
newman run
postman collection run
bru run
schemathesis run
stepci run
k6 run

Todos pueden devolver un código distinto de cero en caso de fallo. Para un ejemplo práctico, consulta cómo ejecutar pruebas de Apidog CLI en GitHub Actions.

¿Alguna de estas herramientas maneja pruebas de carga?

Sí: k6 es la herramienta especializada en carga de esta lista. Sus umbrales permiten fallar una ejecución cuando se supera una latencia, tasa de errores u otra métrica definida. Las demás herramientas se centran principalmente en corrección funcional.

¿Necesito una especificación OpenAPI?

Solo Schemathesis la necesita para generar pruebas. En las demás herramientas, una especificación ayuda pero no es obligatoria. Apidog puede importar OpenAPI 3.x, Swagger 2.0 y colecciones de Postman; Step CI puede validar respuestas contra un esquema.

El patrón es simple: crea pruebas donde te resulte más cómodo, pero ejecuta esas pruebas desde un shell con un código de salida fiable. Si buscas diseño visual y ejecución automatizada en una sola plataforma, descarga Apidog, crea un escenario y añade apidog run a tu pipeline de CI.

DEV Community: Roobia

Gemini 3.7 Flash Precios Explicados: Asegura tus Tarifas Antes de que se Dupliquen

En resumen

Los dos niveles de precios

Cómo calcular el coste de una carga real

Carga de trabajo 1: chatbot de soporte

Carga de trabajo 2: pipeline de documentos PDF

Carga de trabajo 3: bucle de agente

Cómo se compara el precio de 3.7 Flash

Cinco formas de reducir el gasto en tokens

1. Limite la salida por endpoint

2. Almacene en caché el contexto estático

3. Use lotes para trabajo no interactivo

4. Enrute por complejidad

5. Prototype con el nivel gratuito

Rastree el gasto por endpoint con Apidog

Preguntas frecuentes

¿Cuándo se duplica el precio de Gemini 3.7 Flash?

¿Es Gemini 3.7 Flash más barato que Gemini 3.6 Flash?

¿Se aplica el precio introductorio en Vertex AI?

¿Qué cuenta como token de entrada?

¿Cómo estimo tokens antes de enviar una solicitud?

Dónde encaja 3.7 Flash en su pila

¿Qué hay de nuevo en Gemini 3.7 Flash? Características, Benchmarks y Acceso a la API

En resumen

Qué es Gemini 3.7 Flash

Mejoras en benchmarks: Gemini 3.6 vs. 3.7 Flash

Qué probar en codificación y agentes

Precios: tarifa introductoria hasta el 31 de diciembre de 2026

Recomendación para presupuestar

Dónde puedes usarlo hoy

Por qué Google lanzó Flash antes que Gemini 3.5 Pro

Cómo probar la API en cinco minutos

Comparar Gemini 3.6 Flash y 3.7 Flash

Preguntas frecuentes

¿Es Gemini 3.7 Flash de uso gratuito?

¿Cuál es la diferencia entre Gemini 3.6 Flash y 3.7 Flash?

¿Gemini 3.7 Flash reemplaza a Gemini 3.5 Pro?

¿Qué ocurre con los precios el 1 de enero de 2027?

¿Puede Gemini 3.7 Flash procesar imágenes y PDFs?

Dónde encaja Gemini 3.7 Flash en tu pila

¿Cómo usar la API de Gemini 3.7 Flash?

En resumen

Para qué sirve Gemini 3.7 Flash

Obtener una clave de API

AI Studio: ruta rápida

Vertex AI: ruta de producción

Endpoint y autenticación

Primera solicitud con cURL

Inicio rápido con Python

Enviar un PDF

Inicio rápido con Node.js

Streaming

Python

HTTP con SSE

Ajustar generationConfig

Pruebe el endpoint en Apidog antes de escribir código de aplicación

Manejo de errores y límites de velocidad

Preguntas frecuentes

¿Es Gemini 3.7 Flash de uso gratuito?

¿Cuál es la diferencia entre AI Studio y Vertex AI?

¿Puedo enviar imágenes, audio y PDF?

¿Cuál es el tamaño de contexto y el límite de salida?

¿Debo actualizar desde Gemini 3.6 Flash?

Dónde encaja 3.7 Flash en su pila

Grok 4.6 vs GPT-5.6 vs Claude Fable 5: ¿Qué modelo elegir para desarrolladores API?

En resumen

Especificaciones y precios uno al lado del otro

Benchmarks de codificación: Sol para profundidad, Grok para valor

Coste por tarea, no solo coste por token

Ergonomía de la API: coste de integración

Ventanas de contexto: cuándo 500K es suficiente

Fechas de corte de conocimiento y madurez del ecosistema

Qué modelo usar según el trabajo

Prueba los tres en tu stack en una tarde

1. Crea un proyecto con tres entornos

2. Reúne 20 prompts reales

3. Define aserciones medibles

4. Ejecuta cada caso tres veces por modelo

5. Conserva la suite de evaluación

Ajustar `generationConfig`

Instalación de `watermarks-remover`

¿`watermarks-remover` es gratuito?

3. Compruebe la estructura de `messages`

2. Compruebe `finish_reason`

Prueba `deepseek-v4-pro` en Apidog